/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_cat.py

  • Committer: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_cat.py
1
 
# Copyright (C) 2005-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
 
2
# -*- coding: utf-8 -*-
2
3
#
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
15
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
17
 
17
18
 
18
 
"""Black-box tests for brz cat.
 
19
"""Black-box tests for bzr cat.
19
20
"""
20
21
 
21
 
from ... import tests
22
 
from ..matchers import ContainsNoVfsCalls
23
 
from ...transport import memory
 
22
import os
 
23
 
 
24
from bzrlib import tests
 
25
from bzrlib.transport import memory
24
26
 
25
27
 
26
28
class TestCat(tests.TestCaseWithTransport):
27
29
 
28
30
    def test_cat(self):
29
31
        tree = self.make_branch_and_tree('branch')
30
 
        self.build_tree_contents([('branch/a', b'foo\n')])
 
32
        self.build_tree_contents([('branch/a', 'foo\n')])
31
33
        tree.add('a')
32
 
        # 'brz cat' without an option should cat the last revision
33
 
        self.run_bzr(['cat', 'a'], retcode=3, working_dir='branch')
 
34
        os.chdir('branch')
 
35
        # 'bzr cat' without an option should cat the last revision
 
36
        self.run_bzr(['cat', 'a'], retcode=3)
34
37
 
35
38
        tree.commit(message='1')
36
 
        self.build_tree_contents([('branch/a', b'baz\n')])
37
 
 
38
 
        self.assertEqual('foo\n',
39
 
                         self.run_bzr(['cat', 'a'], working_dir='branch')[0])
40
 
 
41
 
        # On Windows, we used to have a bug where newlines got changed into
42
 
        # crlf, whereas cat ought to write out the file exactly as it's
43
 
        # recorded (by default.)  That problem can't be reproduced in-process,
44
 
        # so we need just one test here that
45
 
        self.assertEqual(b'foo\n',
46
 
                         self.run_bzr_subprocess(['cat', 'a'],
47
 
                                                 working_dir='branch')[0])
 
39
        self.build_tree_contents([('a', 'baz\n')])
 
40
 
 
41
        # We use run_bzr_subprocess rather than run_bzr here so that we can
 
42
        # test mangling of line-endings on Windows.
 
43
        self.assertEquals(self.run_bzr_subprocess(['cat', 'a'])[0], 'foo\n')
48
44
 
49
45
        tree.commit(message='2')
50
 
        self.assertEqual(
51
 
            'baz\n', self.run_bzr(['cat', 'a'], working_dir='branch')[0])
52
 
        self.assertEqual(
53
 
            'foo\n', self.run_bzr(['cat', 'a', '-r', '1'],
54
 
                                  working_dir='branch')[0])
55
 
        self.assertEqual(
56
 
            'baz\n', self.run_bzr(['cat', 'a', '-r', '-1'],
57
 
                                  working_dir='branch')[0])
 
46
        self.assertEquals(self.run_bzr_subprocess(['cat', 'a'])[0], 'baz\n')
 
47
        self.assertEquals(self.run_bzr_subprocess(
 
48
            ['cat', 'a', '-r', '1'])[0],
 
49
            'foo\n')
 
50
        self.assertEquals(self.run_bzr_subprocess(
 
51
            ['cat', 'a', '-r', '-1'])[0],
 
52
            'baz\n')
58
53
 
59
54
        rev_id = tree.branch.last_revision()
60
55
 
61
 
        self.assertEqual(
62
 
            'baz\n', self.run_bzr(
63
 
                ['cat', 'a', '-r', 'revid:%s' % rev_id.decode('utf-8')],
64
 
                working_dir='branch')[0])
65
 
 
66
 
        self.assertEqual('foo\n',
67
 
                         self.run_bzr(['cat', 'branch/a',
68
 
                                       '-r', 'revno:1:branch'])[0])
 
56
        self.assertEquals(self.run_bzr_subprocess(
 
57
            ['cat', 'a', '-r', 'revid:%s' % rev_id])[0],
 
58
            'baz\n')
 
59
 
 
60
        os.chdir('..')
 
61
 
 
62
        self.assertEquals(self.run_bzr_subprocess(
 
63
            ['cat', 'branch/a', '-r', 'revno:1:branch'])[0],
 
64
            'foo\n')
69
65
        self.run_bzr(['cat', 'a'], retcode=3)
70
 
        self.run_bzr(['cat', 'a', '-r', 'revno:1:branch-that-does-not-exist'],
71
 
                     retcode=3)
 
66
        self.run_bzr(
 
67
                ['cat', 'a', '-r', 'revno:1:branch-that-does-not-exist'],
 
68
                retcode=3)
72
69
 
73
70
    def test_cat_different_id(self):
74
71
        """'cat' works with old and new files"""
78
75
        # current trees later in the test case
79
76
        # a-rev-tree is special because it appears in both the revision
80
77
        # tree and the working tree
81
 
        self.build_tree_contents([('a-rev-tree', b'foo\n'),
82
 
                                  ('c-rev', b'baz\n'), ('d-rev', b'bar\n'), ('e-rev', b'qux\n')])
83
 
        with tree.lock_write():
 
78
        self.build_tree_contents([('a-rev-tree', 'foo\n'),
 
79
            ('c-rev', 'baz\n'), ('d-rev', 'bar\n'), ('e-rev', 'qux\n')])
 
80
        tree.lock_write()
 
81
        try:
84
82
            tree.add(['a-rev-tree', 'c-rev', 'd-rev', 'e-rev'])
85
 
            tree.commit('add test files', rev_id=b'first')
 
83
            tree.commit('add test files', rev_id='first')
86
84
            # remove currently uses self._write_inventory -
87
85
            # work around that for now.
88
86
            tree.flush()
90
88
            tree.rename_one('a-rev-tree', 'b-tree')
91
89
            tree.rename_one('c-rev', 'a-rev-tree')
92
90
            tree.rename_one('e-rev', 'old-rev')
93
 
            self.build_tree_contents([('e-rev', b'new\n')])
 
91
            self.build_tree_contents([('e-rev', 'new\n')])
94
92
            tree.add(['e-rev'])
 
93
        finally:
 
94
            # calling bzr as another process require free lock on win32
 
95
            tree.unlock()
95
96
 
96
97
        # 'b-tree' is not present in the old tree.
97
 
        self.run_bzr_error(["^brz: ERROR: u?'b-tree' "
 
98
        self.run_bzr_error(["^bzr: ERROR: u?'b-tree' "
98
99
                            "is not present in revision .+$"],
99
100
                           'cat b-tree --name-from-revision')
100
101
 
101
102
        # get to the old file automatically
102
 
        out, err = self.run_bzr('cat d-rev')
103
 
        self.assertEqual('', err)
 
103
        out, err = self.run_bzr_subprocess('cat d-rev')
104
104
        self.assertEqual('bar\n', out)
 
105
        self.assertEqual('', err)
105
106
 
106
107
        out, err = \
107
 
            self.run_bzr('cat a-rev-tree --name-from-revision')
 
108
                self.run_bzr_subprocess('cat a-rev-tree --name-from-revision')
108
109
        self.assertEqual('foo\n', out)
109
110
        self.assertEqual('', err)
110
111
 
111
 
        out, err = self.run_bzr('cat a-rev-tree')
 
112
        out, err = self.run_bzr_subprocess('cat a-rev-tree')
112
113
        self.assertEqual('baz\n', out)
113
114
        self.assertEqual('', err)
114
115
 
115
116
        # the actual file-id for e-rev doesn't exist in the old tree
116
 
        out, err = self.run_bzr('cat e-rev -rrevid:first')
 
117
        out, err = self.run_bzr_subprocess('cat e-rev -rrevid:first')
117
118
        self.assertEqual('qux\n', out)
118
119
        self.assertEqual('', err)
119
120
 
124
125
        wt.commit('Making sure there is a basis_tree available')
125
126
 
126
127
        url = self.get_readonly_url() + '/README'
127
 
        out, err = self.run_bzr(['cat', url])
 
128
        out, err = self.run_bzr_subprocess(['cat', url])
128
129
        self.assertEqual('contents of README\n', out)
129
130
 
130
131
    def test_cat_branch_revspec(self):
133
134
        wt.add('README')
134
135
        wt.commit('Making sure there is a basis_tree available')
135
136
        wt = self.make_branch_and_tree('b')
 
137
        os.chdir('b')
136
138
 
137
 
        out, err = self.run_bzr(['cat', '-r', 'branch:../a', 'README'],
138
 
                                working_dir='b')
 
139
        out, err = self.run_bzr_subprocess(
 
140
            ['cat', '-r', 'branch:../a', 'README'])
139
141
        self.assertEqual('contents of a/README\n', out)
140
142
 
141
143
    def test_cat_filters(self):
146
148
        url = self.get_readonly_url() + '/README'
147
149
 
148
150
        # Test unfiltered output
149
 
        out, err = self.run_bzr(['cat', url])
 
151
        out, err = self.run_bzr_subprocess(['cat', url])
150
152
        self.assertEqual('contents of README\n', out)
151
153
 
152
154
        # Test --filters option is legal but has no impact if no filters
153
 
        out, err = self.run_bzr(['cat', '--filters', url])
 
155
        out, err = self.run_bzr_subprocess(['cat', '--filters', url])
154
156
        self.assertEqual('contents of README\n', out)
155
157
 
156
158
    def test_cat_filters_applied(self):
158
160
        # subprocess because we really need to patch in a plugin that
159
161
        # registers the filters. Instead, we patch in a custom
160
162
        # filter_stack and use run_bzr() ...
161
 
        from ..test_filters import _stack_2
162
 
        from ...tree import Tree
 
163
        from cStringIO import StringIO
 
164
        from bzrlib.commands import run_bzr
 
165
        from bzrlib.tests.test_filters import _stack_2
 
166
        from bzrlib.trace import mutter
 
167
        from bzrlib.tree import Tree
163
168
        wt = self.make_branch_and_tree('.')
164
169
        self.build_tree_contents([
165
 
            ('README', b"junk\nline 1 of README\nline 2 of README\n"),
 
170
            ('README', "junk\nline 1 of README\nline 2 of README\n"),
166
171
            ])
167
172
        wt.add('README')
168
173
        wt.commit('Making sure there is a basis_tree available')
169
174
        url = self.get_readonly_url() + '/README'
170
175
        real_content_filter_stack = Tree._content_filter_stack
171
 
 
172
176
        def _custom_content_filter_stack(tree, path=None, file_id=None):
173
177
            return _stack_2
174
178
        Tree._content_filter_stack = _custom_content_filter_stack
185
189
        self.build_tree(['README'])
186
190
        wt.add('README')
187
191
        wt.commit('Making sure there is a basis_tree available')
188
 
        wt.branch.controldir.destroy_workingtree()
 
192
        wt.branch.bzrdir.destroy_workingtree()
189
193
 
190
194
        url = self.get_readonly_url() + '/README'
191
 
        out, err = self.run_bzr(['cat', url])
 
195
        out, err = self.run_bzr_subprocess(['cat', url])
192
196
        self.assertEqual('contents of README\n', out)
193
197
 
194
198
    def test_cat_nonexistent_branch(self):
195
199
        self.vfs_transport_factory = memory.MemoryServer
196
 
        self.run_bzr_error(['^brz: ERROR: Not a branch'],
 
200
        self.run_bzr_error(['^bzr: ERROR: Not a branch'],
197
201
                           ['cat', self.get_url()])
198
202
 
199
203
    def test_cat_directory(self):
202
206
        wt.add('README')
203
207
        wt.commit('Making sure there is a basis_tree available')
204
208
 
205
 
        out, err = self.run_bzr(['cat', '--directory=a', 'README'])
 
209
        out, err = self.run_bzr_subprocess(['cat', '--directory=a', 'README'])
206
210
        self.assertEqual('contents of a/README\n', out)
207
211
 
208
212
    def test_cat_remote_directory(self):
212
216
        wt.commit('Making sure there is a basis_tree available')
213
217
 
214
218
        url = self.get_readonly_url() + '/a'
215
 
        out, err = self.run_bzr(['cat', '-d', url, 'README'])
 
219
        out, err = self.run_bzr_subprocess(['cat', '-d', url, 'README'])
216
220
        self.assertEqual('contents of a/README\n', out)
217
 
 
218
 
 
219
 
class TestSmartServerCat(tests.TestCaseWithTransport):
220
 
 
221
 
    def test_simple_branch_cat(self):
222
 
        self.setup_smart_server_with_call_log()
223
 
        t = self.make_branch_and_tree('branch')
224
 
        self.build_tree_contents([('branch/foo', b'thecontents')])
225
 
        t.add("foo")
226
 
        t.commit("message")
227
 
        self.reset_smart_call_log()
228
 
        out, err = self.run_bzr(['cat', "%s/foo" % self.get_url('branch')])
229
 
        # This figure represent the amount of work to perform this use case. It
230
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
231
 
        # being too low. If rpc_count increases, more network roundtrips have
232
 
        # become necessary for this use case. Please do not adjust this number
233
 
        # upwards without agreement from bzr's network support maintainers.
234
 
        self.assertLength(9, self.hpss_calls)
235
 
        self.assertLength(1, self.hpss_connections)
236
 
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)