[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]
[tor-commits] [bridgedb/develop] Revise HTTPS DummyRequest test utility for changes in Twisted>14.0.2.
commit 22817ee11fd7d21cf38ee6050a9bcd3dd2b7849a
Author: Isis Lovecruft <isis@xxxxxxxxxxxxxx>
Date: Mon May 2 16:16:40 2016 +0000
Revise HTTPS DummyRequest test utility for changes in Twisted>14.0.2.
---
test/https_helpers.py | 228 +++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 226 insertions(+), 2 deletions(-)
diff --git a/test/https_helpers.py b/test/https_helpers.py
index cc1ddfa..14755ec 100644
--- a/test/https_helpers.py
+++ b/test/https_helpers.py
@@ -13,6 +13,10 @@
import io
+from twisted.internet.defer import Deferred
+from twisted.internet.address import IPv4Address
+from twisted.web.http_headers import Headers
+from twisted.web.server import NOT_DONE_YET, Session
from twisted.web.test import requesthelper
from bridgedb.persistent import Conf
@@ -121,15 +125,232 @@ class DummyHTTPSDistributor(object):
return [self._bridge_class() for _ in range(self._bridgesPerResponseMin)]
-class DummyRequest(requesthelper.DummyRequest):
+class RequestHelperDummyRequest(object):
+ """
+ Represents a dummy or fake request.
+
+ Taken from Twisted-14.0.2 because this helper class changed in 16.0.0.
+
+ @ivar _finishedDeferreds: C{None} or a C{list} of L{Deferreds} which will
+ be called back with C{None} when C{finish} is called or which will be
+ errbacked if C{processingFailed} is called.
+
+ @type headers: C{dict}
+ @ivar headers: A mapping of header name to header value for all request
+ headers.
+
+ @type outgoingHeaders: C{dict}
+ @ivar outgoingHeaders: A mapping of header name to header value for all
+ response headers.
+
+ @type responseCode: C{int}
+ @ivar responseCode: The response code which was passed to
+ C{setResponseCode}.
+
+ @type written: C{list} of C{bytes}
+ @ivar written: The bytes which have been written to the request.
+ """
+ uri = b'http://dummy/'
+ method = b'GET'
+ client = None
+
+ def registerProducer(self, prod,s):
+ self.go = 1
+ while self.go:
+ prod.resumeProducing()
+
+ def unregisterProducer(self):
+ self.go = 0
+
+
+ def __init__(self, postpath, session=None):
+ self.sitepath = []
+ self.written = []
+ self.finished = 0
+ self.postpath = postpath
+ self.prepath = []
+ self.session = None
+ self.protoSession = session or Session(0, self)
+ self.args = {}
+ self.outgoingHeaders = {}
+ self.requestHeaders = Headers()
+ self.responseHeaders = Headers()
+ self.responseCode = None
+ self.headers = {}
+ self._finishedDeferreds = []
+ self._serverName = b"dummy"
+ self.clientproto = b"HTTP/1.0"
+
+ def getHeader(self, name):
+ """
+ Retrieve the value of a request header.
+
+ @type name: C{bytes}
+ @param name: The name of the request header for which to retrieve the
+ value. Header names are compared case-insensitively.
+
+ @rtype: C{bytes} or L{NoneType}
+ @return: The value of the specified request header.
+ """
+ return self.headers.get(name.lower(), None)
+
+
+ def getAllHeaders(self):
+ """
+ Retrieve all the values of the request headers as a dictionary.
+
+ @return: The entire C{headers} L{dict}.
+ """
+ return self.headers
+
+
+ def setHeader(self, name, value):
+ """TODO: make this assert on write() if the header is content-length
+ """
+ self.outgoingHeaders[name.lower()] = value
+
+ def getSession(self):
+ if self.session:
+ return self.session
+ assert not self.written, "Session cannot be requested after data has been written."
+ self.session = self.protoSession
+ return self.session
+
+
+ def render(self, resource):
+ """
+ Render the given resource as a response to this request.
+
+ This implementation only handles a few of the most common behaviors of
+ resources. It can handle a render method that returns a string or
+ C{NOT_DONE_YET}. It doesn't know anything about the semantics of
+ request methods (eg HEAD) nor how to set any particular headers.
+ Basically, it's largely broken, but sufficient for some tests at least.
+ It should B{not} be expanded to do all the same stuff L{Request} does.
+ Instead, L{DummyRequest} should be phased out and L{Request} (or some
+ other real code factored in a different way) used.
+ """
+ result = resource.render(self)
+ if result is NOT_DONE_YET:
+ return
+ self.write(result)
+ self.finish()
+
+
+ def write(self, data):
+ if not isinstance(data, bytes):
+ raise TypeError("write() only accepts bytes")
+ self.written.append(data)
+
+ def notifyFinish(self):
+ """
+ Return a L{Deferred} which is called back with C{None} when the request
+ is finished. This will probably only work if you haven't called
+ C{finish} yet.
+ """
+ finished = Deferred()
+ self._finishedDeferreds.append(finished)
+ return finished
+
+
+ def finish(self):
+ """
+ Record that the request is finished and callback and L{Deferred}s
+ waiting for notification of this.
+ """
+ self.finished = self.finished + 1
+ if self._finishedDeferreds is not None:
+ observers = self._finishedDeferreds
+ self._finishedDeferreds = None
+ for obs in observers:
+ obs.callback(None)
+
+
+ def processingFailed(self, reason):
+ """
+ Errback and L{Deferreds} waiting for finish notification.
+ """
+ if self._finishedDeferreds is not None:
+ observers = self._finishedDeferreds
+ self._finishedDeferreds = None
+ for obs in observers:
+ obs.errback(reason)
+
+
+ def addArg(self, name, value):
+ self.args[name] = [value]
+
+
+ def setResponseCode(self, code, message=None):
+ """
+ Set the HTTP status response code, but takes care that this is called
+ before any data is written.
+ """
+ assert not self.written, "Response code cannot be set after data has been written: %s." % "@@@@".join(self.written)
+ self.responseCode = code
+ self.responseMessage = message
+
+
+ def setLastModified(self, when):
+ assert not self.written, "Last-Modified cannot be set after data has been written: %s." % "@@@@".join(self.written)
+
+
+ def setETag(self, tag):
+ assert not self.written, "ETag cannot be set after data has been written: %s." % "@@@@".join(self.written)
+
+
+ def getClientIP(self):
+ """
+ Return the IPv4 address of the client which made this request, if there
+ is one, otherwise C{None}.
+ """
+ if isinstance(self.client, IPv4Address):
+ return self.client.host
+ return None
+
+
+ def getRequestHostname(self):
+ """
+ Get a dummy hostname associated to the HTTP request.
+
+ @rtype: C{bytes}
+ @returns: a dummy hostname
+ """
+ return self._serverName
+
+
+ def getHost(self):
+ """
+ Get a dummy transport's host.
+
+ @rtype: C{IPv4Address}
+ @returns: a dummy transport's host
+ """
+ return IPv4Address('TCP', '127.0.0.1', 80)
+
+
+ def getClient(self):
+ """
+ Stub to get the client doing the HTTP request.
+ This merely just ensures that this method exists here. Feel free to
+ extend it.
+ """
+
+
+class DummyRequest(RequestHelperDummyRequest):
"""Wrapper for :api:`twisted.test.requesthelper.DummyRequest` to add
redirect support.
"""
def __init__(self, *args, **kwargs):
- requesthelper.DummyRequest.__init__(self, *args, **kwargs)
+ RequestHelperDummyRequest.__init__(self, *args, **kwargs)
self.redirect = self._redirect(self)
self.content = io.StringIO()
+ self.headers = {} # Needed for Twisted>14.0.2
+ #self.outgoingHeaders = {}
+ #self.responseHeaders = Headers()
+ #self.requestHeaders = Headers()
+
def writeContent(self, data):
"""Add some **data** to the faked body of this request.
@@ -159,3 +380,6 @@ class DummyRequest(requesthelper.DummyRequest):
newRequest = type(request)
newRequest.uri = request.uri
return newRequest
+
+
+#DummyRequest = RequestHelperDummyRequest
_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits