"""Unittests for the various HTTPServer modules.

Written by Cody A.W. Somerville <cody-somerville@ubuntu.com>,

Josip Dzolonga, and Michael Otteneder for the 2007/08 GHOP contest.

"""

from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer

from SimpleHTTPServer import SimpleHTTPRequestHandler

from CGIHTTPServer import CGIHTTPRequestHandler

import os

import sys

import base64

import shutil

import urllib

import httplib

import tempfile

import threading

import unittest

from test import test_support

class NoLogRequestHandler:

    def log_message(self, *args):

        # don't write log messages to stderr

        pass

class TestServerThread(threading.Thread):

    def __init__(self, test_object, request_handler):

        threading.Thread.__init__(self)

        self.request_handler = request_handler

        self.test_object = test_object

        self.test_object.lock.acquire()

    def run(self):

        self.server = HTTPServer(('', 0), self.request_handler)

        self.test_object.PORT = self.server.socket.getsockname()[1]

        self.test_object.lock.release()

        try:

            self.server.serve_forever()

        finally:

            self.server.server_close()

    def stop(self):

        self.server.shutdown()

class BaseTestCase(unittest.TestCase):

    def setUp(self):

        self.lock = threading.Lock()

        self.thread = TestServerThread(self, self.request_handler)

        self.thread.start()

        self.lock.acquire()

    def tearDown(self):

        self.lock.release()

        self.thread.stop()

    def request(self, uri, method='GET', body=None, headers={}):

        self.connection = httplib.HTTPConnection('localhost', self.PORT)

        self.connection.request(method, uri, body, headers)

        return self.connection.getresponse()

class BaseHTTPServerTestCase(BaseTestCase):

    class request_handler(NoLogRequestHandler, BaseHTTPRequestHandler):

        protocol_version = 'HTTP/1.1'

        default_request_version = 'HTTP/1.1'

        def do_TEST(self):

            self.send_response(204)

            self.send_header('Content-Type', 'text/html')

            self.send_header('Connection', 'close')

            self.end_headers()

        def do_KEEP(self):

            self.send_response(204)

            self.send_header('Content-Type', 'text/html')

            self.send_header('Connection', 'keep-alive')

            self.end_headers()

        def do_KEYERROR(self):

            self.send_error(999)

        def do_CUSTOM(self):

            self.send_response(999)

            self.send_header('Content-Type', 'text/html')

            self.send_header('Connection', 'close')

            self.end_headers()

    def setUp(self):

        BaseTestCase.setUp(self)

        self.con = httplib.HTTPConnection('localhost', self.PORT)

        self.con.connect()

    def test_command(self):

        self.con.request('GET', '/')

        res = self.con.getresponse()

        self.assertEquals(res.status, 501)

    def test_request_line_trimming(self):

        self.con._http_vsn_str = 'HTTP/1.1\n'

        self.con.putrequest('GET', '/')

        self.con.endheaders()

        res = self.con.getresponse()

        self.assertEquals(res.status, 501)

    def test_version_bogus(self):

        self.con._http_vsn_str = 'FUBAR'

        self.con.putrequest('GET', '/')

        self.con.endheaders()

        res = self.con.getresponse()

        self.assertEquals(res.status, 400)

    def test_version_digits(self):

        self.con._http_vsn_str = 'HTTP/9.9.9'

        self.con.putrequest('GET', '/')

        self.con.endheaders()

        res = self.con.getresponse()

        self.assertEquals(res.status, 400)

    def test_version_none_get(self):

        self.con._http_vsn_str = ''

        self.con.putrequest('GET', '/')

        self.con.endheaders()

        res = self.con.getresponse()

        self.assertEquals(res.status, 501)

    def test_version_none(self):

        self.con._http_vsn_str = ''

        self.con.putrequest('PUT', '/')

        self.con.endheaders()

        res = self.con.getresponse()

        self.assertEquals(res.status, 400)

    def test_version_invalid(self):

        self.con._http_vsn = 99

        self.con._http_vsn_str = 'HTTP/9.9'

        self.con.putrequest('GET', '/')

        self.con.endheaders()

        res = self.con.getresponse()

        self.assertEquals(res.status, 505)

    def test_send_blank(self):

        self.con._http_vsn_str = ''

        self.con.putrequest('', '')

        self.con.endheaders()

        res = self.con.getresponse()

        self.assertEquals(res.status, 400)

    def test_header_close(self):

        self.con.putrequest('GET', '/')

        self.con.putheader('Connection', 'close')

        self.con.endheaders()

        res = self.con.getresponse()

        self.assertEquals(res.status, 501)

    def test_head_keep_alive(self):

        self.con._http_vsn_str = 'HTTP/1.1'

        self.con.putrequest('GET', '/')

        self.con.putheader('Connection', 'keep-alive')

        self.con.endheaders()

        res = self.con.getresponse()

        self.assertEquals(res.status, 501)

    def test_handler(self):

        self.con.request('TEST', '/')

        res = self.con.getresponse()

        self.assertEquals(res.status, 204)

    def test_return_header_keep_alive(self):

        self.con.request('KEEP', '/')

        res = self.con.getresponse()

        self.assertEquals(res.getheader('Connection'), 'keep-alive')

        self.con.request('TEST', '/')

    def test_internal_key_error(self):

        self.con.request('KEYERROR', '/')

        res = self.con.getresponse()

        self.assertEquals(res.status, 999)

    def test_return_custom_status(self):

        self.con.request('CUSTOM', '/')

        res = self.con.getresponse()

        self.assertEquals(res.status, 999)

class SimpleHTTPServerTestCase(BaseTestCase):

    class request_handler(NoLogRequestHandler, SimpleHTTPRequestHandler):

        pass

    def setUp(self):

        BaseTestCase.setUp(self)

        self.cwd = os.getcwd()

        basetempdir = tempfile.gettempdir()

        os.chdir(basetempdir)

        self.data = 'We are the knights who say Ni!'

        self.tempdir = tempfile.mkdtemp(dir=basetempdir)

        self.tempdir_name = os.path.basename(self.tempdir)

        temp = open(os.path.join(self.tempdir, 'test'), 'wb')

        temp.write(self.data)

        temp.close()

    def tearDown(self):

        try:

            os.chdir(self.cwd)

            try:

                shutil.rmtree(self.tempdir)

            except:

                pass

        finally:

            BaseTestCase.tearDown(self)

    def check_status_and_reason(self, response, status, data=None):

        body = response.read()

        self.assert_(response)

        self.assertEquals(response.status, status)

        self.assert_(response.reason != None)

        if data:

            self.assertEqual(data, body)

    def test_get(self):

        #constructs the path relative to the root directory of the HTTPServer

        response = self.request(self.tempdir_name + '/test')

        self.check_status_and_reason(response, 200, data=self.data)

        response = self.request(self.tempdir_name + '/')

        self.check_status_and_reason(response, 200)

        response = self.request(self.tempdir_name)

        self.check_status_and_reason(response, 301)

        response = self.request('/ThisDoesNotExist')

        self.check_status_and_reason(response, 404)

        response = self.request('/' + 'ThisDoesNotExist' + '/')

        self.check_status_and_reason(response, 404)

        f = open(os.path.join(self.tempdir_name, 'index.html'), 'w')

        response = self.request('/' + self.tempdir_name + '/')

        self.check_status_and_reason(response, 200)

        if os.name == 'posix':

            # chmod won't work as expected on Windows platforms

            os.chmod(self.tempdir, 0)

            response = self.request(self.tempdir_name + '/')

            self.check_status_and_reason(response, 404)

            os.chmod(self.tempdir, 0755)

    def test_head(self):

        response = self.request(

            self.tempdir_name + '/test', method='HEAD')

        self.check_status_and_reason(response, 200)

        self.assertEqual(response.getheader('content-length'),

                         str(len(self.data)))

        self.assertEqual(response.getheader('content-type'),

                         'application/octet-stream')

    def test_invalid_requests(self):

        response = self.request('/', method='FOO')

        self.check_status_and_reason(response, 501)

        # requests must be case sensitive,so this should fail too

        response = self.request('/', method='get')

        self.check_status_and_reason(response, 501)

        response = self.request('/', method='GETs')

        self.check_status_and_reason(response, 501)

cgi_file1 = """\

#!%s

print "Content-type: text/html"

print

print "Hello World"

"""

cgi_file2 = """\

#!%s

import cgi

print "Content-type: text/html"

print

form = cgi.FieldStorage()

print "%%s, %%s, %%s" %% (form.getfirst("spam"), form.getfirst("eggs"),\

              form.getfirst("bacon"))

"""

class CGIHTTPServerTestCase(BaseTestCase):

    class request_handler(NoLogRequestHandler, CGIHTTPRequestHandler):

        pass

    def setUp(self):

        BaseTestCase.setUp(self)

        self.parent_dir = tempfile.mkdtemp()

        self.cgi_dir = os.path.join(self.parent_dir, 'cgi-bin')

        os.mkdir(self.cgi_dir)

        self.file1_path = os.path.join(self.cgi_dir, 'file1.py')

        with open(self.file1_path, 'w') as file1:

            file1.write(cgi_file1 % sys.executable)

        os.chmod(self.file1_path, 0777)

        self.file2_path = os.path.join(self.cgi_dir, 'file2.py')

        with open(self.file2_path, 'w') as file2:

            file2.write(cgi_file2 % sys.executable)

        os.chmod(self.file2_path, 0777)

        self.cwd = os.getcwd()

        os.chdir(self.parent_dir)

    def tearDown(self):

        try:

            os.chdir(self.cwd)

            os.remove(self.file1_path)

            os.remove(self.file2_path)

            os.rmdir(self.cgi_dir)

            os.rmdir(self.parent_dir)

        finally:

            BaseTestCase.tearDown(self)

    def test_headers_and_content(self):

        res = self.request('/cgi-bin/file1.py')

        self.assertEquals(('Hello World\n', 'text/html', 200), \

             (res.read(), res.getheader('Content-type'), res.status))

    def test_post(self):

        params = urllib.urlencode({'spam' : 1, 'eggs' : 'python', 'bacon' : 123456})

        headers = {'Content-type' : 'application/x-www-form-urlencoded'}

        res = self.request('/cgi-bin/file2.py', 'POST', params, headers)

        self.assertEquals(res.read(), '1, python, 123456\n')

    def test_invaliduri(self):

        res = self.request('/cgi-bin/invalid')

        res.read()

        self.assertEquals(res.status, 404)

    def test_authorization(self):

        headers = {'Authorization' : 'Basic %s' % \

                base64.b64encode('username:pass')}

        res = self.request('/cgi-bin/file1.py', 'GET', headers=headers)

        self.assertEquals(('Hello World\n', 'text/html', 200), \

             (res.read(), res.getheader('Content-type'), res.status))

def test_main(verbose=None):

    try:

        cwd = os.getcwd()

        test_support.run_unittest(BaseHTTPServerTestCase,

                                  SimpleHTTPServerTestCase,

                                  CGIHTTPServerTestCase

                                  )

    finally:

        os.chdir(cwd)

if __name__ == '__main__':

    test_main()