def requestMock(path, method="GET", host="localhost", port=8080, isSecure=False, body=None, headers=None): if not headers: headers = {} if not body: body = '' request = server.Request(DummyChannel(), False) request.gotLength(len(body)) request.content = StringIO() request.content.write(body) request.requestHeaders = Headers(headers) request.setHost(host, port, isSecure) request.uri = path request.prepath = [] request.postpath = path.split('/')[1:] request.method = method request.clientproto = 'HTTP/1.1' request.setHeader = Mock(wraps=request.setHeader) request.setResponseCode = Mock(wraps=request.setResponseCode) request.finish = Mock(wraps=request.finish) request.write = Mock(wraps=request.write) def registerProducer(producer, streaming): # This is a terrible terrible hack. producer.resumeProducing() producer.resumeProducing() request.registerProducer = registerProducer request.unregisterProducer = Mock() return request
def test_metrics(self): prometheus_metrics = create_metrics(self.metrics_definitions) resource = http.PrometheusMetricsResource(prometheus_metrics) request = Request(DummyChannel(), False) content = resource.render_GET(request).decode('utf-8') self.assertIn('TYPE sample_histogram histogram', content) self.assertIn('TYPE sample_counter counter', content)
def test_render_GET_logs_node_event_with_original_path_ip(self): path = factory.make_name("path") ip = factory.make_ip_address() request = Request(DummyChannel(), False) request.requestHeaders = Headers({ "X-Original-URI": [path], "X-Original-Remote-IP": [ip] }) log_info = self.patch(http.log, "info") mock_deferLater = self.patch(http, "deferLater") mock_deferLater.side_effect = always_succeed_with(None) resource = http.HTTPLogResource() resource.render_GET(request) self.assertThat( log_info, MockCalledOnceWith("{path} requested by {remote_host}", path=path, remote_host=ip), ) self.assertThat( mock_deferLater, MockCalledOnceWith( ANY, 0, http.send_node_event_ip_address, event_type=EVENT_TYPES.NODE_HTTP_REQUEST, ip_address=ip, description=path, ), )
def test_renderRealRequest(self): """ The request managed by L{WebSocketsResource.render} doesn't contain unnecessary HTTP headers like I{Content-Type} or I{Transfer-Encoding}. """ channel = DummyChannel() channel.transport = StringTransportWithDisconnection() channel.transport.protocol = channel request = Request(channel, False) headers = { "upgrade": "Websocket", "connection": "Upgrade", "sec-websocket-key": "secure", "sec-websocket-version": "13" } for key, value in headers.items(): request.requestHeaders.setRawHeaders(key, [value]) request.method = "GET" request.clientproto = "HTTP/1.1" result = self.resource.render(request) self.assertEqual(NOT_DONE_YET, result) self.assertEqual( [("Connection", ["Upgrade"]), ("Upgrade", ["WebSocket"]), ("Sec-Websocket-Accept", ["oYBv54i42V5dw6KnZqOFroecUTc="])], list(request.responseHeaders.getAllRawHeaders())) self.assertEqual( "HTTP/1.1 101 Switching Protocols\r\n" "Connection: Upgrade\r\n" "Upgrade: WebSocket\r\n" "Sec-Websocket-Accept: oYBv54i42V5dw6KnZqOFroecUTc=\r\n\r\n", channel.transport.value()) self.assertEqual(101, request.code) self.assertIdentical(None, request.transport)
def test_renderRealRequest(self): """ The request managed by L{WebSocketsResource.render} doesn't contain unnecessary HTTP headers like I{Content-Type}. """ channel = DummyChannel() channel.transport = StringTransportWithDisconnection() channel.transport.protocol = channel request = Request(channel, False) headers = { b"upgrade": b"Websocket", b"connection": b"Upgrade", b"sec-websocket-key": b"secure", b"sec-websocket-version": b"13" } for key, value in headers.items(): request.requestHeaders.setRawHeaders(key, [value]) request.method = b"GET" request.clientproto = b"HTTP/1.1" result = self.resource.render(request) self.assertEqual(NOT_DONE_YET, result) self.assertEqual( [(b"Connection", [b"Upgrade"]), (b"Sec-Websocket-Accept", [b"oYBv54i42V5dw6KnZqOFroecUTc="]), (b"Upgrade", [b"WebSocket"])], sorted(request.responseHeaders.getAllRawHeaders())) self.assertThat( channel.transport.value(), StartsWith(b"HTTP/1.1 101 Switching Protocols\r\n" b"Transfer-Encoding: chunked\r\n")) self.assertEqual(101, request.code) self.assertIdentical(None, request.transport)
def test_render_GET_logs_node_event_status_message(self): path = factory.make_name("squashfs") ip = factory.make_ip_address() request = Request(DummyChannel(), False) request.requestHeaders = Headers({ "X-Original-URI": [path], "X-Original-Remote-IP": [ip] }) mock_deferLater = self.patch(http, "deferLater") mock_deferLater.side_effect = always_succeed_with(None) mock_send_node_event_ip_address = self.patch( http, "send_node_event_ip_address") resource = http.HTTPLogResource() resource.render_GET(request) self.assertThat( mock_deferLater, MockCalledOnceWith( ANY, 0, http.send_node_event_ip_address, event_type=EVENT_TYPES.NODE_HTTP_REQUEST, ip_address=ip, description=path, ), ) self.assertThat( mock_send_node_event_ip_address, MockCalledOnceWith(event_type=EVENT_TYPES.LOADING_EPHEMERAL, ip_address=ip), )
def test_setHeader(self): """ L{http.Request.setHeader} sets the value of the given response header. """ req = http.Request(DummyChannel(), None) req.setHeader("test", "lemur") self.assertEquals(req.responseHeaders.getRawHeaders("test"), ["lemur"])
def renderRequest(self, headers=None, url="/test", ssl=False, queued=False, body=None): """ Render a request against C{self.site}, writing the WebSocket handshake. """ if headers is None: headers = [("Upgrade", "WebSocket"), ("Connection", "Upgrade"), ("Host", "localhost"), ("Origin", "http://localhost/")] channel = DummyChannel() if ssl: channel.transport = channel.SSL() channel.site = self.site request = self.site.requestFactory(channel, queued) for k, v in headers: request.requestHeaders.addRawHeader(k, v) request.gotLength(0) request.requestReceived("GET", url, "HTTP/1.1") if body: request.channel._transferDecoder.finishCallback(body) return channel
def test_getHeaderNotFound(self): """ L{http.Request.getHeader} returns C{None} when asked for the value of a request header which is not present. """ req = http.Request(DummyChannel(), None) self.assertEquals(req.getHeader("test"), None)
def test_getAllHeadersNoHeaders(self): """ L{http.Request.getAllHeaders} returns an empty C{dict} if there are no request headers. """ req = http.Request(DummyChannel(), None) self.assertEquals(req.getAllHeaders(), {})
def setUp(self): self.channel = DummyChannel() self.request = request = Request(self.channel, False) # Simulate request handling request.startedWriting = True transport = WebSocketTransport(request) self.handler = TestHandler(transport) transport._attachHandler(self.handler)
def setUp(self): self.channel = DummyChannel() request = Request(self.channel, False) transport = WebSocketTransport(request) handler = TestHandler(transport) transport._attachHandler(handler) self.decoder = WebSocketFrameDecoder(request, handler) self.decoder.MAX_LENGTH = 100
def test_get_client_proxy_ip_with_x_forwarded(self): d = DummyChannel() request = server.Request(d, False) request.gotLength(0) request.requestHeaders.setRawHeaders(b"x-forwarded-for", [b"80.80.80.80"]) request.requestReceived(b'GET', b'/foo%2Fbar', b'HTTP/1.0') self.assertEqual(request.getClientProxyIP(), '192.168.1.1')
def test_setHost(self): """ L{http.Request.setHost} sets the value of the host request header. """ req = http.Request(DummyChannel(), None) req.setHost("example.com", 443) self.assertEqual( req.requestHeaders.getRawHeaders("host"), ["example.com"])
def test_redirectToUnicodeURL(self): """ L{redirectTo} will raise TypeError if unicode object is passed in URL """ request = Request(DummyChannel(), True) request.method = 'GET' targetURL = u'http://target.example.com/4321' self.assertRaises(TypeError, redirectTo, targetURL, request)
def test_metrics_disabled(self): prometheus_metrics = create_metrics( None, registry=prometheus_client.CollectorRegistry()) resource = http.PrometheusMetricsResource(prometheus_metrics) request = Request(DummyChannel(), False) content = resource.render_GET(request).decode('utf-8') self.assertEqual(request.code, 404) self.assertEqual(content, '')
def test_getAllHeadersMultipleHeaders(self): """ When there are multiple values for a single request header, L{http.Request.getAllHeaders} returns only the last value. """ req = http.Request(DummyChannel(), None) req.requestHeaders.setRawHeaders("test", ["lemur", "panda"]) self.assertEquals(req.getAllHeaders(), {"test": "panda"})
def test_getAllHeaders(self): """ L{http.Request.getAllheaders} returns a C{dict} mapping all request header names to their corresponding values. """ req = http.Request(DummyChannel(), None) req.requestHeaders.setRawHeaders("test", ["lemur"]) self.assertEquals(req.getAllHeaders(), {"test": "lemur"})
def _prequest(**headers): """ Make a request with the given request headers for the persistence tests. """ request = http.Request(DummyChannel(), None) for k, v in headers.iteritems(): request.requestHeaders.setRawHeaders(k, v) return request
def test_getHeaderReceivedMultiples(self): """ When there are multiple values for a single request header, L{http.Request.getHeader} returns the last value. """ req = http.Request(DummyChannel(), None) req.requestHeaders.setRawHeaders("test", ["lemur", "panda"]) self.assertEquals(req.getHeader("test"), "panda")
def test_getHeader(self): """ L{http.Request.getHeader} returns the value of the named request header. """ req = http.Request(DummyChannel(), None) req.requestHeaders.setRawHeaders("test", ["lemur"]) self.assertEquals(req.getHeader("test"), "lemur")
def test_requestFeature(self): self.log.addFeature(request) req = Request(DummyChannel(), False) req.method = 'GET' req.uri = '/foo' self.log.request(req).info('handling request') self.assertIn('method=GET', self.out.getvalue()) self.assertIn('uri=/foo', self.out.getvalue())
def test_setResponseCodeAcceptsIntegers(self): """ L{http.Request.setResponseCode} accepts C{int} or C{long} for the code parameter and raises L{TypeError} if passed anything else. """ req = http.Request(DummyChannel(), None) req.setResponseCode(1) req.setResponseCode(1L) self.assertRaises(TypeError, req.setResponseCode, "1")
def test_registerProducerWhenQueuedPausesPushProducer(self): """ Calling L{Request.registerProducer} with an IPushProducer when the request is queued pauses the producer. """ req = http.Request(DummyChannel(), True) producer = DummyProducer() req.registerProducer(producer, True) self.assertEquals(['pause'], producer.events)
def __init__(self, channel=DummyChannel(), queued=None, api_mode="test", api_version="0.1", api_name="TestAPI", uri="", method="GET", user="", password=""): self.client = address.IPv4Address('TCP', "1.2.3.4", 40323) self.api_mode = api_mode self.api_version = api_version self.api_name = api_name self.save_channel = channel return foundation.ShijiRequest.__init__(self, channel, queued)
def test_registerProducerTwiceFails(self): """ Calling L{Request.registerProducer} when a producer is already registered raises ValueError. """ req = http.Request(DummyChannel(), None) req.registerProducer(DummyProducer(), True) self.assertRaises(ValueError, req.registerProducer, DummyProducer(), True)
def test_registerProducerWhenQueuedDoesntPausePullProducer(self): """ Calling L{Request.registerProducer} with an IPullProducer when the request is queued does not pause the producer, because it doesn't make sense to pause a pull producer. """ req = http.Request(DummyChannel(), True) producer = DummyProducer() req.registerProducer(producer, False) self.assertEquals([], producer.events)
def test_registerProducerWhenNotQueuedRegistersPullProducer(self): """ Calling L{Request.registerProducer} with an IPullProducer when the request is not queued registers the producer as a pull producer on the request's transport. """ req = http.Request(DummyChannel(), False) producer = DummyProducer() req.registerProducer(producer, False) self.assertEquals([(producer, False)], req.transport.producers)
def test_finishAfterConnectionLost(self): """ Calling L{Request.finish} after L{Request.connectionLost} has been called results in a L{RuntimeError} being raised. """ channel = DummyChannel() transport = channel.transport req = http.Request(channel, False) req.connectionLost(Failure(ConnectionLost("The end."))) self.assertRaises(RuntimeError, req.finish)
def test_parseCookiesMultipleHeaders(self): """ L{http.Request.parseCookies} can extract cookies from multiple Cookie headers. """ req = http.Request(DummyChannel(), None) req.requestHeaders.setRawHeaders( "cookie", ['test="lemur"', 'test2="panda"']) req.parseCookies() self.assertEquals(req.received_cookies, {"test": '"lemur"', "test2": '"panda"'})