def test_prePathURLHost(self):
     """
     Verify that L{FakeRequest.prePathURL} will turn the C{Host} header of
     the request into the netloc of the returned URL, if it's present.
     """
     req = FakeRequest(currentSegments=["a", "b"], uri="/a/b/c/", headers={"host": "foo.bar"})
     self.assertEqual(req.prePathURL(), "http://foo.bar/a/b")

 def test_setResponseCode(self):
     """
     Test that the response code of a fake request can be set.
     """
     req = FakeRequest()
     req.setResponseCode(BAD_REQUEST)
     self.assertEqual(req.code, BAD_REQUEST)

 def test_missingContentMD5(self):
     """
     Submitting a request with no Content-MD5 header should succeed.
     """
     req = FakeRequest()
     req.content = StringIO('wrongdata')
     return self.creator.handlePUT(req)

 def test_prePathURL(self):
     """
     Verify that L{FakeRequest.prePathURL} returns the prepath of the
     requested URL.
     """
     req = FakeRequest(currentSegments=['a'], uri='/a/b')
     self.assertEqual(req.prePathURL(), 'http://localhost/a')

 def test_smashInitialHeaderCase(self):
     """
     L{FakeRequest.getHeader} will return the value of a header specified to
     L{FakeRequest.__init__} even if the header names have differing case.
     """
     host = 'example.com'
     request = FakeRequest(headers={'HoSt': host})
     self.assertEqual(request.getHeader('hOsT'), host)

 def test_caseInsensitiveHeaders(self):
     """
     L{FakeRequest.getHeader} will return the value of a header regardless
     of casing.
     """
     host = 'example.com'
     request = FakeRequest()
     request.received_headers['host'] = host
     self.assertEqual(request.getHeader('hOsT'), host)

 def test_headers(self):
     """
     Check that setting a header with L{FakeRequest.setHeader} actually
     places it in the headers dictionary.
     """
     host = 'divmod.com'
     req = FakeRequest()
     req.setHeader('host', host)
     self.assertEqual(req.headers['host'], host)

 def test_headers(self):
     """
     Check that setting a header with L{FakeRequest.setHeader} actually
     places it in the headers dictionary.
     """
     host = "divmod.com"
     req = FakeRequest()
     req.setHeader("host", host)
     self.assertEqual(req.responseHeaders.getRawHeaders("host"), [host])

 def test_incorrectContentMD5(self):
     """
     Submitting a request with a Content-MD5 header that disagrees with the
     uploaded data should fail.
     """
     req = FakeRequest()
     req.received_headers['content-md5'] = '72VMQKtPF0f8aZkV1PcJAg=='
     req.content = StringIO('wrongdata')
     self.assertRaises(ValueError, self.creator.handlePUT, req)

 def test_correctContentMD5(self):
     """
     Submitting a request with a Content-MD5 header that agrees with the
     uploaded data should succeed.
     """
     req = FakeRequest()
     req.received_headers['content-md5'] = '72VMQKtPF0f8aZkV1PcJAg=='
     req.content = StringIO('testdata')
     return self.creator.handlePUT(req)

 def test_domainSpecified(self):
     """
     Test that L{usernameFromRequest} returns the username in the request
     if that username specifies a domain.
     """
     request = FakeRequest(headers={'host': 'divmod.com'})
     request.args = {'username': ['[email protected]']}
     username = usernameFromRequest(request)
     self.assertEqual(username, '[email protected]')

 def render2(self, page, **kwargs):
     # use this to exercise the normal Nevow docFactory rendering. It
     # returns a string. If one of the render_* methods returns a
     # Deferred, this will throw an exception. (note that
     # page.renderString is the Deferred-returning equivalent)
     req = FakeRequest(**kwargs)
     req.fields = None
     ctx = self.make_context(req)
     return page.renderSynchronously(ctx)

 def test_caseInsensitiveHeaders(self):
     """
     L{FakeRequest.getHeader} will return the value of a header regardless
     of casing.
     """
     host = "example.com"
     request = FakeRequest()
     request.requestHeaders.setRawHeaders("host", [host])
     self.assertEqual(request.getHeader("hOsT"), host)

 def test_prePathURLHost(self):
     """
     Verify that L{FakeRequest.prePathURL} will turn the C{Host} header of
     the request into the netloc of the returned URL, if it's present.
     """
     req = FakeRequest(currentSegments=['a', 'b'],
                       uri='/a/b/c/',
                       headers={'host': 'foo.bar'})
     self.assertEqual(req.prePathURL(), 'http://foo.bar/a/b')

 def test_domainUnspecified(self):
     """
     Test that L{usernameFromRequest} adds the value of host header to the
     username in the request if the username doesn't already specify a
     domain.
     """
     request = FakeRequest(headers={'host': 'divmod.com'})
     request.args = {'username': ['joe']}
     username = usernameFromRequest(request)
     self.assertEqual(username, '[email protected]')

    def test_savorSessionCookie(self):
        """
        L{PersistentSessionWrapper.savorSessionCookie} adds a cookie with a
        large maximum age and a request-appropriate domain to the request.
        """
        request = FakeRequest(headers={"host": "example.com"})
        resource = PersistentSessionWrapper(None, None, domains=["example.org", "example.com"])

        resource.savorSessionCookie(request)
        self.assertEqual(request.cookies, {resource.cookieKey: request.getSession().uid})

 def test_getRootURL(self):
     """
     L{FakeRequest.getRootURL} returns C{None} when
     L{FakeRequest.rememberRootURL} has not yet been called.  After
     L{FakeRequest.rememberRootURL} has been called,
     L{FakeRequest.getRootURL} returns the value which was passed to it.
     """
     request = FakeRequest()
     self.assertIdentical(request.getRootURL(), None)
     request.rememberRootURL("foo/bar")
     self.assertEqual(request.getRootURL(), "foo/bar")

 def test_rendering(self):
     """
     L{AddBlogPostDialogFragment} can be rendered as part of a Mantissa
     public Athena page.
     """
     page = PublicAthenaLivePage(self.store, self.fragment, None, None)
     request = FakeRequest()
     request.args = {'title': ['foo'],
                     'body': ['bar'],
                     'url': ['baz']}
     return renderLivePage(page, reqFactory=lambda: request)

    def test_headerSeparation(self):
        """
        Request headers and response headers are different things.

        Test that they are handled separately.
        """
        req = FakeRequest()
        req.setHeader("foo", "bar")
        self.assertFalse(req.requestHeaders.hasHeader("foo"))
        self.assertEqual(req.getHeader("foo"), None)
        req.requestHeaders.setRawHeaders("foo", ["bar"])
        self.assertEqual(req.getHeader("foo"), "bar")

 def render1(self, page, **kwargs):
     # use this to exercise an overridden renderHTTP, usually for
     # output=json or render_GET. It always returns a Deferred.
     req = FakeRequest(**kwargs)
     req.fields = None
     ctx = self.make_context(req)
     d = defer.maybeDeferred(page.renderHTTP, ctx)
     def _done(res):
         if isinstance(res, str):
             return res + req.v
         return req.v
     d.addCallback(_done)
     return d