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