def test_render_POST_empty_authorization(self): resource = StatusHandlerResource(sentinel.status_worker) request = DummyRequest([]) request.requestHeaders.addRawHeader(b"authorization", "") output = resource.render_POST(request) self.assertEquals(b"", output) self.assertEquals(401, request.responseCode)
def test_non_xml_compliant_banner_will_send_default_invalid_format_banner( self): request = DummyRequest(['']) banner_file_name = 'banner.txt' xml_invalid_banner = '<p>some unclosed paragraph' self._write(banner_file_name, xml_invalid_banner) self.resource._disclaimer_banner = 'service/_trial_temp/' + banner_file_name d = self.web.get(request) def assert_default_invalid_banner_disclaimer_rendered(_): self.assertEqual(200, request.responseCode) written_response = ''.join(request.written) self.assertIn( "Invalid XML template format for service/_trial_temp/banner.txt.", written_response) def tear_down(_): os.remove(banner_file_name) d.addCallback(assert_default_invalid_banner_disclaimer_rendered) d.addCallback(tear_down) return d
def testDeferredResource(self): r = resource.Resource() r.isLeaf = 1 s = SDResource(r) d = DummyRequest(['foo', 'bar', 'baz']) resource.getChildForRequest(s, d) self.assertEqual(d.postpath, ['bar', 'baz'])
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 test_missing(self): """ minimally-defined static servers just need anonymous-storage-FURL and permutation-seed-base32. The WUI used to have problems rendering servers that lacked nickname and version. This tests that we can render such minimal servers. """ ann = {"anonymous-storage-FURL": "pb://w2hqnbaa25yw4qgcvghl5psa3srpfgw3@tcp:127.0.0.1:51309/vucto2z4fxment3vfxbqecblbf6zyp6x", "permutation-seed-base32": "w2hqnbaa25yw4qgcvghl5psa3srpfgw3", } srv = NativeStorageServer("server_id", ann, None, {}, EMPTY_CLIENT_CONFIG) srv.get_connection_status = lambda: ConnectionStatus(False, "summary", {}, 0, 0) class FakeClient(_Client): def __init__(self): service.MultiService.__init__(self) self.storage_broker = StorageFarmBroker( permute_peers=True, tub_maker=None, node_config=EMPTY_CLIENT_CONFIG, ) self.storage_broker.test_add_server("test-srv", srv) root = RootElement(FakeClient(), time.time) req = DummyRequest(b"") tag = Tag(b"") # Pick all items from services table. items = root.services_table(req, tag).item(req, tag) # Coerce `items` to list and pick the first item from it. item = list(items)[0] self.assertEqual(item.slotData.get("version"), "") self.assertEqual(item.slotData.get("nickname"), "")
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_render(self): """ L{ResourceScriptDirectory.getChild} returns a resource which renders a response with the HTTP 200 status code and the content of the rpy's C{request} global. """ tmp = FilePath(self.mktemp()) tmp.makedirs() tmp.child("test.rpy").setContent(b""" from twisted.web.resource import Resource class TestResource(Resource): isLeaf = True def render_GET(self, request): return b'ok' resource = TestResource()""") resource = ResourceScriptDirectory(tmp._asBytesPath()) request = DummyRequest([b'']) child = resource.getChild(b"test.rpy", request) d = _render(child, request) def cbRendered(ignored): self.assertEqual(b"".join(request.written), b"ok") d.addCallback(cbRendered) return d
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.outgoingHeaders.get('X-Content-Security-Policy'.lower())) self.assertEquals( expected_csp_headers, request.outgoingHeaders.get('Content-Security-Policy'.lower())) self.assertEquals(expected_csp_headers, request.outgoingHeaders.get('X-Webkit-CSP'.lower()))
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_pathInfo(self): """ L{twcgi.CGIScript.render} sets the process environment I{PATH_INFO} from the request path. """ class FakeReactor: """ A fake reactor recording the environment passed to spawnProcess. """ def spawnProcess(self, process, filename, args, env, wdir): """ Store the C{env} L{dict} to an instance attribute. @param process: Ignored @param filename: Ignored @param args: Ignored @param env: The environment L{dict} which will be stored @param wdir: Ignored """ self.process_env = env _reactor = FakeReactor() resource = twcgi.CGIScript(self.mktemp(), reactor=_reactor) request = DummyRequest(["a", "b"]) request.client = address.IPv4Address("TCP", "127.0.0.1", 12345) _render(resource, request) self.assertEqual(_reactor.process_env["PATH_INFO"], "/a/b")
def test_useReactorArgument(self): """ L{twcgi.FilteredScript.runProcess} uses the reactor passed as an argument to the constructor. """ class FakeReactor: """ A fake reactor recording whether spawnProcess is called. """ called = False def spawnProcess(self, *args, **kwargs): """ Set the C{called} flag to C{True} if C{spawnProcess} is called. @param args: Positional arguments. @param kwargs: Keyword arguments. """ self.called = True fakeReactor = FakeReactor() request = DummyRequest(["a", "b"]) request.client = address.IPv4Address("TCP", "127.0.0.1", 12345) resource = twcgi.FilteredScript("dummy-file", reactor=fakeReactor) _render(resource, request) self.assertTrue(fakeReactor.called)
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__error_when_starting_changes_page_to_error(self): service = self.make_webapp() self.addCleanup(service.stopService) mock_prepare = self.patch_autospec(service, "prepareApplication") mock_prepare.side_effect = factory.make_exception() # No error is returned. with TwistedLoggerFixture(): service.startService() # The site's page (for any path) shows the error. request = DummyRequest("any/where".split("/")) resource = service.site.getResourceFor(request) content = resource.render(request) page = html.fromstring(content) self.expectThat( page.find(".//title").text_content(), Equals("503 - MAAS failed to start")) self.expectThat( page.find(".//h1").text_content(), Equals("MAAS failed to start")) self.assertDocTestMatches( dedent("""\ Traceback (most recent call last): ... maastesting.factory.TestException#... """), page.find(".//pre").text_content())
def request_same_or_different_thread_thread(self): hr = HendrixWSGIResource(reactor, self.tp, self.wsgi_thing) request1 = DummyRequest('r1') request1.isSecure = lambda: False request1.content = "llamas" d = deferToThreadPool(reactor, self.tp, hr.render, request1) return d
def test_respond_json_deferred_should_populate_response(self): request = DummyRequest(['']) body = respond_json_deferred({"test": "yep"}, request) self.assertEqual(200, request.code) self.assertEqual(b"{\"test\": \"yep\"}", request.written[0]) self.assertEqual([b"application/json"], request.responseHeaders.getRawHeaders("Content-Type"))
def test__render_POST_bad_authorization(self): resource = StatusHandlerResource(sentinel.status_worker) request = DummyRequest([]) request.requestHeaders.addRawHeader(b'authorization', factory.make_name('auth')) output = resource.render_POST(request) self.assertEquals(b'', output) self.assertEquals(401, request.responseCode)
def test_getResourceFor_wraps_render_wo_underlay_raises_no_method(self): root = Resource() maas = Resource() root.putChild(b"MAAS", maas) site = OverlaySite(root) request = DummyRequest([b"MAAS"]) resource = site.getResourceFor(request) self.assertThat(resource, Is(maas)) self.assertRaises(UnsupportedMethod, resource.render, request)
def test_read_blob(self, get_path): path = os.path.join(self.tempdir, 'blob') with open(path, 'w') as f: f.write('bl0b') get_path.return_value = path backend = _blobs.FilesystemBlobsBackend(blobs_path=self.tempdir) consumer = DummyRequest(['']) yield backend.read_blob('user', 'blob_id', consumer) self.assertEqual(['bl0b'], consumer.written)
def test_render_get(self, pay_mock): # add requests request1 = DummyRequest(postpath=[b'user', b'bob']) request2 = DummyRequest(postpath=[b'user', b'bob']) self.sse.render_GET(request=request1) self.sse.render_GET(request=request2) self.assertEqual( len(self.sse.subscribers.connections['user'] ['bob.id.fedoraproject.org']), 2) # req1 started the looping call so it gets an extra message self.assertEqual(request1.written, [ b'', b"data: unittest\r\n\r\n", ]) # req2 is waiting for the next cycle for it to be sent a message so its # empty self.assertEqual(request2.written, [b''])
def request_same_or_different_thread_thread(self): hr = HendrixWSGIResource(reactor, self.tp, self.wsgi_thing) request1 = DummyRequest([b'r1']) request1.isSecure = lambda: False request1.content = b"llamas" request1.client = IPv4Address("TCP", b"50.0.50.0", 5000) d = deferToThreadPool(reactor, self.tp, hr.render, request1) d.addCallback(lambda _: request1.notifyFinish()) return d
def test_handle_request_valid(self, alc_mock, dlce_mock): alc_mock.return_value = None dlce_mock.return_value = True request = DummyRequest(postpath=['user', 'bob']) self.sse.handle_request(request) # handle request does not format the path self.assertTrue('user' in self.sse.subscribers.connections) self.assertTrue('bob' in self.sse.subscribers.connections['user'])
def make_request(self, content=None, token=None): request = DummyRequest([]) if token is None: token = factory.make_name('token') request.requestHeaders.addRawHeader(b'authorization', 'oauth_token=%s' % token) if content is not None: request.content = BytesIO(content) return request
def test_exhaustedPostPath(self): """ L{getChildForRequest} returns whatever resource has been reached by the time the request's C{postpath} is empty. """ request = DummyRequest([]) resource = Resource() result = getChildForRequest(resource, request) self.assertIdentical(resource, result)
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_leafResource(self): """ L{getChildForRequest} returns the first resource it encounters with a C{isLeaf} attribute set to C{True}. """ request = DummyRequest([b"foo", b"bar"]) resource = Resource() resource.isLeaf = True result = getChildForRequest(resource, request) self.assertIdentical(resource, result)
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_getResourceFor_returns_resource_from_underlay(self): underlay_root = Resource() underlay_maas = Resource() underlay_root.putChild(b"MAAS", underlay_maas) overlay_root = Resource() site = OverlaySite(overlay_root) site.underlay = Site(underlay_root) request = DummyRequest([b"MAAS"]) resource = site.getResourceFor(request) self.assertThat(resource, Is(underlay_maas))
def setUp(self): self.request = DummyRequest(b"/uri") self.request.fields = {} def prepathURL(): return b"http://127.0.0.1.99999/" + b"/".join(self.request.prepath) self.request.prePathURL = prepathURL self.client = Mock() self.res = URIHandler(self.client)
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