yamllint
doc8 # Apache-2.0
bashate # Apache-2.0
-ansible-lint
+ansible-lint[core]
bandit
munch # MIT
[testenv:ansiblelint]
basepython = python3.9
commands =
- ansible-lint -x303,305,306 ansible/site.yml
+ ansible-lint -xcommand-instead-of-module,command-instead-of-shell,risky-shell-pipe ansible/site.yml
[testenv:py38]
commands = nosetests xtesting/tests/unit
robotframework===4.1.2
-bandit===1.1.0
+bandit===1.7.0
behave===1.2.6
-behave-html-formatter===0.9.4
-pylint===2.9.6
-flake8===3.9.2
+behave-html-formatter===0.9.8
+pylint===2.11.1
+flake8===4.0.1
nose===1.3.7
-ansible-lint===4.3.7
+ansible-lint===5.2.1
if not os.path.isfile(rc_file):
LOGGER.debug("No env file %s found", rc_file)
return
- with open(rc_file, "r") as rcfd:
+ with open(rc_file, "r", encoding='utf-8') as rcfd:
for line in rcfd:
var = (line.rstrip('"\n').replace('export ', '').split(
"=") if re.search(r'(.*)=(.*)', line) else None)
def get_dict_by_test(testname):
# pylint: disable=missing-docstring
with open(pkg_resources.resource_filename(
- 'xtesting', 'ci/testcases.yaml')) as tyaml:
+ 'xtesting', 'ci/testcases.yaml'), encoding='utf-8') as tyaml:
testcases_yaml = yaml.safe_load(tyaml)
for dic_tier in testcases_yaml.get("tiers"):
for dic_testcase in dic_tier['testcases']:
self.overall_result = Result.EX_ERROR
if test.is_blocking():
raise BlockingTestFailed(
- "The test case {} failed and is blocking".format(
- test.get_name()))
+ f"The test case {test.get_name()} "
+ "failed and is blocking")
return self.overall_result
def run_all(self):
os.makedirs(constants.RESULTS_DIR)
except OSError as ex:
if ex.errno != errno.EEXIST:
- print("{} {}".format("Cannot create", constants.RESULTS_DIR))
+ print(f"Cannot create {constants.RESULTS_DIR}")
return testcase.TestCase.EX_RUN_ERROR
if env.get('DEBUG').lower() == 'true':
logging.config.fileConfig(pkg_resources.resource_filename(
self.generate_tiers()
def read_test_yaml(self):
- with open(self.testcases_file) as tc_file:
+ with open(self.testcases_file, encoding='utf-8') as tc_file:
self.testcases_yaml = yaml.safe_load(tc_file)
self.dic_tier_array = []
def parse_results(self):
"""Parse output.json and get the details in it."""
- with open(self.json_file) as stream_:
+ with open(self.json_file, encoding='utf-8') as stream_:
self.response = json.load(stream_)
if self.response:
self.total_tests = len(self.response)
except Exception: # pylint: disable=broad-except
self.__logger.exception("Cannot create %s", self.res_dir)
return self.EX_RUN_ERROR
- config = ['--junit', '--junit-directory={}'.format(self.res_dir),
- '--format=json', '--outfile={}'.format(self.json_file)]
+ config = ['--junit', f'--junit-directory={self.res_dir}',
+ '--format=json', f'--outfile={self.json_file}']
html_file = os.path.join(self.res_dir, 'output.html')
config += ['--format=behave_html_formatter:HTMLFormatter',
- '--outfile={}'.format(html_file)]
+ f'--outfile={html_file}']
if kwargs.get("tags", False):
config += ['--tags='+','.join(kwargs.get("tags", []))]
if kwargs.get("console", False):
try:
url = env.get('TEST_DB_URL')
req = requests.get(
- "{}?build_tag={}".format(url, env.get('BUILD_TAG')),
+ f"{url}?build_tag={env.get('BUILD_TAG')}",
headers=testcase.TestCase.headers)
req.raise_for_status()
output = req.json()
for j, _ in enumerate(
output["results"][i]["details"]["links"]):
output["results"][i]["details"]["links"][j] = re.sub(
- "^{}/*".format(os.environ["HTTP_DST_URL"]), '',
+ "^{os.environ['HTTP_DST_URL']}/*", '',
output["results"][i]["details"]["links"][j])
Campaign.__logger.debug("data to archive: \n%s", output)
- with open("{}.json".format(env.get('BUILD_TAG')), "w") as dfile:
+ with open("{env.get('BUILD_TAG')}.json", "w",
+ encoding='utf-8') as dfile:
json.dump(output, dfile)
except Exception: # pylint: disable=broad-except
Campaign.__logger.exception(
prefix = os.path.join(s3path, build_tag)
# pylint: disable=no-member
for s3_object in b3resource.Bucket(bucket_name).objects.filter(
- Prefix="{}/".format(prefix)):
+ Prefix=f"{prefix}/"):
path, _ = os.path.split(s3_object.key)
- lpath = re.sub('^{}/*'.format(s3path), '', path)
+ lpath = re.sub(f'^{s3path}/*', '', path)
if lpath and not os.path.exists(lpath):
os.makedirs(lpath)
# pylint: disable=no-member
b3resource.Bucket(bucket_name).download_file(
s3_object.key,
- re.sub('^{}/*'.format(s3path), '', s3_object.key),
+ re.sub(f'^{s3path}/*', '', s3_object.key),
Config=config)
Campaign.__logger.info(
"Downloading %s",
- re.sub('^{}/*'.format(s3path), '', s3_object.key))
+ re.sub(f'^{s3path}/*', '', s3_object.key))
return Campaign.EX_OK
except Exception: # pylint: disable=broad-except
Campaign.__logger.exception("Cannot publish the artifacts")
build_tag = env.get('BUILD_TAG')
assert Campaign.dump_db() == Campaign.EX_OK
assert Campaign.dump_artifacts() == Campaign.EX_OK
- with zipfile.ZipFile('{}.zip'.format(build_tag),
+ with zipfile.ZipFile(f'{build_tag}.zip',
'w', zipfile.ZIP_DEFLATED) as zfile:
- zfile.write("{}.json".format(build_tag))
+ zfile.write(f"{build_tag}.json")
for root, _, files in os.walk(build_tag):
for filename in files:
zfile.write(os.path.join(root, filename))
"S3_ENDPOINT_URL"] else 8 * 1024 * 1024
config = TransferConfig(multipart_threshold=multipart_threshold)
bucket_name = urlparse(dst_s3_url).netloc
- mime_type = mimetypes.guess_type('{}.zip'.format(build_tag))
+ mime_type = mimetypes.guess_type(f'{build_tag}.zip')
path = urlparse(dst_s3_url).path.strip("/")
# pylint: disable=no-member
b3resource.Bucket(bucket_name).upload_file(
- '{}.zip'.format(build_tag),
- os.path.join(path, '{}.zip'.format(build_tag)),
+ f'{build_tag}.zip',
+ os.path.join(path, f'{build_tag}.zip'),
Config=config,
ExtraArgs={'ContentType': mime_type[
0] or 'application/octet-stream'})
dst_http_url = os.environ["HTTP_DST_URL"]
- link = os.path.join(dst_http_url, '{}.zip'.format(build_tag))
+ link = os.path.join(dst_http_url, f'{build_tag}.zip')
Campaign.__logger.info(
"All data were successfully published:\n\n%s", link)
return Campaign.EX_OK
def __init__(self, **kwargs):
super().__init__(**kwargs)
- self.result_file = "{}/{}.log".format(self.res_dir, self.case_name)
+ self.result_file = f"{self.res_dir}/{self.case_name}.log"
def execute(self, **kwargs):
"""Execute the cmd passed as arg
max_duration = kwargs.get("max_duration")
if not os.path.isdir(self.res_dir):
os.makedirs(self.res_dir)
- with open(self.result_file, 'w') as f_stdout:
+ with open(self.result_file, 'w', encoding='utf-8') as f_stdout:
self.__logger.info("Calling %s", cmd)
with subprocess.Popen(
cmd, shell=True, stdout=subprocess.PIPE,
"Killing process after %d second(s).",
max_duration)
return -2
- with open(self.result_file, 'r') as f_stdin:
+ with open(self.result_file, 'r', encoding='utf-8') as f_stdin:
self.__logger.debug("$ %s\n%s", cmd, f_stdin.read().rstrip())
return process.returncode
except KeyError:
"""Parse testPlan.csv containing the status of each testcase of the test file.
See sample file in `xtesting/samples/mts/output/testPlan.csv`
"""
- with open(self.mts_result_csv_file) as stream_:
+ with open(self.mts_result_csv_file, encoding='utf-8') as stream_:
self.__logger.info("Parsing file : %s", self.mts_result_csv_file)
reader = csv.reader(stream_, delimiter=';')
rownum = 0
return -3
# Build command line to launch for MTS
- cmd = ("cd {} && ./startCmd.sh {} {} -sequential -levelLog:{}"
- " -storageLog:{}"
- " -config:stats.REPORT_DIRECTORY+{}"
- " -config:logs.STORAGE_DIRECTORY+{}"
+ cmd = (f"cd {cwd} && ./startCmd.sh {test_file} "
+ f"{enabled_testcases_str} -sequential -levelLog:{log_level}"
+ f" -storageLog:{store_method}"
+ f" -config:stats.REPORT_DIRECTORY+{self.mts_stats_dir}"
+ f" -config:logs.STORAGE_DIRECTORY+{self.mts_logs_dir}"
" -genReport:true"
- " -showRep:false").format(cwd,
- test_file,
- enabled_testcases_str,
- log_level,
- store_method,
- self.mts_stats_dir,
- self.mts_logs_dir)
+ " -showRep:false")
# Make sure to create the necessary output sub-folders for MTS
# and cleanup output files from previous run.
result = robot.api.ExecutionResult(self.xml_file)
writer = resultwriter.ResultWriter(result)
return writer.write_results(
- report='{}/report.html'.format(self.res_dir),
- log='{}/log.html'.format(self.res_dir),
- xunit='{}/xunit.xml'.format(self.res_dir))
+ report=f'{self.res_dir}/report.html',
+ log=f'{self.res_dir}/log.html',
+ xunit=f'{self.res_dir}/xunit.xml')
def run(self, **kwargs):
"""Run the RobotFramework suites
assert self.stop_time
if self.stop_time < self.start_time:
return "XX:XX"
- return "{}:{}".format(
- str(int(self.stop_time - self.start_time) // 60).zfill(2),
- str(int(self.stop_time - self.start_time) % 60).zfill(2))
+ return(
+ f"{str(int(self.stop_time - self.start_time) // 60).zfill(2)}:"
+ f"{str(int(self.stop_time - self.start_time) % 60).zfill(2)}")
+
except Exception: # pylint: disable=broad-except
self.__logger.error("Please run test before getting the duration")
return "XX:XX"
ExtraArgs={'ContentType': mime_type[
0] or 'application/octet-stream'})
link = os.path.join(dst_http_url, log_file)
- output_str += "\n{}".format(link)
+ output_str += f"\n{link}"
self.details["links"].append(link)
for root, _, files in os.walk(self.res_dir):
for pub_file in files:
link = os.path.join(dst_http_url, os.path.relpath(
os.path.join(root, pub_file),
start=self.dir_results))
- output_str += "\n{}".format(link)
+ output_str += f"\n{link}"
self.details["links"].append(link)
self.__logger.info(
"All artifacts were successfully published: %s\n", output_str)
Exception
"""
stream.seek(0)
- with open("{}/results.xml".format(self.res_dir), "w") as xml:
+ with open(f"{self.res_dir}/results.xml", "w", encoding='utf-8') as xml:
with subprocess.Popen(
['subunit2junitxml'], stdin=subprocess.PIPE,
stdout=subprocess.PIPE) as stats:
Raises:
CalledProcessError
"""
- cmd = ['subunit2html', stream, '{}/results.html'.format(self.res_dir)]
+ cmd = ['subunit2html', stream, f'{self.res_dir}/results.html']
output = subprocess.check_output(cmd)
self.__logger.debug("\n%s\n\n%s", ' '.join(cmd), output)
stream=stream, verbosity=2).run(self.suite).decorated
self.generate_stats(stream)
self.generate_xunit(stream)
- with open('{}/subunit_stream'.format(self.res_dir), 'wb') as subfd:
+ with open(f'{self.res_dir}/subunit_stream', 'wb') as subfd:
stream.seek(0)
shutil.copyfileobj(stream, subfd)
- self.generate_html('{}/subunit_stream'.format(self.res_dir))
+ self.generate_html(f'{self.res_dir}/subunit_stream')
self.stop_time = time.time()
self.details = {
"testsRun": result.testsRun,
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.uuid = uuid.uuid4()
- self.user_name = "{}-{}".format(self.case_name, self.uuid)
- self.tenant_name = "{}-{}".format(self.case_name, self.uuid)
+ self.user_name = f"{self.case_name}-{self.uuid}"
+ self.tenant_name = f"{self.case_name}-{self.uuid}"
self.snaps_creds = {}
self.created_object = []
self.os_project = None
- self.tenant_description = "Created by OPNFV Functest: {}".format(
- self.case_name)
+ self.tenant_description = (
+ f"Created by OPNFV Functest: {self.case_name}")
def run(self, **kwargs):
"""
mock_method.return_value.__iter__ = lambda self: iter(
self.readline, '')
self.runner.source_envfile(envfile)
- mock_method.assert_called_once_with(envfile, 'r')
+ mock_method.assert_called_once_with(envfile, 'r', encoding='utf-8')
self.assertEqual(os.environ[key], value)
def test_source_envfile(self):
html_file = os.path.join(self.test.res_dir, 'output.html')
args_list = [
'--junit',
- '--junit-directory={}'.format(self.test.res_dir),
- '--format=json', '--outfile={}'.format(self.test.json_file),
+ f'--junit-directory={self.test.res_dir}',
+ '--format=json', f'--outfile={self.test.json_file}',
'--format=behave_html_formatter:HTMLFormatter',
- '--outfile={}'.format(html_file),
+ f'--outfile={html_file}',
'--tags='+','.join(self.tags)]
args_list.append('foo')
args[0].assert_called_once_with(args_list)
html_file = os.path.join(self.test.res_dir, 'output.html')
args_list = [
'--junit',
- '--junit-directory={}'.format(self.test.res_dir),
- '--format=json', '--outfile={}'.format(self.test.json_file),
+ f'--junit-directory={self.test.res_dir}',
+ '--format=json', f'--outfile={self.test.json_file}',
'--format=behave_html_formatter:HTMLFormatter',
- '--outfile={}'.format(html_file),
+ f'--outfile={html_file}',
'--tags='+','.join(self.tags)]
if console:
args_list += ['--format=pretty', '--outfile=-']
def test_run_ko1(self, *args):
with mock.patch('builtins.open', mock.mock_open()) as mopen:
self._test_run(testcase.TestCase.EX_RUN_ERROR)
- mopen.assert_called_once_with(self._output_file, "w")
+ mopen.assert_called_once_with(self._output_file, "w", encoding='utf-8')
args[0].assert_called_once_with(
self._cmd, shell=True, stderr=mock.ANY, stdout=mock.ANY)
args[1].assert_called_once_with(self.feature.res_dir)
args[0].configure_mock(**attrs)
with mock.patch('builtins.open', mock.mock_open()) as mopen:
self._test_run(testcase.TestCase.EX_RUN_ERROR)
- self.assertIn(mock.call(self._output_file, 'w'), mopen.mock_calls)
- self.assertIn(mock.call(self._output_file, 'r'), mopen.mock_calls)
+ self.assertIn(
+ mock.call(self._output_file, 'w', encoding='utf-8'),
+ mopen.mock_calls)
+ self.assertIn(
+ mock.call(self._output_file, 'r', encoding='utf-8'),
+ mopen.mock_calls)
args[0].assert_called_once_with(
self._cmd, shell=True, stderr=mock.ANY, stdout=mock.ANY)
args[1].assert_called_once_with(self.feature.res_dir)
args[1].configure_mock(**attrs)
with mock.patch('builtins.open', mock.mock_open()) as mopen:
self._test_run_max_duration(testcase.TestCase.EX_RUN_ERROR)
- self.assertIn(mock.call(self._output_file, 'w'), mopen.mock_calls)
- self.assertNotIn(mock.call(self._output_file, 'r'), mopen.mock_calls)
+ self.assertIn(
+ mock.call(self._output_file, 'w', encoding='utf-8'),
+ mopen.mock_calls)
+ self.assertNotIn(
+ mock.call(self._output_file, 'r', encoding='utf-8'),
+ mopen.mock_calls)
args[1].assert_called_once_with(
self._cmd, shell=True, stderr=mock.ANY, stdout=mock.ANY)
wait.assert_called_once_with(timeout=FeatureTestingBase._max_duration)
args[0].configure_mock(**attrs)
with mock.patch('builtins.open', mock.mock_open()) as mopen:
self._test_run(testcase.TestCase.EX_OK)
- self.assertIn(mock.call(self._output_file, 'w'), mopen.mock_calls)
- self.assertIn(mock.call(self._output_file, 'r'), mopen.mock_calls)
+ self.assertIn(
+ mock.call(self._output_file, 'w', encoding='utf-8'),
+ mopen.mock_calls)
+ self.assertIn(
+ mock.call(self._output_file, 'r', encoding='utf-8'),
+ mopen.mock_calls)
args[0].assert_called_once_with(
self._cmd, shell=True, stderr=mock.ANY, stdout=mock.ANY)
args[1].assert_called_once_with(self.feature.res_dir)
args[0].configure_mock(**attrs)
with mock.patch('builtins.open', mock.mock_open()) as mopen:
self._test_run_console(True, testcase.TestCase.EX_OK)
- self.assertIn(mock.call(self._output_file, 'w'), mopen.mock_calls)
- self.assertIn(mock.call(self._output_file, 'r'), mopen.mock_calls)
+ self.assertIn(
+ mock.call(self._output_file, 'w', encoding='utf-8'),
+ mopen.mock_calls)
+ self.assertIn(
+ mock.call(self._output_file, 'r', encoding='utf-8'),
+ mopen.mock_calls)
args[0].assert_called_once_with(
self._cmd, shell=True, stderr=mock.ANY, stdout=mock.ANY)
args[1].assert_called_once_with(self.feature.res_dir)
args[0].configure_mock(**attrs)
with mock.patch('builtins.open', mock.mock_open()) as mopen:
self._test_run_console(False, testcase.TestCase.EX_OK)
- self.assertIn(mock.call(self._output_file, 'w'), mopen.mock_calls)
- self.assertIn(mock.call(self._output_file, 'r'), mopen.mock_calls)
+ self.assertIn(
+ mock.call(self._output_file, 'w', encoding='utf-8'),
+ mopen.mock_calls)
+ self.assertIn(
+ mock.call(self._output_file, 'r', encoding='utf-8'),
+ mopen.mock_calls)
args[0].assert_called_once_with(
self._cmd, shell=True, stderr=mock.ANY, stdout=mock.ANY)
args[1].assert_called_once_with(self.feature.res_dir)
args[0].configure_mock(**attrs)
with mock.patch('builtins.open', mock.mock_open()) as mopen:
self._test_run_console(False, testcase.TestCase.EX_OK)
- self.assertIn(mock.call(self._output_file, 'w'), mopen.mock_calls)
- self.assertIn(mock.call(self._output_file, 'r'), mopen.mock_calls)
+ self.assertIn(
+ mock.call(self._output_file, 'w', encoding='utf-8'),
+ mopen.mock_calls)
+ self.assertIn(
+ mock.call(self._output_file, 'r', encoding='utf-8'),
+ mopen.mock_calls)
args[0].assert_called_once_with(
self._cmd, shell=True, stderr=mock.ANY, stdout=mock.ANY)
args[1].assert_called_once_with(self.feature.res_dir)
args[0].assert_called_once_with(self.test.xml_file)
args[1].assert_called_once_with(args[0].return_value)
args[2].assert_called_once_with(
- report='{}/report.html'.format(self.test.res_dir),
- log='{}/log.html'.format(self.test.res_dir),
- xunit='{}/xunit.xml'.format(self.test.res_dir))
+ report=f'{self.test.res_dir}/report.html',
+ log=f'{self.test.res_dir}/log.html',
+ xunit=f'{self.test.res_dir}/xunit.xml')
@mock.patch('robot.reporting.resultwriter.ResultWriter.write_results',
return_value=0)
args[0].assert_called_once_with(self.test.xml_file)
args[1].assert_called_once_with(args[0].return_value)
args[2].assert_called_once_with(
- report='{}/report.html'.format(self.test.res_dir),
- log='{}/log.html'.format(self.test.res_dir),
- xunit='{}/xunit.xml'.format(self.test.res_dir))
+ report=f'{self.test.res_dir}/report.html',
+ log=f'{self.test.res_dir}/log.html',
+ xunit=f'{self.test.res_dir}/xunit.xml')
class RunTesting(unittest.TestCase):
['subunit2junitxml'], stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
mock_open.assert_called_once_with(
- '{}/results.xml'.format(self.psrunner.res_dir), 'w')
+ f'{self.psrunner.res_dir}/results.xml', 'w', encoding='utf-8')
@mock.patch('subprocess.Popen')
def test_generate_xunit_ok(self, *args):
['subunit2junitxml'], stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
mock_open.assert_called_once_with(
- '{}/results.xml'.format(self.psrunner.res_dir), 'w')
+ f'{self.psrunner.res_dir}/results.xml', 'w', encoding='utf-8')
@mock.patch('subprocess.check_output', side_effect=Exception)
def test_generate_html_ko(self, *args):
self.psrunner.generate_html(stream)
args[0].assert_called_once_with(
['subunit2html', stream,
- '{}/results.html'.format(self.psrunner.res_dir)])
+ f'{self.psrunner.res_dir}/results.html'])
@mock.patch('subprocess.check_output')
def test_generate_html_ok(self, *args):
self.psrunner.generate_html(stream)
args[0].assert_called_once_with(
['subunit2html', stream,
- '{}/results.html'.format(self.psrunner.res_dir)])
+ f'{self.psrunner.res_dir}/results.html'])
@mock.patch('xtesting.core.unit.Suite.generate_html')
@mock.patch('xtesting.core.unit.Suite.generate_xunit')
with mock.patch('builtins.open', mock.mock_open()) as m_open:
self.assertEqual(self.psrunner.run(), status)
m_open.assert_called_once_with(
- '{}/subunit_stream'.format(self.psrunner.res_dir), 'wb')
+ f'{self.psrunner.res_dir}/subunit_stream', 'wb')
self.assertEqual(self.psrunner.is_successful(), result)
args[0].assert_called_once_with(self.psrunner.suite)
args[1].assert_not_called()
args[2].assert_called_once_with(mock.ANY)
args[3].assert_called_once_with(mock.ANY)
args[4].assert_called_once_with(
- '{}/subunit_stream'.format(self.psrunner.res_dir))
+ f'{self.psrunner.res_dir}/subunit_stream')
@mock.patch('xtesting.core.unit.Suite.generate_html')
@mock.patch('xtesting.core.unit.Suite.generate_xunit')
with mock.patch('builtins.open', mock.mock_open()) as m_open:
self.assertEqual(self.psrunner.run(name=name), status)
m_open.assert_called_once_with(
- '{}/subunit_stream'.format(self.psrunner.res_dir), 'wb')
+ f'{self.psrunner.res_dir}/subunit_stream', 'wb')
self.assertEqual(self.psrunner.is_successful(), result)
args[0].assert_called_once_with(self.psrunner.suite)
args[1].assert_called_once_with()
args[2].assert_called_once_with(mock.ANY)
args[3].assert_called_once_with(mock.ANY)
args[4].assert_called_once_with(
- '{}/subunit_stream'.format(self.psrunner.res_dir))
+ f'{self.psrunner.res_dir}/subunit_stream')
@mock.patch('xtesting.core.unit.Suite.generate_html')
@mock.patch('xtesting.core.unit.Suite.generate_xunit')
__author__ = "Cedric Ollivier <cedric.ollivier@orange.com>"
DIR = '/dev'
-FILE = '{}/null'.format(DIR)
-URL = 'file://{}'.format(FILE)
+FILE = f'{DIR}/null'
+URL = f'file://{FILE}'
class FakeTestCase(testcase.TestCase):
create=True) as mock_open:
test = self._get_testcase()
self.assertEqual(test.push_to_db(), testcase.TestCase.EX_OK)
- mock_open.assert_called_once_with(FILE, 'a')
+ mock_open.assert_called_once_with(FILE, 'a', encoding='utf-8')
handle = mock_open()
call_args, _ = handle.write.call_args
self.assertIn('POST', call_args[0])
except OSError as ex:
if ex.errno != errno.EEXIST:
raise
- with open(parseresult.path, 'a') as dumpfile:
+ with open(parseresult.path, 'a', encoding='utf-8') as dumpfile:
headers = ""
for key in request.headers:
headers += key + " " + request.headers[key] + "\n"
- message = "{} {}\n{}\n{}\n\n\n".format(
- request.method, request.url, headers, request.body)
+ message = (
+ f"{request.method} {request.url}"
+ f"\n{headers}\n{request.body}\n\n\n")
dumpfile.write(message)
return mock.Mock()
Code Review / functest-xtesting.git / commitdiff