def test_valid_token(self):
registry = FakeSingleSignOnRegistry()
token = registry.register("valid credentials")
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token)
self.assertIn("hello world", response)
def test_valid_token_with_mocking_fw_as_spy(self):
token = SSOToken()
registry = Mock(SingleSignOnRegistry)
registry.is_valid = Mock(return_value=True)
my_service = MyService(registry)
my_service.handle_request('Do stuff', token=token)
registry.is_valid.assert_called_with(token)
def test_single_sign_on_receives_correct_token():
mock_sso_registry = Mock(SingleSignOnRegistry)
correct_token = SSOToken()
mock_sso_registry.is_valid = Mock(side_effect=confirm_token(correct_token))
service = MyService(mock_sso_registry)
service.handle(Request("Emily"), correct_token)
mock_sso_registry.is_valid.assert_called()
def test_valid_token_with_spy(self):
token = SSOToken()
registry = SpySingleSignOnRegistry(accept_all_tokens=True)
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token)
self.assertIn(token, registry.checked_tokens)
def test_valid_token_with_mock(self):
token = SSOToken()
registry = MockSingleSignOnRegistry(expected_token=token, token_is_valid=True)
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token)
self.assertTrue(registry.is_valid_was_called)
def test_valid_token_with_mock(self):
token = SSOToken()
registry = MockSingleSignOnRegistry(expected_token=token, token_is_valid=True)
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token)
self.assertTrue(registry.is_valid_was_called)
def test_valid_token_with_spy(self):
token = SSOToken()
registry = SpySingleSignOnRegistry(accept_all_tokens=True)
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token)
self.assertIn(token, registry.checked_tokens)
def test_valid_token(self):
registry = FakeSingleSignOnRegistry()
token = registry.register("valid credentials")
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token)
self.assertIn("hello world", response)
def test_invalid_token_with_spy(self):
token = SSOToken()
registry = SpySingleSignOnRegistry(accept_all_tokens=False)
my_service = MyService(registry)
my_service.handle_request('do stuff', token=token)
self.assertIn(token, registry.checked_tokens)
def test_valid_token_with_mocking_fw_as_spy(self):
token = SSOToken()
registry = Mock(SingleSignOnRegistry)
registry.is_valid = Mock(return_value=True)
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token)
registry.is_valid.assert_called_with(token)
def test_single_sign_on_with_invalid_token():
spy_sso_registry = Mock(SingleSignOnRegistry)
spy_sso_registry.is_valid.return_value = False
service = MyService(spy_sso_registry)
token = SSOToken()
response = service.handle(Request("Emily"), token)
spy_sso_registry.is_valid.assert_called_with(token)
assert response.text == "Please sign in"
def test_invalid_tolen_with_mock(self):
token = SSOToken()
registry = MockSingleSignOnRegistry(expected_token=token, token_is_valid=False)
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token=token)
# check that mock was called during the test, is_valid was called on
# the mock registry
self.assertTrue(registry.is_valid_was_called)
def test_valid_token_with_fw_as_spy(self):
token = SSOToken()
# use Mock framework in order to create spy test
registry = Mock(SingleSignOnRegistry)
registry.is_valid = Mock(return_value=True)
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token)
registry.is_valid.assert_called_with(token)
def test_valid_token_with_mocking_fw_as_mock(self):
valid_token = SSOToken()
registry = Mock(SingleSignOnRegistry)
def is_valid(token):
if not token == valid_token:
raise Exception("Got the wrong token")
return True
registry.is_valid = Mock(side_effect=is_valid)
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token=valid_token)
registry.is_valid.assert_called_with(valid_token)
def test_invalid_token_with_mocking_fw_as_mock(self):
invalid_token = SSOToken()
registry = Mock(SingleSignOnRegistry)
def is_valid(token):
if not token == invalid_token:
raise Exception('Got the wrong token')
return False
registry.is_valid = Mock(side_effect=is_valid)
my_service = MyService(registry)
my_service.handle_request('Do stuff', token=invalid_token)
registry.is_valid.assert_called_with(invalid_token)
def test_valid_token_with_mocking_fw_as_mock(self):
valid_token = SSOToken()
registry = Mock(SpySingleSignOnRegistry)
# raise an exception if we get wrong token
def is_valid(token):
if not token == valid_token:
raise Exception("Got the wrong token")
return True
# pass above to the registry test, as what should happen when the is
# valid method is called.
registry.is_valid = Mock(side_effect=is_valid)
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token=valid_token)
registry.is_valid.assert_called_with(valid_token)
def test_hello_name():
stub_sso_registry = Mock(SingleSignOnRegistry)
service = MyService(stub_sso_registry)
response = service.handle(Request("Emily"), SSOToken())
assert response.text == "Hello Emily!"
def test_single_sign_on():
spy_sso_registry = Mock(SingleSignOnRegistry)
service = MyService(spy_sso_registry)
token = SSOToken()
service.handle(Request("Emily"), token)
spy_sso_registry.is_valid.assert_called_with(token)
def test_invalid_token(self):
registry = FakeSingleSignOnRegistry()
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token=None)
self.assertIn("please enter your login details", response)
def test_invalid_token(self):
registry = FakeSingleSignOnRegistry()
my_service = MyService(registry)
response = my_service.handle_request("do stuff", token=None)
self.assertIn("please enter your login details", response)
