def test_go_to_admin_login_page(self): # in method under test, stub the expected function calls with correct arguments expect(LibraryLoader.get_instance().sl, times=1).go_to(url=admin_login_page_url) expect(LibraryLoader.get_instance().sl, times=1).wait_until_element_is_enabled( locator=locator['admin_login_page']['login_button']) expect(LibraryLoader.get_instance().sl, times=1).element_text_should_be( locator=locator['admin_login_page']['title'], expected=expected['admin_login_page']['title_text']) expect(LibraryLoader.get_instance().sl, times=1).element_text_should_be( locator=locator['admin_login_page']['username_title'], expected=expected['admin_login_page']['username_text']) expect(LibraryLoader.get_instance().sl, times=1).element_text_should_be( locator=locator['admin_login_page']['password_title'], expected=expected['admin_login_page']['password_text']) expect(LibraryLoader.get_instance().sl, times=1).element_attribute_value_should_be( locator=locator['admin_login_page']['login_button'], attribute='value', expected=expected['admin_login_page']['login_button_text']) # CUT gets magically the mock instances (i.e. _loader & sl) admin_login_page = AdminLoginPage() # method under test gets called admin_login_page.go_to_admin_login_page() # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def testNoUnwantedInteractionsWorks(self, verification): rex = Dog() expect(rex, **verification).bark('Miau').thenReturn('Wuff') rex.bark('Miau') rex.bark('Miau') verifyNoUnwantedInteractions(rex)
def test_request_params(self, host, api, expected_host, expected_url, insecure, expected_verify, stream): # Setup params = XnatServerParams(host=host, user='******', insecure=insecure) session = XnatSession(params) # Request cookie1 = 'first_session_id' with self._mock_auth_login(expected_host=expected_host, success=True, verify=expected_verify, cookie=cookie1): self._do_request(session=session, cookie=cookie1, api=api, expected_url=expected_url, expected_verify=expected_verify, stream=stream) verifyNoUnwantedInteractions() # Deletion session to logout with self._mock_auth_logout(expected_host=expected_host, success=True, verify=expected_verify, cookie=cookie1): session.__del__() verifyNoUnwantedInteractions()
def test_login_short_way(self): # stub the expected function calls in method under test expect(LibraryLoader.get_instance().bl, times=1).fill_secret( selector=locator['admin_login_page']['username_field'], secret=self.credentials['valid_admin']['username']).thenReturn( None) expect(LibraryLoader.get_instance().bl, times=1).fill_secret( selector=locator['admin_login_page']['password_field'], secret=self.credentials['valid_admin']['password']).thenReturn( None) expect(LibraryLoader.get_instance().bl, times=1).click(selector=locator['admin_login_page'] ['login_button']).thenReturn(None) # CUT gets magically the mock instances (i.e. _loader & bl) admin_login_page = AdminLoginPage() # method under test gets called admin_login_page.login(self.credentials['valid_admin']['username'], self.credentials['valid_admin']['password']) # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_push_to_prometheus(): url = "http://prometheus.com" with expect(prometheus_client, times=1).push_to_gateway(url, **kwargs).thenReturn(":ok"): assert aws_cost_exporter.push_to_prometheus(url, "stuff", 0) verifyNoUnwantedInteractions()
def testUseWhenAndExpectTogetherVerifyNoUnwatedInteractions(self): rex = Dog() when(rex).waggle() expect(rex, times=1).bark('Miau') rex.waggle() rex.bark('Miau') verifyNoUnwantedInteractions()
def test_capture_simple(caplog): caplog.set_level(10, 'elib_run.process') context = _dummy_context() when(context.capture).readline(block=False).thenReturn(b'random string').thenReturn(None) _capture_output.capture_output_from_running_process(context) verifyNoUnwantedInteractions() verifyStubbedInvocationsAreUsed() assert ['random string'] == context.process_output_chunks assert 'random string' in caplog.text
def test_get_log_weight_from_canform(): """ Test that the _update_covform function is called before returning the log-weight parameter. """ gaussian_a = Gaussian(prec=2.0, h_vec=1.0, g_val=0.0, var_names=["a"]) expect(Gaussian, times=1)._update_covform() gaussian_a.get_log_weight() verifyNoUnwantedInteractions() unstub()
def test_process_finished(dummy_kwargs): command = mock() when(command).poll().thenReturn(None).thenReturn(0) context = _run_context.RunContext(**dummy_kwargs) setattr(context, '_command', command) assert not context.process_finished() assert context.process_finished() verifyNoUnwantedInteractions() verifyStubbedInvocationsAreUsed()
def test_capture_muted(): context = _dummy_context() context.mute = True when(context.capture).readline(block=False).thenReturn(b'random string').thenReturn(None) when(context.process_logger).debug(...) _capture_output.capture_output_from_running_process(context) verify(context.process_logger, times=0).debug(...) verifyNoUnwantedInteractions() verifyStubbedInvocationsAreUsed() assert ['random string'] == context.process_output_chunks
def testNoUnwantedInteractionsForAllRegisteredObjects(self): rex = Dog() mox = Dog() expect(rex, times=1).bark('Miau') expect(mox, times=1).bark('Miau') rex.bark('Miau') mox.bark('Miau') verifyNoUnwantedInteractions()
def test_start_process(dummy_kwargs): command = mock() when(command).run(async_=True) context = _run_context.RunContext(**dummy_kwargs) setattr(context, '_command', command) assert context.start_time == 0 verifyZeroInteractions() context.start_process() assert context.start_time != 0 verifyStubbedInvocationsAreUsed() verifyNoUnwantedInteractions()
def test_get_g_from_covform(): """ Test that the _update_canform function is called before returning the g parameter. """ gaussian_a = Gaussian(cov=2.0, mean=1.0, log_weight=0.0, var_names=["a"]) expect(Gaussian, times=1)._update_canform() gaussian_a.get_g() verifyNoUnwantedInteractions() unstub()
def do_test_select_checkbox_for_group(group_name): # configure the mock selenium library for select_checkbox_for_group()'s calls group_element_checkbox_locator = locator['groups_page']['generic_group_element_checkbox'] % group_name expect(LibraryLoader.get_instance().sl).click_element(locator=group_element_checkbox_locator).thenReturn(None) # CUT gets magically the mock instances (i.e. _loader & sl) groups_page = GroupsPage() # method under test gets called groups_page.select_checkbox_for_group(group_name) # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_go_to_admin_main_page(self): # configure the mock selenium library for go_to_admin_main_page()'s calls expect(LibraryLoader.get_instance().sl).go_to( expected_admin_main_page_url).thenReturn(None) # CUT gets magically the mock instances (i.e. _loader & sl) admin_main_page = AdminMainPage() # method under test gets called admin_main_page.go_to_admin_main_page() # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_press_go(self): # configure the mock browser library expect(LibraryLoader.get_instance().bl).click( selector=locator['groups_page']['go_button']).thenReturn(None) # CUT gets magically the mock instances (i.e. _loader & sl) groups_page = GroupsPage() # method under test gets called groups_page.press_go() # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_click_on_save_button(self): # configure the mock browser library for click_on_save_button()'s calls expect(LibraryLoader.get_instance().bl).click( selector=locator['add_group_page']['save_button']).thenReturn(None) # CUT gets magically the mock instances (i.e. _loader & sl) add_group_page = AddGroupPage() # method under test gets called add_group_page.click_on_save_button() # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_select_delete_selected_groups_dropdown(self): # configure the mock selenium library for select_delete_selected_groups_dropdown()'s calls expect(LibraryLoader.get_instance().sl).click_element( locator=locator['groups_page']['delete_selected_groups_option'] ).thenReturn(None) # CUT gets magically the mock instances (i.e. _loader & sl) groups_page = GroupsPage() # method under test gets called groups_page.select_delete_selected_groups_dropdown() # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_press_confirm_button(self): # configure the mock selenium library for press_confirm_button()'s calls expect(LibraryLoader.get_instance().sl).click_element( locator=locator['confirm_groups_deletions_page'] ['confirm_deletion_button']).thenReturn(None) # CUT gets magically the mock instances (i.e. _loader & sl) confirm_group_deletions_page = ConfirmGroupsDeletionsPage() # method under test gets called confirm_group_deletions_page.press_confirm_button() # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_enter_name_for_new_group(self): # configure the mock browser library for enter_name_for_new_group()'s calls group_name = 'blog_editors' expect(LibraryLoader.get_instance().bl).fill_text( selector=locator['add_group_page']['input_name_field'], txt=group_name).thenReturn(None) # CUT gets magically the mock instances (i.e. _loader & sl) add_group_page = AddGroupPage() # method under test gets called add_group_page.enter_name_for_new_group(group_name=group_name) # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_clear_available_permissions_filter(self): # configure the mock browser library for clear_available_permissions_filter()'s calls expect(LibraryLoader.get_instance().bl).clear_text( selector=locator['add_group_page'] ['input_permission_field']).thenReturn(None) # CUT gets magically the mock instances (i.e. _loader & sl) add_group_page = AddGroupPage() # method under test gets called add_group_page.clear_available_permissions_filter() # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_choose_all_filtered_permissions(self): # configure mock calls in choose_all_filtered_permissions() filtered_permission_elements = AddGroupPageUT.get_filtered_permission_elements( ) expect(LibraryLoader.get_instance().bl).wait_for_elements_state( selector=locator['add_group_page']['generic_filtered_permission'], state=ElementState.visible).thenReturn(None) expect(LibraryLoader.get_instance().bl).get_elements( selector=locator['add_group_page']['generic_filtered_permission'] ).thenReturn(filtered_permission_elements) control_option = ControlOption() setattr(control_option, 'name', 'Control') for element in filtered_permission_elements: expect( LibraryLoader.get_instance().bl).get_text(element).thenReturn( element.text) expect(LibraryLoader.get_instance().bl).click( element, MouseButton.left, 1, None, None, None, False, False, ...).thenReturn(None) expect(LibraryLoader.get_instance().bl).click( locator['add_group_page']['choose_all_permissions_option'], MouseButton.left).thenReturn(None) # configure mock calls in _verify_permissions_added() chosen_permission_elements = AddGroupPageUT.get_filtered_permission_elements( ) expect(LibraryLoader.get_instance().bl).get_elements( selector=locator['add_group_page']['generic_chosen_permission'] ).thenReturn(chosen_permission_elements) for element in chosen_permission_elements: expect( LibraryLoader.get_instance().bl).get_text(element).thenReturn( element.text) # CUT gets magically the mock instances (i.e. _loader & sl) add_group_page = AddGroupPage() # method under test gets called add_group_page.choose_all_filtered_permissions() # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_reauth_success(self): # Tests when a REST call fails with authentication error, so # a new session is created and the REST call retries and succeeds host = 'http://test.server' params = XnatServerParams(host=host, user='******', insecure=False) session = XnatSession(params) # First request cookie1 = 'first_session_id' with self._mock_auth_login(expected_host=host, success=True, verify=True, cookie=cookie1): api1 = 'my-api/call1' expected_url1 = host + '/' + api1 self._do_request(session=session, cookie=cookie1, api=api1, expected_url=expected_url1, expected_verify=True) verifyNoUnwantedInteractions() # Trigger an authentication failure on new rest call but let reauth # succeed cookie2 = 'second_session_id' with self._mock_auth_login(expected_host=host, success=True, verify=True, cookie=cookie2): api2 = 'my-api/call2' expected_url2 = host + '/' + api2 self._do_request(session=session, cookie=cookie1, api=api2, retry_cookie=cookie2, expected_url=expected_url2, expected_verify=True, success_first=False, success_second=True) # New session is valid so logout with self._mock_auth_logout(expected_host=host, success=True, verify=True, cookie=cookie2): session.__del__() verifyNoUnwantedInteractions()
def do_test_verify_group_added(group_name): # configure the mock selenium library for verify_group_added()'s calls locator_formatter = locator['groups_page']['generic_group_element'] % group_name expect(LibraryLoader.get_instance().sl).element_text_should_be( locator=locator_formatter, expected=group_name ).thenReturn(None) # CUT gets magically the mock instances (i.e. _loader & sl) groups_page = GroupsPage() # method under test gets called groups_page.verify_group_added(group_name) # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_reauth_retry_failure(self): # This captures the case where user credentials succeed but the # subsequent REST call still returns an unauthorised error. In this # case a response is returned to the rest client rather than # raising an exception as it suggests some other access issue rather # than user credentials. host = 'http://test.server' params = XnatServerParams(host=host, user='******', insecure=False) session = XnatSession(params) # First request cookie1 = 'first_session_id' with self._mock_auth_login(expected_host=host, success=True, verify=True, cookie=cookie1): api1 = 'my-api/call1' expected_url1 = host + '/' + api1 self._do_request(session=session, cookie=cookie1, api=api1, expected_url=expected_url1, expected_verify=True) verifyNoUnwantedInteractions() # Trigger an authentication failure on rest call, let the reauth # succeed but make the request retry fail cookie2 = 'second_session_id' with self._mock_auth_login(expected_host=host, success=True, verify=True, cookie=cookie2): api2 = 'my-api/call2' expected_url2 = host + '/' + api2 with pytest.raises(MockHttpError) as e_info: self._do_request(session=session, cookie=cookie1, api=api2, retry_cookie=cookie2, expected_url=expected_url2, expected_verify=True, success_first=False, success_second=False)
def do_test_verify_group_added(group_name): # configure the mock browser library for verify_group_added()'s calls added_group_locator = locator['groups_page'][ 'generic_group_element'] % group_name expect(LibraryLoader.get_instance().bl).get_text( selector=added_group_locator, assertion_operator=AssertionOperator.equal, assertion_expected=group_name).thenReturn(None) # CUT gets magically the mock instances (i.e. _loader & sl) groups_page = GroupsPage() # method under test gets called groups_page.verify_group_added(group_name) # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_reauth_failure(self): # Tests when a REST call fails with authentication error, try to create # a new session but this fails host = 'http://test.server' params = XnatServerParams(host=host, user='******', insecure=False) session = XnatSession(params) # First request cookie1 = 'first_session_id' with self._mock_auth_login(expected_host=host, success=True, verify=True, cookie=cookie1): api1 = 'my-api/call1' expected_url1 = host + '/' + api1 self._do_request(session=session, cookie=cookie1, api=api1, expected_url=expected_url1, expected_verify=True) verifyNoUnwantedInteractions() # Trigger an authentication failure on rest call, let the reauth fail cookie2 = 'fourth_session_id' with self._mock_auth_login(expected_host=host, success=False, verify=True, cookie=cookie2): api2 = 'my-api/call2' expected_url2 = host + '/' + api2 with pytest.raises(UserError) as e_info: self._do_request(session=session, cookie=cookie1, api=api2, retry_cookie=None, expected_url=expected_url2, expected_verify=True, success_first=False, success_second=False) # Should be no sessions remaining due to failure session.__del__() verifyNoUnwantedInteractions()
def test_auto_logout(self, host, expected_host): server_params = XnatServerParams(host=host, user='******') session = XnatSession(server_params) # Login cookie = 'first_session_id' with self._mock_auth_login(expected_host=expected_host, success=True, verify=True, cookie=cookie): session.login() verifyNoUnwantedInteractions() # Check auto logout on session deletion with self._mock_auth_logout(expected_host=expected_host, success=True, verify=True, cookie=cookie): session.__del__() verifyNoUnwantedInteractions()
def test_go_to_admin_login_page(self): # in method under test, stub the expected function calls with correct arguments expect(LibraryLoader.get_instance().bl, times=1).go_to(url=admin_login_page_url) expect(LibraryLoader.get_instance().bl, times=1).wait_for_elements_state( selector=locator['admin_login_page']['login_button'], state=ElementState.visible) expect(LibraryLoader.get_instance().bl, times=1).get_text( selector=locator['admin_login_page']['title'], assertion_operator=AssertionOperator.equal, assertion_expected=expected['admin_login_page']['title_text']) expect(LibraryLoader.get_instance().bl, times=1).get_text( selector=locator['admin_login_page']['username_title'], assertion_operator=AssertionOperator.equal, assertion_expected=expected['admin_login_page']['username_text']) expect(LibraryLoader.get_instance().bl, times=1).get_text( selector=locator['admin_login_page']['password_title'], assertion_operator=AssertionOperator.equal, assertion_expected=expected['admin_login_page']['password_text']) expect(LibraryLoader.get_instance().bl, times=1).get_attribute( selector=locator['admin_login_page']['login_button'], attribute='value', assertion_operator=AssertionOperator.equal, assertion_expected=expected['admin_login_page'] ['login_button_text']) # CUT gets magically the mock instances (i.e. _loader & bl) admin_login_page = AdminLoginPage() # method under test gets called admin_login_page.go_to_admin_login_page() # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def test_choose_all_filtered_permissions(self): # configure mock calls in choose_all_filtered_permissions() filtered_permission_elements = AddGroupPageUT.get_filtered_permission_elements( ) expect(LibraryLoader.get_instance().sl).get_webelements( locator=locator['add_group_page']['generic_filtered_permission'] ).thenReturn(filtered_permission_elements) for element in filtered_permission_elements: expect( LibraryLoader.get_instance().sl).get_text(element).thenReturn( element.text) expect(LibraryLoader.get_instance().sl).press_keys( element, 'CTRL').thenReturn(None) expect(LibraryLoader.get_instance().sl).click_link( locator=locator['add_group_page'] ['choose_all_permissions_option']).thenReturn(None) # configure mock calls in _verify_permissions_added() chosen_permission_elements = AddGroupPageUT.get_filtered_permission_elements( ) expect(LibraryLoader.get_instance().sl).get_webelements( locator=locator['add_group_page']['generic_chosen_permission'] ).thenReturn(chosen_permission_elements) for element in chosen_permission_elements: expect( LibraryLoader.get_instance().sl).get_text(element).thenReturn( element.text) # CUT gets magically the mock instances (i.e. _loader & sl) add_group_page = AddGroupPage() # method under test gets called add_group_page.choose_all_filtered_permissions() # Verifies that expectations set via expect are met # all registered objects will be checked. verifyNoUnwantedInteractions()
def testNoUnwantedInteractionsBarksIfUnsatisfied(self, verification): rex = Dog() expect(rex, **verification).bark('Miau').thenReturn('Wuff') with pytest.raises(VerificationError): verifyNoUnwantedInteractions(rex)