class TestSwagger2YAML(BZTestCase):
def setUp(self):
super(TestSwagger2YAML, self).setUp()
self.engine = EngineEmul()
def _get_swagger2yaml(self, path, file_name=None):
return Swagger2YAML(FakeOptions(file_name=file_name),
RESOURCES_DIR + path)
def _get_tmp(self, prefix='test', suffix='.yml'):
return self.engine.create_artifact(prefix, suffix)
def test_convert(self):
self.maxDiff = None
source = RESOURCES_DIR + "/swagger/petstore.json"
result = self._get_tmp()
options = FakeOptions(file_name=result)
process(options, [source])
actual = yaml.load(open(result).read())
expected = yaml.load(
open(RESOURCES_DIR + "/swagger/petstore-converted.yaml").read())
self.assertEqual(actual, expected)
def test_convert_scenarios_from_paths(self):
self.maxDiff = None
source = RESOURCES_DIR + "/swagger/bzm-api.json"
result = self._get_tmp()
options = FakeOptions(file_name=result, scenarios_from_paths=True)
process(options, [source])
actual = yaml.load(open(result).read())
expected = yaml.load(
open(RESOURCES_DIR + "/swagger/bzm-api-converted.yaml").read())
self.assertEqual(actual, expected)
class TestConverter(BZTestCase):
def setUp(self):
super(TestConverter, self).setUp()
self.engine = EngineEmul()
def _get_soapui2yaml(self, path, file_name=None, test_case=None):
return SoapUI2YAML(
FakeOptions(file_name=file_name, test_case=test_case),
__dir__() + path)
def _get_tmp(self, prefix='test', suffix='.yml'):
return self.engine.create_artifact(prefix, suffix)
def test_convert(self):
source = __dir__() + "/resources/soapui/project.xml"
result = self._get_tmp()
options = FakeOptions(file_name=result, test_case="index")
process(options, [source])
actual = yaml.load(open(result).read())
expected = yaml.load(
open(__dir__() + "/resources/soapui/project.xml.yml").read())
self.assertEqual(actual, expected)
def test_flickr(self):
source = __dir__() + "/resources/soapui/flickr-sample.xml"
result = self._get_tmp()
options = FakeOptions(file_name=result)
process(options, [source])
actual = yaml.load(open(result).read())
expected = yaml.load(
open(__dir__() + "/resources/soapui/flickr-sample.xml.yml").read())
self.assertEqual(actual, expected)
def test_encode_decode_infinities(self):
engine = EngineEmul()
obj = Configuration()
obj.merge({
"foo": float("inf"),
})
cfg = engine.create_artifact("config", ".json")
obj.dump(cfg, Configuration.JSON)
with open(cfg) as fds:
dump = json.loads(fds.read())
self.assertEqual(dump["foo"], "inf")
self.assertEqual(dehumanize_time(dump["foo"]), float("inf"))
def test_encode_decode_infinities(self):
engine = EngineEmul()
obj = Configuration()
obj.merge({
"foo": float("inf"),
})
cfg = engine.create_artifact("config", ".json")
obj.dump(cfg, Configuration.JSON)
with open(cfg) as fds:
dump = json.loads(fds.read())
self.assertEqual(dump["foo"], "inf")
self.assertEqual(dehumanize_time(dump["foo"]), float("inf"))
class TestSwagger2YAML(BZTestCase):
def setUp(self):
super(TestSwagger2YAML, self).setUp()
self.engine = EngineEmul()
def _get_swagger2yaml(self, path, file_name=None):
return Swagger2YAML(FakeOptions(file_name=file_name), RESOURCES_DIR + path)
def _get_tmp(self, prefix='test', suffix='.yml'):
return self.engine.create_artifact(prefix, suffix)
def test_convert(self):
self.maxDiff = None
source = RESOURCES_DIR + "/swagger/petstore.json"
result = self._get_tmp()
options = FakeOptions(file_name=result)
process(options, [source])
actual = yaml.load(open(result).read())
expected = yaml.load(open(RESOURCES_DIR + "/swagger/petstore-converted.yaml").read())
self.assertEqual(actual, expected)
class TestConverter(BZTestCase):
def setUp(self):
super(TestConverter, self).setUp()
self.engine = EngineEmul()
def _get_soapui2yaml(self, path, file_name=None, test_case=None):
return SoapUI2YAML(FakeOptions(file_name=file_name, test_case=test_case), __dir__() + path)
def _get_tmp(self, prefix='test', suffix='.yml'):
return self.engine.create_artifact(prefix, suffix)
def test_convert(self):
source = RESOURCES_DIR + "soapui/project.xml"
result = self._get_tmp()
options = FakeOptions(file_name=result, test_case="index")
process(options, [source])
actual = yaml.load(open(result).read())
expected = yaml.load(open(RESOURCES_DIR + "soapui/project.xml.yml").read())
self.assertEqual(actual, expected)
def test_flickr(self):
source = RESOURCES_DIR + "soapui/flickr-sample.xml"
result = self._get_tmp()
options = FakeOptions(file_name=result)
process(options, [source])
actual = yaml.load(open(result).read())
expected = yaml.load(open(RESOURCES_DIR + "soapui/flickr-sample.xml.yml").read())
self.assertEqual(actual, expected)
def test_egalaxy(self):
source = RESOURCES_DIR + "soapui/egalaxy.xml"
result = self._get_tmp()
options = FakeOptions(file_name=result)
process(options, [source])
actual = yaml.load(open(result).read())
expected = yaml.load(open(RESOURCES_DIR + "soapui/egalaxy.xml.yml").read())
self.assertEqual(actual, expected)
class TestSwagger2YAML(BZTestCase):
def setUp(self):
super(TestSwagger2YAML, self).setUp()
self.engine = EngineEmul()
def _get_swagger2yaml(self, path, file_name=None):
return Swagger2YAML(FakeOptions(file_name=file_name),
RESOURCES_DIR + path)
def _get_tmp(self, prefix='test', suffix='.yml'):
return self.engine.create_artifact(prefix, suffix)
def test_convert(self):
source = RESOURCES_DIR + "/swagger/petstore.json"
expected = RESOURCES_DIR + "/swagger/petstore-converted.yaml"
result = self._get_tmp()
options = FakeOptions(file_name=result)
process(options, [source])
# shutil.copy(result, expected)
actual = yaml.full_load(open(result).read())
expected = yaml.full_load(open(expected).read())
self.assertEqual(actual, expected)
def test_convert_scenarios_from_paths(self):
source = RESOURCES_DIR + "/swagger/bzm-api.json"
expected = RESOURCES_DIR + "/swagger/bzm-api-converted.yaml"
result = self._get_tmp()
options = FakeOptions(file_name=result, scenarios_from_paths=True)
process(options, [source])
# shutil.copy(result, expected)
actual = yaml.full_load(open(result).read())
expected = yaml.full_load(open(expected).read())
self.assertEqual(actual, expected)
def test_convert_security_apikey_header(self):
source = RESOURCES_DIR + "/swagger/auth-key.json"
expected = RESOURCES_DIR + "/swagger/auth-key-converted.yaml"
result = self._get_tmp()
options = FakeOptions(file_name=result)
process(options, [source])
# shutil.copy(result, expected)
actual = yaml.full_load(open(result).read())
expected = yaml.full_load(open(expected).read())
self.assertEqual(actual, expected)
def test_convert_security_basic(self):
source = RESOURCES_DIR + "/swagger/auth-basic.json"
expected = RESOURCES_DIR + "/swagger/auth-basic-converted.yaml"
result = self._get_tmp()
options = FakeOptions(file_name=result)
process(options, [source])
# shutil.copy(result, expected)
actual = yaml.full_load(open(result).read())
expected = yaml.full_load(open(expected).read())
self.assertEqual(actual, expected)
def test_convert_security_basic_local(self):
source = RESOURCES_DIR + "/swagger/auth-basic-local.json"
expected = RESOURCES_DIR + "/swagger/auth-basic-local-converted.yaml"
result = self._get_tmp()
options = FakeOptions(file_name=result)
process(options, [source])
# shutil.copy(result, expected)
actual = yaml.full_load(open(result).read())
expected = yaml.full_load(open(expected).read())
self.assertEqual(actual, expected)
def test_convert_security_apikey_query(self):
source = RESOURCES_DIR + "/swagger/auth-key-as-param.json"
expected = RESOURCES_DIR + "/swagger/auth-key-as-param-converted.yaml"
result = self._get_tmp()
options = FakeOptions(file_name=result)
process(options, [source])
# shutil.copy(result, expected)
actual = yaml.full_load(open(result).read())
expected = yaml.full_load(open(expected).read())
self.assertEqual(actual, expected)
def test_convert_interpolation_values(self):
source = RESOURCES_DIR + "/swagger/bzm-api.json"
expected = RESOURCES_DIR + "/swagger/bzm-converted-values.yaml"
result = self._get_tmp()
options = FakeOptions(file_name=result)
process(options, [source])
# shutil.copy(result, expected)
actual = yaml.full_load(open(result).read())
expected = yaml.full_load(open(expected).read())
self.assertEqual(actual, expected)
def test_convert_interpolation_variables(self):
source = RESOURCES_DIR + "/swagger/bzm-api.json"
expected = RESOURCES_DIR + "/swagger/bzm-converted-variables.yaml"
result = self._get_tmp()
options = FakeOptions(
file_name=result,
parameter_interpolation=Swagger.INTERPOLATE_WITH_JMETER_VARS)
process(options, [source])
# shutil.copy(result, expected)
actual = yaml.full_load(open(result).read())
expected = yaml.full_load(open(expected).read())
self.assertEqual(actual, expected)
def test_convert_interpolation_none(self):
source = RESOURCES_DIR + "/swagger/bzm-api.json"
expected = RESOURCES_DIR + "/swagger/bzm-converted-none.yaml"
result = self._get_tmp()
options = FakeOptions(
file_name=result,
parameter_interpolation=Swagger.INTERPOLATE_DISABLE)
process(options, [source])
# shutil.copy(result, expected)
actual = yaml.full_load(open(result).read())
expected = yaml.full_load(open(expected).read())
self.assertEqual(actual, expected)
def test_convert_security_apikey_multiscenarios(self):
source = RESOURCES_DIR + "/swagger/auth-key.json"
expected = RESOURCES_DIR + "/swagger/auth-key-multiscenarios-converted.yaml"
result = self._get_tmp()
options = FakeOptions(file_name=result, scenarios_from_paths=True)
process(options, [source])
# shutil.copy(result, expected)
actual = yaml.full_load(open(result).read())
expected = yaml.full_load(open(expected).read())
self.assertEqual(actual, expected)
class TestConverter(BZTestCase):
def setUp(self):
super(TestConverter, self).setUp()
self.engine = EngineEmul()
self.obj = JMX2YAML(file_name=None, options=FakeOptions())
def configure(self, src_file, dst_file=None, dump_jmx=None):
self.obj.src_file = src_file
self.obj.options = FakeOptions(file_name=dst_file, dump_jmx=dump_jmx)
def tearDown(self):
if self.obj.dst_file and os.path.isfile(self.obj.dst_file):
os.remove(self.obj.dst_file)
super(TestConverter, self).tearDown()
@staticmethod
def same_yaml(file1, file2):
yml1 = yaml.load(open(file1).read())
yml2 = yaml.load(open(file2).read())
return yml1 == yml2
def _get_tmp(self, prefix='test', suffix='.yml'):
return self.engine.create_artifact(prefix, suffix)
def test_objprop(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/http.jmx", self._get_tmp())
self.sniff_log(self.obj.log)
self.obj.process()
self.assertNotIn("Removing unknown element: name (None)", self.log_recorder.warn_buff.getvalue())
self.assertNotIn("Removing unknown element: value (None)", self.log_recorder.warn_buff.getvalue())
def test_loadjmx1(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/http.jmx", self._get_tmp())
self.sniff_log(self.obj.log)
self.obj.process()
self.assertIn("Loading jmx file", self.log_recorder.info_buff.getvalue())
self.assertNotEqual("", self.log_recorder.debug_buff.getvalue())
self.assertEqual("", self.log_recorder.err_buff.getvalue())
def test_loadjmx2(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/notfound.jmx")
self.sniff_log(self.obj.log)
try:
self.obj.process()
self.fail()
except BaseException as exc:
self.assertIn("File does not exist", exc.args[0])
self.assertIn("Loading jmx file", self.log_recorder.info_buff.getvalue())
self.assertEqual("", self.log_recorder.debug_buff.getvalue())
def test_loadjmx3(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/broken.jmx")
self.sniff_log(self.obj.log)
try:
self.obj.process()
self.fail()
except BaseException as exc:
self.assertIn("XML parsing failed", exc.args[0])
self.assertIn("Loading jmx file", self.log_recorder.info_buff.getvalue())
self.assertIn("Error while processing jmx file", self.log_recorder.err_buff.getvalue())
def test_loadjmx4(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/http.jmx", self._get_tmp('tmp', 'file'))
self.sniff_log(self.obj.log)
self.obj.process()
self.assertIn("Loading jmx file", self.log_recorder.info_buff.getvalue())
self.assertIn("Done processing, result saved in", self.log_recorder.info_buff.getvalue())
self.assertIn("Removing unknown element", self.log_recorder.warn_buff.getvalue())
def test_export_clean_jmx(self):
tmp_jmx_name = self._get_tmp('tmp', '.jmx')
open(tmp_jmx_name, 'w+').close() # touch file
self.configure(RESOURCES_DIR + "yaml/converter/disabled.jmx", dump_jmx=tmp_jmx_name)
self.sniff_log(self.obj.log)
self.obj.process()
self.assertIn("Loading jmx file", self.log_recorder.info_buff.getvalue())
self.assertIn("already exists and will be overwritten", self.log_recorder.warn_buff.getvalue())
def test_not_jmx(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/not-jmx.xml")
try:
self.obj.process()
self.fail()
except BaseException as exc:
self.assertIn("Bad jmx format", exc.args[0])
def test_clean_disabled_jmx(self):
self.configure(RESOURCES_DIR + "yaml/converter/disabled.jmx", self._get_tmp())
self.obj.process()
disabled_elements = [element for element in self.obj.converter.dialect.tree.iter() if
element.get("enabled") == "false"]
self.assertEquals(0, len(disabled_elements))
def test_copy_global_csv_dataset(self):
self.configure(RESOURCES_DIR + "yaml/converter/global_copy.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
datasets_first_tg = yml.get("scenarios").get("Thread Group one").get("data-sources")
datasets_second_tg = yml.get("scenarios").get("Thread Group two").get("data-sources")
global_csv_tg_one = [dataset for dataset in datasets_first_tg if dataset.get('path') == 'global.csv']
global_csv_tg_two = [dataset for dataset in datasets_second_tg if dataset.get('path') == 'global.csv']
local_csv_tg_one = [dataset for dataset in datasets_first_tg if dataset.get('path') == 'local.csv']
local_csv_tg_two = [dataset for dataset in datasets_second_tg if dataset.get('path') == 'local.csv']
self.assertEqual(len(global_csv_tg_one), len(global_csv_tg_two), 1)
self.assertEqual(len(local_csv_tg_one), 1)
self.assertEqual(len(local_csv_tg_two), 0)
def test_parse_csv_dataset(self):
self.configure(RESOURCES_DIR + "yaml/converter/global_copy.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
datasets = yml.get("scenarios").get("Thread Group one").get("data-sources")
local_csv = [dataset for dataset in datasets if dataset.get('path') == 'local.csv'][0]
self.assertEqual(local_csv['loop'], False)
self.assertEqual(local_csv['delimiter'], ',')
self.assertEqual(local_csv['quoted'], False)
def test_copy_global_headers(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/global_copy.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
headers_first_tg = yml.get("scenarios").get("Thread Group one").get("headers", [])
headers_second_tg = yml.get("scenarios").get("Thread Group two").get("headers", [])
self.assertEqual(len(headers_first_tg), 3)
self.assertEqual(len(headers_second_tg), 2)
def test_cache_cookie_dns_overrides(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/global_copy.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
cache_first_tg = tg_one.get("store-cache")
cache_second_tg = tg_two.get("store-cache")
cookie_first_tg = tg_one.get("store-cookie")
cookie_second_tg = tg_two.get("store-cookie")
dns_cache_mgr_first_tg = tg_one.get("use-dns-cache-mgr")
dns_cache_mgr_second_tg = tg_two.get("use-dns-cache-mgr")
self.assertEqual(cache_first_tg, True)
self.assertEqual(cache_second_tg, True)
self.assertEqual(cookie_first_tg, False)
self.assertEqual(cookie_second_tg, True)
self.assertEqual(dns_cache_mgr_first_tg, True)
self.assertEqual(dns_cache_mgr_second_tg, True)
def test_think_time_overrides(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/global_copy.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
request_tg_two = tg_two.get("requests")[0]
tg_one_timer = tg_one.get("think-time")
tg_two_timer = tg_two.get("think-time")
req_timer = request_tg_two.get("think-time")
self.assertEqual(tg_one_timer, "200ms")
self.assertEqual(tg_two_timer, "300ms")
self.assertEqual(req_timer, "100ms")
def test_request_defaults(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/global_copy.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
self.assertEqual(tg_one.get("default-address"), "https://127.0.0.2/")
self.assertEqual(tg_two.get("default-address"), "http://127.0.0.3:2582/resources/")
self.assertEqual(tg_one.get("timeout"), "500ms")
self.assertEqual(tg_two.get("timeout"), "100ms")
self.assertEqual(tg_one.get("retrieve-resources"), True)
self.assertEqual(tg_two.get("retrieve-resources"), True)
self.assertEqual(tg_one.get("concurrent-pool-size"), 5)
self.assertEqual(tg_two.get("concurrent-pool-size"), 10)
def test_copy_global_request_assertions(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/assertions.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_assertions = tg_one.get("assert")
self.assertEqual(len(tg_one_assertions), 2) # global assertion + tg assertion
tg_two_assertions = tg_two.get("assert")
self.assertEqual(len(tg_two_assertions), 1) # global only assertion
tg_one_req_one_assertion = tg_one.get("requests")[0].get("assert")[0]
expected = {"subject": "headers", "contains": ["tg1httpreq1", "tg1httpreq12"],
"assume-success": False, "not": False, "regexp": False}
self.assertEqual(tg_one_req_one_assertion, expected)
tg_one_assertion = tg_one.get("assert")[0]
expected = {"subject": "body", "contains": ["tg1body_text_not_contains"],
"assume-success": False, "not": True, 'regexp': False}
self.assertEqual(tg_one_assertion, expected)
def test_broken_request_assertions(self):
# see comments in broken_resp_asserts.jmx for explanation of cases
# don't save broken_resp_asserts.jmx by jmeter
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/broken_resp_asserts.jmx", yml)
self.obj.process()
yml1 = RESOURCES_DIR + "yaml/converter/broken_resp_asserts.yml"
yml2 = yml
self.assertTrue(yml1, yml2)
def test_copy_global_json_assertions(self):
self.configure(RESOURCES_DIR + "yaml/converter/assertions.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_assertions = tg_one.get("assert-jsonpath")
self.assertEqual(len(tg_one_assertions), 1) # global assertion + tg assertion
tg_two_assertions = tg_two.get("assert-jsonpath")
self.assertEqual(len(tg_two_assertions), 1) # global only assertion
tg_one_req_one_jp = tg_one.get("requests")[0].get("assert-jsonpath", []) # no assertions
self.assertEqual(len(tg_one_req_one_jp), 0)
tg_two_req_one_jp = tg_two.get("requests")[0].get("assert-jsonpath", [])
self.assertEqual(len(tg_two_req_one_jp), 1)
expected = {"expect-null": True, "invert": True, "jsonpath": '$(":input")', "validate": True, "regexp": True}
self.assertEqual(expected, tg_two_req_one_jp[0])
# test concurrency, ramp-up, iterations in execution
tg_one_exec = yml.get(ScenarioExecutor.EXEC)[0]
tg_two_exec = yml.get(ScenarioExecutor.EXEC)[1]
tg_three_exec = yml.get(ScenarioExecutor.EXEC)[2]
self.assertEqual(tg_one_exec.get("concurrency"), 10)
self.assertEqual(tg_two_exec.get("concurrency"), 15)
self.assertEqual(tg_three_exec.get("concurrency"), 1)
self.assertEqual(tg_one_exec.get("ramp-up"), '10s')
self.assertEqual(tg_two_exec.get("ramp-up"), '60s')
self.assertEqual(tg_three_exec.get("ramp-up"), '2s')
self.assertEqual(tg_one_exec.get("iterations"), 1)
self.assertEqual(tg_two_exec.get("iterations"), 1)
self.assertEqual(tg_three_exec.get("iterations"), 100)
def test_xpath_assertions(self):
self.configure(RESOURCES_DIR + "yaml/converter/assertions.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
tg = yml.get("scenarios").get("tg3")
assertions = tg.get("assert-xpath")
self.assertEqual(len(assertions), 2)
self.assertEqual(assertions[0], {
"xpath": "/note/to",
"ignore-whitespace": False,
"invert": False,
"validate-xml": False,
"use-tolerant-parser": False,
})
self.assertEqual(assertions[1], {
"xpath": "/note/from",
"ignore-whitespace": True,
"invert": True,
"validate-xml": True,
"use-tolerant-parser": True,
})
def test_extractors(self):
self.configure(RESOURCES_DIR + "yaml/converter/extractors.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_three = yml.get("scenarios").get("tg3")
tg_one_extractors = tg_one.get("extract-regexp")
tg_two_extractors = tg_two.get("extract-regexp")
self.assertEqual(len(tg_one_extractors), 1) # global
self.assertEqual(len(tg_two_extractors), 1) # global + local - ignored
tg_one_req_exr = tg_one.get("requests")[0].get("extract-regexp", {})
self.assertEqual(len(tg_one_req_exr), 2)
expected = {'template': '1', 'match-no': 1, 'regexp': '*tg1hr1', 'default': 'default'}
self.assertEqual(expected, tg_one_req_exr.get("test_tg1hr1"))
# test extract-jsonpath
tg_one_extractors = tg_one.get("extract-jsonpath")
tg_two_extractors = tg_two.get("extract-jsonpath")
self.assertEqual(len(tg_one_extractors), 5) # 4x global + local
self.assertEqual(len(tg_two_extractors), 4) # 4x global
tg_three_req_exr = tg_three.get("requests")[0].get("extract-jsonpath", {})
self.assertEqual(len(tg_three_req_exr), 1) # 1x local
# test extract-xpath
tg_three_extractors = tg_three.get("extract-xpath")
self.assertEqual(len(tg_three_extractors), 2) # 2 global
self.assertEqual(tg_three_extractors['bookAuthor'], {
"xpath": "/books/[@title()='1984']/author",
"default": "no_author",
"ignore-whitespace": False,
"validate-xml": False,
"use-tolerant-parser": False,
})
self.assertEqual(tg_three_extractors['author'], {
"xpath": "/books/[@title()='Fahrenheit 451']/author",
"default": "no",
"ignore-whitespace": True,
"validate-xml": True,
"use-tolerant-parser": False,
})
self.assertEqual(tg_one_extractors['VAR1'], {
"jsonpath": "$.foo",
"default": "DEF_1",
})
self.assertEqual(tg_one_extractors['VAR2'], {
"jsonpath": "$.bar",
"default": "DEF_2",
})
def test_request_body(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/extractors.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_req_one_body = tg_one.get("requests")[0].get("body")
self.assertEqual(tg_one_req_one_body, "body-string")
tg_one_req_one_body = tg_one.get("requests")[1].get("body")
self.assertEqual(tg_one_req_one_body, {"body_param1": "value1", "body_param2": "value2"})
tg_two_req_one_body = tg_two.get("requests")[0].get("body")
self.assertEqual(tg_two_req_one_body, None)
def test_json_body(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/json_body.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
reqs1 = yml.get("scenarios").get("tg1")['requests']
reqs2 = yml.get("scenarios").get("tg2")['requests']
bodies = {req['label']: req.get('body', None) for req in reqs1 + reqs2}
targets = {'r1_1': None, 'r1_2': list, 'r1_3': str, 'r1_4': dict,
'r2_1': None, 'r2_2': dict, 'r2_3': str, 'r2_4': str}
for label in targets:
self.assertTrue((bodies[label] is None and targets[label] is None)
or isinstance(bodies[label], targets[label]))
def test_duration_throughput(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/duration.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get(ScenarioExecutor.EXEC)[0]
tg_two = yml.get(ScenarioExecutor.EXEC)[1]
tg_three = yml.get(ScenarioExecutor.EXEC)[2]
self.assertEqual("10s", tg_one.get("ramp-up"))
self.assertEqual("60s", tg_one.get("hold-for"))
self.assertEqual("10s", tg_one.get("ramp-up"))
self.assertEqual(100, tg_one.get("throughput"))
self.assertEqual("10s", tg_two.get("ramp-up"))
self.assertEqual("20s", tg_two.get("hold-for"))
self.assertEqual(20, tg_two.get("throughput"))
self.assertEqual("60s", tg_three.get("ramp-up"))
self.assertEqual("40s", tg_three.get("hold-for"))
self.assertEqual(100, tg_three.get("throughput"))
def test_all(self):
self.configure(RESOURCES_DIR + "yaml/converter/disabled.jmx")
self.obj.process()
yml1 = RESOURCES_DIR + "yaml/converter/disabled.yml"
yml2 = self.obj.dst_file
self.assertTrue(self.same_yaml(yml1, yml2))
def test_params_conversion(self):
self.configure(RESOURCES_DIR + "yaml/converter/params_conversion.jmx")
self.sniff_log(self.obj.log)
self.obj.process()
yml1 = self.obj.dst_file
yml2 = RESOURCES_DIR + "yaml/converter/params_conversion.yml"
self.assertTrue(self.same_yaml(yml1, yml2))
self.assertNotIn('n1', self.log_recorder.warn_buff.getvalue())
self.assertNotIn('n2', self.log_recorder.warn_buff.getvalue())
self.assertIn('n1_101', self.log_recorder.debug_buff.getvalue())
self.assertIn('n1_011', self.log_recorder.debug_buff.getvalue())
self.assertIn('n1_001', self.log_recorder.debug_buff.getvalue())
def test_param_null(self):
self.configure(RESOURCES_DIR + "yaml/converter/param-null.jmx")
self.obj.process()
def test_load_profile_default_values(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/default.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
execution = yml.get(ScenarioExecutor.EXEC)[0]
self.assertEqual("60s", execution.get("ramp-up"))
self.assertEqual("60s", execution.get("hold-for"))
self.assertEqual(1, execution.get("concurrency"))
self.assertEqual(1, execution.get("iterations"))
def test_variables(self):
self.configure(RESOURCES_DIR + "yaml/converter/vars.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
scenarios = yml.get("scenarios")
tg_one = scenarios["TG1"]
self.assertEqual(tg_one.get('variables'),
{"tg1_local": "tg1", "global_var": "global", "auth_token": "shouldn't be masked"})
tg_two = scenarios["TG2"]
self.assertEqual(tg_two.get('variables'),
{"tg2_local": "tg2", "global_var": "global", "auth_token": "shouldn't be masked"})
def test_no_variables(self):
self.configure(RESOURCES_DIR + "yaml/converter/default.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
execution = yml.get(ScenarioExecutor.EXEC)[0]
scenarios = yml.get("scenarios")
scenario = scenarios[execution.get("scenario")]
self.assertNotIn("variables", scenario)
def test_controllers_to_requests(self):
self.configure(RESOURCES_DIR + "yaml/converter/controllers.jmx")
self.obj.process()
yml1 = RESOURCES_DIR + "yaml/converter/controllers.yml"
yml2 = self.obj.dst_file
self.assertTrue(self.same_yaml(yml1, yml2))
def test_jsr223(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/jsr223.jmx")
try:
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
scenarios = yml.get("scenarios")
scenario = scenarios["Thread Group"]
requests = scenario["requests"]
self.assertEqual(len(requests), 1)
request = requests[0]
self.assertIn("jsr223", request)
jsrs = request["jsr223"]
self.assertIsInstance(jsrs, list)
self.assertEqual(len(jsrs), 5)
self.assertEqual(jsrs[0]["language"], "beanshell")
self.assertEqual(jsrs[0]["script-text"], "scripty")
self.assertEqual(jsrs[0]["parameters"], "parames")
self.assertNotIn('script-file', jsrs[0])
self.assertEqual(jsrs[1]["language"], "javascript")
self.assertEqual(jsrs[1]["script-text"], u'console.log("ПРИВЕТ");\nline("2");')
self.assertEqual(jsrs[1]["parameters"], "a b c")
self.assertNotIn('script-file', jsrs[1])
self.assertEqual(jsrs[2]["language"], "javascript")
self.assertEqual(jsrs[2]["script-file"], "script.js")
self.assertEqual(jsrs[2]["parameters"], None)
self.assertNotIn('script-text', jsrs[2])
self.assertEqual(jsrs[3]["language"], "beanshell")
self.assertEqual(jsrs[3]["execute"], "before")
self.assertEqual(jsrs[3]["parameters"], None)
self.assertEqual(jsrs[3]['script-text'], 'console.log("beanshell aka jsr223");')
self.assertNotIn('script-file', jsrs[3])
self.assertEqual(jsrs[4]["language"], "java")
self.assertEqual(jsrs[4]["execute"], "before")
self.assertEqual(jsrs[4]["parameters"], None)
self.assertIn('BlazeDemo.java', jsrs[4]['script-file'])
self.assertNotIn('script-text', jsrs[4])
self.assertTrue(os.path.exists(os.path.join(get_full_path(self.obj.dst_file, step_up=1), 'script.js')))
finally:
os.remove(os.path.join(get_full_path(self.obj.dst_file, step_up=1), 'script.js'))
def test_unicode(self):
self.configure(RESOURCES_DIR + "yaml/converter/unicode.jmx")
self.obj.process()
def test_path_without_domain(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/http.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
scenarios = yml.get("scenarios")
scenario = scenarios["Thread Group"]
requests = scenario["requests"]
self.assertEqual(len(requests), 3)
without_domain = requests[2]
self.assertEqual(without_domain['url'], '/path')
def test_request_content_encoding(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/http.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
scenarios = yml.get("scenarios")
scenario = scenarios["Thread Group"]
requests = scenario["requests"]
self.assertEqual(len(requests), 3)
request = requests[1]
self.assertEqual(request['content-encoding'], 'utf-8')
def test_request_redirect_policy(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/http.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
scenarios = yml.get("scenarios")
scenario = scenarios["Thread Group"]
requests = scenario["requests"]
self.assertEqual(len(requests), 3)
self.assertEqual(requests[0].get('follow-redirects'), True)
self.assertEqual(requests[1].get('follow-redirects'), True)
self.assertEqual(requests[2].get('follow-redirects'), False)
class TestConverter(BZTestCase):
def setUp(self):
self.engine = EngineEmul()
def _get_jmx2yaml(self, path, file_name=None, dump_jmx=False):
return JMX2YAML(FakeOptions(file_name=file_name, dump_jmx=dump_jmx),
__dir__() + path)
def _get_tmp(self, prefix='test', suffix='.yml'):
return self.engine.create_artifact(prefix, suffix)
def test_loadjmx1(self):
log_recorder = RecordingHandler()
obj = self._get_jmx2yaml("/jmx/http.jmx", self._get_tmp())
obj.log.addHandler(log_recorder)
obj.process()
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertNotEqual("", log_recorder.debug_buff.getvalue())
self.assertEqual("", log_recorder.err_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_loadjmx2(self):
log_recorder = RecordingHandler()
obj = self._get_jmx2yaml("/jmx/notfound.jmx")
obj.log.addHandler(log_recorder)
try:
obj.process()
self.fail()
except BaseException as exc:
self.assertIn("File does not exist", exc.args[0])
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertIn("does not exist", log_recorder.err_buff.getvalue())
self.assertEqual("", log_recorder.debug_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_loadjmx3(self):
log_recorder = RecordingHandler()
obj = self._get_jmx2yaml("/jmx/broken.jmx")
obj.log.addHandler(log_recorder)
try:
obj.process()
self.fail()
except BaseException as exc:
self.assertIn("XML parsing failed", exc.args[0])
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertIn("Error while processing jmx file",
log_recorder.err_buff.getvalue())
self.assertIn("XML parsing error", log_recorder.debug_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_loadjmx4(self):
log_recorder = RecordingHandler()
obj = self._get_jmx2yaml("/jmx/http.jmx", self._get_tmp('tmp', 'file'))
obj.log.addHandler(log_recorder)
obj.process()
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertIn("Done processing, result saved in",
log_recorder.info_buff.getvalue())
self.assertIn("Removing unknown element",
log_recorder.warn_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_export_clean_jmx(self):
tmp_jmx_name = self._get_tmp('tmp', '.jmx')
open(tmp_jmx_name, 'w+').close() # touch file
obj = self._get_jmx2yaml("/yaml/converter/disabled.jmx",
dump_jmx=tmp_jmx_name)
log_recorder = RecordingHandler()
obj.log.addHandler(log_recorder)
obj.process()
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertIn("already exists and will be overwritten",
log_recorder.warn_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_not_jmx(self):
obj = self._get_jmx2yaml("/jmx/not-jmx.xml")
try:
obj.process()
self.fail()
except BaseException as exc:
self.assertIn("Bad jmx format", exc.args[0])
def test_clean_disabled_jmx(self):
obj = self._get_jmx2yaml("/yaml/converter/disabled.jmx")
obj.process()
disabled_elements = [
element for element in obj.converter.dialect.tree.iter()
if element.get("enabled") == "false"
]
self.assertEquals(0, len(disabled_elements))
def test_copy_global_csv_dataset(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
datasets_first_tg = yml.get("scenarios").get("Thread Group one").get(
"data-sources")
datasets_second_tg = yml.get("scenarios").get("Thread Group two").get(
"data-sources")
global_csv_tg_one = [
dataset for dataset in datasets_first_tg
if dataset.get('path') == 'global.csv'
]
global_csv_tg_two = [
dataset for dataset in datasets_second_tg
if dataset.get('path') == 'global.csv'
]
local_csv_tg_one = [
dataset for dataset in datasets_first_tg
if dataset.get('path') == 'local.csv'
]
local_csv_tg_two = [
dataset for dataset in datasets_second_tg
if dataset.get('path') == 'local.csv'
]
self.assertEqual(len(global_csv_tg_one), len(global_csv_tg_two), 1)
self.assertEqual(len(local_csv_tg_one), 1)
self.assertEqual(len(local_csv_tg_two), 0)
def test_copy_global_headers(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
headers_first_tg = yml.get("scenarios").get("Thread Group one").get(
"headers", [])
headers_second_tg = yml.get("scenarios").get("Thread Group two").get(
"headers", [])
self.assertEqual(len(headers_first_tg), 3)
self.assertEqual(len(headers_second_tg), 2)
def test_cache_cookie_dns_overrides(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
cache_first_tg = tg_one.get("store-cache")
cache_second_tg = tg_two.get("store-cache")
cookie_first_tg = tg_one.get("store-cookie")
cookie_second_tg = tg_two.get("store-cookie")
dns_cache_mgr_first_tg = tg_one.get("use-dns-cache-mgr")
dns_cache_mgr_second_tg = tg_two.get("use-dns-cache-mgr")
self.assertEqual(cache_first_tg, True)
self.assertEqual(cache_second_tg, True)
self.assertEqual(cookie_first_tg, False)
self.assertEqual(cookie_second_tg, True)
self.assertEqual(dns_cache_mgr_first_tg, True)
self.assertEqual(dns_cache_mgr_second_tg, True)
def test_think_time_overrides(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
request_tg_two = tg_two.get("requests")[0]
tg_one_timer = tg_one.get("think-time")
tg_two_timer = tg_two.get("think-time")
req_timer = request_tg_two.get("think-time")
self.assertEqual(tg_one_timer, "200ms")
self.assertEqual(tg_two_timer, "300ms")
self.assertEqual(req_timer, "100ms")
def test_request_defaults(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
self.assertEqual(tg_one.get("default-address"), "https://127.0.0.2/")
self.assertEqual(tg_two.get("default-address"),
"http://127.0.0.3:2582/resources/")
self.assertEqual(tg_one.get("timeout"), "500ms")
self.assertEqual(tg_two.get("timeout"), "100ms")
self.assertEqual(tg_one.get("retrieve-resources"), True)
self.assertEqual(tg_two.get("retrieve-resources"), True)
self.assertEqual(tg_one.get("concurrent-pool-size"), 5)
self.assertEqual(tg_two.get("concurrent-pool-size"), 10)
def test_copy_global_request_assertions(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/assertions.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_assertions = tg_one.get("assert")
self.assertEqual(len(tg_one_assertions),
2) # global assertion + tg assertion
tg_two_assertions = tg_two.get("assert")
self.assertEqual(len(tg_two_assertions), 1) # global only assertion
tg_one_req_one_assertion = tg_one.get("requests")[0].get("assert")[0]
expected = {
'subject': 'headers',
'contains': ["tg1httpreq1", "tg1httpreq12"],
"not": False,
'regexp': True
}
self.assertEqual(tg_one_req_one_assertion, expected)
tg_one_assertion = tg_one.get("assert")[0]
expected = {
'subject': 'body',
'contains': ["tg1body_text_not_contains"],
"not": True,
'regexp': True
}
self.assertEqual(tg_one_assertion, expected)
def test_copy_global_json_assertions(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/assertions.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_assertions = tg_one.get("assert-jsonpath")
self.assertEqual(len(tg_one_assertions),
1) # global assertion + tg assertion
tg_two_assertions = tg_two.get("assert-jsonpath")
self.assertEqual(len(tg_two_assertions), 1) # global only assertion
tg_one_req_one_jp = tg_one.get("requests")[0].get(
"assert-jsonpath", []) # no assertions
self.assertEqual(len(tg_one_req_one_jp), 0)
tg_two_req_one_jp = tg_two.get("requests")[0].get(
"assert-jsonpath", [])
self.assertEqual(len(tg_two_req_one_jp), 1)
expected = {
"expect-null": True,
"invert": True,
"jsonpath": '$(":input")',
"validate": True
}
self.assertEqual(expected, tg_two_req_one_jp[0])
# test concurrency, ramp-up, iterations in execution
tg_one_exec = yml.get(ScenarioExecutor.EXEC)[0]
tg_two_exec = yml.get(ScenarioExecutor.EXEC)[1]
tg_three_exec = yml.get(ScenarioExecutor.EXEC)[2]
self.assertEqual(tg_one_exec.get("concurrency"), 10)
self.assertEqual(tg_two_exec.get("concurrency"), 15)
self.assertEqual(tg_three_exec.get("concurrency"), None)
self.assertEqual(tg_one_exec.get("ramp-up"), '10s')
self.assertEqual(tg_two_exec.get("ramp-up"), None)
self.assertEqual(tg_three_exec.get("ramp-up"), '2s')
self.assertEqual(tg_one_exec.get("iterations"), None)
self.assertEqual(tg_two_exec.get("iterations"), None)
self.assertEqual(tg_three_exec.get("iterations"), 100)
def test_extractors(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/extractors.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_three = yml.get("scenarios").get("tg3")
tg_one_extractors = tg_one.get("extract-regexp")
tg_two_extractors = tg_two.get("extract-regexp")
self.assertEqual(len(tg_one_extractors), 1) # global
self.assertEqual(len(tg_two_extractors), 1) # global + local - ignored
tg_one_req_exr = tg_one.get("requests")[0].get("extract-regexp", {})
self.assertEqual(len(tg_one_req_exr), 2)
expected = {
'template': '1',
'match-no': 1,
'regexp': '*tg1hr1',
'default': 'default'
}
self.assertEqual(expected, tg_one_req_exr.get("test_tg1hr1"))
# test extract-jsonpath
tg_one_extractors = tg_one.get("extract-jsonpath")
tg_two_extractors = tg_two.get("extract-jsonpath")
self.assertEqual(len(tg_one_extractors), 3) # 2x global + local
self.assertEqual(len(tg_two_extractors), 2) # 2x global
tg_three_req_exr = tg_three.get("requests")[0].get(
"extract-jsonpath", {})
self.assertEqual(len(tg_three_req_exr), 1) # 1x local
def test_request_body(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/extractors.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_req_one_body = tg_one.get("requests")[0].get("body")
self.assertEqual(tg_one_req_one_body, "body-string")
tg_one_req_one_body = tg_one.get("requests")[1].get("body")
self.assertEqual(tg_one_req_one_body, {
"body_param1": "value1",
"body_param2": "value2"
})
tg_two_req_one_body = tg_two.get("requests")[0].get("body")
self.assertEqual(tg_two_req_one_body, None)
def test_duration_throughput(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/duration.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get(ScenarioExecutor.EXEC)[0]
tg_two = yml.get(ScenarioExecutor.EXEC)[1]
tg_three = yml.get(ScenarioExecutor.EXEC)[2]
self.assertEqual("10s", tg_one.get("ramp-up"))
self.assertEqual(None, tg_one.get("hold-for"))
self.assertEqual("10s", tg_one.get("ramp-up"))
self.assertEqual(100, tg_one.get("throughput"))
self.assertEqual("10s", tg_two.get("ramp-up"))
self.assertEqual("20s", tg_two.get("hold-for"))
self.assertEqual(20, tg_two.get("throughput"))
self.assertEqual(None, tg_three.get("ramp-up"))
self.assertEqual("40s", tg_three.get("hold-for"))
self.assertEqual(100, tg_three.get("throughput"))
def test_all(self):
obj = self._get_jmx2yaml("/yaml/converter/disabled.jmx",
self._get_tmp())
obj.process()
yml = yaml.load(
open(__dir__() + "/yaml/converter/disabled.yml").read())
self.assertEqual(obj.converter.convert(obj.file_to_convert), yml)
def test_param_null(self):
obj = self._get_jmx2yaml("/yaml/converter/param-null.jmx",
self._get_tmp())
obj.process()
obj.converter.convert(obj.file_to_convert)
def temp_yaml(self):
emul = EngineEmul()
return emul.create_artifact("test", ".yml")
class TestConverter(BZTestCase):
def setUp(self):
self.engine = EngineEmul()
def _get_jmx2yaml(self, path, file_name=None, dump_jmx=False):
return JMX2YAML(FakeOptions(file_name=file_name, dump_jmx=dump_jmx), __dir__() + path)
def _get_tmp(self, prefix='test', suffix='.yml'):
return self.engine.create_artifact(prefix, suffix)
def test_loadjmx1(self):
log_recorder = RecordingHandler()
obj = self._get_jmx2yaml("/jmeter/jmx/http.jmx", self._get_tmp())
obj.log.addHandler(log_recorder)
obj.process()
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertNotEqual("", log_recorder.debug_buff.getvalue())
self.assertEqual("", log_recorder.err_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_loadjmx2(self):
log_recorder = RecordingHandler()
obj = self._get_jmx2yaml("/jmeter/jmx/notfound.jmx")
obj.log.addHandler(log_recorder)
try:
obj.process()
self.fail()
except BaseException as exc:
self.assertIn("File does not exist", exc.args[0])
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertIn("does not exist", log_recorder.err_buff.getvalue())
self.assertEqual("", log_recorder.debug_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_loadjmx3(self):
log_recorder = RecordingHandler()
obj = self._get_jmx2yaml("/jmeter/jmx/broken.jmx")
obj.log.addHandler(log_recorder)
try:
obj.process()
self.fail()
except BaseException as exc:
self.assertIn("XML parsing failed", exc.args[0])
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertIn("Error while processing jmx file", log_recorder.err_buff.getvalue())
self.assertIn("XML parsing error", log_recorder.debug_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_loadjmx4(self):
log_recorder = RecordingHandler()
obj = self._get_jmx2yaml("/jmeter/jmx/http.jmx", self._get_tmp('tmp', 'file'))
obj.log.addHandler(log_recorder)
obj.process()
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertIn("Done processing, result saved in", log_recorder.info_buff.getvalue())
self.assertIn("Removing unknown element", log_recorder.warn_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_export_clean_jmx(self):
tmp_jmx_name = self._get_tmp('tmp', '.jmx')
open(tmp_jmx_name, 'w+').close() # touch file
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/disabled.jmx", yml, dump_jmx=tmp_jmx_name)
log_recorder = RecordingHandler()
obj.log.addHandler(log_recorder)
obj.process()
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertIn("already exists and will be overwritten", log_recorder.warn_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_not_jmx(self):
obj = self._get_jmx2yaml("/jmeter/jmx/not-jmx.xml")
try:
obj.process()
self.fail()
except BaseException as exc:
self.assertIn("Bad jmx format", exc.args[0])
def test_clean_disabled_jmx(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/disabled.jmx", yml)
obj.process()
disabled_elements = [element for element in obj.converter.dialect.tree.iter() if
element.get("enabled") == "false"]
self.assertEquals(0, len(disabled_elements))
def test_copy_global_csv_dataset(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
datasets_first_tg = yml.get("scenarios").get("Thread Group one").get("data-sources")
datasets_second_tg = yml.get("scenarios").get("Thread Group two").get("data-sources")
global_csv_tg_one = [dataset for dataset in datasets_first_tg if dataset.get('path') == 'global.csv']
global_csv_tg_two = [dataset for dataset in datasets_second_tg if dataset.get('path') == 'global.csv']
local_csv_tg_one = [dataset for dataset in datasets_first_tg if dataset.get('path') == 'local.csv']
local_csv_tg_two = [dataset for dataset in datasets_second_tg if dataset.get('path') == 'local.csv']
self.assertEqual(len(global_csv_tg_one), len(global_csv_tg_two), 1)
self.assertEqual(len(local_csv_tg_one), 1)
self.assertEqual(len(local_csv_tg_two), 0)
def test_copy_global_headers(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
headers_first_tg = yml.get("scenarios").get("Thread Group one").get("headers", [])
headers_second_tg = yml.get("scenarios").get("Thread Group two").get("headers", [])
self.assertEqual(len(headers_first_tg), 3)
self.assertEqual(len(headers_second_tg), 2)
def test_cache_cookie_dns_overrides(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
cache_first_tg = tg_one.get("store-cache")
cache_second_tg = tg_two.get("store-cache")
cookie_first_tg = tg_one.get("store-cookie")
cookie_second_tg = tg_two.get("store-cookie")
dns_cache_mgr_first_tg = tg_one.get("use-dns-cache-mgr")
dns_cache_mgr_second_tg = tg_two.get("use-dns-cache-mgr")
self.assertEqual(cache_first_tg, True)
self.assertEqual(cache_second_tg, True)
self.assertEqual(cookie_first_tg, False)
self.assertEqual(cookie_second_tg, True)
self.assertEqual(dns_cache_mgr_first_tg, True)
self.assertEqual(dns_cache_mgr_second_tg, True)
def test_think_time_overrides(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
request_tg_two = tg_two.get("requests")[0]
tg_one_timer = tg_one.get("think-time")
tg_two_timer = tg_two.get("think-time")
req_timer = request_tg_two.get("think-time")
self.assertEqual(tg_one_timer, "200ms")
self.assertEqual(tg_two_timer, "300ms")
self.assertEqual(req_timer, "100ms")
def test_request_defaults(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
self.assertEqual(tg_one.get("default-address"), "https://127.0.0.2/")
self.assertEqual(tg_two.get("default-address"), "http://127.0.0.3:2582/resources/")
self.assertEqual(tg_one.get("timeout"), "500ms")
self.assertEqual(tg_two.get("timeout"), "100ms")
self.assertEqual(tg_one.get("retrieve-resources"), True)
self.assertEqual(tg_two.get("retrieve-resources"), True)
self.assertEqual(tg_one.get("concurrent-pool-size"), 5)
self.assertEqual(tg_two.get("concurrent-pool-size"), 10)
def test_copy_global_request_assertions(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/assertions.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_assertions = tg_one.get("assert")
self.assertEqual(len(tg_one_assertions), 2) # global assertion + tg assertion
tg_two_assertions = tg_two.get("assert")
self.assertEqual(len(tg_two_assertions), 1) # global only assertion
tg_one_req_one_assertion = tg_one.get("requests")[0].get("assert")[0]
expected = {'subject': 'headers', 'contains': ["tg1httpreq1", "tg1httpreq12"], "not": False, 'regexp': True}
self.assertEqual(tg_one_req_one_assertion, expected)
tg_one_assertion = tg_one.get("assert")[0]
expected = {'subject': 'body', 'contains': ["tg1body_text_not_contains"], "not": True, 'regexp': True}
self.assertEqual(tg_one_assertion, expected)
def test_copy_global_json_assertions(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/assertions.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_assertions = tg_one.get("assert-jsonpath")
self.assertEqual(len(tg_one_assertions), 1) # global assertion + tg assertion
tg_two_assertions = tg_two.get("assert-jsonpath")
self.assertEqual(len(tg_two_assertions), 1) # global only assertion
tg_one_req_one_jp = tg_one.get("requests")[0].get("assert-jsonpath", []) # no assertions
self.assertEqual(len(tg_one_req_one_jp), 0)
tg_two_req_one_jp = tg_two.get("requests")[0].get("assert-jsonpath", [])
self.assertEqual(len(tg_two_req_one_jp), 1)
expected = {"expect-null": True, "invert": True, "jsonpath": '$(":input")', "validate": True}
self.assertEqual(expected, tg_two_req_one_jp[0])
# test concurrency, ramp-up, iterations in execution
tg_one_exec = yml.get(ScenarioExecutor.EXEC)[0]
tg_two_exec = yml.get(ScenarioExecutor.EXEC)[1]
tg_three_exec = yml.get(ScenarioExecutor.EXEC)[2]
self.assertEqual(tg_one_exec.get("concurrency"), 10)
self.assertEqual(tg_two_exec.get("concurrency"), 15)
self.assertEqual(tg_three_exec.get("concurrency"), None)
self.assertEqual(tg_one_exec.get("ramp-up"), '10s')
self.assertEqual(tg_two_exec.get("ramp-up"), None)
self.assertEqual(tg_three_exec.get("ramp-up"), '2s')
self.assertEqual(tg_one_exec.get("iterations"), None)
self.assertEqual(tg_two_exec.get("iterations"), None)
self.assertEqual(tg_three_exec.get("iterations"), 100)
def test_xpath_assertions(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/assertions.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg = yml.get("scenarios").get("tg3")
assertions = tg.get("assert-xpath")
self.assertEqual(len(assertions), 2)
self.assertEqual(assertions[0], {
"xpath": "/note/to",
"ignore-whitespace": False,
"invert": False,
"validate-xml": False,
"use-tolerant-parser": False,
})
self.assertEqual(assertions[1], {
"xpath": "/note/from",
"ignore-whitespace": True,
"invert": True,
"validate-xml": True,
"use-tolerant-parser": True,
})
def test_extractors(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/extractors.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_three = yml.get("scenarios").get("tg3")
tg_one_extractors = tg_one.get("extract-regexp")
tg_two_extractors = tg_two.get("extract-regexp")
self.assertEqual(len(tg_one_extractors), 1) # global
self.assertEqual(len(tg_two_extractors), 1) # global + local - ignored
tg_one_req_exr = tg_one.get("requests")[0].get("extract-regexp", {})
self.assertEqual(len(tg_one_req_exr), 2)
expected = {'template': '1', 'match-no': 1, 'regexp': '*tg1hr1', 'default': 'default'}
self.assertEqual(expected, tg_one_req_exr.get("test_tg1hr1"))
# test extract-jsonpath
tg_one_extractors = tg_one.get("extract-jsonpath")
tg_two_extractors = tg_two.get("extract-jsonpath")
self.assertEqual(len(tg_one_extractors), 3) # 2x global + local
self.assertEqual(len(tg_two_extractors), 2) # 2x global
tg_three_req_exr = tg_three.get("requests")[0].get("extract-jsonpath", {})
self.assertEqual(len(tg_three_req_exr), 1) # 1x local
# test extract-xpath
tg_three_extractors = tg_three.get("extract-xpath")
self.assertEqual(len(tg_three_extractors), 2) # 2 global
self.assertEqual(tg_three_extractors['bookAuthor'], {
"xpath": "/books/[@title()='1984']/author",
"default": "no_author",
"ignore-whitespace": False,
"validate-xml": False,
"use-tolerant-parser": False,
})
self.assertEqual(tg_three_extractors['author'], {
"xpath": "/books/[@title()='Fahrenheit 451']/author",
"default": "no",
"ignore-whitespace": True,
"validate-xml": True,
"use-tolerant-parser": False,
})
def test_request_body(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/extractors.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_req_one_body = tg_one.get("requests")[0].get("body")
self.assertEqual(tg_one_req_one_body, "body-string")
tg_one_req_one_body = tg_one.get("requests")[1].get("body")
self.assertEqual(tg_one_req_one_body, {"body_param1": "value1", "body_param2": "value2"})
tg_two_req_one_body = tg_two.get("requests")[0].get("body")
self.assertEqual(tg_two_req_one_body, None)
def test_duration_throughput(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/duration.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get(ScenarioExecutor.EXEC)[0]
tg_two = yml.get(ScenarioExecutor.EXEC)[1]
tg_three = yml.get(ScenarioExecutor.EXEC)[2]
self.assertEqual("10s", tg_one.get("ramp-up"))
self.assertEqual(None, tg_one.get("hold-for"))
self.assertEqual("10s", tg_one.get("ramp-up"))
self.assertEqual(100, tg_one.get("throughput"))
self.assertEqual("10s", tg_two.get("ramp-up"))
self.assertEqual("20s", tg_two.get("hold-for"))
self.assertEqual(20, tg_two.get("throughput"))
self.assertEqual(None, tg_three.get("ramp-up"))
self.assertEqual("40s", tg_three.get("hold-for"))
self.assertEqual(100, tg_three.get("throughput"))
def test_all(self):
obj = self._get_jmx2yaml("/yaml/converter/disabled.jmx", self._get_tmp())
obj.process()
yml = yaml.load(open(__dir__() + "/yaml/converter/disabled.yml").read())
self.assertEqual(obj.converter.convert(obj.file_to_convert), yml)
def test_param_null(self):
obj = self._get_jmx2yaml("/yaml/converter/param-null.jmx", self._get_tmp())
obj.process()
obj.converter.convert(obj.file_to_convert)
class TestConverter(BZTestCase):
def setUp(self):
self.engine = EngineEmul()
def _get_jmx2yaml(self, path, file_name=None, dump_jmx=False):
return JMX2YAML(FakeOptions(file_name=file_name, dump_jmx=dump_jmx),
__dir__() + path)
def _get_tmp(self, prefix='test', suffix='.yml'):
return self.engine.create_artifact(prefix, suffix)
def test_loadjmx1(self):
log_recorder = RecordingHandler()
obj = self._get_jmx2yaml("/jmeter/jmx/http.jmx", self._get_tmp())
obj.log.addHandler(log_recorder)
obj.process()
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertNotEqual("", log_recorder.debug_buff.getvalue())
self.assertEqual("", log_recorder.err_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_loadjmx2(self):
log_recorder = RecordingHandler()
obj = self._get_jmx2yaml("/jmeter/jmx/notfound.jmx")
obj.log.addHandler(log_recorder)
try:
obj.process()
self.fail()
except BaseException as exc:
self.assertIn("File does not exist", exc.args[0])
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertEqual("", log_recorder.debug_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_loadjmx3(self):
log_recorder = RecordingHandler()
obj = self._get_jmx2yaml("/jmeter/jmx/broken.jmx")
obj.log.addHandler(log_recorder)
try:
obj.process()
self.fail()
except BaseException as exc:
self.assertIn("XML parsing failed", exc.args[0])
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertIn("Error while processing jmx file",
log_recorder.err_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_loadjmx4(self):
log_recorder = RecordingHandler()
obj = self._get_jmx2yaml("/jmeter/jmx/http.jmx",
self._get_tmp('tmp', 'file'))
obj.log.addHandler(log_recorder)
obj.process()
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertIn("Done processing, result saved in",
log_recorder.info_buff.getvalue())
self.assertIn("Removing unknown element",
log_recorder.warn_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_export_clean_jmx(self):
tmp_jmx_name = self._get_tmp('tmp', '.jmx')
open(tmp_jmx_name, 'w+').close() # touch file
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/disabled.jmx",
yml,
dump_jmx=tmp_jmx_name)
log_recorder = RecordingHandler()
obj.log.addHandler(log_recorder)
obj.process()
self.assertIn("Loading jmx file", log_recorder.info_buff.getvalue())
self.assertIn("already exists and will be overwritten",
log_recorder.warn_buff.getvalue())
obj.log.removeHandler(log_recorder)
def test_not_jmx(self):
obj = self._get_jmx2yaml("/jmeter/jmx/not-jmx.xml")
try:
obj.process()
self.fail()
except BaseException as exc:
self.assertIn("Bad jmx format", exc.args[0])
def test_clean_disabled_jmx(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/disabled.jmx", yml)
obj.process()
disabled_elements = [
element for element in obj.converter.dialect.tree.iter()
if element.get("enabled") == "false"
]
self.assertEquals(0, len(disabled_elements))
def test_copy_global_csv_dataset(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
datasets_first_tg = yml.get("scenarios").get("Thread Group one").get(
"data-sources")
datasets_second_tg = yml.get("scenarios").get("Thread Group two").get(
"data-sources")
global_csv_tg_one = [
dataset for dataset in datasets_first_tg
if dataset.get('path') == 'global.csv'
]
global_csv_tg_two = [
dataset for dataset in datasets_second_tg
if dataset.get('path') == 'global.csv'
]
local_csv_tg_one = [
dataset for dataset in datasets_first_tg
if dataset.get('path') == 'local.csv'
]
local_csv_tg_two = [
dataset for dataset in datasets_second_tg
if dataset.get('path') == 'local.csv'
]
self.assertEqual(len(global_csv_tg_one), len(global_csv_tg_two), 1)
self.assertEqual(len(local_csv_tg_one), 1)
self.assertEqual(len(local_csv_tg_two), 0)
def test_parse_csv_dataset(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
datasets = yml.get("scenarios").get("Thread Group one").get(
"data-sources")
local_csv = [
dataset for dataset in datasets
if dataset.get('path') == 'local.csv'
][0]
self.assertEqual(local_csv['loop'], False)
self.assertEqual(local_csv['delimiter'], ',')
self.assertEqual(local_csv['quoted'], False)
def test_copy_global_headers(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
headers_first_tg = yml.get("scenarios").get("Thread Group one").get(
"headers", [])
headers_second_tg = yml.get("scenarios").get("Thread Group two").get(
"headers", [])
self.assertEqual(len(headers_first_tg), 3)
self.assertEqual(len(headers_second_tg), 2)
def test_cache_cookie_dns_overrides(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
cache_first_tg = tg_one.get("store-cache")
cache_second_tg = tg_two.get("store-cache")
cookie_first_tg = tg_one.get("store-cookie")
cookie_second_tg = tg_two.get("store-cookie")
dns_cache_mgr_first_tg = tg_one.get("use-dns-cache-mgr")
dns_cache_mgr_second_tg = tg_two.get("use-dns-cache-mgr")
self.assertEqual(cache_first_tg, True)
self.assertEqual(cache_second_tg, True)
self.assertEqual(cookie_first_tg, False)
self.assertEqual(cookie_second_tg, True)
self.assertEqual(dns_cache_mgr_first_tg, True)
self.assertEqual(dns_cache_mgr_second_tg, True)
def test_think_time_overrides(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
request_tg_two = tg_two.get("requests")[0]
tg_one_timer = tg_one.get("think-time")
tg_two_timer = tg_two.get("think-time")
req_timer = request_tg_two.get("think-time")
self.assertEqual(tg_one_timer, "200ms")
self.assertEqual(tg_two_timer, "300ms")
self.assertEqual(req_timer, "100ms")
def test_request_defaults(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/global_copy.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
self.assertEqual(tg_one.get("default-address"), "https://127.0.0.2/")
self.assertEqual(tg_two.get("default-address"),
"http://127.0.0.3:2582/resources/")
self.assertEqual(tg_one.get("timeout"), "500ms")
self.assertEqual(tg_two.get("timeout"), "100ms")
self.assertEqual(tg_one.get("retrieve-resources"), True)
self.assertEqual(tg_two.get("retrieve-resources"), True)
self.assertEqual(tg_one.get("concurrent-pool-size"), 5)
self.assertEqual(tg_two.get("concurrent-pool-size"), 10)
def test_copy_global_request_assertions(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/assertions.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_assertions = tg_one.get("assert")
self.assertEqual(len(tg_one_assertions),
2) # global assertion + tg assertion
tg_two_assertions = tg_two.get("assert")
self.assertEqual(len(tg_two_assertions), 1) # global only assertion
tg_one_req_one_assertion = tg_one.get("requests")[0].get("assert")[0]
expected = {
'subject': 'headers',
'contains': ["tg1httpreq1", "tg1httpreq12"],
"not": False,
'regexp': True
}
self.assertEqual(tg_one_req_one_assertion, expected)
tg_one_assertion = tg_one.get("assert")[0]
expected = {
'subject': 'body',
'contains': ["tg1body_text_not_contains"],
"not": True,
'regexp': True
}
self.assertEqual(tg_one_assertion, expected)
def test_copy_global_json_assertions(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/assertions.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_assertions = tg_one.get("assert-jsonpath")
self.assertEqual(len(tg_one_assertions),
1) # global assertion + tg assertion
tg_two_assertions = tg_two.get("assert-jsonpath")
self.assertEqual(len(tg_two_assertions), 1) # global only assertion
tg_one_req_one_jp = tg_one.get("requests")[0].get(
"assert-jsonpath", []) # no assertions
self.assertEqual(len(tg_one_req_one_jp), 0)
tg_two_req_one_jp = tg_two.get("requests")[0].get(
"assert-jsonpath", [])
self.assertEqual(len(tg_two_req_one_jp), 1)
expected = {
"expect-null": True,
"invert": True,
"jsonpath": '$(":input")',
"validate": True
}
self.assertEqual(expected, tg_two_req_one_jp[0])
# test concurrency, ramp-up, iterations in execution
tg_one_exec = yml.get(ScenarioExecutor.EXEC)[0]
tg_two_exec = yml.get(ScenarioExecutor.EXEC)[1]
tg_three_exec = yml.get(ScenarioExecutor.EXEC)[2]
self.assertEqual(tg_one_exec.get("concurrency"), 10)
self.assertEqual(tg_two_exec.get("concurrency"), 15)
self.assertEqual(tg_three_exec.get("concurrency"), 1)
self.assertEqual(tg_one_exec.get("ramp-up"), '10s')
self.assertEqual(tg_two_exec.get("ramp-up"), '60s')
self.assertEqual(tg_three_exec.get("ramp-up"), '2s')
self.assertEqual(tg_one_exec.get("iterations"), 1)
self.assertEqual(tg_two_exec.get("iterations"), 1)
self.assertEqual(tg_three_exec.get("iterations"), 100)
def test_xpath_assertions(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/assertions.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg = yml.get("scenarios").get("tg3")
assertions = tg.get("assert-xpath")
self.assertEqual(len(assertions), 2)
self.assertEqual(
assertions[0], {
"xpath": "/note/to",
"ignore-whitespace": False,
"invert": False,
"validate-xml": False,
"use-tolerant-parser": False,
})
self.assertEqual(
assertions[1], {
"xpath": "/note/from",
"ignore-whitespace": True,
"invert": True,
"validate-xml": True,
"use-tolerant-parser": True,
})
def test_extractors(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/extractors.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_three = yml.get("scenarios").get("tg3")
tg_one_extractors = tg_one.get("extract-regexp")
tg_two_extractors = tg_two.get("extract-regexp")
self.assertEqual(len(tg_one_extractors), 1) # global
self.assertEqual(len(tg_two_extractors), 1) # global + local - ignored
tg_one_req_exr = tg_one.get("requests")[0].get("extract-regexp", {})
self.assertEqual(len(tg_one_req_exr), 2)
expected = {
'template': '1',
'match-no': 1,
'regexp': '*tg1hr1',
'default': 'default'
}
self.assertEqual(expected, tg_one_req_exr.get("test_tg1hr1"))
# test extract-jsonpath
tg_one_extractors = tg_one.get("extract-jsonpath")
tg_two_extractors = tg_two.get("extract-jsonpath")
self.assertEqual(len(tg_one_extractors), 3) # 2x global + local
self.assertEqual(len(tg_two_extractors), 2) # 2x global
tg_three_req_exr = tg_three.get("requests")[0].get(
"extract-jsonpath", {})
self.assertEqual(len(tg_three_req_exr), 1) # 1x local
# test extract-xpath
tg_three_extractors = tg_three.get("extract-xpath")
self.assertEqual(len(tg_three_extractors), 2) # 2 global
self.assertEqual(
tg_three_extractors['bookAuthor'], {
"xpath": "/books/[@title()='1984']/author",
"default": "no_author",
"ignore-whitespace": False,
"validate-xml": False,
"use-tolerant-parser": False,
})
self.assertEqual(
tg_three_extractors['author'], {
"xpath": "/books/[@title()='Fahrenheit 451']/author",
"default": "no",
"ignore-whitespace": True,
"validate-xml": True,
"use-tolerant-parser": False,
})
def test_request_body(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/extractors.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_req_one_body = tg_one.get("requests")[0].get("body")
self.assertEqual(tg_one_req_one_body, "body-string")
tg_one_req_one_body = tg_one.get("requests")[1].get("body")
self.assertEqual(tg_one_req_one_body, {
"body_param1": "value1",
"body_param2": "value2"
})
tg_two_req_one_body = tg_two.get("requests")[0].get("body")
self.assertEqual(tg_two_req_one_body, None)
def test_duration_throughput(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/duration.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get(ScenarioExecutor.EXEC)[0]
tg_two = yml.get(ScenarioExecutor.EXEC)[1]
tg_three = yml.get(ScenarioExecutor.EXEC)[2]
self.assertEqual("10s", tg_one.get("ramp-up"))
self.assertEqual("60s", tg_one.get("hold-for"))
self.assertEqual("10s", tg_one.get("ramp-up"))
self.assertEqual(100, tg_one.get("throughput"))
self.assertEqual("10s", tg_two.get("ramp-up"))
self.assertEqual("20s", tg_two.get("hold-for"))
self.assertEqual(20, tg_two.get("throughput"))
self.assertEqual("60s", tg_three.get("ramp-up"))
self.assertEqual("40s", tg_three.get("hold-for"))
self.assertEqual(100, tg_three.get("throughput"))
def test_all(self):
obj = self._get_jmx2yaml("/yaml/converter/disabled.jmx",
self._get_tmp())
obj.process()
yml = yaml.load(
open(__dir__() + "/yaml/converter/disabled.yml").read())
self.assertEqual(obj.converter.convert(obj.file_to_convert), yml)
def test_param_null(self):
obj = self._get_jmx2yaml("/yaml/converter/param-null.jmx",
self._get_tmp())
obj.process()
obj.converter.convert(obj.file_to_convert)
def test_load_profile_default_values(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/default.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
execution = yml.get(ScenarioExecutor.EXEC)[0]
self.assertEqual("60s", execution.get("ramp-up"))
self.assertEqual("60s", execution.get("hold-for"))
self.assertEqual(1, execution.get("concurrency"))
self.assertEqual(1, execution.get("iterations"))
def test_variables(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/vars.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
scenarios = yml.get("scenarios")
tg_one = scenarios["TG1"]
self.assertEqual(tg_one.get('variables'), {
"tg1_local": "tg1",
"global_var": "global"
})
tg_two = scenarios["TG2"]
self.assertEqual(tg_two.get('variables'), {
"tg2_local": "tg2",
"global_var": "global"
})
def test_no_variables(self):
yml = self._get_tmp()
obj = self._get_jmx2yaml("/yaml/converter/default.jmx", yml)
obj.process()
yml = yaml.load(open(yml).read())
execution = yml.get(ScenarioExecutor.EXEC)[0]
scenarios = yml.get("scenarios")
scenario = scenarios[execution.get("scenario")]
self.assertNotIn("variables", scenario)
def test_controllers_to_requests(self):
obj = self._get_jmx2yaml("/yaml/converter/controllers.jmx",
self._get_tmp())
obj.process()
yml = yaml.load(
open(__dir__() + "/yaml/converter/controllers.yml").read())
self.assertEqual(obj.converter.convert(obj.file_to_convert), yml)
def test_jsr223(self):
yml_file = self._get_tmp()
obj = self._get_jmx2yaml("/jmeter/jmx/jsr223.jmx", yml_file)
obj.process()
yml = yaml.load(open(yml_file).read())
scenarios = yml.get("scenarios")
scenario = scenarios["Thread Group"]
requests = scenario["requests"]
self.assertEqual(len(requests), 1)
request = requests[0]
self.assertIn("jsr223", request)
jsrs = request["jsr223"]
self.assertIsInstance(jsrs, list)
self.assertEqual(len(jsrs), 3)
self.assertEqual(jsrs[0]["language"], "beanshell")
self.assertEqual(jsrs[0]["script-file"], "script.bsh")
self.assertEqual(jsrs[0]["parameters"], "parames")
self.assertEqual(jsrs[1]["language"], "javascript")
self.assertEqual(jsrs[1]["script-file"], "script.js")
self.assertEqual(jsrs[1]["parameters"], "a b c")
self.assertEqual(jsrs[2]["language"], "javascript")
self.assertEqual(jsrs[2]["script-file"], "script-1.js")
self.assertEqual(jsrs[2]["parameters"], None)
self.assertTrue(
os.path.exists(
os.path.join(get_full_path(yml_file, step_up=1),
'script.bsh')))
self.assertTrue(
os.path.exists(
os.path.join(get_full_path(yml_file, step_up=1), 'script.js')))
self.assertTrue(
os.path.exists(
os.path.join(get_full_path(yml_file, step_up=1),
'script-1.js')))
def test_unicode(self):
obj = self._get_jmx2yaml("/yaml/converter/unicode.jmx",
self._get_tmp())
obj.process()
obj.converter.convert(obj.file_to_convert)
def test_path_without_domain(self):
yml_file = self._get_tmp()
obj = self._get_jmx2yaml("/jmeter/jmx/http.jmx", yml_file)
obj.process()
yml = yaml.load(open(yml_file).read())
scenarios = yml.get("scenarios")
scenario = scenarios["Thread Group"]
requests = scenario["requests"]
self.assertEqual(len(requests), 3)
without_domain = requests[2]
self.assertEqual(without_domain['url'], '/path')
def test_request_content_encoding(self):
yml_file = self._get_tmp()
obj = self._get_jmx2yaml("/jmeter/jmx/http.jmx", yml_file)
obj.process()
yml = yaml.load(open(yml_file).read())
scenarios = yml.get("scenarios")
scenario = scenarios["Thread Group"]
requests = scenario["requests"]
self.assertEqual(len(requests), 3)
request = requests[1]
self.assertEqual(request['content-encoding'], 'utf-8')
class TestConverter(BZTestCase):
def setUp(self):
super(TestConverter, self).setUp()
self.engine = EngineEmul()
self.obj = JMX2YAML(file_name=None, options=FakeOptions())
def configure(self, src_file, dst_file=None, dump_jmx=None):
self.obj.src_file = src_file
self.obj.options = FakeOptions(file_name=dst_file, dump_jmx=dump_jmx)
def tearDown(self):
if self.obj.dst_file and os.path.isfile(self.obj.dst_file):
os.remove(self.obj.dst_file)
super(TestConverter, self).tearDown()
@staticmethod
def same_yaml(file1, file2):
yml1 = yaml.load(open(file1).read())
yml2 = yaml.load(open(file2).read())
return yml1 == yml2
def _get_tmp(self, prefix='test', suffix='.yml'):
return self.engine.create_artifact(prefix, suffix)
def test_objprop(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/http.jmx", self._get_tmp())
self.sniff_log(self.obj.log)
self.obj.process()
self.assertNotIn("Removing unknown element: name (None)", self.log_recorder.warn_buff.getvalue())
self.assertNotIn("Removing unknown element: value (None)", self.log_recorder.warn_buff.getvalue())
def test_loadjmx1(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/http.jmx", self._get_tmp())
self.sniff_log(self.obj.log)
self.obj.process()
self.assertIn("Loading jmx file", self.log_recorder.info_buff.getvalue())
self.assertNotEqual("", self.log_recorder.debug_buff.getvalue())
self.assertEqual("", self.log_recorder.err_buff.getvalue())
def test_loadjmx2(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/notfound.jmx")
self.sniff_log(self.obj.log)
try:
self.obj.process()
self.fail()
except BaseException as exc:
self.assertIn("File does not exist", exc.args[0])
self.assertIn("Loading jmx file", self.log_recorder.info_buff.getvalue())
self.assertEqual("", self.log_recorder.debug_buff.getvalue())
def test_loadjmx3(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/broken.jmx")
self.sniff_log(self.obj.log)
try:
self.obj.process()
self.fail()
except BaseException as exc:
self.assertIn("XML parsing failed", exc.args[0])
self.assertIn("Loading jmx file", self.log_recorder.info_buff.getvalue())
self.assertIn("Error while processing jmx file", self.log_recorder.err_buff.getvalue())
def test_loadjmx4(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/http.jmx", self._get_tmp('tmp', 'file'))
self.sniff_log(self.obj.log)
self.obj.process()
self.assertIn("Loading jmx file", self.log_recorder.info_buff.getvalue())
self.assertIn("Done processing, result saved in", self.log_recorder.info_buff.getvalue())
self.assertIn("Removing unknown element", self.log_recorder.warn_buff.getvalue())
def test_export_clean_jmx(self):
tmp_jmx_name = self._get_tmp('tmp', '.jmx')
open(tmp_jmx_name, 'w+').close() # touch file
self.configure(RESOURCES_DIR + "yaml/converter/disabled.jmx", dump_jmx=tmp_jmx_name)
self.sniff_log(self.obj.log)
self.obj.process()
self.assertIn("Loading jmx file", self.log_recorder.info_buff.getvalue())
self.assertIn("already exists and will be overwritten", self.log_recorder.warn_buff.getvalue())
def test_not_jmx(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/not-jmx.xml")
try:
self.obj.process()
self.fail()
except BaseException as exc:
self.assertIn("Bad jmx format", exc.args[0])
def test_clean_disabled_jmx(self):
self.configure(RESOURCES_DIR + "yaml/converter/disabled.jmx", self._get_tmp())
self.obj.process()
disabled_elements = [element for element in self.obj.converter.dialect.tree.iter() if
element.get("enabled") == "false"]
self.assertEquals(0, len(disabled_elements))
def test_copy_global_csv_dataset(self):
self.configure(RESOURCES_DIR + "yaml/converter/global_copy.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
datasets_first_tg = yml.get("scenarios").get("Thread Group one").get("data-sources")
datasets_second_tg = yml.get("scenarios").get("Thread Group two").get("data-sources")
global_csv_tg_one = [dataset for dataset in datasets_first_tg if dataset.get('path') == 'global.csv']
global_csv_tg_two = [dataset for dataset in datasets_second_tg if dataset.get('path') == 'global.csv']
local_csv_tg_one = [dataset for dataset in datasets_first_tg if dataset.get('path') == 'local.csv']
local_csv_tg_two = [dataset for dataset in datasets_second_tg if dataset.get('path') == 'local.csv']
self.assertEqual(len(global_csv_tg_one), len(global_csv_tg_two), 1)
self.assertEqual(len(local_csv_tg_one), 1)
self.assertEqual(len(local_csv_tg_two), 0)
def test_parse_csv_dataset(self):
self.configure(RESOURCES_DIR + "yaml/converter/global_copy.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
datasets = yml.get("scenarios").get("Thread Group one").get("data-sources")
local_csv = [dataset for dataset in datasets if dataset.get('path') == 'local.csv'][0]
self.assertEqual(local_csv['loop'], False)
self.assertEqual(local_csv['delimiter'], ',')
self.assertEqual(local_csv['quoted'], False)
def test_copy_global_headers(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/global_copy.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
headers_first_tg = yml.get("scenarios").get("Thread Group one").get("headers", [])
headers_second_tg = yml.get("scenarios").get("Thread Group two").get("headers", [])
self.assertEqual(len(headers_first_tg), 3)
self.assertEqual(len(headers_second_tg), 2)
def test_cache_cookie_dns_overrides(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/global_copy.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
cache_first_tg = tg_one.get("store-cache")
cache_second_tg = tg_two.get("store-cache")
cookie_first_tg = tg_one.get("store-cookie")
cookie_second_tg = tg_two.get("store-cookie")
dns_cache_mgr_first_tg = tg_one.get("use-dns-cache-mgr")
dns_cache_mgr_second_tg = tg_two.get("use-dns-cache-mgr")
self.assertEqual(cache_first_tg, True)
self.assertEqual(cache_second_tg, True)
self.assertEqual(cookie_first_tg, False)
self.assertEqual(cookie_second_tg, True)
self.assertEqual(dns_cache_mgr_first_tg, True)
self.assertEqual(dns_cache_mgr_second_tg, True)
def test_think_time_overrides(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/global_copy.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
request_tg_two = tg_two.get("requests")[0]
tg_one_timer = tg_one.get("think-time")
tg_two_timer = tg_two.get("think-time")
req_timer = request_tg_two.get("think-time")
self.assertEqual(tg_one_timer, "200ms")
self.assertEqual(tg_two_timer, "300ms")
self.assertEqual(req_timer, "100ms")
def test_request_defaults(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/global_copy.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get('Thread Group one')
tg_two = yml.get("scenarios").get('Thread Group two')
self.assertEqual(tg_one.get("default-address"), "https://127.0.0.2/")
self.assertEqual(tg_two.get("default-address"), "http://127.0.0.3:2582/resources/")
self.assertEqual(tg_one.get("timeout"), "500ms")
self.assertEqual(tg_two.get("timeout"), "100ms")
self.assertEqual(tg_one.get("retrieve-resources"), True)
self.assertEqual(tg_two.get("retrieve-resources"), True)
self.assertEqual(tg_one.get("concurrent-pool-size"), 5)
self.assertEqual(tg_two.get("concurrent-pool-size"), 10)
def test_copy_global_request_assertions(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/assertions.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_assertions = tg_one.get("assert")
self.assertEqual(len(tg_one_assertions), 2) # global assertion + tg assertion
tg_two_assertions = tg_two.get("assert")
self.assertEqual(len(tg_two_assertions), 1) # global only assertion
tg_one_req_one_assertion = tg_one.get("requests")[0].get("assert")[0]
expected = {"subject": "headers", "contains": ["tg1httpreq1", "tg1httpreq12"],
"assume-success": False, "not": False, "regexp": False}
self.assertEqual(tg_one_req_one_assertion, expected)
tg_one_assertion = tg_one.get("assert")[0]
expected = {"subject": "body", "contains": ["tg1body_text_not_contains"],
"assume-success": False, "not": True, 'regexp': False}
self.assertEqual(tg_one_assertion, expected)
def test_broken_request_assertions(self):
# see comments in broken_resp_asserts.jmx for explanation of cases
# don't save broken_resp_asserts.jmx by jmeter
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/broken_resp_asserts.jmx", yml)
self.obj.process()
yml1 = RESOURCES_DIR + "yaml/converter/broken_resp_asserts.yml"
yml2 = yml
self.assertTrue(yml1, yml2)
def test_copy_global_json_assertions(self):
self.configure(RESOURCES_DIR + "yaml/converter/assertions.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_assertions = tg_one.get("assert-jsonpath")
self.assertEqual(len(tg_one_assertions), 1) # global assertion + tg assertion
tg_two_assertions = tg_two.get("assert-jsonpath")
self.assertEqual(len(tg_two_assertions), 1) # global only assertion
tg_one_req_one_jp = tg_one.get("requests")[0].get("assert-jsonpath", []) # no assertions
self.assertEqual(len(tg_one_req_one_jp), 0)
tg_two_req_one_jp = tg_two.get("requests")[0].get("assert-jsonpath", [])
self.assertEqual(len(tg_two_req_one_jp), 1)
expected = {"expect-null": True, "invert": True, "jsonpath": '$(":input")', "validate": True, "regexp": True}
self.assertEqual(expected, tg_two_req_one_jp[0])
# test concurrency, ramp-up, iterations in execution
tg_one_exec = yml.get(ScenarioExecutor.EXEC)[0]
tg_two_exec = yml.get(ScenarioExecutor.EXEC)[1]
tg_three_exec = yml.get(ScenarioExecutor.EXEC)[2]
self.assertEqual(tg_one_exec.get("concurrency"), 10)
self.assertEqual(tg_two_exec.get("concurrency"), 15)
self.assertEqual(tg_three_exec.get("concurrency"), 1)
self.assertEqual(tg_one_exec.get("ramp-up"), '10s')
self.assertEqual(tg_two_exec.get("ramp-up"), '60s')
self.assertEqual(tg_three_exec.get("ramp-up"), '2s')
self.assertEqual(tg_one_exec.get("iterations"), 1)
self.assertEqual(tg_two_exec.get("iterations"), 1)
self.assertEqual(tg_three_exec.get("iterations"), 100)
def test_xpath_assertions(self):
self.configure(RESOURCES_DIR + "yaml/converter/assertions.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
tg = yml.get("scenarios").get("tg3")
assertions = tg.get("assert-xpath")
self.assertEqual(len(assertions), 2)
self.assertEqual(assertions[0], {
"xpath": "/note/to",
"ignore-whitespace": False,
"invert": False,
"validate-xml": False,
"use-tolerant-parser": False,
})
self.assertEqual(assertions[1], {
"xpath": "/note/from",
"ignore-whitespace": True,
"invert": True,
"validate-xml": True,
"use-tolerant-parser": True,
})
def test_extractors(self):
self.configure(RESOURCES_DIR + "yaml/converter/extractors.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_three = yml.get("scenarios").get("tg3")
tg_one_extractors = tg_one.get("extract-regexp")
tg_two_extractors = tg_two.get("extract-regexp")
self.assertEqual(len(tg_one_extractors), 1) # global
self.assertEqual(len(tg_two_extractors), 1) # global + local - ignored
tg_one_req_exr = tg_one.get("requests")[0].get("extract-regexp", {})
self.assertEqual(len(tg_one_req_exr), 2)
expected = {'template': '1', 'match-no': 1, 'regexp': '*tg1hr1', 'default': 'default'}
self.assertEqual(expected, tg_one_req_exr.get("test_tg1hr1"))
# test extract-jsonpath
tg_one_extractors = tg_one.get("extract-jsonpath")
tg_two_extractors = tg_two.get("extract-jsonpath")
self.assertEqual(len(tg_one_extractors), 5) # 4x global + local
self.assertEqual(len(tg_two_extractors), 4) # 4x global
tg_three_req_exr = tg_three.get("requests")[0].get("extract-jsonpath", {})
self.assertEqual(len(tg_three_req_exr), 1) # 1x local
# test extract-xpath
tg_three_extractors = tg_three.get("extract-xpath")
self.assertEqual(len(tg_three_extractors), 2) # 2 global
self.assertEqual(tg_three_extractors['bookAuthor'], {
"xpath": "/books/[@title()='1984']/author",
"default": "no_author",
"ignore-whitespace": False,
"validate-xml": False,
"use-tolerant-parser": False,
})
self.assertEqual(tg_three_extractors['author'], {
"xpath": "/books/[@title()='Fahrenheit 451']/author",
"default": "no",
"ignore-whitespace": True,
"validate-xml": True,
"use-tolerant-parser": False,
})
self.assertEqual(tg_one_extractors['VAR1'], {
"jsonpath": "$.foo",
"default": "DEF_1",
})
self.assertEqual(tg_one_extractors['VAR2'], {
"jsonpath": "$.bar",
"default": "DEF_2",
})
def test_request_body(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/extractors.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get("scenarios").get("tg1")
tg_two = yml.get("scenarios").get("tg2")
tg_one_req_one_body = tg_one.get("requests")[0].get("body")
self.assertEqual(tg_one_req_one_body, "body-string")
tg_one_req_one_body = tg_one.get("requests")[1].get("body")
self.assertEqual(tg_one_req_one_body, {"body_param1": "value1", "body_param2": "value2"})
tg_two_req_one_body = tg_two.get("requests")[0].get("body")
self.assertEqual(tg_two_req_one_body, None)
def test_json_body(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/json_body.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
reqs1 = yml.get("scenarios").get("tg1")['requests']
reqs2 = yml.get("scenarios").get("tg2")['requests']
bodies = {req['label']: req.get('body', None) for req in reqs1 + reqs2}
targets = {'r1_1': None, 'r1_2': list, 'r1_3': str, 'r1_4': dict,
'r2_1': None, 'r2_2': dict, 'r2_3': str, 'r2_4': str, 'r2_5': str}
for label in targets:
self.assertTrue((bodies[label] is None and targets[label] is None)
or isinstance(bodies[label], targets[label]))
def test_duration_throughput(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/duration.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
tg_one = yml.get(ScenarioExecutor.EXEC)[0]
tg_two = yml.get(ScenarioExecutor.EXEC)[1]
tg_three = yml.get(ScenarioExecutor.EXEC)[2]
self.assertEqual("10s", tg_one.get("ramp-up"))
self.assertEqual("60s", tg_one.get("hold-for"))
self.assertEqual("10s", tg_one.get("ramp-up"))
self.assertEqual(100, tg_one.get("throughput"))
self.assertEqual("10s", tg_two.get("ramp-up"))
self.assertEqual("20s", tg_two.get("hold-for"))
self.assertEqual(20, tg_two.get("throughput"))
self.assertEqual("60s", tg_three.get("ramp-up"))
self.assertEqual("40s", tg_three.get("hold-for"))
self.assertEqual(100, tg_three.get("throughput"))
def test_all(self):
self.configure(RESOURCES_DIR + "yaml/converter/disabled.jmx")
self.obj.process()
yml1 = RESOURCES_DIR + "yaml/converter/disabled.yml"
yml2 = self.obj.dst_file
self.assertTrue(self.same_yaml(yml1, yml2))
def test_params_conversion(self):
self.configure(RESOURCES_DIR + "yaml/converter/params_conversion.jmx")
self.sniff_log(self.obj.log)
self.obj.process()
yml1 = self.obj.dst_file
yml2 = RESOURCES_DIR + "yaml/converter/params_conversion.yml"
self.assertTrue(self.same_yaml(yml1, yml2))
self.assertNotIn('n1', self.log_recorder.warn_buff.getvalue())
self.assertNotIn('n2', self.log_recorder.warn_buff.getvalue())
self.assertIn('n1_101', self.log_recorder.debug_buff.getvalue())
self.assertIn('n1_011', self.log_recorder.debug_buff.getvalue())
self.assertIn('n1_001', self.log_recorder.debug_buff.getvalue())
def test_param_null(self):
self.configure(RESOURCES_DIR + "yaml/converter/param-null.jmx")
self.obj.process()
def test_load_profile_default_values(self):
yml = self._get_tmp()
self.configure(RESOURCES_DIR + "yaml/converter/default.jmx", yml)
self.obj.process()
yml = yaml.load(open(yml).read())
execution = yml.get(ScenarioExecutor.EXEC)[0]
self.assertEqual("60s", execution.get("ramp-up"))
self.assertEqual("60s", execution.get("hold-for"))
self.assertEqual(1, execution.get("concurrency"))
self.assertEqual(1, execution.get("iterations"))
def test_variables(self):
self.configure(RESOURCES_DIR + "yaml/converter/vars.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
scenarios = yml.get("scenarios")
tg_one = scenarios["TG1"]
self.assertEqual(tg_one.get('variables'),
{"tg1_local": "tg1", "global_var": "global", "auth_token": "shouldn't be masked"})
tg_two = scenarios["TG2"]
self.assertEqual(tg_two.get('variables'),
{"tg2_local": "tg2", "global_var": "global", "auth_token": "shouldn't be masked"})
def test_no_variables(self):
self.configure(RESOURCES_DIR + "yaml/converter/default.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
execution = yml.get(ScenarioExecutor.EXEC)[0]
scenarios = yml.get("scenarios")
scenario = scenarios[execution.get("scenario")]
self.assertNotIn("variables", scenario)
def test_controllers_to_requests(self):
self.configure(RESOURCES_DIR + "yaml/converter/controllers.jmx")
self.obj.process()
yml1 = RESOURCES_DIR + "yaml/converter/controllers.yml"
yml2 = self.obj.dst_file
self.assertTrue(self.same_yaml(yml1, yml2))
def test_jsr223(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/jsr223.jmx")
try:
self.obj.process()
lines = FileReader(self.obj.dst_file).get_lines(last_pass=True)
yml = yaml.load(''.join(lines))
scenarios = yml.get("scenarios")
scenario = scenarios["Thread Group"]
requests = scenario["requests"]
self.assertEqual(len(requests), 1)
request = requests[0]
self.assertIn("jsr223", request)
jsrs = request["jsr223"]
self.assertTrue(isinstance(jsrs, list))
self.assertEqual(len(jsrs), 5)
self.assertEqual(jsrs[0]["language"], "beanshell")
self.assertEqual(jsrs[0]["script-text"], "scripty")
self.assertEqual(jsrs[0]["parameters"], "parames")
self.assertNotIn('script-file', jsrs[0])
self.assertEqual(jsrs[1]["language"], "javascript")
self.assertEqual(jsrs[1]["script-text"], u'console.log("ПРИВЕТ");\nline("2");')
self.assertEqual(jsrs[1]["parameters"], "a b c")
self.assertNotIn('script-file', jsrs[1])
self.assertEqual(jsrs[2]["language"], "javascript")
self.assertEqual(jsrs[2]["script-file"], "script.js")
self.assertEqual(jsrs[2]["parameters"], None)
self.assertNotIn('script-text', jsrs[2])
self.assertEqual(jsrs[3]["language"], "beanshell")
self.assertEqual(jsrs[3]["execute"], "before")
self.assertEqual(jsrs[3]["parameters"], None)
self.assertEqual(jsrs[3]['script-text'], 'console.log("beanshell aka jsr223");')
self.assertNotIn('script-file', jsrs[3])
self.assertEqual(jsrs[4]["language"], "java")
self.assertEqual(jsrs[4]["execute"], "before")
self.assertEqual(jsrs[4]["parameters"], None)
self.assertIn('BlazeDemo.java', jsrs[4]['script-file'])
self.assertNotIn('script-text', jsrs[4])
self.assertTrue(os.path.exists(os.path.join(get_full_path(self.obj.dst_file, step_up=1), 'script.js')))
finally:
os.remove(os.path.join(get_full_path(self.obj.dst_file, step_up=1), 'script.js'))
def test_unicode(self):
self.configure(RESOURCES_DIR + "yaml/converter/unicode.jmx")
self.obj.process()
def test_path_without_domain(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/http.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
scenarios = yml.get("scenarios")
scenario = scenarios["Thread Group"]
requests = scenario["requests"]
self.assertEqual(len(requests), 3)
without_domain = requests[2]
self.assertEqual(without_domain['url'], '/path')
def test_request_content_encoding(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/http.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
scenarios = yml.get("scenarios")
scenario = scenarios["Thread Group"]
requests = scenario["requests"]
self.assertEqual(len(requests), 3)
request = requests[1]
self.assertEqual(request['content-encoding'], 'utf-8')
def test_request_redirect_policy(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/http.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
scenarios = yml.get("scenarios")
scenario = scenarios["Thread Group"]
requests = scenario["requests"]
self.assertEqual(len(requests), 3)
self.assertEqual(requests[0].get('follow-redirects'), True)
self.assertEqual(requests[1].get('follow-redirects'), True)
self.assertEqual(requests[2].get('follow-redirects'), False)
def test_controllers(self):
self.configure(RESOURCES_DIR + "jmeter/jmx/all_controllers.jmx")
self.obj.process()
yml = yaml.load(open(self.obj.dst_file).read())
requests = yml.get("scenarios").get("Thread Group").get("requests")
self.assertEqual(len(requests), 14)
