/loggerhead/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/loggerhead/trunk

« back to all changes in this revision

Viewing changes to loggerhead/tests/test_controllers.py

  • Committer: webmaster at geoffish
  • Date: 2011-07-07 19:09:11 UTC
  • mfrom: (452 trunk)
  • mto: (459.2.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 461.
  • Revision ID: webmaster@geoffish.tk-20110707190911-sl2h7de0kr261uyt
Merged lp:loggerhead

Show diffs side-by-side

added added

removed removed

Lines of Context:
loggerhead/tests/test_controllers.py
 
1
<<<<<<< TREE
1
2
from cStringIO import StringIO
2
3
import logging
3
4
import tarfile
5
6
from paste.httpexceptions import HTTPServerError
6
7
 
7
8
from bzrlib import errors
 
9
=======
 
10
import simplejson
 
11
>>>>>>> MERGE-SOURCE
8
12
 
9
13
from loggerhead.apps.branch import BranchWSGIApp
10
14
from loggerhead.controllers.annotate_ui import AnnotateUI
11
15
from loggerhead.controllers.inventory_ui import InventoryUI
12
16
from loggerhead.controllers.revision_ui import RevisionUI
13
 
from loggerhead.tests.test_simple import BasicTests
 
17
from loggerhead.tests.test_simple import BasicTests, consume_app
14
18
from loggerhead import util
15
19
 
16
20
 
17
21
class TestInventoryUI(BasicTests):
18
22
 
 
23
    def make_bzrbranch_for_tree_shape(self, shape):
 
24
        tree = self.make_branch_and_tree('.')
 
25
        self.build_tree(shape)
 
26
        tree.smart_add([])
 
27
        tree.commit('')
 
28
        self.addCleanup(tree.branch.lock_read().unlock)
 
29
        return tree.branch
 
30
 
19
31
    def make_bzrbranch_and_inventory_ui_for_tree_shape(self, shape):
20
 
        tree = self.make_branch_and_tree('.')
21
 
        self.build_tree(shape)
22
 
        tree.smart_add([])
23
 
        tree.commit('')
24
 
        tree.branch.lock_read()
25
 
        self.addCleanup(tree.branch.unlock)
26
 
        branch_app = BranchWSGIApp(tree.branch, '')
27
 
        branch_app.log.setLevel(logging.CRITICAL)
28
 
        # These are usually set in BranchWSGIApp.app(), which is set from env
29
 
        # settings set by BranchesFromTransportRoot, so we fake it.
30
 
        branch_app._static_url_base = '/'
31
 
        branch_app._url_base = '/'
32
 
        return tree.branch, InventoryUI(branch_app, branch_app.get_history)
33
 
 
34
 
    def consume_app(self, app, extra_environ=None):
35
 
        env = {'SCRIPT_NAME': '/files', 'PATH_INFO': ''}
36
 
        if extra_environ is not None:
37
 
            env.update(extra_environ)
38
 
        body = StringIO()
39
 
        start = []
40
 
        def start_response(status, headers, exc_info=None):
41
 
            start.append((status, headers, exc_info))
42
 
            return body.write
43
 
        extra_content = list(app(env, start_response))
44
 
        body.writelines(extra_content)
45
 
        return start[0], body.getvalue()
 
32
        branch = self.make_bzrbranch_for_tree_shape(shape)
 
33
        branch_app = self.make_branch_app(branch)
 
34
        return branch, InventoryUI(branch_app, branch_app.get_history)
46
35
 
47
36
    def test_get_filelist(self):
48
37
        bzrbranch, inv_ui = self.make_bzrbranch_and_inventory_ui_for_tree_shape(
49
38
            ['filename'])
50
39
        inv = bzrbranch.repository.get_inventory(bzrbranch.last_revision())
51
 
        self.assertEqual(1, len(inv_ui.get_filelist(inv, '', 'filename')))
 
40
        self.assertEqual(1, len(inv_ui.get_filelist(inv, '', 'filename', 'head')))
52
41
 
53
42
    def test_smoke(self):
54
43
        bzrbranch, inv_ui = self.make_bzrbranch_and_inventory_ui_for_tree_shape(
55
44
            ['filename'])
56
 
        start, content = self.consume_app(inv_ui)
 
45
        start, content = consume_app(inv_ui,
 
46
            {'SCRIPT_NAME': '/files', 'PATH_INFO': ''})
57
47
        self.assertEqual(('200 OK', [('Content-Type', 'text/html')], None),
58
48
                         start)
59
49
        self.assertContainsRe(content, 'filename')
61
51
    def test_no_content_for_HEAD(self):
62
52
        bzrbranch, inv_ui = self.make_bzrbranch_and_inventory_ui_for_tree_shape(
63
53
            ['filename'])
64
 
        start, content = self.consume_app(inv_ui,
65
 
                            extra_environ={'REQUEST_METHOD': 'HEAD'})
 
54
        start, content = consume_app(inv_ui,
 
55
            {'SCRIPT_NAME': '/files', 'PATH_INFO': '',
 
56
             'REQUEST_METHOD': 'HEAD'})
66
57
        self.assertEqual(('200 OK', [('Content-Type', 'text/html')], None),
67
58
                         start)
68
59
        self.assertEqual('', content)
69
60
 
 
61
    def test_get_values_smoke(self):
 
62
        branch = self.make_bzrbranch_for_tree_shape(['a-file'])
 
63
        branch_app = self.make_branch_app(branch)
 
64
        env = {'SCRIPT_NAME': '', 'PATH_INFO': '/files'}
 
65
        inv_ui = branch_app.lookup_app(env)
 
66
        inv_ui.parse_args(env)
 
67
        values = inv_ui.get_values('', {}, {})
 
68
        self.assertEqual('a-file', values['filelist'][0].filename)
 
69
 
 
70
    def test_json_render_smoke(self):
 
71
        branch = self.make_bzrbranch_for_tree_shape(['a-file'])
 
72
        branch_app = self.make_branch_app(branch)
 
73
        env = {'SCRIPT_NAME': '', 'PATH_INFO': '/+json/files'}
 
74
        inv_ui = branch_app.lookup_app(env)
 
75
        self.assertOkJsonResponse(inv_ui, env)
 
76
 
70
77
 
71
78
class TestRevisionUI(BasicTests):
72
79
 
73
 
    def make_bzrbranch_and_revision_ui_for_tree_shapes(self, shape1, shape2):
 
80
    def make_branch_app_for_revision_ui(self, shape1, shape2):
74
81
        tree = self.make_branch_and_tree('.')
75
82
        self.build_tree_contents(shape1)
76
83
        tree.smart_add([])
77
 
        tree.commit('')
 
84
        tree.commit('msg 1', rev_id='rev-1')
78
85
        self.build_tree_contents(shape2)
79
86
        tree.smart_add([])
80
 
        tree.commit('')
81
 
        tree.branch.lock_read()
82
 
        self.addCleanup(tree.branch.unlock)
83
 
        branch_app = BranchWSGIApp(tree.branch)
84
 
        branch_app._environ = {
85
 
            'wsgi.url_scheme':'',
86
 
            'SERVER_NAME':'',
87
 
            'SERVER_PORT':'80',
88
 
            }
89
 
        branch_app._url_base = ''
90
 
        branch_app.friendly_name = ''
91
 
        return tree.branch, RevisionUI(branch_app, branch_app.get_history)
 
87
        tree.commit('msg 2', rev_id='rev-2')
 
88
        branch = tree.branch
 
89
        self.addCleanup(branch.lock_read().unlock)
 
90
        return self.make_branch_app(branch)
92
91
 
93
92
    def test_get_values(self):
94
 
        branch, rev_ui = self.make_bzrbranch_and_revision_ui_for_tree_shapes(
95
 
            [], [])
96
 
        rev_ui.args = ['2']
97
 
        util.set_context({})
98
 
        self.assertIsInstance(
99
 
            rev_ui.get_values('', {}, []),
100
 
            dict)
 
93
        branch_app = self.make_branch_app_for_revision_ui([], [])
 
94
        env = {'SCRIPT_NAME': '', 'PATH_INFO': '/revision/2'}
 
95
        rev_ui = branch_app.lookup_app(env)
 
96
        rev_ui.parse_args(env)
 
97
        self.assertIsInstance(rev_ui.get_values('', {}, []), dict)
 
98
 
 
99
    def test_get_values_smoke(self):
 
100
        branch_app = self.make_branch_app_for_revision_ui(
 
101
                [('file', 'content\n'), ('other-file', 'other\n')],
 
102
                [('file', 'new content\n')])
 
103
        env = {'SCRIPT_NAME': '/',
 
104
               'PATH_INFO': '/revision/head:'}
 
105
        revision_ui = branch_app.lookup_app(env)
 
106
        revision_ui.parse_args(env)
 
107
        values = revision_ui.get_values('', {}, {})
 
108
 
 
109
        self.assertEqual(values['revid'], 'rev-2')
 
110
        self.assertEqual(values['change'].comment, 'msg 2')
 
111
        self.assertEqual(values['file_changes'].modified[0].filename, 'file')
 
112
        self.assertEqual(values['merged_in'], None)
 
113
 
 
114
    def test_json_render_smoke(self):
 
115
        branch_app = self.make_branch_app_for_revision_ui(
 
116
                [('file', 'content\n'), ('other-file', 'other\n')],
 
117
                [('file', 'new content\n')])
 
118
        env = {'SCRIPT_NAME': '', 'PATH_INFO': '/+json/revision/head:'}
 
119
        revision_ui = branch_app.lookup_app(env)
 
120
        self.assertOkJsonResponse(revision_ui, env)
 
121
 
101
122
 
102
123
 
103
124
class TestAnnotateUI(BasicTests):
122
143
        ann_ui.args = ['rev2']
123
144
        annotate_info = ann_ui.get_values('filename',
124
145
            kwargs={'file_id': 'file_id'}, headers={})
125
 
        annotated = list(annotate_info['annotated'])
 
146
        annotated = annotate_info['annotated']
126
147
        self.assertEqual(2, len(annotated))
127
 
        self.assertEqual('2', annotated[0].change.revno)
128
 
        self.assertEqual('1', annotated[1].change.revno)
129
 
 
 
148
        self.assertEqual('2', annotated[1].change.revno)
 
149
        self.assertEqual('1', annotated[2].change.revno)
 
150
 
 
151
 
 
152
class TestFileDiffUI(BasicTests):
 
153
 
 
154
    def make_branch_app_for_filediff_ui(self):
 
155
        builder = self.make_branch_builder('branch')
 
156
        builder.start_series()
 
157
        builder.build_snapshot('rev-1-id', None, [
 
158
            ('add', ('', 'root-id', 'directory', '')),
 
159
            ('add', ('filename', 'f-id', 'file', 'content\n'))],
 
160
            message="First commit.")
 
161
        builder.build_snapshot('rev-2-id', None, [
 
162
            ('modify', ('f-id', 'new content\n'))])
 
163
        builder.finish_series()
 
164
        branch = builder.get_branch()
 
165
        self.addCleanup(branch.lock_read().unlock)
 
166
        return self.make_branch_app(branch)
 
167
 
 
168
    def test_get_values_smoke(self):
 
169
        branch_app = self.make_branch_app_for_filediff_ui()
 
170
        env = {'SCRIPT_NAME': '/',
 
171
               'PATH_INFO': '/+filediff/rev-2-id/rev-1-id/f-id'}
 
172
        filediff_ui = branch_app.lookup_app(env)
 
173
        filediff_ui.parse_args(env)
 
174
        values = filediff_ui.get_values('', {}, {})
 
175
        chunks = values['chunks']
 
176
        self.assertEqual('insert', chunks[0].diff[1].type)
 
177
        self.assertEqual('new content', chunks[0].diff[1].line)
 
178
 
 
179
    def test_json_render_smoke(self):
 
180
        branch_app = self.make_branch_app_for_filediff_ui()
 
181
        env = {'SCRIPT_NAME': '/',
 
182
               'PATH_INFO': '/+json/+filediff/rev-2-id/rev-1-id/f-id'}
 
183
        filediff_ui = branch_app.lookup_app(env)
 
184
        self.assertOkJsonResponse(filediff_ui, env)
 
185
 
 
186
 
 
187
class TestRevLogUI(BasicTests):
 
188
 
 
189
    def make_branch_app_for_revlog_ui(self):
 
190
        builder = self.make_branch_builder('branch')
 
191
        builder.start_series()
 
192
        builder.build_snapshot('rev-id', None, [
 
193
            ('add', ('', 'root-id', 'directory', '')),
 
194
            ('add', ('filename', 'f-id', 'file', 'content\n'))],
 
195
            message="First commit.")
 
196
        builder.finish_series()
 
197
        branch = builder.get_branch()
 
198
        self.addCleanup(branch.lock_read().unlock)
 
199
        return self.make_branch_app(branch)
 
200
 
 
201
    def test_get_values_smoke(self):
 
202
        branch_app = self.make_branch_app_for_revlog_ui()
 
203
        env = {'SCRIPT_NAME': '/',
 
204
               'PATH_INFO': '/+revlog/rev-id'}
 
205
        revlog_ui = branch_app.lookup_app(env)
 
206
        revlog_ui.parse_args(env)
 
207
        values = revlog_ui.get_values('', {}, {})
 
208
        self.assertEqual(values['file_changes'].added[1].filename, 'filename')
 
209
        self.assertEqual(values['entry'].comment, "First commit.")
 
210
 
 
211
    def test_json_render_smoke(self):
 
212
        branch_app = self.make_branch_app_for_revlog_ui()
 
213
        env = {'SCRIPT_NAME': '', 'PATH_INFO': '/+json/+revlog/rev-id'}
 
214
        revlog_ui = branch_app.lookup_app(env)
 
215
        self.assertOkJsonResponse(revlog_ui, env)
130
216
 
131
217
class TestDownloadTarballUI(BasicTests):
132
218
 
140
226
        f = open('tarball', 'w')
141
227
        f.write(res)
142
228
        f.close()
143
 
        self.failIf(not tarfile.is_tarfile('tarball'))
144
 
        # Now check the content. TBC
 
229
        self.failIf(not tarfile.is_tarfile('tarball'))
 
 
b'\\ No newline at end of file'