class TestJTLReader(BZTestCase): def setUp(self): super(TestJTLReader, self).setUp() self.obj = None def configure(self, jtl_file): self.obj = JTLReader(jtl_file, logging.getLogger('')) def tearDown(self): if self.obj: close_reader_file(self.obj.csvreader) close_reader_file(self.obj.errors_reader) super(TestJTLReader, self).tearDown() def test_tranctl_jtl(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/tranctl.jtl") values = [x for x in self.obj.datapoints(final_pass=True)] self.assertEquals(1, len(values)) def test_tabs_jtl(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/tabs.jtl") values = [x for x in self.obj.datapoints(final_pass=True)] self.assertEquals(4, len(values)) def test_reader_unicode(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/unicode.jtl") self.obj.ignored_labels = [u"Тест.Эхо"] for point in self.obj.datapoints(final_pass=True): cumulative = point[DataPoint.CUMULATIVE] self.assertIn(u"САП.АутентифицироватьРасш", cumulative) self.assertNotIn(u"Тест.Эхо", cumulative) def test_jtl_doublequoting(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/doublequoting.jtl") list(self.obj.datapoints(final_pass=True))
def test_jtl_quoting_issue(self): def exec_and_communicate(*args, **kwargs): return "", "" self.configure({"execution": { "concurrency": 1, "iterations": 1, "scenario": { "default-address": "http://httpbin.org/status/503", "requests": [ "/" ] } }}) tmp_aec, tmp_ex = bzt.utils.exec_and_communicate, sys.executable try: bzt.utils.exec_and_communicate = exec_and_communicate self.obj.prepare() sys.executable = RESOURCES_DIR + "locust/locust-mock" + EXE_SUFFIX self.obj.startup() finally: bzt.utils.exec_and_communicate = tmp_aec sys.executable = tmp_ex while not self.obj.check(): time.sleep(self.obj.engine.check_interval) self.obj.shutdown() self.obj.post_process() kpi_path = RESOURCES_DIR + "locust/locust-kpi.jtl" reader = JTLReader(kpi_path, self.obj.log) list(reader.datapoints())
def prepare(self): self.install_required_tools() self.scenario = self.get_scenario() self.__setup_script() self.is_master = self.execution.get("master", self.is_master) if self.is_master: count_error = TaurusConfigError( "Slaves count required when starting in master mode") slaves = self.execution.get("slaves", count_error) self.expected_slaves = int(slaves) self.engine.existing_artifact(self.script) if self.is_master: self.slaves_ldjson = self.engine.create_artifact( "locust-slaves", ".ldjson") self.reader = SlavesReader(self.slaves_ldjson, self.expected_slaves, self.log) else: self.kpi_jtl = self.engine.create_artifact("kpi", ".jtl") self.reader = JTLReader(self.kpi_jtl, self.log, None) if isinstance(self.engine.aggregator, ConsolidatingAggregator): self.engine.aggregator.add_underling(self.reader)
def _get_reader(self): with open(self.data_file) as fhd: header = fhd.readline(2048).strip() # just header chunk of file # TODO: detect CSV dialect for JTLs if header.startswith(self.AB_HEADER): reader = TSVDataReader(self.data_file, self.log) reader.url_label = "N/A" return reader elif header.startswith("<?xml"): return XMLJTLReader(self.data_file, self.log) elif self.PBENCH_FORMAT.match(header): return PBenchKPIReader(self.data_file, self.log, self.errors_file) elif header.startswith("RUN\t") or "\tRUN\t" in header: return GatlingLogReader(self.data_file, self.log, None) elif "timestamp" in header.lower() and "elapsed" in header.lower(): return JTLReader(self.data_file, self.log, self.errors_file) elif "worker process" in header.lower() and header.startswith( "worker."): return GrinderLogReader(self.data_file, self.log) else: self.log.info("Header line was: %s", header) raise TaurusInternalException( "Unable to detect results format for: %s" % self.data_file)
def prepare(self): self.__check_installed() self.locustfile = self.get_locust_file() if not self.locustfile or not os.path.exists(self.locustfile): raise ValueError("Locust file not found: %s" % self.locustfile) self.is_master = self.execution.get("master", self.is_master) if self.is_master: slaves = self.execution.get( "slaves", ValueError( "Slaves count required when starting in master mode")) self.expected_slaves = int(slaves) self.engine.existing_artifact(self.locustfile) if self.is_master: self.slaves_ldjson = self.engine.create_artifact( "locust-slaves", ".ldjson") self.reader = SlavesReader(self.slaves_ldjson, self.expected_slaves, self.log) else: self.kpi_jtl = self.engine.create_artifact("kpi", ".jtl") self.reader = JTLReader(self.kpi_jtl, self.log, None) if isinstance(self.engine.aggregator, ConsolidatingAggregator): self.engine.aggregator.add_underling(self.reader)
def prepare(self): self.set_virtual_display() self.scenario = self.get_scenario() self._verify_script() self.kpi_file = self.engine.create_artifact("selenium_tests_report", ".csv") self.err_jtl = self.engine.create_artifact("selenium_tests_err", ".xml") script_type = self.detect_script_type(self.scenario.get(Scenario.SCRIPT)) runner_config = BetterDict() if script_type == ".py": runner_class = NoseTester runner_config.merge(self.settings.get("selenium-tools").get("nose")) else: # script_type == ".jar" or script_type == ".java": runner_class = JUnitTester runner_config.merge(self.settings.get("selenium-tools").get("junit")) runner_config['props-file'] = self.engine.create_artifact("customrunner", ".properties") runner_config["script-type"] = script_type self.runner_working_dir = self.engine.create_artifact(runner_config.get("working-dir", "classes"), "") runner_config["working-dir"] = self.runner_working_dir runner_config.get("artifacts-dir", self.engine.artifacts_dir) runner_config.get("working-dir", self.runner_working_dir) runner_config.get("report-file", self.kpi_file) runner_config.get("err-file", self.err_jtl) runner_config.get("stdout", self.engine.create_artifact("junit", ".out")) runner_config.get("stderr", self.engine.create_artifact("junit", ".err")) self._cp_resource_files(self.runner_working_dir) self.runner = runner_class(runner_config, self.scenario, self.get_load(), self.log) self.runner.prepare() self.reader = JTLReader(self.kpi_file, self.log, self.err_jtl) if isinstance(self.engine.aggregator, ConsolidatingAggregator): self.engine.aggregator.add_underling(self.reader)
def prepare(self): self.stdout = open(self.engine.create_artifact("locust", ".out"), 'w') self.stderr = open(self.engine.create_artifact("locust", ".err"), 'w') self.install_required_tools() self.scenario = self.get_scenario() self.__setup_script() self.engine.existing_artifact(self.script) # path to taurus dir. It's necessary for bzt usage inside tools/helpers self.env.add_path({"PYTHONPATH": get_full_path(__file__, step_up=3)}) self.is_master = self.execution.get("master", self.is_master) if self.is_master: count_error = TaurusConfigError( "Slaves count required when starting in master mode") self.expected_slaves = int( self.execution.get("slaves", count_error)) slaves_ldjson = self.engine.create_artifact( "locust-slaves", ".ldjson") self.reader = SlavesReader(slaves_ldjson, self.expected_slaves, self.log) self.env.set({"SLAVES_LDJSON": slaves_ldjson}) else: kpi_jtl = self.engine.create_artifact("kpi", ".jtl") self.reader = JTLReader(kpi_jtl, self.log) self.env.set({"JTL": kpi_jtl}) if isinstance(self.engine.aggregator, ConsolidatingAggregator): self.engine.aggregator.add_underling(self.reader)
def prepare(self): """ 1) Locate script or folder 2) detect script type 3) create runner instance, prepare runner """ self.scenario = self.get_scenario() self._verify_script() self.kpi_file = self.engine.create_artifact("selenium_tests_report", ".csv") self.err_jtl = self.engine.create_artifact("selenium_tests_err", ".xml") script_type = self.detect_script_type( self.scenario.get(Scenario.SCRIPT)) if script_type == ".py": self.runner = NoseTester runner_config = self.settings.get("selenium-tools").get("nose") elif script_type == ".jar" or script_type == ".java": self.runner = JunitTester runner_config = self.settings.get("selenium-tools").get("junit") else: raise ValueError("Unsupported script type: %s" % script_type) runner_config["script-type"] = script_type self.runner_working_dir = self.engine.create_artifact( runner_config.get("working-dir", "classes"), "") runner_config["working-dir"] = self.runner_working_dir runner_config.get("artifacts-dir", self.engine.artifacts_dir) runner_config.get("working-dir", self.runner_working_dir) runner_config.get("report-file", self.kpi_file) runner_config.get("err-file", self.err_jtl) runner_config.get("stdout", self.engine.create_artifact("junit", ".out")) runner_config.get("stderr", self.engine.create_artifact("junit", ".err")) self._cp_resource_files(self.runner_working_dir) self.runner = self.runner(runner_config, self.scenario, self.log) self.runner.prepare() self.reader = JTLReader(self.kpi_file, self.log, self.err_jtl) if isinstance(self.engine.aggregator, ConsolidatingAggregator): self.engine.aggregator.add_underling(self.reader) display_conf = self.settings.get("virtual-display") if display_conf: if is_windows(): self.log.warning( "Cannot have virtual display on Windows, ignoring") else: width = display_conf.get("width", 1024) height = display_conf.get("height", 768) self.virtual_display = Display(size=(width, height))
def test_jtl_quoting_issue(self): self.obj.execution.merge({ "concurrency": 1, "iterations": 1, "scenario": { "default-address": "http://httpbin.org/status/503", "requests": ["/"] } }) self.obj.prepare() self.obj.startup() while not self.obj.check(): time.sleep(self.obj.engine.check_interval) self.obj.shutdown() self.obj.post_process() kpi_path = os.path.join(self.obj.engine.artifacts_dir, "kpi.jtl") self.assertTrue(os.path.exists(kpi_path)) reader = JTLReader(kpi_path, self.obj.log, None) for point in reader.datapoints(): pass
def test_jtl_quoting_issue(self): self.configure({"execution": { "concurrency": 1, "iterations": 1, "scenario": { "default-address": "http://httpbin.org/status/503", "requests": [ "/" ] } }}) self.obj.prepare() self.obj.startup() while not self.obj.check(): time.sleep(self.obj.engine.check_interval) self.obj.shutdown() self.obj.post_process() kpi_path = os.path.join(self.obj.engine.artifacts_dir, "kpi.jtl") self.assertTrue(os.path.exists(kpi_path)) reader = JTLReader(kpi_path, self.obj.log) list(reader.datapoints())
def prepare(self): """ 1) Locate script or folder 2) detect script type 3) create runner instance, prepare runner """ self.scenario = self.get_scenario() if "requests" in self.scenario: if self.scenario.get("requests"): self.scenario["script"] = self.__tests_from_requests() else: raise RuntimeError( "Nothing to test, no requests were provided in scenario") self.kpi_file = self.engine.create_artifact("selenium_tests_report", ".csv") self.err_jtl = self.engine.create_artifact("selenium_tests_err", ".xml") script_type = self.detect_script_type(self.scenario.get("script")) runner_config = BetterDict() if script_type == ".py": self.runner = NoseTester runner_config = self.settings.get("selenium-tools").get("nose") elif script_type == ".jar" or script_type == ".java": self.runner = JunitTester runner_config = self.settings.get("selenium-tools").get("junit") runner_config["script-type"] = script_type self.runner_working_dir = self.engine.create_artifact( runner_config.get("working-dir", "classes"), "") runner_config["working-dir"] = self.runner_working_dir runner_config.get("artifacts-dir", self.engine.artifacts_dir) runner_config.get("working-dir", self.runner_working_dir) runner_config.get("report-file", self.kpi_file) runner_config.get("err-file", self.err_jtl) runner_config.get("stdout", self.engine.create_artifact("junit", ".out")) runner_config.get("stderr", self.engine.create_artifact("junit", ".err")) self._cp_resource_files(self.runner_working_dir) self.runner = self.runner(runner_config, self.scenario, self.log) self.runner.prepare() self.reader = JTLReader(self.kpi_file, self.log, self.err_jtl) if isinstance(self.engine.aggregator, ConsolidatingAggregator): self.engine.aggregator.add_underling(self.reader)
def prepare(self): """ 1) Locate script or folder 2) detect script type 3) create runner instance, prepare runner """ scenario = self.get_scenario() self.kpi_file = self.engine.create_artifact("selenium_tests_report", ".csv") script_type, script_is_folder = self.detect_script_type( scenario.get("script")) runner_config = BetterDict() if script_type == ".py": self.runner = NoseTester runner_config = self.settings.get("selenium-tools").get("nose") elif script_type == ".jar" or script_type == ".java": self.runner = JunitTester runner_config = self.settings.get("selenium-tools").get("junit") runner_config["script-type"] = script_type runner_working_dir = self.engine.create_artifact( runner_config.get("working-dir", "classes"), "") runner_config["working-dir"] = runner_working_dir runner_config.get("artifacts-dir", self.engine.artifacts_dir) runner_config.get("working-dir", runner_working_dir) runner_config.get("report-file", self.kpi_file) runner_config.get("stdout", self.engine.create_artifact("junit", ".out")) runner_config.get("stderr", self.engine.create_artifact("junit", ".err")) if Scenario.SCRIPT in scenario: if script_is_folder: shutil.copytree(scenario.get("script"), runner_working_dir) else: os.makedirs(runner_working_dir) shutil.copy2(scenario.get("script"), runner_working_dir) self.runner = self.runner(runner_config, scenario, self.log) self.runner.prepare() self.reader = JTLReader(self.kpi_file, self.log, None) if isinstance(self.engine.aggregator, ConsolidatingAggregator): self.engine.aggregator.add_underling(self.reader)
def check(self): for line in self._tailer.get_lines(): if "Adding worker" in line: marker = "results=" pos = line.index(marker) fname = line[pos + len(marker):].strip() self.log.debug("Adding result reader for %s", fname) if not self.engine.is_functional_mode(): reader = JTLReader(fname, self.log) if isinstance(self.engine.aggregator, ConsolidatingAggregator): self.engine.aggregator.add_underling(reader) else: reader = FuncSamplesReader(self.report_file, self.engine, self.log) if isinstance(self.engine.aggregator, FunctionalAggregator): self.engine.aggregator.add_underling(reader) self._readers.append(reader) return super(ApiritifNoseExecutor, self).check()
def _get_reader(self): with open(self.data_file) as fhd: header = fhd.readline(2048).strip() # just header chunk of file if header.startswith(self.AB_HEADER): reader = TSVDataReader(self.data_file, self.log) reader.url_label = "N/A" return reader elif header.startswith("<?xml"): return XMLJTLReader(self.data_file, self.log) elif header.startswith("RUN\t") or "\tRUN\t" in header: return GatlingLogReader(self.data_file, self.log, None) elif "timestamp" in header.lower() and "elapsed" in header.lower(): return JTLReader(self.data_file, self.log, self.errors_file) elif re.match("^[0-9]{19},", header): # Vegeta CSV does not have a header, every line starts with a timestamp in nanoseconds return VegetaLogReader(self.data_file, self.log) else: self.log.info("Header line was: %s", header) raise TaurusInternalException("Unable to detect results format for: %s" % self.data_file)
def test_tabs_jtl(self): obj = JTLReader(RESOURCES_DIR + "/jmeter/jtl/tabs.jtl", logging.getLogger(''), None) values = [x for x in obj.datapoints(True)] self.assertEquals(4, len(values))
class TestJTLReader(BZTestCase): def setUp(self): super(TestJTLReader, self).setUp() self.obj = None def configure(self, jtl_file): self.obj = JTLReader(jtl_file, ROOT_LOGGER) def tearDown(self): if self.obj: close_reader_file(self.obj.csvreader) close_reader_file(self.obj.errors_reader) super(TestJTLReader, self).tearDown() def test_tranctl_jtl(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/tranctl.jtl") values = [x for x in self.obj.datapoints(final_pass=True)] self.assertEquals(1, len(values)) def test_tabs_jtl(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/tabs.jtl") values = [x for x in self.obj.datapoints(final_pass=True)] self.assertEquals(4, len(values)) def test_reader_unicode(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/unicode.jtl") self.obj.ignored_labels = [u"Тест.Эхо"] for point in self.obj.datapoints(final_pass=True): cumulative = point[DataPoint.CUMULATIVE] self.assertIn(u"САП.АутентифицироватьРасш", cumulative) self.assertNotIn(u"Тест.Эхо", cumulative) def test_jtl_doublequoting(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/doublequoting.jtl") list(self.obj.datapoints(final_pass=True)) def test_jtl_csv_sniffer_unicode_crash(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/quote-guessing-crash.jtl") list(self.obj.datapoints(final_pass=True)) def test_stdev_performance(self): start = time.time() self.configure(RESOURCES_DIR + "/jmeter/jtl/slow-stdev.jtl") res = list(self.obj.datapoints(final_pass=True)) lst_json = to_json(res) self.assertNotIn('"perc": {},', lst_json) elapsed = time.time() - start ROOT_LOGGER.debug("Elapsed/per datapoint: %s / %s", elapsed, elapsed / len(res)) # self.assertLess(elapsed, len(res)) # less than 1 datapoint per sec is a no-go exp = [2.2144798867972773, 0.7207704268609725, 0.606834452578833, 0.8284089170237546, 0.5858142211763572, 0.622922628329711, 0.5529488620851849, 0.6933748292117727, 0.4876162181858197, 0.42471180222446503, 0.2512251128133865] self.assertEqual(exp, [x[DataPoint.CURRENT][''][KPISet.STDEV_RESP_TIME] for x in res]) def test_kpiset_trapped_getitem(self): def new(): subj = KPISet(perc_levels=(100.0,)) subj[KPISet.RESP_TIMES].add(0.1) subj[KPISet.RESP_TIMES].add(0.01) subj[KPISet.RESP_TIMES].add(0.001) subj.recalculate() return subj def enc_dec_iter(vals): vals = list(vals) dct = {x[0]: x[1] for x in vals} jsoned = to_json(dct) return json.loads(jsoned) exp = {u'avg_ct': 0, u'avg_lt': 0, u'avg_rt': 0, u'bytes': 0, u'concurrency': 0, u'errors': [], u'fail': 0, u'perc': {u'100.0': 0.1}, u'rc': {}, u'rt': {u'0.001': 1, u'0.01': 1, u'0.1': 1}, u'stdev_rt': 0.058 if PY2 else 0.05802585630561603, u'succ': 0, u'throughput': 0} self.assertEqual(exp, enc_dec_iter(new().items())) if PY2: self.assertEqual(exp, enc_dec_iter(new().viewitems())) self.assertEqual(exp, enc_dec_iter(new().iteritems())) self.assertEqual('{"100.0": 0.1}', to_json(new().get(KPISet.PERCENTILES), indent=None))
def register_file(self, report_filename): reader = JTLReader(report_filename, self.log) self.add_underling(reader)
def prepare(self): super(MyCustomExecutor, self).prepare() self.reporting_setup(suffix='.csv') self.reader = JTLReader(self.report_file, self.log) if isinstance(self.engine.aggregator, ConsolidatingAggregator): self.engine.aggregator.add_underling(self.reader)
def configure(self, jtl_file): self.obj = JTLReader(jtl_file, logging.getLogger(''))
def configure(self, jtl_file): self.obj = JTLReader(jtl_file, ROOT_LOGGER)
def register_file(self, report_filename): self.filenames.append(report_filename) reader = JTLReader(report_filename, self.log) self.readers.append(reader)
class TestJTLReader(BZTestCase): def setUp(self): super(TestJTLReader, self).setUp() self.obj = None def configure(self, jtl_file): self.obj = JTLReader(jtl_file, ROOT_LOGGER) def tearDown(self): if self.obj: close_reader_file(self.obj.csvreader) close_reader_file(self.obj.errors_reader) super(TestJTLReader, self).tearDown() def test_tranctl_jtl(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/tranctl.jtl") values = [x for x in self.obj.datapoints(final_pass=True)] self.assertEquals(1, len(values)) def test_tabs_jtl(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/tabs.jtl") values = [x for x in self.obj.datapoints(final_pass=True)] self.assertEquals(4, len(values)) def test_reader_unicode(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/unicode.jtl") self.obj.ignored_labels = [u"Тест.Эхо"] for point in self.obj.datapoints(final_pass=True): cumulative = point[DataPoint.CUMULATIVE] self.assertIn(u"САП.АутентифицироватьРасш", cumulative) self.assertNotIn(u"Тест.Эхо", cumulative) def test_jtl_doublequoting(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/doublequoting.jtl") list(self.obj.datapoints(final_pass=True)) def test_jtl_csv_sniffer_unicode_crash(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/quote-guessing-crash.jtl") list(self.obj.datapoints(final_pass=True)) def test_stdev_performance(self): start = time.time() self.configure(RESOURCES_DIR + "jmeter/jtl/slow-stdev.jtl") res = list(self.obj.datapoints(final_pass=True)) lst_json = to_json(res) self.assertNotIn('"perc": {},', lst_json) elapsed = time.time() - start ROOT_LOGGER.debug("Elapsed/per datapoint: %s / %s", elapsed, elapsed / len(res)) # self.assertLess(elapsed, len(res)) # less than 1 datapoint per sec is a no-go exp = [ 0.53060066889723, 0.39251356581014, 0.388405157629, 0.38927586980868, 0.30511697736531, 0.21160424043633, 0.07339064994943 ] self.assertEqual(exp, [ round(x[DataPoint.CURRENT][''][KPISet.STDEV_RESP_TIME], 14) for x in res ]) def test_kpiset_trapped_getitem(self): def new(): subj = KPISet(perc_levels=(100.0, )) subj[KPISet.RESP_TIMES].add(0.1) subj[KPISet.RESP_TIMES].add(0.01) subj[KPISet.RESP_TIMES].add(0.001) subj.recalculate() return subj def enc_dec_iter(vals): vals = list(vals) dct = {x[0]: x[1] for x in vals} jsoned = to_json(dct) return json.loads(jsoned) exp = { u'avg_ct': 0, u'avg_lt': 0, u'avg_rt': 0, u'bytes': 0, u'concurrency': 0, u'errors': [], u'fail': 0, u'perc': { u'100.0': 0.1 }, u'rc': {}, u'rt': { u'0.001': 1, u'0.01': 1, u'0.1': 1 }, u'stdev_rt': 0.05802585630561603, u'succ': 0, u'throughput': 0 } self.assertEqual(exp, enc_dec_iter(new().items())) self.assertEqual('{"100.0": 0.1}', to_json(new().get(KPISet.PERCENTILES), indent=None))
def test_tranctl_jtl(self): obj = JTLReader(__dir__() + "/../data/tranctl.jtl", logging.getLogger(''), None) values = [x for x in obj.datapoints(True)] self.assertEquals(1, len(values))
class TestJTLReader(BZTestCase): def setUp(self): super(TestJTLReader, self).setUp() self.obj = None def configure(self, jtl_file): self.obj = JTLReader(jtl_file, ROOT_LOGGER) def tearDown(self): if self.obj: close_reader_file(self.obj.csvreader) close_reader_file(self.obj.errors_reader) super(TestJTLReader, self).tearDown() def test_tranctl_jtl(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/tranctl.jtl") values = [x for x in self.obj.datapoints(final_pass=True)] self.assertEquals(1, len(values)) def test_tabs_jtl(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/tabs.jtl") values = [x for x in self.obj.datapoints(final_pass=True)] self.assertEquals(4, len(values)) def test_reader_unicode(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/unicode.jtl") self.obj.ignored_labels = [u"Тест.Эхо"] for point in self.obj.datapoints(final_pass=True): cumulative = point[DataPoint.CUMULATIVE] self.assertIn(u"САП.АутентифицироватьРасш", cumulative) self.assertNotIn(u"Тест.Эхо", cumulative) def test_jtl_doublequoting(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/doublequoting.jtl") list(self.obj.datapoints(final_pass=True)) def test_jtl_csv_sniffer_unicode_crash(self): self.configure(RESOURCES_DIR + "/jmeter/jtl/quote-guessing-crash.jtl") list(self.obj.datapoints(final_pass=True)) def test_stdev_performance(self): start = time.time() self.configure(RESOURCES_DIR + "/jmeter/jtl/slow-stdev.jtl") res = list(self.obj.datapoints(final_pass=True)) lst_json = to_json(res) self.assertNotIn('"perc": {},', lst_json) elapsed = time.time() - start ROOT_LOGGER.debug("Elapsed/per datapoint: %s / %s", elapsed, elapsed / len(res)) # self.assertLess(elapsed, len(res)) # less than 1 datapoint per sec is a no-go exp = [ 2.2144798867972773, 0.7207704268609725, 0.606834452578833, 0.8284089170237546, 0.5858142211763572, 0.622922628329711, 0.5529488620851849, 0.6933748292117727, 0.4876162181858197, 0.42471180222446503, 0.2512251128133865 ] self.assertEqual( exp, [x[DataPoint.CURRENT][''][KPISet.STDEV_RESP_TIME] for x in res]) def test_kpiset_trapped_getitem(self): def new(): subj = KPISet() subj.perc_levels = (100.0, ) subj[KPISet.RESP_TIMES].add(0.1) subj[KPISet.RESP_TIMES].add(0.01) subj[KPISet.RESP_TIMES].add(0.001) subj.recalculate() return subj def enc_dec_iter(vals): vals = list(vals) dct = {x[0]: x[1] for x in vals} jsoned = to_json(dct) return json.loads(jsoned) exp = { u'avg_ct': 0, u'avg_lt': 0, u'avg_rt': 0, u'bytes': 0, u'concurrency': 0, u'errors': [], u'fail': 0, u'perc': { u'100.0': 0.1 }, u'rc': {}, u'rt': { u'0.001': 1, u'0.01': 1, u'0.1': 1 }, u'stdev_rt': 0.058 if PY2 else 0.05802585630561603, u'succ': 0, u'throughput': 0 } self.assertEqual(exp, enc_dec_iter(new().items())) if PY2: self.assertEqual(exp, enc_dec_iter(new().viewitems())) self.assertEqual(exp, enc_dec_iter(new().iteritems())) self.assertEqual('{"100.0": 0.1}', to_json(new().get(KPISet.PERCENTILES), indent=None))
def create_load_reader(self, report_file): return JTLReader(report_file, self.log, None)
def test_reader_unicode(self): reader = JTLReader(RESOURCES_DIR + "/jmeter/jtl/unicode.jtl", logging.getLogger(''), None) reader.ignored_labels = [u("Тест.Эхо")] for point in reader.datapoints(): cumulative = point[DataPoint.CUMULATIVE] self.assertNotIn("Тест.Эхо", cumulative)
def test_jtl_doublequoting(self): obj = JTLReader(RESOURCES_DIR + "/jmeter/jtl/doublequoting.jtl", logging.getLogger(), None) list(obj.datapoints(True))