/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: Jelmer Vernooij
  • Date: 2020-01-24 00:06:05 UTC
  • mto: This revision was merged to the branch mainline in revision 7459.
  • Revision ID: jelmer@jelmer.uk-20200124000605-qw2v9i7pjfrcy12m
https://launchpad.net/bugs/402814
Support importing Git submodules as tree references.

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')
174
169
        url = self.get_readonly_url() + '/README'
175
170
        real_content_filter_stack = Tree._content_filter_stack
 
171
 
176
172
        def _custom_content_filter_stack(tree, path=None, file_id=None):
177
173
            return _stack_2
178
174
        Tree._content_filter_stack = _custom_content_filter_stack
189
185
        self.build_tree(['README'])
190
186
        wt.add('README')
191
187
        wt.commit('Making sure there is a basis_tree available')
192
 
        wt.branch.bzrdir.destroy_workingtree()
 
188
        wt.branch.controldir.destroy_workingtree()
193
189
 
194
190
        url = self.get_readonly_url() + '/README'
195
 
        out, err = self.run_bzr_subprocess(['cat', url])
 
191
        out, err = self.run_bzr(['cat', url])
196
192
        self.assertEqual('contents of README\n', out)
197
193
 
198
194
    def test_cat_nonexistent_branch(self):
199
195
        self.vfs_transport_factory = memory.MemoryServer
200
 
        self.run_bzr_error(['^bzr: ERROR: Not a branch'],
 
196
        self.run_bzr_error(['^brz: ERROR: Not a branch'],
201
197
                           ['cat', self.get_url()])
 
198
 
 
199
    def test_cat_directory(self):
 
200
        wt = self.make_branch_and_tree('a')
 
201
        self.build_tree(['a/README'])
 
202
        wt.add('README')
 
203
        wt.commit('Making sure there is a basis_tree available')
 
204
 
 
205
        out, err = self.run_bzr(['cat', '--directory=a', 'README'])
 
206
        self.assertEqual('contents of a/README\n', out)
 
207
 
 
208
    def test_cat_remote_directory(self):
 
209
        wt = self.make_branch_and_tree('a')
 
210
        self.build_tree(['a/README'])
 
211
        wt.add('README')
 
212
        wt.commit('Making sure there is a basis_tree available')
 
213
 
 
214
        url = self.get_readonly_url() + '/a'
 
215
        out, err = self.run_bzr(['cat', '-d', url, 'README'])
 
216
        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)