← 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-Doyle
  • Date: 2012-01-23 21:10:46 UTC
  • mfrom: (461.3.1 bug-390029)
  • Revision ID: michael.hudson@linaro.org-20120123211046-ec3rqt27goxfnxnq
fix a crash in comparing a revision to itself

Show diffs side-by-side

added added

removed removed

Lines of Context:
loggerhead/tests/test_simple.py
1
 
# Copyright (C) 2008, 2009 Canonical Ltd.
 
1
# Copyright (C) 2007, 2008, 2009, 2011 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
20
23
 
21
24
from bzrlib.tests import TestCaseWithTransport
22
 
from bzrlib.util.configobj.configobj import ConfigObj
 
25
try:
 
26
    from bzrlib.util.configobj.configobj import ConfigObj
 
27
except ImportError:
 
28
    from configobj import ConfigObj
23
29
from bzrlib import config
24
30
 
25
31
from loggerhead.apps.branch import BranchWSGIApp
 
32
from loggerhead.apps.http_head import HeadMiddleware
26
33
from paste.fixture import TestApp
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')
 
34
from paste.httpexceptions import HTTPExceptionHandler, HTTPMovedPermanently
 
35
 
 
36
from loggerhead.tests.fixtures import (
 
37
    SampleBranch,
 
38
    )
37
39
 
38
40
 
39
41
class BasicTests(TestCaseWithTransport):
50
52
        branch_app = BranchWSGIApp(self.tree.branch, '', **kw).app
51
53
        return TestApp(HTTPExceptionHandler(branch_app))
52
54
 
 
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
 
53
72
 
54
73
class TestWithSimpleTree(BasicTests):
55
74
 
56
75
    def setUp(self):
57
76
        BasicTests.setUp(self)
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)
 
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')
68
91
 
69
92
    def test_changes(self):
70
93
        app = self.setUpLoggerhead()
71
94
        res = app.get('/changes')
72
95
        res.mustcontain(cgi.escape(self.msg))
73
96
 
 
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
 
74
102
    def test_changes_branch_from(self):
75
103
        app = self.setUpLoggerhead(served_url="lp:loggerhead")
76
104
        res = app.get('/changes')
77
105
        self.failUnless("To get this branch, use:" in res)
78
106
        self.failUnless("lp:loggerhead" in res)
79
 
        app = self.setUpLoggerhead(served_url=None)
 
107
 
 
108
    def test_no_empty_download_location(self):
 
109
        """With no served_url, no instructions how to get it"""
 
110
        app = self.setUpLoggerhead()
80
111
        res = app.get('/changes')
81
112
        self.failIf("To get this branch, use:" in res)
82
113
 
88
119
    def test_annotate(self):
89
120
        app = self.setUpLoggerhead()
90
121
        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>', '')
91
132
        for line in self.filecontents.splitlines():
92
 
            res.mustcontain(cgi.escape(line))
 
133
            escaped = cgi.escape(line)
 
134
            self.assertTrue(escaped in body_no_span,
 
135
                            "did not find %r in %r" % (escaped, body_no_span))
93
136
 
94
137
    def test_inventory(self):
95
138
        app = self.setUpLoggerhead()
117
160
    def test_revision(self):
118
161
        app = self.setUpLoggerhead()
119
162
        res = app.get('/revision/1')
 
163
        res.mustcontain(no=['anotherfile<'])
 
164
        res.mustcontain('anotherfile&lt;')
120
165
        res.mustcontain('myfilename')
121
166
 
122
167
 
157
202
        res = app.get('/changes', status=404)
158
203
 
159
204
 
 
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
 
160
270
#class TestGlobalConfig(BasicTests):
161
271
#    """
162
272
#    Test that global config settings are respected