def testReadLines(self):
     stream = HTTPInputStream(BytesIO(data), {})
     output = b''.join(stream.readlines(4))
     self.assertEqual(output, self.getCacheStreamValue(stream))
     output += b''.join(stream.readlines())
     self.assertEqual(output, self.getCacheStreamValue(stream))
     self.assertEqual(data, self.getCacheStreamValue(stream))

 def testRead(self):
     stream = HTTPInputStream(BytesIO(data), {})
     output = b''
     self.assertEqual(output, self.getCacheStreamValue(stream))
     output += stream.read(5)
     self.assertEqual(output, self.getCacheStreamValue(stream))
     output += stream.read()
     self.assertEqual(output, self.getCacheStreamValue(stream))
     self.assertEqual(data, self.getCacheStreamValue(stream))

 def testReadLine(self):
     stream = HTTPInputStream(StringIO(data), {})
     output = stream.readline()
     self.assertEqual(output, self.getCacheStreamValue(stream))
     output += stream.readline()
     self.assertEqual(output, self.getCacheStreamValue(stream))
     output += stream.readline()
     self.assertEqual(output, self.getCacheStreamValue(stream))
     output += stream.readline()
     self.assertEqual(output, self.getCacheStreamValue(stream))
     self.assertEqual(data, self.getCacheStreamValue(stream))

    def testCachingWithContentLength(self):
        # The HTTPInputStream implementation will cache the input
        # stream in a temporary file (instead of in memory) when the
        # reported content length is over a certain number (100000 is
        # definitely over that).

        # HTTPInputStream understands both CONTENT_LENGTH...
        stream = HTTPInputStream(StringIO(data), {'CONTENT_LENGTH': '100000'})
        self.assert_(isinstance(stream.getCacheStream(), TempFileType))

        # ... and HTTP_CONTENT_LENGTH.
        stream = HTTPInputStream(StringIO(data), {'HTTP_CONTENT_LENGTH':
                                                  '100000'})
        self.assert_(isinstance(stream.getCacheStream(), TempFileType))

        # If CONTENT_LENGTH is absent or empty, it takes the value
        # given in HTTP_CONTENT_LENGTH:
        stream = HTTPInputStream(StringIO(data),
                                 {'CONTENT_LENGTH': '',
                                  'HTTP_CONTENT_LENGTH': '100000'})
        self.assert_(isinstance(stream.getCacheStream(), TempFileType))

        # In fact, HTTPInputStream can be instantiated with both an
        # empty CONTENT_LENGTH and an empty HTTP_CONTENT_LENGTH:
        stream = HTTPInputStream(StringIO(data),
                                 {'CONTENT_LENGTH': '',
                                  'HTTP_CONTENT_LENGTH': ''})

    def testWorkingWithNonClosingStreams(self):
        # It turns out that some Web servers (Paste for example) do not send
        # the EOF signal after the data has been transmitted and the read()
        # simply hangs if no expected content length has been specified.
        #
        # In this test we simulate the hanging of the server by throwing an
        # exception.
        class ServerHung(Exception):
            pass

        class NonClosingStream(object):
            def read(self, size=-1):
                if size == -1:
                    raise ServerHung
                return b'a'*size

        stream = HTTPInputStream(NonClosingStream(), {'CONTENT_LENGTH': '10'})
        self.assertEqual(stream.getCacheStream().read(), b'aaaaaaaaaa')
        stream = HTTPInputStream(NonClosingStream(), {})
        self.assertRaises(ServerHung, stream.getCacheStream)

 def testGetCacheStream(self):
     stream = HTTPInputStream(BytesIO(data), {})
     stream.read(5)
     self.assertEqual(data, stream.getCacheStream().read())