← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to loggerhead/tests/test_simple.py

  • Committer: Michael Hudson
  • Date: 2009-06-25 02:45:34 UTC
  • mfrom: (371.1.13 no-transport-sharing)
  • Revision ID: michael.hudson@canonical.com-20090625024534-3kv75gtfge51r656
fix the horrible connection-sharing bug (#390972) and a few other ones about serving .bzr data

Show diffs side-by-side

added added

removed removed

Lines of Context:
loggerhead/tests/test_simple.py
1
 
# Copyright (C) 2007, 2008, 2009, 2011 Canonical Ltd.
 
1
# Copyright (C) 2008, 2009 Canonical Ltd.
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
 
18
18
import cgi
19
19
import logging
20
 
import re
21
 
import simplejson
22
 
from cStringIO import StringIO
23
20
 
24
21
from bzrlib.tests import TestCaseWithTransport
25
 
try:
26
 
    from bzrlib.util.configobj.configobj import ConfigObj
27
 
except ImportError:
28
 
    from configobj import ConfigObj
 
22
from bzrlib.util.configobj.configobj import ConfigObj
29
23
from bzrlib import config
30
24
 
31
25
from loggerhead.apps.branch import BranchWSGIApp
32
 
from loggerhead.apps.http_head import HeadMiddleware
33
26
from paste.fixture import TestApp
34
 
from paste.httpexceptions import HTTPExceptionHandler, HTTPMovedPermanently
35
 
 
36
 
from loggerhead.tests.fixtures import (
37
 
    SampleBranch,
38
 
    )
 
27
from paste.httpexceptions import HTTPExceptionHandler
 
28
 
 
29
 
 
30
 
 
31
def test_config_root():
 
32
    from loggerhead.apps.config import Root
 
33
    config = ConfigObj()
 
34
    app = TestApp(HTTPExceptionHandler(Root(config)))
 
35
    res = app.get('/')
 
36
    res.mustcontain('loggerhead branches')
39
37
 
40
38
 
41
39
class BasicTests(TestCaseWithTransport):
52
50
        branch_app = BranchWSGIApp(self.tree.branch, '', **kw).app
53
51
        return TestApp(HTTPExceptionHandler(branch_app))
54
52
 
55
 
    def assertOkJsonResponse(self, app, env):
56
 
        start, content = consume_app(app, env)
57
 
        self.assertEqual('200 OK', start[0])
58
 
        self.assertEqual('application/json', dict(start[1])['Content-Type'])
59
 
        self.assertEqual(None, start[2])
60
 
        simplejson.loads(content)
61
 
 
62
 
    def make_branch_app(self, branch, **kw):
63
 
        branch_app = BranchWSGIApp(branch, friendly_name='friendly-name', **kw)
64
 
        branch_app._environ = {
65
 
            'wsgi.url_scheme':'',
66
 
            'SERVER_NAME':'',
67
 
            'SERVER_PORT':'80',
68
 
            }
69
 
        branch_app._url_base = ''
70
 
        return branch_app
71
 
 
72
53
 
73
54
class TestWithSimpleTree(BasicTests):
74
55
 
75
56
    def setUp(self):
76
57
        BasicTests.setUp(self)
77
 
        self.sample_branch_fixture = SampleBranch(self)
78
 
 
79
 
        # XXX: This could be cleaned up more... -- mbp 2011-11-25
80
 
        self.useFixture(self.sample_branch_fixture)
81
 
        self.tree = self.sample_branch_fixture.tree
82
 
        self.fileid = self.sample_branch_fixture.fileid
83
 
        self.filecontents = self.sample_branch_fixture.filecontents
84
 
        self.msg = self.sample_branch_fixture.msg
85
 
 
86
 
    def test_public_private(self):
87
 
        app = self.make_branch_app(self.tree.branch, private=True)
88
 
        self.assertEqual(app.public_private_css(), 'private')
89
 
        app = self.make_branch_app(self.tree.branch)
90
 
        self.assertEqual(app.public_private_css(), 'public')
 
58
        self.createBranch()
 
59
 
 
60
        self.filecontents = ('some\nmultiline\ndata\n'
 
61
                             'with<htmlspecialchars\n')
 
62
        self.build_tree_contents(
 
63
            [('myfilename', self.filecontents)])
 
64
        self.tree.add('myfilename')
 
65
        self.fileid = self.tree.path2id('myfilename')
 
66
        self.msg = 'a very exciting commit message <'
 
67
        self.revid = self.tree.commit(message=self.msg)
91
68
 
92
69
    def test_changes(self):
93
70
        app = self.setUpLoggerhead()
94
71
        res = app.get('/changes')
95
72
        res.mustcontain(cgi.escape(self.msg))
96
73
 
97
 
    def test_changes_for_file(self):
98
 
        app = self.setUpLoggerhead()
99
 
        res = app.get('/changes?filter_file_id=myfilename-id')
100
 
        res.mustcontain(cgi.escape(self.msg))
101
 
 
102
74
    def test_changes_branch_from(self):
103
75
        app = self.setUpLoggerhead(served_url="lp:loggerhead")
104
76
        res = app.get('/changes')
105
77
        self.failUnless("To get this branch, use:" in res)
106
78
        self.failUnless("lp:loggerhead" in res)
107
 
 
108
 
    def test_no_empty_download_location(self):
109
 
        """With no served_url, no instructions how to get it"""
110
 
        app = self.setUpLoggerhead()
 
79
        app = self.setUpLoggerhead(served_url=None)
111
80
        res = app.get('/changes')
112
81
        self.failIf("To get this branch, use:" in res)
113
82
 
119
88
    def test_annotate(self):
120
89
        app = self.setUpLoggerhead()
121
90
        res = app.get('/annotate', params={'file_id': self.fileid})
122
 
        # If pygments is installed, it inserts <span class="pyg" content into
123
 
        # the output, to trigger highlighting. And it specifically highlights
124
 
        # the &lt; that we are interested in seeing in the output.
125
 
        # Without pygments we have a simple: 'with&lt;htmlspecialchars'
126
 
        # With it, we have
127
 
        # '<span class='pyg-n'>with</span><span class='pyg-o'>&lt;</span>'
128
 
        # '<span class='pyg-n'>htmlspecialchars</span>
129
 
        # So we pre-filter the body, to make sure remove spans of that type.
130
 
        body_no_span = re.sub(r'<span class="pyg-.">', '', res.body)
131
 
        body_no_span = body_no_span.replace('</span>', '')
132
91
        for line in self.filecontents.splitlines():
133
 
            escaped = cgi.escape(line)
134
 
            self.assertTrue(escaped in body_no_span,
135
 
                            "did not find %r in %r" % (escaped, body_no_span))
 
92
            res.mustcontain(cgi.escape(line))
136
93
 
137
94
    def test_inventory(self):
138
95
        app = self.setUpLoggerhead()
160
117
    def test_revision(self):
161
118
        app = self.setUpLoggerhead()
162
119
        res = app.get('/revision/1')
163
 
        res.mustcontain(no=['anotherfile<'])
164
 
        res.mustcontain('anotherfile&lt;')
165
120
        res.mustcontain('myfilename')
166
121
 
167
122
 
202
157
        res = app.get('/changes', status=404)
203
158
 
204
159
 
205
 
class TestControllerRedirects(BasicTests):
206
 
    """
207
 
    Test that a file under /files redirects to /view,
208
 
    and a directory under /view redirects to /files.
209
 
    """
210
 
 
211
 
    def setUp(self):
212
 
        BasicTests.setUp(self)
213
 
        self.createBranch()
214
 
        self.build_tree(('file', 'folder/', 'folder/file'))
215
 
        self.tree.smart_add([])
216
 
        self.tree.commit('')
217
 
 
218
 
    def test_view_folder(self):
219
 
        app = TestApp(BranchWSGIApp(self.tree.branch, '').app)
220
 
 
221
 
        e = self.assertRaises(HTTPMovedPermanently, app.get, '/view/head:/folder')
222
 
        self.assertEqual(e.location(), '/files/head:/folder')
223
 
 
224
 
    def test_files_file(self):
225
 
        app = TestApp(BranchWSGIApp(self.tree.branch, '').app)
226
 
 
227
 
        e = self.assertRaises(HTTPMovedPermanently, app.get, '/files/head:/folder/file')
228
 
        self.assertEqual(e.location(), '/view/head:/folder/file')
229
 
        e = self.assertRaises(HTTPMovedPermanently, app.get, '/files/head:/file')
230
 
        self.assertEqual(e.location(), '/view/head:/file')
231
 
 
232
 
 
233
 
class TestHeadMiddleware(BasicTests):
234
 
 
235
 
    def setUp(self):
236
 
        BasicTests.setUp(self)
237
 
        self.createBranch()
238
 
        self.msg = 'trivial commit message'
239
 
        self.revid = self.tree.commit(message=self.msg)
240
 
 
241
 
    def setUpLoggerhead(self, **kw):
242
 
        branch_app = BranchWSGIApp(self.tree.branch, '', **kw).app
243
 
        return TestApp(HTTPExceptionHandler(HeadMiddleware(branch_app)))
244
 
 
245
 
    def test_get(self):
246
 
        app = self.setUpLoggerhead()
247
 
        res = app.get('/changes')
248
 
        res.mustcontain(self.msg)
249
 
        self.assertEqual('text/html', res.header('Content-Type'))
250
 
 
251
 
    def test_head(self):
252
 
        app = self.setUpLoggerhead()
253
 
        res = app.get('/changes', extra_environ={'REQUEST_METHOD': 'HEAD'})
254
 
        self.assertEqual('text/html', res.header('Content-Type'))
255
 
        self.assertEqualDiff('', res.body)
256
 
 
257
 
 
258
 
def consume_app(app, env):
259
 
    body = StringIO()
260
 
    start = []
261
 
    def start_response(status, headers, exc_info=None):
262
 
        start.append((status, headers, exc_info))
263
 
        return body.write
264
 
    extra_content = list(app(env, start_response))
265
 
    body.writelines(extra_content)
266
 
    return start[0], body.getvalue()
267
 
 
268
 
 
269
 
 
270
160
#class TestGlobalConfig(BasicTests):
271
161
#    """
272
162
#    Test that global config settings are respected