def get_driver(browser: str, resolution: str): if browser.upper() == "CH": driver = webdriver.Chrome( executable_path=ChromeDriverManager().install()) elif browser.upper() == "CH_HL": options = webdriver.ChromeOptions() options.add_argument("--headless") options.add_argument("--no-sandbox") options.add_argument("--disable-dev-shm-usage") options.add_argument("--disable-setuid-sandbox") driver = webdriver.Chrome( executable_path=ChromeDriverManager().install(), chrome_options=options) else: raise KeyError(f"Unexpected browser '{browser.upper()}'." f"Check your behave.ini file for available variables") if resolution != "1200x800": resolution = resolution.split("x") screen_width = resolution[0] screen_height = resolution[1] assert_that(int(screen_width), is_(greater_than_or_equal_to(800)), reason='Width should be greater than 800') assert_that(int(screen_width), is_(less_than_or_equal_to(2000)), reason='Width should be lower than 2000') assert_that(int(screen_height), is_(greater_than_or_equal_to(600)), reason='Height should be greater than 600') assert_that(int(screen_height), is_(less_than_or_equal_to(2000)), reason='Height should be lower than 2000') driver.set_window_size(width=screen_width, height=screen_height) return driver
def it_returns_random_point_within_the_given_data_boundaries(): centroid = ml.random_centroid_in((-15, -3, 20, 10)) cx = centroid[0] cy = centroid[1] assert_that(cx, all_of( greater_than_or_equal_to(-15), less_than_or_equal_to(20))) assert_that(cy, all_of( greater_than_or_equal_to(-3), less_than_or_equal_to(10)))
def check_latlon_subsetting(self, lat_max, lat_min, lon_max, lon_min, lat_var='latitude', lon_var='longitude'): self.ds = Dataset(self.OUTPUT_FILENAME) lat = self.ds.variables[lat_var][:] lon = self.ds.variables[lon_var][:] assert_that(min(lon), greater_than_or_equal_to(lon_min)) assert_that(max(lon), less_than_or_equal_to(lon_max)) assert_that(min(lat), greater_than_or_equal_to(lat_min)) assert_that(max(lat), less_than_or_equal_to(lat_max)) self.ds.close()
def test_credential_error_no_heart_beat(self): hb = NodeHeartBeat(interval=0.01) hb.add('spa', '1.1.1.1') hb.add('spb', '1.1.1.2') assert_that(hb.is_available('spa'), equal_to(True)) assert_that(hb.is_available('spb'), equal_to(True)) time.sleep(0.1) assert_that(hb.command_count, less_than_or_equal_to(2)) assert_that(hb.command_count, less_than_or_equal_to(2)) hb.stop()
def step_impl(context): actual_time = parser.parse(context.time) assert_that( actual_time, less_than_or_equal_to( datetime.datetime.now( datetime.timezone.utc).replace(microsecond=0)))
def assert_valid_metadata(self): actual_time = parser.parse(self.response.headers['Date']) assert_that( actual_time, less_than_or_equal_to( datetime.datetime.now( datetime.timezone.utc).replace(microsecond=0)))
def _select_comparison_method(self, left, right, comparison_type): if comparison_type == Types.EQUAL: assert_that(left, equal_to(right)) elif comparison_type == Types.NOT_EQUAL: assert_that(left, is_not(equal_to(right))) elif comparison_type == Types.LESS_THAN: assert_that(left, less_than(right)) elif comparison_type == Types.LESS_THAN_EQUAL: assert_that(left, less_than_or_equal_to(right)) elif comparison_type == Types.GREATER_THAN: assert_that(left, greater_than(right)) elif comparison_type == Types.GREATER_THAN_EQUAL: assert_that(left, greater_than_or_equal_to(right)) elif comparison_type == Types.IS: assert_that(left, is_(right)) elif comparison_type == Types.IS_NOT: assert_that(left, is_not(right)) elif comparison_type == Types.IN: assert_that(left, is_in(right)) elif comparison_type == Types.NOT_IN: assert_that(left, is_not(is_in(right))) elif comparison_type == Types.MATCHES_REGEXP: assert_that(left, matches_regexp(right)) else: raise Exception()
def check_response_time(self, cmd_args, time_limit, *, specify_default_user=False, use_default_identity=False, use_default_password=False, as_sudo=False): """Check given command completes within the specified time limit Returns the contents of stdout as a string. """ start = time.monotonic() if use_default_password: cmd_output = self._run_leapp_with_askpass(cmd_args) else: add_default_user = specify_default_user or use_default_identity cmd_output = self._run_leapp( cmd_args, add_default_user=add_default_user, add_default_identity=use_default_identity, as_sudo=as_sudo) response_time = time.monotonic() - start assert_that(response_time, less_than_or_equal_to(time_limit)) return cmd_output
def check_response_time(self, cmd_args, time_limit, *, specify_default_user=False, as_sudo=False, expect_failure=False): """Check given command completes within the specified time limit Returns the contents of stdout as a string. """ is_migrate = 'migrate-machine' in cmd_args start = time.monotonic() add_default_user = specify_default_user try: cmd_output = self._run_leapp(cmd_args, add_default_user=add_default_user, is_migrate=is_migrate, as_sudo=as_sudo) except subprocess.CalledProcessError as exc: if not expect_failure: raise cmd_output = exc.stdout else: if expect_failure: raise AssertionError("Command succeeded unexpectedly") response_time = time.monotonic() - start assert_that(response_time, less_than_or_equal_to(time_limit)) return cmd_output
def check_iperf_loss_context(self, server_ssh, ip, port, time=60, max_loss=0): """Step to check that iperf loss inside CM is less than max_loss. Note: This step requires to iperf server will be launched with listening for UDP protocol. Args: server_ssh (obj): instance of stepler.third_party.ssh.SshClient ip (str): iperf server ip address port (int): iperf server port time (int, optional): time to generate traffic max_loss (float): maximum allowed datagramm loss in percents Raises: AssertionError: if iperf loss is greater than `max_loss` """ with iperf.iperf(remote=server_ssh, ip=ip, time=time, port=port, udp=True) as result: yield assert_that(result['summary']['error_percent'], less_than_or_equal_to(max_loss))
def check_pres_subsetting(self, pres_max, pres_min, pres_name='air_pressure'): import numpy as np self.ds = Dataset(self.OUTPUT_FILENAME) pres = self.ds.variables[pres_name][:] assert_that(np.min(pres), greater_than_or_equal_to(pres_min)) assert_that(np.max(pres), less_than_or_equal_to(pres_max)) self.ds.close()
def check_latlon_subsetting(self, lat_max, lat_min, lon_max, lon_min, gridded): if gridded: lat_name = "lat" lon_name = "lon" output_path = self.GRIDDED_OUTPUT_FILENAME else: lat_name = "latitude" lon_name = "longitude" output_path = self.UNGRIDDED_OUTPUT_FILENAME ds = Dataset(output_path) lat = ds.variables[lat_name][:] lon = ds.variables[lon_name][:] assert_that(min(lon), greater_than_or_equal_to(lon_min)) assert_that(max(lon), less_than_or_equal_to(lon_max)) assert_that(min(lat), greater_than_or_equal_to(lat_min)) assert_that(max(lat), less_than_or_equal_to(lat_max))
def does_not_exist_within_timeout(self, finder, **options): try: self.wait_find_with_result_matcher( finder, has_length(less_than_or_equal_to(0)), **options) return True except NotFoundError: return False
def test_GIVEN_multiple_gridded_variables_on_different_grids_WHEN_subset_THEN_subset_correctly(self): variable1 = 'v_1' variable2 = 'rh' filename = valid_1d_filename lat_min, lat_max = 40, 60 arguments = ['subset', variable1 + ',' + variable2 + ':' + filename, 'y=[%s,%s]' % (lat_min, lat_max), '-o', self.OUTPUT_FILENAME] main_arguments = parse_args(arguments) subset_cmd(main_arguments) self.ds = Dataset(self.OUTPUT_FILENAME) lat = self.ds.variables['latitude'][:] assert_that(min(lat), greater_than_or_equal_to(lat_min)) assert_that(max(lat), less_than_or_equal_to(lat_max)) lat_1 = self.ds.variables['latitude_1'][:] assert_that(min(lat_1), greater_than_or_equal_to(lat_min)) assert_that(max(lat_1), less_than_or_equal_to(lat_max)) self.check_output_contains_variables(self.OUTPUT_FILENAME, [variable1, variable2])
def test_search_performance(self): with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor: number_of_threads = 10 futures = [executor.submit(self.measure_search) for i in range(number_of_threads)] response_times = [completed.result()["response time"] for completed in as_completed(futures)] hit_numbers = [completed.result()["number of hits"] for completed in as_completed(futures)] assert_that(hit_numbers, only_contains(greater_than_or_equal_to(5))) assert_that(response_times, only_contains(less_than_or_equal_to(1000)))
def does_not_exist_within_timeout(self, finder): try: self.wait_find_with_result_matcher( finder, has_length(less_than_or_equal_to(0)) ) return True except NotFoundError: return False
def between(lower: Any, upper: Any, lower_inclusive=True, upper_inclusive=True) -> Matcher[Any]: """TODO""" return all_of( greater_than_or_equal_to(lower) if lower_inclusive else greater_than(lower), less_than_or_equal_to(upper) if upper_inclusive else less_than(upper), )
def check_response_time(self, cmd_args, time_limit): """Check given command completes within the specified time limit Returns the contents of stdout as a string. """ start = time.monotonic() cmd_output = self._run_leapp(*cmd_args) response_time = time.monotonic() - start assert_that(response_time, less_than_or_equal_to(time_limit)) return cmd_output
def step_impl(context, cid): redis = CloudRedis() link = eval(redis.get_link_by_cid(cid)) logger.info("cid %s link route is %s" % (cid, link)) assert link is not None assert_that(link, starts_with('link'), "link route is %s" % link) assert_that(len(link), less_than_or_equal_to(6), "link route is %s and length > 6" % link) assert_that(len(link), greater_than_or_equal_to(5), "link route is %s and length < 5" % link) time.sleep(1)
def test_GIVEN_multiple_gridded_variables_on_different_grids_WHEN_subset_THEN_subset_correctly(self): variable1 = "v_1" variable2 = "rh" filename = valid_1d_filename lat_min, lat_max = 40, 60 arguments = [ "subset", variable1 + "," + variable2 + ":" + filename, "y=[%s,%s]" % (lat_min, lat_max), "-o", self.OUTPUT_NAME, ] main_arguments = parse_args(arguments) subset_cmd(main_arguments) ds = Dataset(self.GRIDDED_OUTPUT_FILENAME) lat = ds.variables["latitude"][:] assert_that(min(lat), greater_than_or_equal_to(lat_min)) assert_that(max(lat), less_than_or_equal_to(lat_max)) lat_1 = ds.variables["latitude_1"][:] assert_that(min(lat_1), greater_than_or_equal_to(lat_min)) assert_that(max(lat_1), less_than_or_equal_to(lat_max)) self.check_output_contains_variables(self.GRIDDED_OUTPUT_FILENAME, [variable1, variable2])
def test_shuffle(self): """ Testing shuffle of elements. """ values = [] for pos in range(100): results = select(1, 10, 1).shuffled() exact_positions = 0 for index, value in enumerate(results): if index + 1 == value: exact_positions += 1 values.append(exact_positions) average = sum(values) / float(len(values)) assert_that(average, less_than_or_equal_to(2.0))
def test_move_right_simple(self): """Testing Tetris.move_left method.""" with mock.patch.object(Tetris, "get_next_shape") as mocked_method: shape = Raster.create_from(Tetris.SHAPES[0]) mocked_method.return_value = shape tetris = Tetris(6, 10) margin = (tetris.raster.width - shape.width) // 2 assert_that(tetris.current_column, equal_to(margin)) tetris.move_right() assert_that(tetris.current_column, equal_to(margin + 1)) expected = tetris.raster.width - tetris.shape.width for _ in range(10): tetris.move_right() assert_that(tetris.current_column, less_than_or_equal_to(expected))
def test_suite_times(report_for): start = time.time() report = report_for(""" def test(): assert True """) stop = time.time() assert_that( report.get('start'), has_float( all_of(greater_than(start * 1000), less_than_or_equal_to(float(report.get('stop')))))) assert_that( report.get('stop'), has_float( all_of( greater_than(float(report.get('start'))), less_than_or_equal_to(stop * 1000), )))
def test_some_fast_work(self): before = datetime.datetime.now() futures = [] for i in range(0, 20): futures += [self._subject.submit(short_sleep)] for future in as_completed(futures): _ = future.result() after = datetime.datetime.now() assert_that((after - before).total_seconds(), less_than_or_equal_to(0.3))
def test_interval_change(self): hb = NodeHeartBeat(interval=0.1) hb.add('spa', '1.1.1.1') hb.add('spb', '1.1.1.2') time.sleep(0.5) hb.interval = 2 time.sleep(1) # total call count is calculated like this: # interval = 0.1, duration = 0.5, 5 >= cycle >= 4 # interval = 2, duration = 1, 0 <= cycle <= 1 # 4 <= total cycle <= 6 # each cycle has 2 call (one for each SP) # 8 <= total call count <= 12 assert_that(hb.command_count, less_than_or_equal_to(12)) assert_that(hb.command_count, greater_than_or_equal_to(8)) hb.stop()
def check_ping_loss_context(self, ip_to_ping, max_loss=0, server_ssh=None): """Step to check that ping losses inside CM is less than max_loss. Args: ip_to_ping (str): ip address to ping max_loss (int): maximum allowed pings loss server_ssh (obj, optional): instance of stepler.third_party.ssh.SshClient. If None - ping will be run from local machine Raises: AssertionError: if ping loss is greater than `max_loss` """ with ping.Pinger(ip_to_ping, remote=server_ssh) as result: yield assert_that(result.loss, less_than_or_equal_to(max_loss))
def check_temporal_subsetting(self, t_min, t_max): import datetime self.ds = Dataset(self.OUTPUT_FILENAME) cis_standard = datetime.datetime(1600, 1, 1, 0, 0, 0) time = self.ds.variables['time'] datetime_min = datetime.datetime.strptime(t_min, "%Y-%m-%dT%H:%M:%S") datetime_max = datetime.datetime.strptime(t_max, "%Y-%m-%dT%H:%M:%S") # Expand the search by a second either way to avoid rounding problems datetime_min -= datetime.timedelta(seconds=1.5) datetime_max += datetime.timedelta(seconds=1.5) time_vals = convert_time_since_to_std_time(time[:], time.units) for time_val in time_vals: delta = datetime.timedelta(days=time_val) datetime_value = cis_standard + delta assert_that(datetime_value, greater_than_or_equal_to(datetime_min)) assert_that(datetime_value, less_than_or_equal_to(datetime_max))
def test_cancels(): proceed = Event() count = 1000 running_count = 0 canceled_count = 0 exception_count = 0 completed_count = 0 futures = [] executor = Executors.thread_pool(max_workers=2).with_cancel_on_shutdown() futures = [executor.submit(proceed.wait) for _ in range(0, count)] # I'm using wait=False here since otherwise it could block on the 2 threads # currently in progress to finish their work items. I can't see a way to # make the test fully synchronized, and using wait=True, without deadlock. executor.shutdown(wait=False) # Now let those two threads complete (if they've started) proceed.set() # Collect status of the futures. for future in futures: if future.running(): running_count += 1 elif future.cancelled(): canceled_count += 1 elif future.exception(): exception_count += 1 elif future.done(): completed_count += 1 # No futures should have failed assert_that(exception_count, equal_to(0)) # Could have been anywhere from 0..2 futures running assert_that(running_count, is_in((0, 1, 2))) # Could have been anywhere from 0..2 futures completed assert_that(completed_count, is_in((0, 1, 2))) # All others should have been cancelled assert_that(canceled_count, less_than_or_equal_to(count)) assert_that(canceled_count, greater_than_or_equal_to(count - 2)) # Harmless to call shutdown again executor.shutdown()
def test_some_fast_work(self): work = MagicMock() work.side_effect = short_sleep() before = datetime.datetime.now() for i in range(0, 20): self._subject.submit(work) while len(work.mock_calls) < 20: time.sleep(0.01) after = datetime.datetime.now() assert_that(work.mock_calls, equal_to([call()] * 20)) assert_that((after - before).total_seconds(), less_than_or_equal_to(0.2))
def test_comparisons(self): mc1 = self._makeOne() mc2 = self._makeOne() assert_that(mc1, is_(mc2)) try: mc2.increment() except NotImplementedError: self.skipTest("Does not support incrementing.") assert_that(mc1, is_(less_than(mc2))) assert_that(mc2, is_(greater_than(mc1))) mc1.increment() assert_that(mc1, is_(less_than_or_equal_to(mc2))) assert_that(hash(mc1), is_(mc1.value))
def test_throttle(block): THREADS = 8 COUNT = 3 samples = [] running_now = [] lock = Lock() def record(x): with lock: running_now.append(x) samples.append(running_now[:]) # Need to ensure the function takes some time to run # so the futures don't complete as fast as we submit them time.sleep(0.001) with lock: running_now.remove(x) futures = [] executor = ThrottleExecutor(Executors.thread_pool(max_workers=THREADS), count=COUNT, block=block) with executor: for i in range(0, 1000): future = executor.submit(record, i) futures.append(future) # They should all be able to complete for future in futures: future.result(30.0) # Now have a look at running counts max_len = 0 for i, sample in enumerate(samples): # There should never have been more futures running than the limit sample_len = len(sample) assert_that(sample_len, less_than_or_equal_to(COUNT), "failed at step %s" % i) max_len = max(max_len, sample_len) # It should have been able to run up to the limit too assert_that(max_len, equal_to(COUNT))
def check_arping_loss_context(self, server_ssh, ip, iface='eth0', max_loss=0): """Step to check that arping losses inside CM is less than max_loss. Args: server_ssh (obj, optional): instance of stepler.third_party.ssh.SshClient ip (str): ip address to ping iface (str, optional): name of interface to arping max_loss (int): maximum allowed pings loss Raises: AssertionError: if ping loss is greater than `max_loss` """ with arping.arping(ip, iface=iface, remote=server_ssh) as result: yield assert_that(result['sent'] - result['received'], less_than_or_equal_to(max_loss))
def step_impl(context, message, url): if message.startswith('Repeat'): repeat_cmd, message = message.split(': ', 1) repeat_times = int(repeat_cmd[-1]) message *= repeat_times if url == 'None': url = None else: if len(' '.join((message, url))) >= 140: message = message[:136 - len(url)] + '... %s' % url else: message += ' %s' % url truncated = BaseStream.truncate_message(None, message, url) assert_that(len(truncated), less_than_or_equal_to(140)) if url is None and len(truncated) == 140: assert_that(truncated[-3:], equal_to('...'), 'Message was truncated but ellipses are missing.') assert_that(truncated[:-3], equal_to(message[:137])) else: assert_that(truncated, equal_to(message))
def check_aux_subsetting(self, aux_min, aux_max, var): self.ds = Dataset(self.OUTPUT_FILENAME) alt = self.ds.variables[var][:] assert_that(alt.min(), greater_than_or_equal_to(aux_min)) assert_that(alt.max(), less_than_or_equal_to(aux_max)) self.ds.close()
def check_alt_subsetting(self, alt_max, alt_min): self.ds = Dataset(self.OUTPUT_FILENAME) alt = self.ds.variables['altitude'][:] assert_that(min(alt), greater_than_or_equal_to(alt_min)) assert_that(max(alt), less_than_or_equal_to(alt_max)) self.ds.close()
def test_print_queue_calculations(self): default_timeout = 0.1 max_speed_x = 3 max_speed_y = 2 axis_config = { 'x': { 'max_acceleration': 0.5, 'max_speed': max_speed_x, 'bow': 1, 'steps_per_mm': 1 }, 'y': { 'max_acceleration': 0.5, 'max_speed': max_speed_y, 'bow': 1, 'steps_per_mm': 1 }, 'z': { 'steps_per_mm': 1 }, 'e': { 'steps_per_mm': 1 } } queue = PrintQueue(axis_config=axis_config, min_length=20, max_length=21) queue.default_target_speed = 5 # TODO add a movement to check if it accelerates correctly # we do not need any real buffer for i in range(6): queue.add_movement({ 'type': 'move', 'x': i + 1, 'y': i + 1, 'f': 10 }) last_movement = queue.previous_movement assert_that(last_movement['speed'], not_none()) assert_that(last_movement['speed']['x'], not_none()) assert_that(last_movement['speed']['x'], less_than_or_equal_to(max_speed_x)) assert_that(last_movement['speed']['y'], not_none()) assert_that(last_movement['speed']['y'], less_than_or_equal_to(max_speed_y)) assert_that(last_movement['speed']['x'], close_to(max_speed_y, 0.01)) # becaus we go 1/1 each time assert_that(last_movement['speed']['y'], close_to(max_speed_y, 0.01)) queue.add_movement({ 'type': 'move', 'x': 7, 'y': 6 }) last_movement = queue.previous_movement assert_that(last_movement['speed']['x'], less_than_or_equal_to(max_speed_x)) assert_that(last_movement['speed']['x'], greater_than(0)) assert_that(last_movement['speed']['y'], equal_to(0)) previous_movement = queue.planning_list[-1] assert_that(previous_movement['speed']['x'], less_than(max_speed_x)) assert_that(previous_movement['speed']['y'], less_than(max_speed_y)) assert_that(previous_movement['y_stop'], equal_to(True)) # we still go on in x - so in thery we can speed up to desired target speed assert_that(last_movement['speed']['x'], greater_than(previous_movement['speed']['x'])) previous_movement = queue.planning_list[-3] assert_that(previous_movement['speed']['x'], close_to(max_speed_y, 0.5)) # becaus we go 1/1 each time assert_that(previous_movement['speed']['y'], close_to(max_speed_y, 0.5)) queue.add_movement({ 'type': 'move', 'x': 7, 'y': 7 }) last_movement = queue.previous_movement assert_that(last_movement['speed']['x'], equal_to(0)) assert_that(last_movement['speed']['y'], greater_than(0)) assert_that(last_movement['speed']['y'], less_than(max_speed_y)) previous_movement = queue.planning_list[-1] assert_that(previous_movement['speed']['x'], less_than(max_speed_x)) assert_that(previous_movement['x_stop'], equal_to(True)) assert_that(previous_movement['speed']['y'], less_than(max_speed_y)) assert_that(previous_movement['speed']['y'], equal_to(0)) previous_movement = queue.planning_list[-4] assert_that(previous_movement['speed']['x'], close_to(max_speed_y, 0.5)) # becaus we go 1/1 each time assert_that(previous_movement['speed']['y'], close_to(max_speed_y, 0.5)) # let's go back to zero to begin a new test queue.add_movement({ 'type': 'move', 'x': 0, 'y': 7 }) last_movement = queue.previous_movement # it is a long go - so we should be able to speed up to full steam assert_that(last_movement['speed']['x'], close_to(-max_speed_x, 0.5)) assert_that(last_movement['speed']['y'], equal_to(0)) previous_movement = queue.planning_list[-1] assert_that(previous_movement['y_stop'], equal_to(True)) queue.add_movement({ 'type': 'move', 'x': 0, 'y': 0 }) last_movement = queue.previous_movement # it is a long go - so we should be able to speed up to full steam assert_that(last_movement['speed']['x'], equal_to(0)) assert_that(last_movement['speed']['y'], close_to(-max_speed_y, 0.5)) previous_movement = queue.planning_list[-1] assert_that(previous_movement['x_stop'], equal_to(True)) # speed up for i in range(4): queue.add_movement({ 'type': 'move', 'x': i + 1, 'y': i + 1, }) last_movement = queue.previous_movement assert_that(last_movement['speed']['x'], close_to(max_speed_y, 0.01)) # becaus we go 1/1 each time assert_that(last_movement['speed']['y'], close_to(max_speed_y, 0.01)) # and check if we can do a full stop queue.add_movement({ 'type': 'move', 'x': 3, 'y': 3 }) last_movement = queue.previous_movement assert_that(last_movement['speed']['x'], less_than(0)) assert_that(last_movement['speed']['x'], greater_than(-max_speed_x)) assert_that(last_movement['speed']['y'], less_than(0)) assert_that(last_movement['speed']['y'], greater_than(-max_speed_y)) previous_movement = queue.planning_list[-1] assert_that(previous_movement['speed']['x'], less_than(max_speed_x)) assert_that(previous_movement['speed']['y'], less_than(max_speed_y)) assert_that(previous_movement['y_stop'], equal_to(True)) assert_that(previous_movement['x_stop'], equal_to(True)) another_previous_movement = queue.planning_list[-3] assert_that(another_previous_movement['speed']['x'], greater_than(previous_movement['speed']['x'])) # becaus we stopped to turn around assert_that(another_previous_movement['speed']['y'], greater_than(previous_movement['speed']['x']))
def step_impl(context, low, high): cap = cv2.VideoCapture(context.output_file_path) length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) cap.release() assert_that(length, greater_than_or_equal_to(int(low)), less_than_or_equal_to(int(high)))
def step_impl(context, low, high): media_info = MediaInfo.parse(context.output_file_path) duration_in_seconds = int(media_info.tracks[0].duration * 1000) assert_that(duration_in_seconds, greater_than_or_equal_to(int(low)), less_than_or_equal_to(high))