def test_constraints(self, ports): a, b = ports self.expectThat(a, GreaterThan(0)) self.expectThat(a, LessThan(65536)) self.expectThat(b, GreaterThan(0)) self.expectThat(b, LessThan(65536)) self.expectThat(a, Not(Equals(b)))
def test_build_environment_can_depend_on_part_env(self): self.useFixture(FakeOsRelease()) snapcraft_yaml = dedent("""\ name: test base: core18 version: "1" summary: test description: test confinement: strict grade: stable parts: part1: plugin: nil build-environment: - PART_INSTALL: $SNAPCRAFT_PART_INSTALL """) project_config = self.make_snapcraft_project(snapcraft_yaml) part = project_config.parts.get_part("part1") environment = project_config.parts.build_env_for_part(part) snapcraft_definition_index = -1 build_environment_definition_index = -1 for index, variable in enumerate(environment): if variable.startswith("SNAPCRAFT_PART_INSTALL="): snapcraft_definition_index = index if variable.startswith("PART_INSTALL="): build_environment_definition_index = index # Assert that each definition was found, and the part env came before the # build environment self.assertThat(snapcraft_definition_index, GreaterThan(-1)) self.assertThat(build_environment_definition_index, GreaterThan(-1)) self.assertThat(build_environment_definition_index, GreaterThan(snapcraft_definition_index))
class TestGreaterThanInterface(TestCase, TestMatchersInterface): matches_matcher = GreaterThan(4) matches_matches = [5, 8] matches_mismatches = [-2, 0, 4] str_examples = [ ("GreaterThan(12)", GreaterThan(12)), ] describe_examples = [ ('5 is not < 4', 4, GreaterThan(5)), ('4 is not < 4', 4, GreaterThan(4)), ]
def test_window_geometry(self): """Window.geometry property Check that all Window geometry properties work and have a plausible range. """ # ensure we have at least one open app window self.start_mock_app(EmulatorBase) display = Display.create() top = left = right = bottom = None # for multi-monitor setups, make sure we examine the full desktop # space: for monitor in range(display.get_num_screens()): sx, sy, swidth, sheight = Display.create().get_screen_geometry( monitor ) logger.info( "Monitor %d geometry is (%d, %d, %d, %d)", monitor, sx, sy, swidth, sheight, ) if left is None or sx < left: left = sx if top is None or sy < top: top = sy if right is None or sx + swidth >= right: right = sx + swidth if bottom is None or sy + sheight >= bottom: bottom = sy + sheight logger.info( "Total desktop geometry is (%d, %d), (%d, %d)", left, top, right, bottom, ) for win in self.process_manager.get_open_windows(): logger.info("Win '%r' geometry is %r", win, win.geometry) geom = win.geometry self.assertThat(len(geom), Equals(4)) self.assertThat(geom[0], GreaterThan(left - 1)) # no GreaterEquals self.assertThat(geom[1], GreaterThan(top - 1)) self.assertThat(geom[2], LessThan(right)) self.assertThat(geom[3], LessThan(bottom))
def _click_overlay(self): popup_controller = self.get_popup_controller() new_view_watcher = popup_controller.watch_signal( 'newViewCreated(QString)') animation_watcher = popup_controller.watch_signal( 'windowOverlayOpenAnimationDone()') animation_signal_emission = animation_watcher.num_emissions views = self.get_popup_overlay_views() self.assertThat(len(views), Equals(0)) self._click_href_target_blank() self.assertThat(lambda: new_view_watcher.was_emitted, Eventually(Equals(True))) self.assertThat(lambda: len(self.get_popup_overlay_views()), Eventually(Equals(1))) views = self.get_popup_overlay_views() overlay = views[0] self.assertThat( overlay.select_single(objectName="overlayWebview").url, Contains('/open-close-content')) self.assertThat(lambda: animation_watcher.num_emissions, Eventually(GreaterThan(animation_signal_emission)))
def test_pressing_prev_after_5_seconds(self): """Pressing previous after 5s jumps to the start of current song""" self.app.populate_queue() # populate queue now_playing_page = self.app.get_now_playing_page() self.player.isPlaying.wait_for(True) # ensure the track is playing # wait until > 5s self.player.position.wait_for(GreaterThan(5000)) now_playing_page.click_play_button() # pause the track self.player.isPlaying.wait_for(False) # ensure the track has paused source = self.player.currentMeta.filename # store current source now_playing_page.click_previous_button() # click previous # resume the track (to ensure position updates) now_playing_page.click_play_button() # wait until < 5s self.player.position.wait_for(LessThan(5000)) # Check that the source is the same self.assertThat(self.player.currentMeta.filename, Eventually(Equals(source)))
def test_max_overlay_count_reached(self): args = [] self.launch_webcontainer_app_with_local_http_server( args, '/open-close-content', {'WEBAPP_CONTAINER_BLOCK_OPEN_URL_EXTERNALLY': '1'}) self.get_webcontainer_window().visible.wait_for(True) popup_controller = self.get_popup_controller() webview = self.get_oxide_webview() self.assertThat(lambda: webview.visible, Eventually(Equals(True))) animation_watcher = popup_controller.watch_signal( 'windowOverlayOpenAnimationDone()') animation_signal_emission = animation_watcher.num_emissions OVERLAY_MAX_COUNT = 3 for i in range(0, OVERLAY_MAX_COUNT): self.click_href_target_blank() self.assertThat(lambda: animation_watcher.num_emissions, Eventually(GreaterThan(animation_signal_emission))) animation_signal_emission = animation_watcher.num_emissions external_open_watcher = popup_controller.watch_signal( 'openExternalUrlTriggered(QString)') self.click_href_target_blank() self.assertThat(lambda: external_open_watcher.was_emitted, Eventually(Equals(True)))
def test_find_query(self): """Creates a story, then does a find to see if it can be located by a partial name from a separate connection instance. """ searchName = "" exceptionReached = False with PublicTestServerConnection.getV1Meta() as v1create: createdStory = self._create_story(v1create) # make a search term that's just one character shorter searchName = createdStory.Name[:-1] self.addDetail('search-name', text_content(searchName)) with PublicTestServerConnection.getV1Meta() as v1find: findItems = None findItem = None size = 0 firstName = "" try: findItems = v1find.Story.select('Name').find(text=searchName, field='Name') findItem = findItems.first() #actually run the query size = len(findItems) firstName = findItem.Name except Exception as e: raise e #exceptions here are almost always because the query failed to work right exceptionReached = True else: # at the very least we should have found the one we based the search string on self.assertThat(size, GreaterThan(0)) # results need to contain the string we searched for self.assertThat(firstName, Contains(searchName)) self.assertFalse(exceptionReached)
def test_shopping_scope_preview_navigate_right(self): """This test shows that shopping scope results can open previews, then move to the next shopping result. """ self.unity.dash.ensure_visible() scope = self.unity.dash.get_current_scope() self.keyboard.type("playstation") results_category = scope.get_category_by_name(_("More suggestions")) refresh_results_fn = lambda: len(results_category.get_results()) self.assertThat(refresh_results_fn, Eventually(GreaterThan(2), timeout=25)) results = results_category.get_results() results[0].preview() self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(True))) self.preview_container = self.unity.dash.view.get_preview_container() start_index = self.preview_container.relative_nav_index self.preview_container.navigate_right() self.assertThat(self.preview_container.relative_nav_index, Eventually(Equals(start_index + 1)))
def matches_time_or_just_before(time, tolerance=timedelta(seconds=10)): """ Match a time to be equal to a certain time or just before it. Useful when checking for a time that is now +/- some amount of time. """ return MatchesAll(GreaterThan(time - tolerance), MatchesAny(LessThan(time), Equals(time)))
def test_launcher_switcher_cycling_backward(self): """Launcher Switcher must loop through icons when cycling backwards""" self.start_switcher_with_cleanup_cancel() self.launcher_instance.switcher_prev() # FIXME We can't directly check for self.unity.launcher.num_launcher_icons - 1 self.assertThat(self.unity.launcher.key_nav_selection, Eventually(GreaterThan(1)))
def test_automatic_retries(self): hook = self.factory.makeWebhook() job = WebhookDeliveryJob.create(hook, 'test', payload={'foo': 'bar'}) client = MockWebhookClient(response_status=503) self.useFixture(ZopeUtilityFixture(client, IWebhookClient)) # The first attempt fails but schedules a retry five minutes later. self.assertEqual(False, self.runJob(job)) self.assertEqual(JobStatus.WAITING, job.status) self.assertEqual(False, job.successful) self.assertTrue(job.pending) self.assertIsNot(None, job.date_sent) last_date_sent = job.date_sent # Pretend we're five minutes in the future and try again. The # job will be retried again. job.json_data['date_first_sent'] = ( job.date_first_sent - timedelta(minutes=5)).isoformat() job.scheduled_start -= timedelta(minutes=5) self.assertEqual(False, self.runJob(job)) self.assertEqual(JobStatus.WAITING, job.status) self.assertEqual(False, job.successful) self.assertTrue(job.pending) self.assertThat(job.date_sent, GreaterThan(last_date_sent)) # If the job was first tried a day ago, the next attempt gives up. job.json_data['date_first_sent'] = ( job.date_first_sent - timedelta(hours=24)).isoformat() job.scheduled_start -= timedelta(hours=24) self.assertEqual(False, self.runJob(job)) self.assertEqual(JobStatus.FAILED, job.status) self.assertEqual(False, job.successful) self.assertFalse(job.pending)
def test_scheduled_start(self): # Submit four jobs: one in the past, one in the far future, one # in 10 seconds, and one at any time. Wait up to a minute and # ensure that the correct three have completed, and that they # completed in the expected order. self.useFixture( FeatureFixture({'jobs.celery.enabled_classes': 'TestJob'})) now = datetime.now(UTC) job_past = TestJob(scheduled_start=now - timedelta(seconds=60)) job_past.celeryRunOnCommit() self.assertTrue(job_past.is_runnable) job_forever = TestJob(scheduled_start=now + timedelta(seconds=600)) job_forever.celeryRunOnCommit() self.assertFalse(job_forever.is_runnable) job_future = TestJob(scheduled_start=now + timedelta(seconds=10)) job_future.celeryRunOnCommit() self.assertFalse(job_future.is_runnable) job_whenever = TestJob(scheduled_start=None) job_whenever.celeryRunOnCommit() self.assertTrue(job_whenever.is_runnable) transaction.commit() count = 0 while (count < 300 and (job_past.is_pending or job_future.is_pending or job_whenever.is_pending)): sleep(0.2) count += 1 transaction.abort() self.assertEqual(JobStatus.COMPLETED, job_past.status) self.assertEqual(JobStatus.COMPLETED, job_future.status) self.assertEqual(JobStatus.COMPLETED, job_whenever.status) self.assertEqual(JobStatus.WAITING, job_forever.status) self.assertThat(job_future.date_started, GreaterThan(job_past.date_started))
def test_autoscrolling_from_bottom(self): """Tests the autoscrolling from the bottom of the Launcher""" self.open_apps_in_launcher() # Set the autoscroll_offset to 10 (this is arbitrary for this test). autoscroll_offset = 10 launcher_instance = self.get_launcher() (x, y, w, h) = launcher_instance.geometry icons = self.unity.launcher.model.get_launcher_icons_for_monitor( self.launcher_monitor) num_icons = self.unity.launcher.model.num_launcher_icons() last_icon = icons[num_icons - 1] # Move mouse to the middle of the Launcher in order to expand all # of the icons for scrolling launcher_instance.move_mouse_over_launcher() # Make sure the last icon is off the screen or else there is no # scrolling. self.assertThat(last_icon.center.y, GreaterThan(h)) # Autoscroll to the last icon launcher_instance.move_mouse_to_icon(last_icon, autoscroll_offset) (x_fin, y_fin) = self.mouse.position() # Make sure we ended up in the center of the last icon self.assertThat(x_fin, Equals(last_icon.center.x)) self.assertThat(y_fin, Equals(last_icon.center.y))
def test_updateStatus_BUILDING_sets_date_started(self): # updateStatus sets date_started on transition to BUILDING. # date_first_dispatched is also set if it isn't already. self.assertEqual(BuildStatus.NEEDSBUILD, self.build_farm_job.status) self.assertIs(None, self.build_farm_job.date_started) self.assertIs(None, self.build_farm_job.date_first_dispatched) self.build_farm_job.updateStatus(BuildStatus.CANCELLED) self.assertIs(None, self.build_farm_job.date_started) self.assertIs(None, self.build_farm_job.date_first_dispatched) # Setting it to BUILDING for the first time sets date_started # and date_first_dispatched. self.build_farm_job.updateStatus(BuildStatus.NEEDSBUILD) self.build_farm_job.updateStatus(BuildStatus.BUILDING) self.assertIsNot(None, self.build_farm_job.date_started) first = self.build_farm_job.date_started self.assertEqual(first, self.build_farm_job.date_first_dispatched) self.build_farm_job.updateStatus(BuildStatus.FAILEDTOBUILD) with admin_logged_in(): self.build_farm_job.retry() self.assertIs(None, self.build_farm_job.date_started) self.assertEqual(first, self.build_farm_job.date_first_dispatched) # But BUILDING a second time doesn't change # date_first_dispatched. self.build_farm_job.updateStatus(BuildStatus.BUILDING) self.assertThat(self.build_farm_job.date_started, GreaterThan(first)) self.assertEqual(first, self.build_farm_job.date_first_dispatched)
def test__returns_at_most_60kiB_of_JSON(self): # Configure the rack controller subnet to be very large so it # can hold that many BMC connected to the interface for the rack # controller. rack = factory.make_RackController(power_type='') rack_interface = rack.get_boot_interface() subnet = factory.make_Subnet( cidr=str(factory.make_ipv6_network(slash=8))) factory.make_StaticIPAddress(ip=factory.pick_ip_in_Subnet(subnet), subnet=subnet, interface=rack_interface) # Ensure that there are at least 64kiB of power parameters (when # converted to JSON) in the database. example_parameters = {"key%d" % i: "value%d" % i for i in range(250)} remaining = 2**16 while remaining > 0: node = self.make_Node(bmc_connected_to=rack, power_parameters=example_parameters) remaining -= len(json.dumps(node.get_effective_power_parameters())) nodes = list_cluster_nodes_power_parameters( rack.system_id, limit=None) # Remove numeric limit. # The total size of the JSON is less than 60kiB, but only a bit. nodes_json = map(json.dumps, nodes) nodes_json_lengths = map(len, nodes_json) nodes_json_length = sum(nodes_json_lengths) expected_maximum = 60 * (2**10) # 60kiB self.expectThat(nodes_json_length, LessThan(expected_maximum + 1)) expected_minimum = 50 * (2**10) # 50kiB self.expectThat(nodes_json_length, GreaterThan(expected_minimum - 1))
def test_change_searchengine(self): settings = self.open_settings() searchengine = settings.get_searchengine_entry() old_engine = searchengine.currentSearchEngineDisplayName self.assertThat(old_engine, NotEquals("")) self.pointing_device.click_object(searchengine) searchengine_page = settings.get_searchengine_page() self.assertThat( lambda: len( searchengine_page.select_many(objectName="searchEngineDelegate" )), Eventually(GreaterThan(1))) delegates = searchengine_page.select_many( objectName="searchEngineDelegate") delegates.sort(key=lambda delegate: delegate.objectName) new_index = -1 for (i, delegate) in enumerate(delegates): checkbox = delegate.select_single(uitk.CheckBox) if (new_index == -1) and not checkbox.checked: new_index = i self.assertThat(checkbox.checked, Equals(delegate.displayName == old_engine)) new_engine = delegates[new_index].displayName self.assertThat(new_engine, NotEquals(old_engine)) self.pointing_device.click_object(delegates[new_index].select_single( uitk.CheckBox)) searchengine_page.wait_until_destroyed() self.assertThat(searchengine.currentSearchEngineDisplayName, Eventually(Equals(new_engine)))
def test_cache_by_bug_notification_level(self): # The BugNotificationRecipients set is cached by notification level # to avoid duplicate work. The returned set is copy of the cached set. subscriber = self.factory.makePerson() product = self.factory.makeProduct() with person_logged_in(subscriber): subscription = product.addBugSubscription(subscriber, subscriber) bug_filter = subscription.bug_filters[0] bug_filter.bug_notification_level = BugNotificationLevel.COMMENTS bug = self.factory.makeBug(target=product) # The factory call queued LIFECYCLE and COMMENT notifications. bug.clearBugNotificationRecipientsCache() levels = [ BugNotificationLevel.LIFECYCLE, BugNotificationLevel.METADATA, BugNotificationLevel.COMMENTS, ] for level in levels: with StormStatementRecorder() as recorder: first_recipients = bug.getBugNotificationRecipients( level=level) self.assertThat(recorder, HasQueryCount(GreaterThan(1))) with StormStatementRecorder() as recorder: second_recipients = bug.getBugNotificationRecipients( level=level) self.assertThat(recorder, HasQueryCount(Equals(0))) self.assertContentEqual([bug.owner, subscriber], first_recipients) self.assertContentEqual(first_recipients, second_recipients) self.assertIsNot(first_recipients, second_recipients)
def test_patch(self): representation = self.webservice.get(self.webhook_url, api_version='devel').jsonBody() self.assertThat( representation, ContainsDict({ 'active': Equals(True), 'delivery_url': Equals('http://example.com/ep'), 'event_types': Equals([]) })) old_mtime = representation['date_last_modified'] patch = json.dumps({ 'active': False, 'delivery_url': 'http://example.com/ep2', 'event_types': ['git:push:0.1'] }) self.webservice.patch(self.webhook_url, 'application/json', patch, api_version='devel') representation = self.webservice.get(self.webhook_url, api_version='devel').jsonBody() self.assertThat( representation, ContainsDict({ 'active': Equals(False), 'delivery_url': Equals('http://example.com/ep2'), 'date_last_modified': GreaterThan(old_mtime), 'event_types': Equals(['git:push:0.1']) }))
def test_jobs_with_retry_exceptions_are_queued_again(self): # A job that raises a retry error is automatically queued # and executed again. self.useFixture( FeatureFixture( {'jobs.celery.enabled_classes': 'TestJobWithRetryError'})) # Set scheduled_start on the job to ensure that retry delays # override it. job = TestJobWithRetryError(scheduled_start=datetime.now(UTC) + timedelta(seconds=1)) job.celeryRunOnCommit() transaction.commit() count = 0 while count < 300 and job.is_pending: # We have a maximum wait of one minute. We should not get # anywhere close to that on developer machines (10 seconds was # working fine), but when the test suite is run in parallel we # can need a lot more time (see bug 1007576). sleep(0.2) count += 1 transaction.abort() # Collect the start times recorded by the job. dates_started = [ iso8601.parse_date(d) for d in job.job.base_json_data['dates_started'] ] # The first attempt's lease is set to the end of the job, so the # second attempt should start roughly 5 seconds after the first. The # third attempt should start roughly 5 seconds after the second. self.assertThat(dates_started, HasLength(3)) self.assertThat( dates_started, MatchesListwise([ MatchesAll(), MatchesAll( GreaterThan(dates_started[0] + timedelta(seconds=4)), LessThan(dates_started[0] + timedelta(seconds=8))), MatchesAll( GreaterThan(dates_started[1] + timedelta(seconds=4)), LessThan(dates_started[1] + timedelta(seconds=8))), ])) self.assertEqual(3, job.attempt_count) self.assertEqual(JobStatus.COMPLETED, job.status)
def test_clear_with_multiple_lines(self): # This is a regrestion test for http://pad.lv/1359167 self.simple_text_area.write( 'Long text that will make it wrap into multiple lines.') self.assertThat(self.simple_text_area.lineCount, GreaterThan(1)) self.simple_text_area._go_to_start() self.simple_text_area.clear() self.assertEqual(self.simple_text_area.text, '')
def test_default(self): """ There are default values for the delay and maximum time parameters accepted by ``get_default_retry_steps``. """ steps = get_default_retry_steps() self.assertThat(steps, AllMatch(IsInstance(timedelta))) self.assertThat(steps, AllMatch(GreaterThan(timedelta())))
def test_show_list_of_suggestions(self): suggestions = self.main_window.get_suggestions() self.assert_suggestions_eventually_hidden() self.address_bar.focus() self.assert_suggestions_eventually_shown() self.assertThat(suggestions.count, Eventually(GreaterThan(0))) self.address_bar.clear() self.assert_suggestions_eventually_hidden()
def eval_expression_in_page_unsafe(self, expr): webview = self.get_webviewContainer() prev_emissions = self.watcher.num_emissions webview.slots.evalInPageUnsafe(expr) self.assertThat( lambda: self.watcher.num_emissions, Eventually(GreaterThan(prev_emissions))) return webview.get_signal_emissions('resultUpdated(QString)')[-1][0]
def open_panel_menu(self): panel = self.unity.panels.get_panel_for_monitor(0) self.assertThat(lambda: len(panel.menus.get_entries()), Eventually(GreaterThan(0))) self.addCleanup(self.keyboard.press_and_release, "Escape") self.keybinding("panel/open_first_menu") self.assertThat(self.unity.panels.get_active_indicator, Eventually(NotEquals(None)))
def test_comparison(self): """ The binary comparison operations work on ``KubernetesError`` as expected. """ model = v1_5_model a1 = KubernetesError(200, model.v1.Status(status=u"A")) a2 = KubernetesError(200, model.v1.Status(status=u"A")) b = KubernetesError(201, model.v1.Status(status=u"A")) c = KubernetesError(200, model.v1.Status(status=u"B")) # a1 == a2 self.expectThat(a1, Equals(a2)) # not (a1 != a2) self.expectThat(a1, Not(NotEquals(a2))) # not (a1 > a2) self.expectThat(a1, Not(GreaterThan(a2))) # not (a1 < a2) self.expectThat(a1, Not(LessThan(a2))) # not (a1 == b) self.expectThat(a1, Not(Equals(b))) # a1 != b self.expectThat(a1, NotEquals(b)) # a1 < b self.expectThat(a1, LessThan(b)) # not (a1 > b) self.expectThat(a1, Not(GreaterThan(b))) # not (a1 == c) self.expectThat(a1, Not(Equals(b))) # a1 != c self.expectThat(a1, NotEquals(b)) # a1 < c self.expectThat(a1, LessThan(c)) # not (a1 > c) self.expectThat(a1, Not(GreaterThan(c))) largest = KubernetesError(999, model.v1.Status(status=u"Z")) smallest = KubernetesError(1, model.v1.Status(status=u"A")) # a1 < largest self.expectThat(a1, LessThan(largest)) # a1 > smallest self.expectThat(a1, GreaterThan(smallest))
def test_launcher_keynav_prev_works(self): """Must be able to move backwards while in keynav mode.""" self.start_keynav_with_cleanup_cancel() self.launcher_instance.key_nav_next(self.launcher_position) self.assertThat(self.unity.launcher.key_nav_selection, Eventually(GreaterThan(0))) self.launcher_instance.key_nav_prev(self.launcher_position) self.assertThat(self.unity.launcher.key_nav_selection, Eventually(Equals(0)))
def test_time_is_now(self): # utc_now() returns a timestamp which is now. LessThanOrEqual = lambda x: MatchesAny(LessThan(x), Equals(x)) GreaterThanOrEqual = lambda x: MatchesAny(GreaterThan(x), Equals(x)) old_now = datetime.utcnow().replace(tzinfo=UTC) now = utc_now() new_now = datetime.utcnow().replace(tzinfo=UTC) self.assertThat(now, GreaterThanOrEqual(old_now)) self.assertThat(now, LessThanOrEqual(new_now))
def test_long_elapsed_time_increases(self): with sleep.mocked(): last_elapsed = None for elapsed in Timeout.long(): if last_elapsed is not None: self.assertThat(elapsed, GreaterThan(last_elapsed)) else: self.assertEqual(elapsed, 0.0) last_elapsed = elapsed
def eval_expression_in_page_unsafe(self, expr): webview = self.get_webviewContainer() p = self.watcher.num_emissions webview.slots.evalInPageUnsafe(expr) self.assertThat(lambda: self.watcher.num_emissions, Eventually(GreaterThan(p))) results = json.loads( webview.get_signal_emissions('resultUpdated(QString)')[-1][0]) return 'result' in results and results['result'] or None