def mk_request(self, user=None, password=None):
     request = DummyRequest([''])
     if user is not None:
         request.headers["authorization"] = (
             "Basic %s" % base64.b64encode("%s:%s" % (user, password))
         )
     return request

    def test_getChild(self):
        """
        L{NameVirtualHost.getChild} returns correct I{Resource} based off
        the header and modifies I{Request} to ensure proper prepath and
        postpath are set.
        """
        virtualHostResource = NameVirtualHost()
        leafResource = Data(b"leaf data", "")
        leafResource.isLeaf = True
        normResource = Data(b"norm data", "")
        virtualHostResource.addHost(b'leaf.example.org', leafResource)
        virtualHostResource.addHost(b'norm.example.org', normResource)

        request = DummyRequest([])
        request.requestHeaders.addRawHeader(b'host', b'norm.example.org')
        request.prepath = [b'']

        self.assertIsInstance(virtualHostResource.getChild(b'', request),
                              NoResource)
        self.assertEqual(request.prepath, [b''])
        self.assertEqual(request.postpath, [])

        request = DummyRequest([])
        request.requestHeaders.addRawHeader(b'host', b'leaf.example.org')
        request.prepath = [b'']

        self.assertIsInstance(virtualHostResource.getChild(b'', request),
                              Data)
        self.assertEqual(request.prepath,  [])
        self.assertEqual(request.postpath, [b''])

    def test_renderWithHost(self):
        """
        L{NameVirtualHost.render} returns the result of rendering the resource
        which is the value in the instance's C{host} dictionary corresponding
        to the key indicated by the value of the I{Host} header in the request.
        """
        virtualHostResource = NameVirtualHost()
        virtualHostResource.addHost('example.org', Data("winner", ""))

        request = DummyRequest([''])
        request.headers['host'] = 'example.org'
        d = _render(virtualHostResource, request)
        def cbRendered(ignored, request):
            self.assertEqual(''.join(request.written), "winner")
        d.addCallback(cbRendered, request)

        # The port portion of the Host header should not be considered.
        requestWithPort = DummyRequest([''])
        requestWithPort.headers['host'] = 'example.org:8000'
        dWithPort = _render(virtualHostResource, requestWithPort)
        def cbRendered(ignored, requestWithPort):
            self.assertEqual(''.join(requestWithPort.written), "winner")
        dWithPort.addCallback(cbRendered, requestWithPort)

        return gatherResults([d, dWithPort])

 def test_receipt_processing(self):
     """it should be able to process an incoming XML receipt via HTTP"""
     publisher = TestPublisher()
     resource = transport.OperaReceiptResource(publisher)
     request = DummyRequest('/api/v1/sms/opera/receipt.xml')
     request.content = StringIO("""
     <?xml version="1.0"?>
     <!DOCTYPE receipts>
     <receipts>
       <receipt>
         <msgid>26567958</msgid>
         <reference>001efc31</reference>
         <msisdn>+27123456789</msisdn>
         <status>D</status>
         <timestamp>20080831T15:59:24</timestamp>
         <billed>NO</billed>
       </receipt>
     </receipts>
     """.strip())
     resource.render_POST(request)
     self.assertEquals(publisher.queue.pop(), (Message(**{
             'transport_name': 'Opera',
             'transport_msg_id': '001efc31',
             'transport_status': 'D',  # OK / delivered, opera specific
             'transport_delivered_at': datetime(2008, 8, 31, 15, 59, 24),
         }), {
             'routing_key': 'sms.receipt.opera'
         })
     )

 def test_renderSecureRequest(self):
     """
     When the rendered request is over HTTPS, L{WebSocketsResource} wraps
     the protocol of the C{TLSMemoryBIOProtocol} instance.
     """
     request = DummyRequest("/")
     request.requestHeaders = Headers()
     transport = StringTransportWithDisconnection()
     secureProtocol = TLSMemoryBIOProtocol(Factory(), Protocol())
     transport.protocol = secureProtocol
     request.transport = transport
     request.headers.update({
         "upgrade": "Websocket",
         "connection": "Upgrade",
         "sec-websocket-key": "secure",
         "sec-websocket-version": "13"})
     result = self.resource.render(request)
     self.assertEqual(NOT_DONE_YET, result)
     self.assertEqual(
         {"connection": "Upgrade",
          "upgrade": "WebSocket",
          "sec-websocket-accept": "oYBv54i42V5dw6KnZqOFroecUTc="},
         request.outgoingHeaders)
     self.assertEqual([""], request.written)
     self.assertEqual(101, request.responseCode)
     self.assertIdentical(None, request.transport)
     self.assertIsInstance(
         transport.protocol.wrappedProtocol, WebSocketsProtocol)
     self.assertIsInstance(
         transport.protocol.wrappedProtocol._receiver,
         SavingEchoReceiver)

    def test_renderIProtocol(self):
        """
        If the protocol returned by C{lookupProtocol} isn't a
        C{WebSocketsProtocol}, L{WebSocketsResource} wraps it automatically
        with L{WebSocketsProtocolWrapper}.
        """

        def lookupProtocol(names, otherRequest):
            return AccumulatingProtocol(), None

        self.resource = WebSocketsResource(lookupProtocol)

        request = DummyRequest("/")
        request.requestHeaders = Headers()
        transport = StringTransportWithDisconnection()
        transport.protocol = Protocol()
        request.transport = transport
        request.headers.update({
            "upgrade": "Websocket",
            "connection": "Upgrade",
            "sec-websocket-key": "secure",
            "sec-websocket-version": "13"})
        result = self.resource.render(request)
        self.assertEqual(NOT_DONE_YET, result)
        self.assertIsInstance(transport.protocol, WebSocketsProtocolWrapper)
        self.assertIsInstance(transport.protocol.wrappedProtocol,
                              AccumulatingProtocol)

 def test_render(self):
     """
     When rendering a request, L{WebSocketsResource} uses the
     C{Sec-WebSocket-Key} header to generate a C{Sec-WebSocket-Accept}
     value. It creates a L{WebSocketsProtocol} instance connected to the
     protocol provided by the user factory.
     """
     request = DummyRequest("/")
     request.requestHeaders = Headers()
     transport = StringTransportWithDisconnection()
     transport.protocol = Protocol()
     request.transport = transport
     request.headers.update({
         "upgrade": "Websocket",
         "connection": "Upgrade",
         "sec-websocket-key": "secure",
         "sec-websocket-version": "13"})
     result = self.resource.render(request)
     self.assertEqual(NOT_DONE_YET, result)
     self.assertEqual(
         {"connection": "Upgrade",
          "upgrade": "WebSocket",
          "sec-websocket-accept": "oYBv54i42V5dw6KnZqOFroecUTc="},
         request.outgoingHeaders)
     self.assertEqual([""], request.written)
     self.assertEqual(101, request.responseCode)
     self.assertIdentical(None, request.transport)
     self.assertIsInstance(transport.protocol._receiver,
                           SavingEchoReceiver)

    def test_renderProtocol(self):
        """
        If protocols are specified via the C{Sec-WebSocket-Protocol} header,
        L{WebSocketsResource} passes them to its C{lookupProtocol} argument,
        which can decide which protocol to return, and which is accepted.
        """

        def lookupProtocol(names, otherRequest):
            self.assertEqual(["foo", "bar"], names)
            self.assertIdentical(request, otherRequest)
            return self.echoProtocol, "bar"

        self.resource = WebSocketsResource(lookupProtocol)

        request = DummyRequest("/")
        request.requestHeaders = Headers(
            {"sec-websocket-protocol": ["foo", "bar"]})
        transport = StringTransportWithDisconnection()
        transport.protocol = Protocol()
        request.transport = transport
        request.headers.update({
            "upgrade": "Websocket",
            "connection": "Upgrade",
            "sec-websocket-key": "secure",
            "sec-websocket-version": "13"})
        result = self.resource.render(request)
        self.assertEqual(NOT_DONE_YET, result)
        self.assertEqual(
            {"connection": "Upgrade",
             "upgrade": "WebSocket",
             "sec-websocket-protocol": "bar",
             "sec-websocket-accept": "oYBv54i42V5dw6KnZqOFroecUTc="},
            request.outgoingHeaders)
        self.assertEqual([""], request.written)
        self.assertEqual(101, request.responseCode)

    def __init__(self, postpath, params, session=None):
        self.content = StringIO()
        self.content.write(urllib.urlencode(params))
        self.content.seek(0, 0)
        self.requestHeaders = Headers()

        DummyRequest.__init__(self, postpath, session)

 def test_invalidMethod(self):
     """
     L{UserDirectory.render} raises L{UnsupportedMethod} in response to a
     non-I{GET} request.
     """
     request = DummyRequest([""])
     request.method = "POST"
     self.assertRaises(server.UnsupportedMethod, self.directory.render, request)

    def __init__(self, method, url, args=None):
        DummyRequest.__init__(self, url.split('/'))
        self.method = method

        # set args
        args = args or {}
        for k, v in args.items():
            self.addArg(k, v)

 def __init__(self, postpath, params):
     DummyRequest.__init__(self, postpath, None)
     self.content = StringIO()
     self.content.write(json.dumps(params))
     self.content.seek(0, 0)
     self.requestHeaders = Headers()
     self.method = 'POST'
     self.requestHeaders.addRawHeader('content-type', 'application/json')

def create_request(params={}, path='/', method='POST'):
    """
    Creates a dummy Vas2Nets request for testing our resources with
    """
    request = DummyRequest(path)
    request.method = method
    request.args = params
    return request

 def test_song_id_does_not_exist(self):
     raise SkipTest("Twisted using deferToThread seems to break the test db connection that django establishes.  However, with the real django db connection this works fine...")
     r = web.Song(1)
     request = DummyRequest([""])
     d = request.notifyFinish()
     d.addCallback(self._assert_song_does_not_exist, request)
     result = r.render_GET(request)
     self.assertEqual(result, server.NOT_DONE_YET)
     return d

def request_generator(url, method='GET', content=True, headers=True):
    request = DummyRequest(url)
    request.method = method
    if content:
        request.content = StringIO()
    if headers:
        request.requestHeaders = Headers()

    return request

 def makeRequest(self, method='GET', clientAddress=None):
     """
     Create a L{DummyRequest} (change me to create a
     L{twisted.web.http.Request} instead).
     """
     request = DummyRequest('/')
     request.method = method
     request.client = clientAddress
     return request

def test_handles_defaults_correctly():
    u2m = {}
    u2m["/doesn/t/exist"] = root.__default__
    u2m["/sub/doesn/t/exist"] = root.sub.__default__

    for path, method in u2m.items():
        request = DummyRequest([])
        request.path = path
        action = site.routeRequest(request)
        assert getattr(action, "func", None) == method, "Expecting %s but got %s for URL %s" % (method, action, path)

 def test_renderHEAD(self):
     """
     The rendering behavior of L{UnauthorizedResource} for a I{HEAD} request
     is like its handling of a I{GET} request, but no response body is
     written.
     """
     request = DummyRequest([''])
     request.method = 'HEAD'
     self._unauthorizedRenderTest(request)
     self.assertEqual('', ''.join(request.written))

 def __init__(self, method, url, args=None, headers=None):
     DummyRequest.__init__(self, url.split('/'))
     self.uri    = url
     self.method = method
     self.headers.update(headers or {})
     
     # set args
     args = args or {}
     for k, v in args.items():
         self.addArg(k, v)

    def test_hook_bad_ip(self):
        """
        An error is raised when request is comming from an untrusted IP.
        """
        request = DummyRequest([])
        request.client = IPv4Address('TCP', '111.0.0.0', 2345)
        result = hook(request, 'hook_name')

        self.assertEqual(403, request.code)
        self.assertTrue(result.startswith('Error:001: '))