def test_returns_the_key_as_json_if_found(self):
request = DummyRequest(['/keys'])
request.addArg('search', 'some@key')
when(self.keymanager).fetch_key('some@key').thenReturn(
defer.succeed(OpenPGPKey('some@key')))
d = self.web.get(request)
expected = {
u'address': u'some@key',
u'encr_used': False,
u'fingerprint': u'',
u'last_audited_at': 0,
u'private': False,
u'sign_used': False,
u'tags': [u'keymanager-active'],
u'type': u'OpenPGPKey-active',
u'validation': u'Weak_Chain',
u'version': 1,
}
def assert_response(_):
actual = json.loads(ast.literal_eval(request.written[0]))
self.assertEquals(expected, actual)
d.addCallback(assert_response)
return d
def test_returns_the_key_as_json_if_found(self):
request = DummyRequest(['/keys'])
request.addArg('search', 'some@key')
when(self.keymanager).fetch_key('some@key').thenReturn(defer.succeed(OpenPGPKey('some@key')))
d = self.web.get(request)
expected = {
"tags": ["keymanager-key"],
"fingerprint": '',
"private": False,
'sign_used': False,
'refreshed_at': 0,
"expiry_date": 0,
"address": 'some@key',
'encr_used': False,
'last_audited_at': 0,
'key_data': '',
'length': 0,
'key_id': '',
'validation': 'Weak_Chain',
'type': 'OpenPGPKey',
}
def assert_response(_):
actual = json.loads(ast.literal_eval(request.written[0]))
self.assertEquals(expected, actual)
d.addCallback(assert_response)
return d
def test_returns_the_key_as_json_if_found(self):
request = DummyRequest(["/keys"])
request.addArg("search", "some@key")
when(self.keymanager).fetch_key("some@key").thenReturn(defer.succeed(OpenPGPKey("some@key")))
d = self.web.get(request)
expected = {
u"address": u"some@key",
u"encr_used": False,
u"fingerprint": u"",
u"last_audited_at": 0,
u"private": False,
u"sign_used": False,
u"tags": [u"keymanager-active"],
u"type": u"OpenPGPKey-active",
u"validation": u"Weak_Chain",
u"version": 1,
}
def assert_response(_):
actual = json.loads(ast.literal_eval(request.written[0]))
self.assertEquals(expected, actual)
d.addCallback(assert_response)
return d
def test_returns_the_key_as_json_if_found(self):
request = DummyRequest(['/keys'])
request.addArg('search', 'some@key')
when(self.keymanager).fetch_key('some@key').thenReturn(
defer.succeed(OpenPGPKey('some@key')))
d = self.web.get(request)
expected = {
"tags": ["keymanager-key"],
"fingerprint": '',
"private": False,
'sign_used': False,
'refreshed_at': 0,
"expiry_date": 0,
"address": 'some@key',
'encr_used': False,
'last_audited_at': 0,
'key_data': '',
'length': 0,
'key_id': '',
'validation': 'Weak_Chain',
'type': 'OpenPGPKey',
}
def assert_response(_):
actual = json.loads(ast.literal_eval(request.written[0]))
self.assertEquals(expected, actual)
d.addCallback(assert_response)
return d
class CallbackResourceTest(TestCase):
def setUp(self):
self.resource = CallbackResource()
self.resource.factory = DecoupledRequestFactory()
self.request = DummyRequest([''])
self.request.method = 'POST'
self.request.content = StringIO()
def test_no_request_id(self):
def on_rendered(_):
self.assertEqual(self.request.responseCode, 503)
self.assertEqual(['No request_id given'], self.request.written)
return _render(self.resource, self.request).addCallback(on_rendered)
def test_unknown_request_id(self):
self.request.addArg('request_id', 'xxx')
def on_rendered(_):
self.assertEqual(self.request.responseCode, 503)
self.assertEqual(['Request not found'], self.request.written)
return _render(self.resource, self.request).addCallback(on_rendered)
def test_success(self):
self.request.addArg('request_id', 'xxx')
self.resource.factory.requests['xxx'] = DecoupledRequest(
self.resource.factory, 'xxx', DummyRequest(['']))
def on_rendered(_):
self.assertEqual(['ok'], self.request.written)
return _render(self.resource, self.request).addCallback(on_rendered)
def test_returns_the_key_as_json_if_found(self):
request = DummyRequest(['/keys'])
request.addArg('search', 'some@key')
when(self.keymanager).fetch_key('some@key').thenReturn(defer.succeed(OpenPGPKey('some@key')))
d = self.web.get(request)
expected = {
u'address': u'some@key',
u'encr_used': False,
u'fingerprint': u'',
u'last_audited_at': 0,
u'private': False,
u'sign_used': False,
u'tags': [u'keymanager-active'],
u'type': u'OpenPGPKey-active',
u'validation': u'Weak_Chain',
u'version': 1,
}
def assert_response(_):
actual = json.loads(ast.literal_eval(request.written[0]))
self.assertEquals(expected, actual)
d.addCallback(assert_response)
return d
def test_param_resource_override_name():
request = DummyRequest("/")
request.addArg(b"id", b"1234")
request.addArg(b"def", b"true")
resource = DemoPage()
args = resource.parse_args(request)
assert args["def"] is True
def test_param_resource():
request = DummyRequest("/")
request.addArg(b"id", b"1234")
request.addArg(b"show_details", b"false")
resource = DemoPage()
args = resource.parse_args(request)
assert args["id"] == "1234"
assert args["show_details"] is False
def test_returns_404_if_key_not_found(self):
request = DummyRequest(['/keys'])
request.addArg('search', '*****@*****.**')
when(self.keymanager).fetch_key('*****@*****.**').thenReturn(defer.fail(KeyNotFound()))
d = self.web.get(request)
def assert_404(_):
self.assertEquals(404, request.code)
d.addCallback(assert_404)
return d
def test_returns_unauthorized_if_key_is_private(self):
request = DummyRequest(['/keys'])
request.addArg('search', 'some@key')
when(self.keymanager).fetch_key('some@key').thenReturn(defer.succeed(OpenPGPKey('some@key', private=True)))
d = self.web.get(request)
def assert_response(_):
self.assertEquals(401, request.code)
d.addCallback(assert_response)
return d
def test_returns_404_if_key_not_found(self):
request = DummyRequest(['/keys'])
request.addArg('search', '*****@*****.**')
when(self.keymanager).get_key_from_cache('*****@*****.**', OpenPGPKey).thenRaise(KeyNotFound())
d = self.web.get(request)
def assert_404(_):
self.assertEquals(404, request.code)
d.addCallback(assert_404)
return d
def test_param_resource_error():
request = DummyRequest("/")
request.addArg(b"id", b"1234")
request.addArg(b"uuid", b"1234")
resource = DemoPage()
with pytest.raises(Error) as exc_info:
resource.parse_args(request)
assert exc_info.value.message == retwist.ParamResource.ERROR_MSG % (b"uuid", retwist.UUIDParam.MALFORMED_ERROR_MSG)
def test_returns_404_if_key_not_found(self):
request = DummyRequest(['/keys'])
request.addArg('search', '*****@*****.**')
when(self.keymanager).fetch_key('*****@*****.**').thenReturn(
defer.fail(KeyNotFound()))
d = self.web.get(request)
def assert_404(_):
self.assertEquals(404, request.code)
d.addCallback(assert_404)
return d
def test_returns_404_if_key_not_found(self):
request = DummyRequest(['/keys'])
request.addArg('search', '*****@*****.**')
when(self.keymanager).get_key_from_cache(
'*****@*****.**', OpenPGPKey).thenRaise(KeyNotFound())
d = self.web.get(request)
def assert_404(_):
self.assertEquals(404, request.code)
d.addCallback(assert_404)
return d
def test_returns_unauthorized_if_key_is_private(self):
request = DummyRequest(['/keys'])
request.addArg('search', 'some@key')
when(self.keymanager).fetch_key('some@key').thenReturn(
defer.succeed(OpenPGPKey('some@key', private=True)))
d = self.web.get(request)
def assert_response(_):
self.assertEquals(401, request.code)
d.addCallback(assert_response)
return d
def test_returns_the_key_as_json_if_found(self):
request = DummyRequest(['/keys'])
request.addArg('search', 'some@key')
when(self.keymanager).get_key_from_cache('some@key', OpenPGPKey).thenReturn(OpenPGPKey('some@key'))
d = self.web.get(request)
def assert_response(_):
self.assertEquals('"{\\"tags\\": [\\"keymanager-key\\"], \\"fingerprint\\": null, '
'\\"private\\": null, \\"expiry_date\\": null, \\"address\\": '
'\\"some@key\\", \\"last_audited_at\\": null, \\"key_data\\": null, '
'\\"length\\": null, \\"key_id\\": null, \\"validation\\": null, '
'\\"type\\": \\"<class \'leap.keymanager.openpgp.OpenPGPKey\'>\\", '
'\\"first_seen_at\\": null}"', request.written[0])
d.addCallback(assert_response)
return d
def test_should_unauthorize_child_resource_non_ajax_POST_requests_when_csrf_input_mismatch(self):
request = DummyRequest(['mails'])
request.method = 'POST'
request.addArg('csrftoken', 'some csrf token')
mock_content = MagicMock()
mock_content.read = MagicMock(return_value={})
request.content = mock_content
request.getCookie = MagicMock(return_value='mismatched csrf token')
d = self.web.get(request)
def assert_unauthorized(_):
self.assertEqual(401, request.responseCode)
self.assertEqual("Unauthorized!", request.written[0])
d.addCallback(assert_unauthorized)
return d
def test_should_unauthorize_child_resource_non_ajax_POST_requests_when_csrf_input_mismatch(self):
request = DummyRequest(['mails'])
request.method = 'POST'
request.addArg('csrftoken', 'some csrf token')
mock_content = MagicMock()
mock_content.read = MagicMock(return_value={})
request.content = mock_content
request.getCookie = MagicMock(return_value='mismatched csrf token')
d = self.web.get(request)
def assert_unauthorized(_):
self.assertEqual(401, request.responseCode)
self.assertEqual("Unauthorized!", request.written[0])
d.addCallback(assert_unauthorized)
return d
def test_returns_the_key_as_json_if_found(self):
request = DummyRequest(['/keys'])
request.addArg('search', 'some@key')
when(self.keymanager).get_key_from_cache('some@key',
OpenPGPKey).thenReturn(
OpenPGPKey('some@key'))
d = self.web.get(request)
def assert_response(_):
self.assertEquals(
'"{\\"tags\\": [\\"keymanager-key\\"], \\"fingerprint\\": null, '
'\\"private\\": null, \\"expiry_date\\": null, \\"address\\": '
'\\"some@key\\", \\"last_audited_at\\": null, \\"key_data\\": null, '
'\\"length\\": null, \\"key_id\\": null, \\"validation\\": null, '
'\\"type\\": \\"<class \'leap.keymanager.openpgp.OpenPGPKey\'>\\", '
'\\"first_seen_at\\": null}"', request.written[0])
d.addCallback(assert_response)
return d
def test_render_GET_should_unicode_mails_search_query(self, mock_register):
request = DummyRequest([])
non_unicode_search_term = 'coração'
request.addArg('q', non_unicode_search_term)
request.addArg('w', 25)
request.addArg('p', 1)
unicodified_search_term = u'coração'
when(self.mail_service).mails(unicodified_search_term, 25, 1).thenReturn(defer.succeed(([], 0)))
mails_resource = MailsResource(self.services_factory)
web = DummySite(mails_resource)
d = web.get(request)
def assert_response(_):
verify(self.mail_service).mails(unicodified_search_term, 25, 1)
d.addCallback(assert_response)
return d
def test_render_GET_should_unicode_mails_search_query(self, mock_register):
request = DummyRequest(['/mails'])
non_unicode_search_term = 'coração'
request.addArg('q', non_unicode_search_term)
request.addArg('w', 25)
request.addArg('p', 1)
unicodified_search_term = u'coração'
when(self.mail_service).mails(unicodified_search_term, 25, 1).thenReturn(defer.Deferred())
mails_resource = MailsResource(self.services_factory)
mails_resource.isLeaf = True
web = DummySite(mails_resource)
d = web.get(request)
def assert_response(_):
verify(self.mail_service).mails(unicodified_search_term, 25, 1)
d.addCallback(assert_response)
return d
class TestLoginPOST(unittest.TestCase):
def setUp(self):
self.services_factory = mock()
self.provider = mock()
self.resource = LoginResource(self.services_factory, self.provider)
self.web = DummySite(self.resource)
self.request = DummyRequest([''])
username = '******'
self.request.addArg('username', username)
password = '******'
self.username = username
self.password = password
self.request.addArg('password', password)
self.request.method = 'POST'
user_auth = mock()
user_auth.uuid = 'some_user_uuid'
self.user_auth = user_auth
@patch('pixelated.authentication.Authenticator.authenticate')
@patch('twisted.web.util.redirectTo')
@patch('pixelated.resources.session.PixelatedSession.is_logged_in')
def test_should_redirect_to_home_if_user_if_already_logged_in(self, mock_logged_in, mock_redirect, mock_authenticate):
mock_logged_in.return_value = True
when(self.services_factory).has_session(ANY()).thenReturn(True)
mock_redirect.return_value = "mocked redirection"
d = self.web.get(self.request)
def assert_redirected_to_home(_):
mock_redirect.assert_called_once_with('/', self.request)
self.assertFalse(mock_authenticate.called)
d.addCallback(assert_redirected_to_home)
return d
@patch('pixelated.config.leap.BootstrapUserServices.setup')
@patch('pixelated.authentication.Authenticator.authenticate')
def test_should_return_form_back_with_error_message_when_login_fails(self, mock_authenticate,
mock_user_bootstrap_setup):
mock_authenticate.side_effect = UnauthorizedLogin()
d = self.web.get(self.request)
def assert_error_response_and_user_services_not_setup(_):
mock_authenticate.assert_called_once_with(self.username, self.password)
self.assertEqual(401, self.request.responseCode)
written_response = ''.join(self.request.written)
self.assertIn('Invalid username or password', written_response)
self.assertFalse(mock_user_bootstrap_setup.called)
self.assertFalse(self.resource.get_session(self.request).is_logged_in())
d.addCallback(assert_error_response_and_user_services_not_setup)
return d
@patch('pixelated.config.leap.BootstrapUserServices.setup')
@patch('pixelated.authentication.Authenticator.authenticate')
def test_successful_login_responds_interstitial(self, mock_authenticate, mock_user_bootstrap_setup):
mock_authenticate.return_value = self.user_auth
d = self.web.get(self.request)
def assert_interstitial_in_response(_):
mock_authenticate.assert_called_once_with(self.username, self.password)
interstitial_js_in_template = '<script src="startup-assets/Interstitial.js"></script>'
self.assertIn(interstitial_js_in_template, self.request.written[0])
d.addCallback(assert_interstitial_in_response)
return d
@patch('pixelated.config.leap.BootstrapUserServices.setup')
@patch('pixelated.authentication.Authenticator.authenticate')
def test_successful_login_runs_user_services_bootstrap_when_interstitial_loaded(self, mock_authenticate, mock_user_bootstrap_setup):
mock_authenticate.return_value = self.user_auth
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
mock_user_bootstrap_setup.assert_called_once_with(self.user_auth, self.password, 'pt-BR')
d.addCallback(assert_login_setup_service_for_user)
return d
@patch('pixelated.config.leap.BootstrapUserServices.setup')
@patch('pixelated.authentication.Authenticator.authenticate')
def test_successful_adds_cookies_to_indicat_logged_in_status_when_services_are_loaded(self, mock_authenticate, mock_user_bootstrap_setup):
mock_authenticate.return_value = self.user_auth
irrelevant = None
mock_user_bootstrap_setup.return_value = defer.succeed(irrelevant)
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
self.assertTrue(self.resource.get_session(self.request).is_logged_in())
d.addCallback(assert_login_setup_service_for_user)
return d
class TestLoginPOST(unittest.TestCase):
def setUp(self):
self.services_factory = mock()
self.portal = mock()
self.provider = mock()
self.resource = LoginResource(self.services_factory, self.portal)
self.web = DummySite(self.resource)
self.request = DummyRequest([''])
username = '******'
self.request.addArg('username', username)
password = '******'
self.username = username
self.password = password
self.request.addArg('password', password)
self.request.method = 'POST'
leap_session = mock(LeapSession)
user_auth = mock()
user_auth.uuid = 'some_user_uuid'
leap_session.user_auth = user_auth
config = mock()
config.leap_home = 'some_folder'
leap_session.config = config
leap_session.fresh_account = False
self.leap_session = leap_session
self.user_auth = user_auth
def mock_user_has_services_setup(self):
when(self.services_factory).is_logged_in('some_user_uuid').thenReturn(True)
def test_login_responds_interstitial_and_add_corresponding_session_to_services_factory(self):
irrelevant = None
when(self.portal).login(ANY(), None, IResource).thenReturn((irrelevant, self.leap_session, irrelevant))
when(self.services_factory).create_services_from(self.leap_session).thenAnswer(self.mock_user_has_services_setup)
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
verify(self.portal).login(ANY(), None, IResource)
verify(self.services_factory).create_services_from(self.leap_session)
interstitial_js_in_template = '<script src="startup-assets/Interstitial.js"></script>'
self.assertIn(interstitial_js_in_template, self.request.written[0])
self.assertTrue(self.resource.is_logged_in(self.request))
d.addCallback(assert_login_setup_service_for_user)
return d
def test_login_does_not_reload_services_if_already_loaded(self):
irrelevant = None
when(self.portal).login(ANY(), None, IResource).thenReturn((irrelevant, self.leap_session, irrelevant))
when(self.services_factory).is_logged_in('some_user_uuid').thenReturn(True)
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
verify(self.portal).login(ANY(), None, IResource)
verify(self.services_factory).is_logged_in('some_user_uuid')
verifyNoMoreInteractions(self.services_factory)
interstitial_js_in_template = '<script src="startup-assets/Interstitial.js"></script>'
self.assertIn(interstitial_js_in_template, self.request.written[0])
self.assertTrue(self.resource.is_logged_in(self.request))
d.addCallback(assert_login_setup_service_for_user)
return d
def test_should_return_form_back_with_error_message_when_login_fails(self):
when(self.portal).login(ANY(), None, IResource).thenRaise(Exception())
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
verify(self.portal).login(ANY(), None, IResource)
self.assertEqual(401, self.request.responseCode)
written_response = ''.join(self.request.written)
self.assertIn('Invalid credentials', written_response)
self.assertFalse(self.resource.is_logged_in(self.request))
d.addCallback(assert_login_setup_service_for_user)
return d
@patch('pixelated.bitmask_libraries.session.LeapSessionFactory.create')
@patch('leap.auth.SRPAuth.authenticate')
@patch('pixelated.config.services.Services.setup')
def test_leap_session_is_not_created_when_leap_auth_fails(self, mock_service_setup, mock_leap_srp_auth, mock_leap_session_create):
mock_leap_srp_auth.side_effect = SRPAuthenticationError()
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
verify(self.portal).login(ANY(), None, IResource)
self.assertFalse(mock_leap_session_create.called)
self.assertFalse(mock_service_setup.called)
self.assertEqual(401, self.request.responseCode)
self.assertFalse(self.resource.is_logged_in(self.request))
d.addCallback(assert_login_setup_service_for_user)
return d
@patch('twisted.web.util.redirectTo')
@patch('pixelated.resources.session.PixelatedSession.is_logged_in')
def test_should_not_process_login_if_already_logged_in(self, mock_logged_in, mock_redirect):
mock_logged_in.return_value = True
when(self.services_factory).is_logged_in(ANY()).thenReturn(True)
mock_redirect.return_value = "mocked redirection"
when(self.portal).login(ANY(), None, IResource).thenRaise(Exception())
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
verifyZeroInteractions(self.portal)
mock_redirect.assert_called_once_with('/', self.request)
d.addCallback(assert_login_setup_service_for_user)
return d
class TestForceAction(unittest.TestCase):
def setUp(self):
self.builder_name = 'proj0-test-builder'
self.project = 'proj0'
self.builder_status = FakeBuilderStatus(
buildername=self.builder_name,
project=self.project,
)
self.master = FakeMaster()
self.request = DummyRequest([])
self.request.site = mock.Mock(
buildbot_service=mock.Mock(master=self.master), )
self.force_action_resource = ForceAction()
self.force_action_resource.builder_status = self.builder_status
@defer.inlineCallbacks
def test_forcescheduler_form_param(self):
first_scheduler = mock.Mock(spec=ForceScheduler)
first_scheduler.name = 'test-scheduler-0+[force]'
selected_scheduler = mock.Mock(spec=ForceScheduler)
selected_scheduler.name = 'test-scheduler-1+[force]'
self.master.scheduler_manager.addService(first_scheduler)
self.master.scheduler_manager.addService(selected_scheduler)
self.request.addArg('forcescheduler', selected_scheduler.name)
yield self.force_action_resource.force(self.request,
[self.builder_name])
selected_scheduler.force.assert_called_once()
first_scheduler.force.assert_not_called()
@defer.inlineCallbacks
def test_forcescheduler_form_param_empty(self):
first_scheduler = mock.Mock(spec=ForceScheduler, builderNames=[])
first_scheduler.name = 'test-scheduler-0+[force]'
selected_scheduler = mock.Mock(spec=ForceScheduler,
builderNames=[self.builder_name])
selected_scheduler.name = 'test-scheduler-1+[force]'
self.master.scheduler_manager.addService(first_scheduler)
self.master.scheduler_manager.addService(selected_scheduler)
yield self.force_action_resource.force(self.request,
[self.builder_name])
selected_scheduler.force.assert_called_once()
first_scheduler.force.assert_not_called()
@defer.inlineCallbacks
def test_forcescheduler_form_param_empty_only_force_schedulers_allowed(
self):
first_scheduler = mock.Mock(spec=BaseScheduler,
builderNames=[self.builder_name])
first_scheduler.name = 'test-scheduler-0+[force]'
selected_scheduler = mock.Mock(spec=ForceScheduler,
builderNames=[self.builder_name])
selected_scheduler.name = 'test-scheduler-1+[force]'
self.master.scheduler_manager.addService(first_scheduler)
self.master.scheduler_manager.addService(selected_scheduler)
yield self.force_action_resource.force(self.request,
[self.builder_name])
selected_scheduler.force.assert_called_once()
@defer.inlineCallbacks
def test_forcescheduler_form_param_empty_scheduler_not_found(self):
scheduler = mock.Mock(spec=ForceScheduler, builderNames=[])
scheduler.name = 'test-scheduler-0+[force]'
self.master.scheduler_manager.addService(scheduler)
result = yield self.force_action_resource.force(
self.request, [self.builder_name])
self.assertEqual(
result,
(
'projects/{}/builders/{}'.format(self.project,
self.builder_name),
'forcescheduler arg not found, and could not find a default force scheduler for builderName',
),
)
def test_decode_request_arguments(self):
self.request.args['checkbox'] = [
'checkbox-selected-1', 'checkbox-selected-2'
]
args = ForceAction.decode_request_arguments(self.request)
self.assertEqual(args, {
'checkbox-selected-1': True,
'checkbox-selected-2': True
})
class TestLoginPOST(unittest.TestCase):
def setUp(self):
self.services_factory = mock()
self.portal = mock()
self.provider = mock()
self.resource = LoginResource(self.services_factory, self.portal)
self.web = DummySite(self.resource)
self.request = DummyRequest([''])
username = '******'
self.request.addArg('username', username)
password = '******'
self.username = username
self.password = password
self.request.addArg('password', password)
self.request.method = 'POST'
leap_session = mock(LeapSession)
user_auth = mock()
user_auth.uuid = 'some_user_uuid'
leap_session.user_auth = user_auth
config = mock()
config.leap_home = 'some_folder'
leap_session.config = config
leap_session.fresh_account = False
self.leap_session = leap_session
self.user_auth = user_auth
def mock_user_has_services_setup(self):
when(self.services_factory).is_logged_in('some_user_uuid').thenReturn(
True)
def test_login_responds_interstitial_and_add_corresponding_session_to_services_factory(
self):
irrelevant = None
when(self.portal).login(ANY(), None, IResource).thenReturn(
(irrelevant, self.leap_session, irrelevant))
when(self.services_factory).create_services_from(
self.leap_session).thenAnswer(self.mock_user_has_services_setup)
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
verify(self.portal).login(ANY(), None, IResource)
verify(self.services_factory).create_services_from(
self.leap_session)
interstitial_js_in_template = '<script src="startup-assets/Interstitial.js"></script>'
self.assertIn(interstitial_js_in_template, self.request.written[0])
self.assertTrue(self.resource.is_logged_in(self.request))
d.addCallback(assert_login_setup_service_for_user)
return d
def test_login_does_not_reload_services_if_already_loaded(self):
irrelevant = None
when(self.portal).login(ANY(), None, IResource).thenReturn(
(irrelevant, self.leap_session, irrelevant))
when(self.services_factory).is_logged_in('some_user_uuid').thenReturn(
True)
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
verify(self.portal).login(ANY(), None, IResource)
verify(self.services_factory).is_logged_in('some_user_uuid')
verifyNoMoreInteractions(self.services_factory)
interstitial_js_in_template = '<script src="startup-assets/Interstitial.js"></script>'
self.assertIn(interstitial_js_in_template, self.request.written[0])
self.assertTrue(self.resource.is_logged_in(self.request))
d.addCallback(assert_login_setup_service_for_user)
return d
def test_should_return_form_back_with_error_message_when_login_fails(self):
when(self.portal).login(ANY(), None, IResource).thenRaise(Exception())
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
verify(self.portal).login(ANY(), None, IResource)
self.assertEqual(401, self.request.responseCode)
written_response = ''.join(self.request.written)
self.assertIn('Invalid credentials', written_response)
self.assertFalse(self.resource.is_logged_in(self.request))
d.addCallback(assert_login_setup_service_for_user)
return d
@patch('pixelated.bitmask_libraries.session.LeapSessionFactory.create')
@patch('leap.auth.SRPAuth.authenticate')
@patch('pixelated.config.services.Services.setup')
def test_leap_session_is_not_created_when_leap_auth_fails(
self, mock_service_setup, mock_leap_srp_auth,
mock_leap_session_create):
mock_leap_srp_auth.side_effect = SRPAuthenticationError()
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
verify(self.portal).login(ANY(), None, IResource)
self.assertFalse(mock_leap_session_create.called)
self.assertFalse(mock_service_setup.called)
self.assertEqual(401, self.request.responseCode)
self.assertFalse(self.resource.is_logged_in(self.request))
d.addCallback(assert_login_setup_service_for_user)
return d
@patch('twisted.web.util.redirectTo')
@patch('pixelated.resources.session.PixelatedSession.is_logged_in')
def test_should_not_process_login_if_already_logged_in(
self, mock_logged_in, mock_redirect):
mock_logged_in.return_value = True
when(self.services_factory).is_logged_in(ANY()).thenReturn(True)
mock_redirect.return_value = "mocked redirection"
when(self.portal).login(ANY(), None, IResource).thenRaise(Exception())
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
verifyZeroInteractions(self.portal)
mock_redirect.assert_called_once_with('/', self.request)
d.addCallback(assert_login_setup_service_for_user)
return d
class TestLoginPOST(unittest.TestCase):
def setUp(self):
self.services_factory = mock()
self.provider = mock()
self.authenticator = MagicMock()
self.resource = LoginResource(self.services_factory, self.provider, authenticator=self.authenticator)
self.web = DummySite(self.resource)
self.request = DummyRequest([''])
username = '******'
self.request.addArg('username', username)
password = '******'
self.username = username
self.password = password
self.request.addArg('password', password)
self.request.method = 'POST'
user_auth = mock()
user_auth.uuid = 'some_user_uuid'
self.user_auth = user_auth
@patch('twisted.web.util.redirectTo')
@patch('pixelated.resources.session.PixelatedSession.is_logged_in')
def test_should_redirect_to_home_if_user_if_already_logged_in(self, mock_logged_in, mock_redirect):
mock_logged_in.return_value = True
when(self.services_factory).has_session(ANY()).thenReturn(True)
mock_redirect.return_value = "mocked redirection"
d = self.web.get(self.request)
def assert_redirected_to_home(_):
mock_redirect.assert_called_once_with('/', self.request)
self.assertFalse(self.authenticator.authenticate.called)
d.addCallback(assert_redirected_to_home)
return d
@patch('pixelated.config.leap.BootstrapUserServices.setup')
@patch('twisted.web.util.redirectTo')
def test_should_redirect_to_login_with_error_flag_when_login_fails(self,
mock_redirect,
mock_user_bootstrap_setup):
self.authenticator.authenticate.side_effect = UnauthorizedLogin()
mock_redirect.return_value = "mocked redirection"
d = self.web.get(self.request)
def assert_redirected_to_login(_):
self.authenticator.authenticate.assert_called_once_with(self.username, self.password)
mock_redirect.assert_called_once_with('/login?auth-error', self.request)
self.assertFalse(mock_user_bootstrap_setup.called)
self.assertFalse(self.resource.get_session(self.request).is_logged_in())
d.addCallback(assert_redirected_to_login)
return d
@patch('pixelated.config.leap.BootstrapUserServices.setup')
def test_successful_login_responds_interstitial(self, mock_user_bootstrap_setup):
self.authenticator.authenticate.return_value = self.user_auth
d = self.web.get(self.request)
def assert_interstitial_in_response(_):
self.authenticator.authenticate.assert_called_once_with(self.username, self.password)
interstitial_js_in_template = '<script src="/public/interstitial.js"></script>'
self.assertIn(interstitial_js_in_template, self.request.written[0])
d.addCallback(assert_interstitial_in_response)
return d
@patch('pixelated.config.leap.BootstrapUserServices.setup')
def test_successful_login_runs_user_services_bootstrap_when_interstitial_loaded(self, mock_user_bootstrap_setup):
self.authenticator.authenticate.return_value = self.user_auth
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
mock_user_bootstrap_setup.assert_called_once_with(self.user_auth, self.password, 'en-US')
d.addCallback(assert_login_setup_service_for_user)
return d
@patch('pixelated.config.leap.BootstrapUserServices.setup')
def test_successful_adds_cookies_to_indicate_logged_in_status_when_services_are_loaded(self, mock_user_bootstrap_setup):
self.authenticator.authenticate.return_value = self.user_auth
irrelevant = None
mock_user_bootstrap_setup.return_value = defer.succeed(irrelevant)
d = self.web.get(self.request)
def assert_login_setup_service_for_user(_):
self.assertTrue(self.resource.get_session(self.request).is_logged_in())
d.addCallback(assert_login_setup_service_for_user)
return d
@patch('pixelated.resources.session.PixelatedSession.login_started')
def test_session_adds_login_started_status_after_authentication(self, mock_login_started):
self.authenticator.authenticate.return_value = self.user_auth
d = self.web.get(self.request)
def assert_login_started_called(_):
mock_login_started.assert_called_once()
d.addCallback(assert_login_started_called)
return d
@patch('pixelated.resources.session.PixelatedSession.login_successful')
@patch('pixelated.config.leap.BootstrapUserServices.setup')
def test_session_adds_login_successful_status_when_services_setup_finishes(self, mock_user_bootstrap_setup, mock_login_successful):
self.authenticator.authenticate.return_value = self.user_auth
mock_user_bootstrap_setup.return_value = defer.succeed(None)
d = self.web.get(self.request)
def assert_login_successful_called(_):
mock_login_successful.assert_called_once()
d.addCallback(assert_login_successful_called)
return d
@patch('pixelated.resources.session.PixelatedSession.login_error')
@patch('pixelated.config.leap.BootstrapUserServices.setup')
def test_session_adds_login_error_status_when_services_setup_gets_error(self, mock_user_bootstrap_setup, mock_login_error):
self.authenticator.authenticate.return_value = self.user_auth
mock_user_bootstrap_setup.return_value = defer.fail(Exception('Could not setup user services'))
d = self.web.get(self.request)
def assert_login_error_called(_):
mock_login_error.assert_called_once()
d.addCallback(assert_login_error_called)
return d
