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"'})
