← Back to branch summary

~certify-web-dev/twisted/certify-trunk

« back to all changes in this revision

Viewing changes to twisted/web2/test/test_static.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-01-17 14:52:35 UTC
  • mfrom: (1.1.5 upstream) (2.1.2 etch)
  • Revision ID: james.westby@ubuntu.com-20070117145235-btmig6qfmqfen0om
Tags: 2.5.0-0ubuntu1
New upstream version, compatible with python2.5.

Show diffs side-by-side

added added

removed removed

Lines of Context:
twisted/web2/test/test_static.py
 
1
import os
 
2
 
 
3
from twisted.web2.test.test_server import BaseCase
 
4
from twisted.web2 import static
 
5
from twisted.web2 import http_headers
 
6
from twisted.web2 import stream
 
7
from twisted.web2 import iweb
 
8
 
 
9
class TestData(BaseCase):
 
10
    def setUp(self):
 
11
        self.text = "Hello, World\n"
 
12
        self.data = static.Data(self.text, "text/plain")
 
13
 
 
14
    def test_dataState(self):
 
15
        """
 
16
        Test the internal state of the Data object
 
17
        """
 
18
        self.assert_(hasattr(self.data, "created_time"))
 
19
        self.assertEquals(self.data.data, self.text)
 
20
        self.assertEquals(self.data.type, http_headers.MimeType("text", "plain"))
 
21
        self.assertEquals(self.data.contentType(), http_headers.MimeType("text", "plain"))
 
22
 
 
23
 
 
24
    def test_etag(self):
 
25
        """
 
26
        Test that we can get an ETag
 
27
        """
 
28
        self.failUnless(self.data.etag())
 
29
 
 
30
 
 
31
    def test_render(self):
 
32
        """
 
33
        Test that the result from Data.render is acceptable, including the
 
34
        response code, the content-type header, and the actual response body
 
35
        itself.
 
36
        """
 
37
        response = iweb.IResponse(self.data.render(None))
 
38
        self.assertEqual(response.code, 200)
 
39
        self.assert_(response.headers.hasHeader("content-type"))
 
40
        self.assertEqual(response.headers.getHeader("content-type"),
 
41
                         http_headers.MimeType("text", "plain"))
 
42
        def checkStream(data):
 
43
            self.assertEquals(str(data), self.text)
 
44
        return stream.readStream(iweb.IResponse(self.data.render(None)).stream,
 
45
                                 checkStream)
 
46
 
 
47
 
 
48
 
 
49
class TestFileSaver(BaseCase):
 
50
    def setUpClass(self):
 
51
        self.tempdir = self.mktemp()
 
52
        os.mkdir(self.tempdir)
 
53
        
 
54
        self.root = static.FileSaver(self.tempdir,
 
55
                              expectedFields=['FileNameOne'],
 
56
                              maxBytes=16)
 
57
        self.root.addSlash = True
 
58
 
 
59
    def uploadFile(self, fieldname, filename, mimetype, content, resrc=None,
 
60
                   host='foo', path='/'):
 
61
        if not resrc:
 
62
            resrc = self.root
 
63
            
 
64
        ctype = http_headers.MimeType('multipart', 'form-data',
 
65
                                      (('boundary', '---weeboundary'),))
 
66
        
 
67
        return self.getResponseFor(resrc, '/',
 
68
                            headers={'host': 'foo',
 
69
                                     'content-type': ctype },
 
70
                            length=len(content),
 
71
                            method='POST',
 
72
                            content="""-----weeboundary\r
 
73
Content-Disposition: form-data; name="%s"; filename="%s"\r
 
74
Content-Type: %s\r
 
75
\r
 
76
%s\r
 
77
-----weeboundary--\r
 
78
""" % (fieldname, filename, mimetype, content))
 
79
 
 
80
    def _CbAssertInResponse(self, (code, headers, data, failed),
 
81
                            expected_response, expectedFailure=False):
 
82
        
 
83
        expected_code, expected_headers, expected_data = expected_response
 
84
        self.assertEquals(code, expected_code)
 
85
        
 
86
        if expected_data is not None:
 
87
            self.failUnlessSubstring(expected_data, data)
 
88
 
 
89
        for key, value in expected_headers.iteritems():
 
90
            self.assertEquals(headers.getHeader(key), value)
 
91
 
 
92
        self.assertEquals(failed, expectedFailure)
 
93
 
 
94
    def fileNameFromResponse(self, response):
 
95
        (code, headers, data, failure) = response
 
96
        return data[data.index('Saved file')+11:data.index('<br />')]
 
97
 
 
98
    def assertInResponse(self, response, expected_response, failure=False):
 
99
        d = response
 
100
        d.addCallback(self._CbAssertInResponse, expected_response, failure)
 
101
        return d
 
102
 
 
103
    def test_enforcesMaxBytes(self):
 
104
        return self.assertInResponse(
 
105
            self.uploadFile('FileNameOne', 'myfilename', 'text/html', 'X'*32),
 
106
            (200, {}, 'exceeds maximum length'))
 
107
 
 
108
    def test_enforcesMimeType(self):
 
109
        return self.assertInResponse(
 
110
            self.uploadFile('FileNameOne', 'myfilename',
 
111
                            'application/x-python', 'X'),
 
112
            (200, {}, 'type not allowed'))
 
113
 
 
114
    def test_invalidField(self):
 
115
        return self.assertInResponse(
 
116
            self.uploadFile('NotARealField', 'myfilename', 'text/html', 'X'),
 
117
            (200, {}, 'not a valid field'))
 
118
 
 
119
    def test_reportFileSave(self):
 
120
        return self.assertInResponse(
 
121
            self.uploadFile('FileNameOne', 'myfilename', 'text/plain', 'X'),
 
122
            (200, {}, 'Saved file'))
 
123
 
 
124
    def test_compareFileContents(self):
 
125
        def gotFname(fname):
 
126
            contents = file(fname, 'r').read()
 
127
            self.assertEquals(contents, 'Test contents')
 
128
 
 
129
        d = self.uploadFile('FileNameOne', 'myfilename', 'text/plain',
 
130
                            'Test contents')
 
131
        d.addCallback(self.fileNameFromResponse)
 
132
        d.addCallback(gotFname)
 
133
        return d