/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 breezy/tests/blackbox/test_cat.py

  • Committer: Martin
  • Date: 2018-11-16 16:38:22 UTC
  • mto: This revision was merged to the branch mainline in revision 7172.
  • Revision ID: gzlist@googlemail.com-20181116163822-yg1h1cdng6w7w9kn
Make --profile-imports work on Python 3

Also tweak heading to line up correctly.

Show diffs side-by-side

added added

removed removed

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