/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: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

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('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(['cat', 'a', '-r', 'revid:%s' % rev_id],
 
63
                                  working_dir='branch')[0])
 
64
 
 
65
        self.assertEqual('foo\n',
 
66
                          self.run_bzr(['cat', 'branch/a',
 
67
                                        '-r', 'revno:1:branch'])[0])
65
68
        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)
 
69
        self.run_bzr(['cat', 'a', '-r', 'revno:1:branch-that-does-not-exist'],
 
70
                     retcode=3)
69
71
 
70
72
    def test_cat_different_id(self):
71
73
        """'cat' works with old and new files"""
75
77
        # current trees later in the test case
76
78
        # a-rev-tree is special because it appears in both the revision
77
79
        # 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:
 
80
        self.build_tree_contents([('a-rev-tree', b'foo\n'),
 
81
            ('c-rev', b'baz\n'), ('d-rev', b'bar\n'), ('e-rev', b'qux\n')])
 
82
        with tree.lock_write():
82
83
            tree.add(['a-rev-tree', 'c-rev', 'd-rev', 'e-rev'])
83
 
            tree.commit('add test files', rev_id='first')
 
84
            tree.commit('add test files', rev_id=b'first')
84
85
            # remove currently uses self._write_inventory -
85
86
            # work around that for now.
86
87
            tree.flush()
88
89
            tree.rename_one('a-rev-tree', 'b-tree')
89
90
            tree.rename_one('c-rev', 'a-rev-tree')
90
91
            tree.rename_one('e-rev', 'old-rev')
91
 
            self.build_tree_contents([('e-rev', 'new\n')])
 
92
            self.build_tree_contents([('e-rev', b'new\n')])
92
93
            tree.add(['e-rev'])
93
 
        finally:
94
 
            # calling bzr as another process require free lock on win32
95
 
            tree.unlock()
96
94
 
97
95
        # 'b-tree' is not present in the old tree.
98
 
        self.run_bzr_error(["^bzr: ERROR: u?'b-tree' "
99
 
                            "is not present in revision .+$"],
 
96
        self.run_bzr_error([b"^brz: ERROR: u?'b-tree' "
 
97
                            b"is not present in revision .+$"],
100
98
                           'cat b-tree --name-from-revision')
101
99
 
102
100
        # get to the old file automatically
103
 
        out, err = self.run_bzr_subprocess('cat d-rev')
104
 
        self.assertEqual('bar\n', out)
105
 
        self.assertEqual('', err)
 
101
        out, err = self.run_bzr('cat d-rev')
 
102
        self.assertEqual(b'', err)
 
103
        self.assertEqual(b'bar\n', out)
106
104
 
107
105
        out, err = \
108
 
                self.run_bzr_subprocess('cat a-rev-tree --name-from-revision')
109
 
        self.assertEqual('foo\n', out)
110
 
        self.assertEqual('', err)
 
106
                self.run_bzr('cat a-rev-tree --name-from-revision')
 
107
        self.assertEqual(b'foo\n', out)
 
108
        self.assertEqual(b'', err)
111
109
 
112
 
        out, err = self.run_bzr_subprocess('cat a-rev-tree')
113
 
        self.assertEqual('baz\n', out)
114
 
        self.assertEqual('', err)
 
110
        out, err = self.run_bzr('cat a-rev-tree')
 
111
        self.assertEqual(b'baz\n', out)
 
112
        self.assertEqual(b'', err)
115
113
 
116
114
        # 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')
118
 
        self.assertEqual('qux\n', out)
119
 
        self.assertEqual('', err)
 
115
        out, err = self.run_bzr('cat e-rev -rrevid:first')
 
116
        self.assertEqual(b'qux\n', out)
 
117
        self.assertEqual(b'', err)
120
118
 
121
119
    def test_remote_cat(self):
122
120
        wt = self.make_branch_and_tree('.')
125
123
        wt.commit('Making sure there is a basis_tree available')
126
124
 
127
125
        url = self.get_readonly_url() + '/README'
128
 
        out, err = self.run_bzr_subprocess(['cat', url])
129
 
        self.assertEqual('contents of README\n', out)
 
126
        out, err = self.run_bzr(['cat', url])
 
127
        self.assertEqual(b'contents of README\n', out)
130
128
 
131
129
    def test_cat_branch_revspec(self):
132
130
        wt = self.make_branch_and_tree('a')
134
132
        wt.add('README')
135
133
        wt.commit('Making sure there is a basis_tree available')
136
134
        wt = self.make_branch_and_tree('b')
137
 
        os.chdir('b')
138
135
 
139
 
        out, err = self.run_bzr_subprocess(
140
 
            ['cat', '-r', 'branch:../a', 'README'])
141
 
        self.assertEqual('contents of a/README\n', out)
 
136
        out, err = self.run_bzr(['cat', '-r', 'branch:../a', 'README'],
 
137
                                working_dir='b')
 
138
        self.assertEqual(b'contents of a/README\n', out)
142
139
 
143
140
    def test_cat_filters(self):
144
141
        wt = self.make_branch_and_tree('.')
148
145
        url = self.get_readonly_url() + '/README'
149
146
 
150
147
        # Test unfiltered output
151
 
        out, err = self.run_bzr_subprocess(['cat', url])
152
 
        self.assertEqual('contents of README\n', out)
 
148
        out, err = self.run_bzr(['cat', url])
 
149
        self.assertEqual(b'contents of README\n', out)
153
150
 
154
151
        # Test --filters option is legal but has no impact if no filters
155
 
        out, err = self.run_bzr_subprocess(['cat', '--filters', url])
156
 
        self.assertEqual('contents of README\n', out)
 
152
        out, err = self.run_bzr(['cat', '--filters', url])
 
153
        self.assertEqual(b'contents of README\n', out)
157
154
 
158
155
    def test_cat_filters_applied(self):
159
156
        # Test filtering applied to output. This is tricky to do in a
160
157
        # subprocess because we really need to patch in a plugin that
161
158
        # registers the filters. Instead, we patch in a custom
162
159
        # 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
 
160
        from ..test_filters import _stack_2
 
161
        from ...tree import Tree
168
162
        wt = self.make_branch_and_tree('.')
169
163
        self.build_tree_contents([
170
 
            ('README', "junk\nline 1 of README\nline 2 of README\n"),
 
164
            ('README', b"junk\nline 1 of README\nline 2 of README\n"),
171
165
            ])
172
166
        wt.add('README')
173
167
        wt.commit('Making sure there is a basis_tree available')
179
173
        try:
180
174
            out, err = self.run_bzr(['cat', url, '--filters'])
181
175
            # The filter stack will remove the first line and swapcase the rest
182
 
            self.assertEqual('LINE 1 OF readme\nLINE 2 OF readme\n', out)
183
 
            self.assertEqual('', err)
 
176
            self.assertEqual(b'LINE 1 OF readme\nLINE 2 OF readme\n', out)
 
177
            self.assertEqual(b'', err)
184
178
        finally:
185
179
            Tree._content_filter_stack = real_content_filter_stack
186
180
 
189
183
        self.build_tree(['README'])
190
184
        wt.add('README')
191
185
        wt.commit('Making sure there is a basis_tree available')
192
 
        wt.branch.bzrdir.destroy_workingtree()
 
186
        wt.branch.controldir.destroy_workingtree()
193
187
 
194
188
        url = self.get_readonly_url() + '/README'
195
 
        out, err = self.run_bzr_subprocess(['cat', url])
196
 
        self.assertEqual('contents of README\n', out)
 
189
        out, err = self.run_bzr(['cat', url])
 
190
        self.assertEqual(b'contents of README\n', out)
197
191
 
198
192
    def test_cat_nonexistent_branch(self):
199
193
        self.vfs_transport_factory = memory.MemoryServer
200
 
        self.run_bzr_error(['^bzr: ERROR: Not a branch'],
 
194
        self.run_bzr_error([b'^brz: ERROR: Not a branch'],
201
195
                           ['cat', self.get_url()])
 
196
 
 
197
    def test_cat_directory(self):
 
198
        wt = self.make_branch_and_tree('a')
 
199
        self.build_tree(['a/README'])
 
200
        wt.add('README')
 
201
        wt.commit('Making sure there is a basis_tree available')
 
202
 
 
203
        out, err = self.run_bzr(['cat', '--directory=a', 'README'])
 
204
        self.assertEqual(b'contents of a/README\n', out)
 
205
 
 
206
    def test_cat_remote_directory(self):
 
207
        wt = self.make_branch_and_tree('a')
 
208
        self.build_tree(['a/README'])
 
209
        wt.add('README')
 
210
        wt.commit('Making sure there is a basis_tree available')
 
211
 
 
212
        url = self.get_readonly_url() + '/a'
 
213
        out, err = self.run_bzr(['cat', '-d', url, 'README'])
 
214
        self.assertEqual(b'contents of a/README\n', out)
 
215
 
 
216
 
 
217
class TestSmartServerCat(tests.TestCaseWithTransport):
 
218
 
 
219
    def test_simple_branch_cat(self):
 
220
        self.setup_smart_server_with_call_log()
 
221
        t = self.make_branch_and_tree('branch')
 
222
        self.build_tree_contents([('branch/foo', b'thecontents')])
 
223
        t.add("foo")
 
224
        t.commit("message")
 
225
        self.reset_smart_call_log()
 
226
        out, err = self.run_bzr(['cat', "%s/foo" % self.get_url('branch')])
 
227
        # This figure represent the amount of work to perform this use case. It
 
228
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
229
        # being too low. If rpc_count increases, more network roundtrips have
 
230
        # become necessary for this use case. Please do not adjust this number
 
231
        # upwards without agreement from bzr's network support maintainers.
 
232
        self.assertLength(9, self.hpss_calls)
 
233
        self.assertLength(1, self.hpss_connections)
 
234
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)