def test_sync(self):
'''Test the threading/transcription works when async=false'''
reactor = self.buildReactor()
expected = {'some': 'result'}
stub_transcriber = StubTranscriber(transcribe_stub=expected)
controller = TranscriptionsController(stub_transcriber,
reactor=reactor)
req = DummyRequest([])
req.method = 'POST'
req.args = {'transcript': [''], 'audio': [''], 'async': ['false']}
finish = req.notifyFinish()
finish.addCallback(lambda _: reactor.callWhenRunning(reactor.stop))
body = controller.render(req)
assert_equals(body, NOT_DONE_YET)
self.runReactor(reactor, timeout=1)
assert_equals(len(req.written), 1)
got = json.loads(req.written[0])
assert_equals(got, expected)
def test_post_new_attachment(self, mock_fields):
request = DummyRequest(['/attachment'])
request.method = 'POST'
request.content = 'mocked'
attachment_id = 'B5B4ED80AC3B894523D72E375DACAA2FC6606C18EDF680FE95903086C8B5E14A'
_file = MagicMock()
_file.value = 'some mocked value'
_file.type = 'some mocked type'
_file.filename = 'filename.txt'
mock_fields.return_value = {'attachment': _file}
when(self.mail_service).save_attachment(
'some mocked value',
'some mocked type').thenReturn(defer.succeed(attachment_id))
d = self.web.get(request)
def assert_response(_):
self.assertEqual(201, request.code)
self.assertEqual('/attachment/%s' % attachment_id,
request.headers['Location'])
response_json = {
'ident': attachment_id,
'content-type': 'some mocked type',
'name': 'filename.txt',
'size': 17,
'encoding': 'base64'
}
self.assertEqual(response_json, json.loads(request.written[0]))
verify(self.mail_service).save_attachment('some mocked value',
'some mocked type')
d.addCallback(assert_response)
return d
def test_render_GET_should_set_sandbox_csp_header(self):
request = DummyRequest(['/sandbox'])
request.method = 'GET'
request.isSecure = lambda: True
request.redirect = lambda _: 'irrelevant'
expected_csp_headers = "sandbox allow-popups allow-scripts;" \
"default-src 'self';" \
"style-src *;" \
"script-src *;" \
"font-src *;" \
"img-src *;" \
"object-src 'none';" \
"connect-src 'none';"
yield self.web.get(request)
self.assertEquals(
expected_csp_headers,
request.responseHeaders.getRawHeaders(
'X-Content-Security-Policy'.lower())[0])
self.assertEquals(
expected_csp_headers,
request.responseHeaders.getRawHeaders(
'Content-Security-Policy'.lower())[0])
self.assertEquals(
expected_csp_headers,
request.responseHeaders.getRawHeaders('X-Webkit-CSP'.lower())[0])
def test_post_attachment_fails(self, mock_fields):
request = DummyRequest(['/attachment'])
request.method = 'POST'
request.content = 'mocked'
_file = MagicMock()
_file.value = 'some mocked value'
_file.type = 'some mocked type'
mock_fields.return_value = {'attachment': _file}
when(self.mail_service).save_attachment('some mocked value',
'some mocked type').thenReturn(
defer.fail(Exception))
d = self.web.get(request)
def assert_response(_):
self.assertEqual(500, request.code)
self.assertFalse(
request.responseHeaders.hasHeader('Location'.lower()))
self.assertIn("message", json.loads(request.written[0]))
verify(self.mail_service).save_attachment('some mocked value',
'some mocked type')
d.addCallback(assert_response)
return d
def _create_request(self, number_of_commits):
body = {
"commits": [{"rev": i} for i in range(number_of_commits)]
}
request = DummyRequest([b"/"])
request.method = "POST"
request.args["payload"] = [json.dumps(body)]
return request
def test_defaultHEAD(self):
"""
When not otherwise overridden, L{Resource.render} treats a I{HEAD}
request as if it were a I{GET} request.
"""
expected = b"insert response here"
request = DummyRequest([])
request.method = b'HEAD'
resource = BytesReturnedRenderable(expected)
self.assertEqual(expected, resource.render(request))
def test_defaultHEAD(self):
"""
When not otherwise overridden, L{Resource.render} treats a I{HEAD}
request as if it were a I{GET} request.
"""
expected = b"insert response here"
request = DummyRequest([])
request.method = b"HEAD"
resource = BytesReturnedRenderable(expected)
self.assertEqual(expected, resource.render(request))
def test_get(self):
request = DummyRequest(['/account-recovery'])
request.method = 'GET'
d = self.web.get(request)
def assert_200_when_user_logged_in(_):
self.assertEqual(200, request.responseCode)
self.assertIn("DOCTYPE html", request.written[0])
d.addCallback(assert_200_when_user_logged_in)
return d
def test_post_returns_successfully(self):
request = DummyRequest(['/account-recovery'])
request.method = 'POST'
self.resource._handle_post = MagicMock(return_value=defer.succeed(None))
d = self.web.get(request)
def assert_successful_response(_):
self.assertEqual(200, request.responseCode)
d.addCallback(assert_successful_response)
return d
def test_post_returns_failure(self):
request = DummyRequest(['/account-recovery'])
request.method = 'POST'
self.resource._handle_post = MagicMock(return_value=defer.fail(InvalidPasswordError))
d = self.web.get(request)
def assert_error_response(_):
self.assertEqual(500, request.responseCode)
d.addCallback(assert_error_response)
return d
def test_post_returns_internal_server_error(self, mock_update_recovery_code):
mock_update_recovery_code.return_value = defer.fail(Exception)
request = DummyRequest(['/backup-account'])
request.method = 'POST'
request.content = MagicMock()
request.content.getvalue.return_value = '{"email": "*****@*****.**"}'
d = self.web.get(request)
def assert_successful_response(_):
self.assertEqual(500, request.responseCode)
d.addCallback(assert_successful_response)
return d
def test_explicitAllowedMethods(self):
"""
The L{UnsupportedMethod} raised by L{Resource.render} for an unsupported
request method has a C{allowedMethods} attribute set to the value of the
C{allowedMethods} attribute of the L{Resource}, if it has one.
"""
expected = [b"GET", b"HEAD", b"PUT"]
resource = Resource()
resource.allowedMethods = expected
request = DummyRequest([])
request.method = b"FICTIONAL"
exc = self.assertRaises(UnsupportedMethod, resource.render, request)
self.assertEqual(set(expected), set(exc.allowedMethods))
def test_post_returns_successfully(self, mock_update_recovery_code):
mock_update_recovery_code.return_value = defer.succeed("Success")
request = DummyRequest(['/backup-account'])
request.method = 'POST'
request.content = MagicMock()
request.content.getvalue.return_value = '{"email": "*****@*****.**"}'
d = self.web.get(request)
def assert_successful_response(_):
self.assertEqual(204, request.responseCode)
d.addCallback(assert_successful_response)
return d
def test_explicitAllowedMethods(self):
"""
The L{UnsupportedMethod} raised by L{Resource.render} for an unsupported
request method has a C{allowedMethods} attribute set to the value of the
C{allowedMethods} attribute of the L{Resource}, if it has one.
"""
expected = [b'GET', b'HEAD', b'PUT']
resource = Resource()
resource.allowedMethods = expected
request = DummyRequest([])
request.method = b'FICTIONAL'
exc = self.assertRaises(UnsupportedMethod, resource.render, request)
self.assertEqual(set(expected), set(exc.allowedMethods))
def test_implicitAllowedMethods(self):
"""
The L{UnsupportedMethod} raised by L{Resource.render} for an unsupported
request method has a C{allowedMethods} attribute set to a list of the
methods supported by the L{Resource}, as determined by the
I{render_}-prefixed methods which it defines, if C{allowedMethods} is
not explicitly defined by the L{Resource}.
"""
expected = {b"GET", b"HEAD", b"PUT"}
resource = ImplicitAllowedMethods()
request = DummyRequest([])
request.method = b"FICTIONAL"
exc = self.assertRaises(UnsupportedMethod, resource.render, request)
self.assertEqual(expected, set(exc.allowedMethods))
def test_sends_feedback_to_leap_web(self):
request = DummyRequest(['/feedback'])
request.method = 'POST'
content = mock()
when(content).read().thenReturn(json.dumps({'feedback': 'Pixelated is awesome!'}))
request.content = content
d = self.web.get(request)
def assert_posted_feedback_to_leap_web(_):
verify(self.feedback_service).open_ticket('Pixelated is awesome!')
d.addCallback(assert_posted_feedback_to_leap_web)
return d
def test_implicitAllowedMethods(self):
"""
The L{UnsupportedMethod} raised by L{Resource.render} for an unsupported
request method has a C{allowedMethods} attribute set to a list of the
methods supported by the L{Resource}, as determined by the
I{render_}-prefixed methods which it defines, if C{allowedMethods} is
not explicitly defined by the L{Resource}.
"""
expected = set([b'GET', b'HEAD', b'PUT'])
resource = ImplicitAllowedMethods()
request = DummyRequest([])
request.method = b'FICTIONAL'
exc = self.assertRaises(UnsupportedMethod, resource.render, request)
self.assertEqual(expected, set(exc.allowedMethods))
def test_should_unauthorize_child_resource_ajax_requests_when_csrf_mismatch(self):
request = DummyRequest(['/child'])
request.method = 'POST'
self._mock_ajax_csrf(request, 'stubbed csrf token')
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_ajax_requests_when_csrf_mismatch(self):
request = DummyRequest(['/child'])
request.method = 'POST'
self._mock_ajax_csrf(request, 'stubbed csrf token')
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_404_non_existing_resource_with_valid_csrf(self):
request = DummyRequest(['/non-existing-child'])
request.method = 'POST'
self._mock_ajax_csrf(request, 'stubbed csrf token')
request.getCookie = MagicMock(return_value='stubbed csrf token')
d = self.web.get(request)
def assert_not_found(_):
self.assertEqual(404, request.responseCode)
self.assertIn("No Such Resource", request.written[0])
d.addCallback(assert_not_found)
return d
def test_sends_feedback_to_leap_web(self):
request = DummyRequest(['/feedback'])
request.method = 'POST'
content = mock()
when(content).read().thenReturn(
json.dumps({'feedback': 'Pixelated is awesome!'}))
request.content = content
d = self.web.get(request)
def assert_posted_feedback_to_leap_web(_):
verify(self.feedback_service).open_ticket('Pixelated is awesome!')
d.addCallback(assert_posted_feedback_to_leap_web)
return d
def test_errback_is_called(self):
request = DummyRequest(['/logout'])
request.method = 'POST'
session = self.resource.get_session(request)
exception = Exception('')
session.expire = MagicMock(side_effect=exception)
d = self.web.get(request)
def assert_500_when_exception_is_thrown(_):
self.assertEqual(500, request.responseCode)
self.assertEqual('Something went wrong!', request.written[0])
d.addCallback(assert_500_when_exception_is_thrown)
return d
def test_render_PUT_should_store_draft_with_attachments(self, mock_register):
request = DummyRequest([])
request.method = 'PUT'
request.content = mock()
when(request.content).read().thenReturn('{"attachments": [{"ident": "some fake attachment id"}]}')
when(self.mail_service).attachment('some fake attachment id').thenReturn(defer.succeed({'content': mock()}))
mails_resource = MailsResource(self.services_factory)
web = DummySite(mails_resource)
d = web.get(request)
def assert_response(_):
verify(self.mail_service).attachment('some fake attachment id')
d.addCallback(assert_response)
return d
def test_errback_is_called(self):
request = DummyRequest(['/logout'])
request.method = 'POST'
session = self.resource.get_session(request)
exception = Exception('')
session.expire = MagicMock(side_effect=exception)
d = self.web.get(request)
def assert_500_when_exception_is_thrown(_):
self.assertEqual(500, request.responseCode)
self.assertEqual('Something went wrong!', request.written[0])
d.addCallback(assert_500_when_exception_is_thrown)
return d
def test_render_PUT_should_store_draft_with_attachments(self, mock_register):
request = DummyRequest(['/mails'])
request.method = 'PUT'
content = mock()
when(content).read().thenReturn('{"attachments": [{"ident": "some fake attachment id"}]}')
when(self.mail_service).attachment('some fake attachment id').thenReturn(defer.Deferred())
request.content = content
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).attachment('some fake attachment id')
d.addCallback(assert_response)
return d
def test_render_POST_should_archive_mails(self):
request = DummyRequest(["/mails/archive"])
request.method = "POST"
content = mock()
when(content).read().thenReturn(json.dumps({"idents": ["1", "2"]}))
when(self.mail_service).archive_mail("1").thenReturn(defer.Deferred())
when(self.mail_service).archive_mail("2").thenReturn(defer.Deferred())
request.content = content
d = self.web.get(request)
def assert_response(_):
verify(self.mail_service).archive_mail("1")
verify(self.mail_service).archive_mail("2")
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_logout(self, mock_redirect):
request = DummyRequest(['/logout'])
request.method = 'POST'
session = self.resource.get_session(request)
session.expire = MagicMock()
mock_redirect.return_value = 'some redirect response'
d = self.web.get(request)
def expire_session_and_redirect(_):
session = self.resource.get_session(request)
self.services_factory.destroy_session.assert_called_once_with(session.user_uuid)
session.expire.assert_called_once_with()
mock_redirect.assert_called_once_with('/login', request)
d.addCallback(expire_session_and_redirect)
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_render_POST_should_archive_mails(self):
request = DummyRequest(['/mails/archive'])
request.method = 'POST'
content = mock()
when(content).read().thenReturn(json.dumps({'idents': ['1', '2']}))
when(self.mail_service).archive_mail('1').thenReturn(defer.Deferred())
when(self.mail_service).archive_mail('2').thenReturn(defer.Deferred())
request.content = content
d = self.web.get(request)
def assert_response(_):
verify(self.mail_service).archive_mail('1')
verify(self.mail_service).archive_mail('2')
d.addCallback(assert_response)
return d
def test_logout(self, mock_redirect):
request = DummyRequest(['/logout'])
request.method = 'POST'
session = self.resource.get_session(request)
session.expire = MagicMock()
mock_redirect.return_value = 'some redirect response'
d = self.web.get(request)
def expire_session_and_redirect(_):
session = self.resource.get_session(request)
self.services_factory.log_out_user.assert_called_once_with(session.user_uuid)
session.expire.assert_called_once_with()
mock_redirect.assert_called_once_with('/login', request)
d.addCallback(expire_session_and_redirect)
return d
def test_render_POST_should_archive_mails(self):
request = DummyRequest(['/mails/archive'])
request.method = 'POST'
idents = ['1', '2']
content = mock()
when(content).read().thenReturn(json.dumps({'idents': ['1', '2']}))
when(self.mail_service).archive_mail('1').thenReturn(defer.succeed(None))
when(self.mail_service).archive_mail('2').thenReturn(defer.succeed(None))
request.content = content
d = self.web.get(request)
def assert_response(_):
verify(self.mail_service).archive_mail('1')
verify(self.mail_service).archive_mail('2')
d.addCallback(assert_response)
return d
def forge_request(uri='https://www.globaleaks.org/',
headers={},
method=b'GET',
client_addr=None):
"""
Creates a twisted.web.Request compliant request that is from an external
IP address.
"""
_, host, path, query, frag = urlparse.urlsplit(uri)
x = host.split(':')
if len(x) > 1:
port = int(x[1])
else:
port = 80
ret = DummyRequest([''])
ret.method = method
ret.uri = uri
ret.path = path
ret._serverName = bytes(host)
if client_addr is None:
ret.client = IPv4Address('TCP', '1.2.3.4', 12345)
else:
ret.client = client_addr
def getHost():
return IPv4Address('TCP', '127.0.0.1', port)
ret.getHost = getHost
def notifyFinish():
return Deferred()
ret.notifyFinish = notifyFinish
for k, v in headers.iteritems():
ret.requestHeaders.setRawHeaders(bytes(k), [bytes(v)])
ret.headers = ret.getAllHeaders()
return ret
def test_sync_cancel(self):
'''Test that the controller doesn't try to render when the request is cancelled.'''
reactor = self.buildReactor()
stub_transcriber = StubTranscriber()
controller = TranscriptionsController(stub_transcriber,
reactor=reactor)
req = DummyRequest([])
req.method = 'POST'
req.args = {'transcript': [''], 'audio': [''], 'async': ['false']}
controller.render(req)
req.processingFailed(Failure(ConnectionDone("Simulated disconnect")))
reactor.callWhenRunning(reactor.stop)
self.runReactor(reactor)
assert_equals(req.finished, 0)
def test_sync_cancel(self):
'''Test that the controller doesn't try to render when the request is cancelled.'''
reactor = self.buildReactor()
stub_transcriber = StubTranscriber()
controller = TranscriptionsController(stub_transcriber, reactor=reactor)
req = DummyRequest([])
req.method = 'POST'
req.args = {'transcript': [''], 'audio': [''], 'async': ['false']}
controller.render(req)
req.processingFailed(
Failure(ConnectionDone("Simulated disconnect")))
reactor.callWhenRunning(reactor.stop)
self.runReactor(reactor)
assert_equals(req.finished, 0)
def test_render_GET_should_set_sandbox_csp_header(self):
request = DummyRequest(['/sandbox'])
request.method = 'GET'
request.isSecure = lambda: True
request.redirect = lambda _: 'irrelevant'
expected_csp_headers = "sandbox allow-popups allow-scripts;" \
"default-src 'self';" \
"style-src *;" \
"script-src *;" \
"font-src *;" \
"img-src *;" \
"object-src 'none';" \
"connect-src 'none';"
yield self.web.get(request)
self.assertEquals(expected_csp_headers, request.responseHeaders.getRawHeaders('X-Content-Security-Policy'.lower())[0])
self.assertEquals(expected_csp_headers, request.responseHeaders.getRawHeaders('Content-Security-Policy'.lower())[0])
self.assertEquals(expected_csp_headers, request.responseHeaders.getRawHeaders('X-Webkit-CSP'.lower())[0])
def test_errback_is_called(self):
exception = Exception('')
mock_search_engine = MagicMock()
mock_search_engine.tags = MagicMock(side_effect=exception)
mock_service = MagicMock()
mock_service.search_engine = mock_search_engine
self.services_factory.services.return_value = mock_service
self.web = DummySite(self.resource)
request = DummyRequest(['/tags'])
request.method = 'GET'
d = self.web.get(request)
def assert_500_when_exception_is_thrown(_):
self.assertEqual(500, request.responseCode)
self.assertEqual('Something went wrong!', request.written[0])
d.addCallback(assert_500_when_exception_is_thrown)
return d
def test_async(self):
'''Test the redirect works when async=true'''
reactor = self.buildReactor()
uid = 'myuid'
want_location = '/transcriptions/' + uid
stub_transcriber = StubTranscriber(uid_stub=uid)
controller = TranscriptionsController(stub_transcriber, reactor=reactor)
req = DummyRequest([])
req.method = 'POST'
req.args = {'transcript': [''], 'audio': ['']}
body = controller.render(req)
assert_equals(body, '')
assert 'location' in req.outgoingHeaders
got_location = req.outgoingHeaders['location']
assert_equals(want_location, got_location)
def test_render_POST_should_send_email_with_attachments(self, mock_register):
request = DummyRequest([])
request.method = 'POST'
request.content = mock()
when(request.content).read().thenReturn('{"attachments": [{"ident": "some fake attachment id"}]}')
when(self.mail_service).attachment('some fake attachment id').thenReturn(defer.succeed({"content": "some content"}))
as_dictable = mock()
when(as_dictable).as_dict().thenReturn({})
when(self.mail_service).send_mail({"attachments": [{"ident": "some fake attachment id", "raw": "some content"}]})\
.thenReturn(defer.succeed(as_dictable))
mails_resource = MailsResource(self.services_factory)
web = DummySite(mails_resource)
d = web.get(request)
def assert_response(_):
verify(self.mail_service).attachment('some fake attachment id')
verify(self.mail_service).send_mail({"attachments": [{"ident": "some fake attachment id", "raw": "some content"}]})
d.addCallback(assert_response)
return d
def test_post_attachment_fails(self, mock_fields):
request = DummyRequest(['/attachment'])
request.method = 'POST'
request.content = 'mocked'
_file = MagicMock()
_file.value = 'some mocked value'
_file.type = 'some mocked type'
mock_fields.return_value = {'attachment': _file}
when(self.mail_service).save_attachment('some mocked value', 'some mocked type').thenReturn(defer.fail(Exception))
d = self.web.get(request)
def assert_response(_):
self.assertEqual(500, request.code)
self.assertFalse(request.responseHeaders.hasHeader('Location'.lower()))
self.assertIn("message", json.loads(request.written[0]))
verify(self.mail_service).save_attachment('some mocked value', 'some mocked type')
d.addCallback(assert_response)
return d
def test_async(self):
'''Test the redirect works when async=true'''
reactor = self.buildReactor()
uid = 'myuid'
want_location = '/transcriptions/' + uid
stub_transcriber = StubTranscriber(uid_stub=uid)
controller = TranscriptionsController(stub_transcriber, reactor=reactor)
req = DummyRequest([])
req.method = 'POST'
req.args = {'transcript': [''], 'audio': ['']}
body = controller.render(req)
assert_equals(body, '')
assert 'location' in req.outgoingHeaders
got_location = req.outgoingHeaders['location']
assert_equals(want_location, got_location)
def test_render_POST_should_send_email_with_attachments(self, mock_register):
request = DummyRequest(['/mails'])
request.method = 'POST'
content = mock()
when(content).read().thenReturn('{"attachments": [{"ident": "some fake attachment id"}]}')
when(self.mail_service).attachment('some fake attachment id').thenReturn(defer.succeed({"content": "some content"}))
as_dictable = mock()
when(as_dictable).as_dict().thenReturn({})
when(self.mail_service).send_mail({"attachments": [{"ident": "some fake attachment id", "raw": "some content"}]})\
.thenReturn(defer.succeed(as_dictable))
request.content = content
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).attachment('some fake attachment id')
verify(self.mail_service).send_mail({"attachments": [{"ident": "some fake attachment id", "raw": "some content"}]})
d.addCallback(assert_response)
return d
def test_post_updates_recovery_code(self, mock_account_recovery_init, mock_language):
mock_language.return_value = 'pt-BR'
mock_account_recovery = MagicMock()
mock_account_recovery_init.return_value = mock_account_recovery
mock_account_recovery.update_recovery_code.return_value = defer.succeed("Success")
request = DummyRequest(['/backup-account'])
request.method = 'POST'
request.content = MagicMock()
request.content.getvalue.return_value = '{"email": "*****@*****.**"}'
d = self.web.get(request)
def assert_update_recovery_code_called(_):
mock_account_recovery_init.assert_called_with(
self.resource._authenticator.bonafide_session,
self.resource.soledad(request),
self.resource._service(request, '_leap_session').smtp_config,
self.resource._get_backup_email(request),
self.leap_provider.server_name,
language='pt-BR')
mock_account_recovery.update_recovery_code.assert_called()
d.addCallback(assert_update_recovery_code_called)
return d
def test_sync(self):
'''Test the threading/transcription works when async=false'''
reactor = self.buildReactor()
expected = {'some': 'result'}
stub_transcriber = StubTranscriber(transcribe_stub=expected)
controller = TranscriptionsController(stub_transcriber, reactor=reactor)
req = DummyRequest([])
req.method = 'POST'
req.args = {'transcript': [''], 'audio': [''], 'async': ['false']}
finish = req.notifyFinish()
finish.addCallback(lambda _: reactor.callWhenRunning(reactor.stop))
body = controller.render(req)
assert_equals(body, NOT_DONE_YET)
self.runReactor(reactor, timeout=1)
assert_equals(len(req.written), 1)
got = json.loads(req.written[0])
assert_equals(got, expected)
def test_post_new_attachment(self, mock_fields):
request = DummyRequest(['/attachment'])
request.method = 'POST'
request.content = 'mocked'
attachment_id = 'B5B4ED80AC3B894523D72E375DACAA2FC6606C18EDF680FE95903086C8B5E14A'
_file = MagicMock()
_file.value = 'some mocked value'
_file.type = 'some mocked type'
_file.filename = 'filename.txt'
mock_fields.return_value = {'attachment': _file}
when(self.mail_service).save_attachment('some mocked value', 'some mocked type').thenReturn(defer.succeed(attachment_id))
d = self.web.get(request)
def assert_response(_):
self.assertEqual(201, request.code)
self.assertEqual('/attachment/%s' % attachment_id, request.responseHeaders.getRawHeaders("location")[0])
response_json = {'ident': attachment_id, 'content-type': 'some mocked type',
'name': 'filename.txt', 'size': 17, 'encoding': 'base64'}
self.assertEqual(response_json, json.loads(request.written[0]))
verify(self.mail_service).save_attachment('some mocked value', 'some mocked type')
d.addCallback(assert_response)
return d
def forge_request(uri='https://www.globaleaks.org/',
headers=None, body='', client_addr=None, method='GET',
handler_cls=None, attached_file={}):
"""
Creates a twisted.web.Request compliant request that is from an external
IP address.
"""
if headers is None:
headers = {}
_, host, path, query, frag = urlparse.urlsplit(uri)
x = host.split (':')
if len(x) > 1:
port = int(x[1])
else:
port = 80
request = DummyRequest([''])
request.method = method
request.uri = uri
request.path = path
request._serverName = bytes(host)
request.code = 200
request.client_ip = '127.0.0.1'
request.client_proto = 'https'
request.client_using_tor = False
def getResponseBody():
return ''.join(request.written)
request.getResponseBody = getResponseBody
if client_addr is None:
request.client = IPv4Address('TCP', '1.2.3.4', 12345)
else:
request.client = client_addr
def getHost():
return IPv4Address('TCP', '127.0.0.1', port)
request.getHost = getHost
def notifyFinish():
return Deferred()
request.notifyFinish = notifyFinish
for k, v in headers.items():
request.requestHeaders.setRawHeaders(bytes(k), [bytes(v)])
request.headers = request.getAllHeaders()
request.args = {}
if attached_file is not None:
request.args = {'file': [attached_file]}
class fakeBody(object):
def read(self):
if isinstance(body, dict):
return json.dumps(body)
else:
return body
def close(self):
pass
request.content = fakeBody()
return request
def test_get_is_not_supported_for_logout(self):
request = DummyRequest(['/logout'])
request.method = 'GET'
self.assertRaises(UnsupportedMethod, self.web.get, request)
def test_get_is_not_supported_for_logout(self):
request = DummyRequest(['/logout'])
request.method = 'GET'
self.assertRaises(UnsupportedMethod, self.web.get, request)
def forge_request(uri=b'https://www.globaleaks.org/',
headers=None, body='', client_addr=None, method=b'GET'):
"""
Creates a twisted.web.Request compliant request that is from an external
IP address.
"""
if headers is None:
headers = {}
_, host, path, query, frag = urlsplit(uri)
x = host.split(b':')
if len(x) > 1:
port = int(x[1])
else:
port = 80
request = DummyRequest([b''])
request.tid = 1
request.method = method
request.uri = uri
request.path = path
request._serverName = host
request.code = 200
request.client_ip = b'127.0.0.1'
request.client_proto = b'https'
request.client_using_tor = False
def getResponseBody():
# Ugh, hack. Twisted returns this all as bytes, and we want it as str
if isinstance(request.written[0], binary_type):
return b''.join(request.written)
else:
return ''.join(request.written)
request.getResponseBody = getResponseBody
if client_addr is None:
request.client = IPv4Address('TCP', b'1.2.3.4', 12345)
else:
request.client = client_addr
def getHost():
return IPv4Address('TCP', b'127.0.0.1', port)
request.getHost = getHost
def notifyFinish():
return Deferred()
request.notifyFinish = notifyFinish
request.requestHeaders.setRawHeaders('host', [b'127.0.0.1'])
request.requestHeaders.setRawHeaders('user-agent', [b'NSA Agent'])
for k, v in headers.items():
request.requestHeaders.setRawHeaders(k, [v])
request.headers = request.getAllHeaders()
class fakeBody(object):
def read(self):
if isinstance(body, dict):
ret = json.dumps(body)
else:
ret = body
if isinstance(ret, text_type):
ret = ret.encode('utf-8')
return ret
def close(self):
pass
request.content = fakeBody()
return request
def forge_request(uri=b'https://www.globaleaks.org/',
headers=None, body='', client_addr=None, method=b'GET'):
"""
Creates a twisted.web.Request compliant request that is from an external
IP address.
"""
if headers is None:
headers = {}
_, host, path, query, frag = urlsplit(uri)
x = host.split(b':')
if len(x) > 1:
port = int(x[1])
else:
port = 80
request = DummyRequest([b''])
request.tid = 1
request.method = method
request.uri = uri
request.path = path
request._serverName = host
request.code = 200
request.client_ip = b'127.0.0.1'
request.client_proto = b'https'
request.client_using_tor = False
def getResponseBody():
# Ugh, hack. Twisted returns this all as bytes, and we want it as str
if isinstance(request.written[0], binary_type):
return b''.join(request.written)
else:
return ''.join(request.written)
request.getResponseBody = getResponseBody
if client_addr is None:
request.client = IPv4Address('TCP', b'1.2.3.4', 12345)
else:
request.client = client_addr
def getHost():
return IPv4Address('TCP', b'127.0.0.1', port)
request.getHost = getHost
def notifyFinish():
return Deferred()
request.notifyFinish = notifyFinish
request.requestHeaders.setRawHeaders('host', [b'127.0.0.1'])
request.requestHeaders.setRawHeaders('user-agent', [b'NSA Agent'])
for k, v in headers.items():
request.requestHeaders.setRawHeaders(k, [v])
request.headers = request.getAllHeaders()
class fakeBody(object):
def read(self):
if isinstance(body, dict):
ret = json.dumps(body)
else:
ret = body
if isinstance(ret, text_type):
ret = ret.encode('utf-8')
return ret
def close(self):
pass
request.content = fakeBody()
return request
