/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-11-19 18:28:52 UTC
  • mto: This revision was merged to the branch mainline in revision 7526.
  • Revision ID: jelmer@jelmer.uk-20201119182852-4za22s5mhakix4dq
Remove sixish data type.

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 ...transport import memory
26
23
 
27
24
 
28
25
class TestCat(tests.TestCaseWithTransport):
29
26
 
30
27
    def test_cat(self):
31
28
        tree = self.make_branch_and_tree('branch')
32
 
        self.build_tree_contents([('branch/a', 'foo\n')])
 
29
        self.build_tree_contents([('branch/a', b'foo\n')])
33
30
        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)
 
31
        # 'brz cat' without an option should cat the last revision
 
32
        self.run_bzr(['cat', 'a'], retcode=3, working_dir='branch')
37
33
 
38
34
        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')
 
35
        self.build_tree_contents([('branch/a', b'baz\n')])
 
36
 
 
37
        self.assertEqual('foo\n',
 
38
                         self.run_bzr(['cat', 'a'], working_dir='branch')[0])
 
39
 
 
40
        # On Windows, we used to have a bug where newlines got changed into
 
41
        # crlf, whereas cat ought to write out the file exactly as it's
 
42
        # recorded (by default.)  That problem can't be reproduced in-process,
 
43
        # so we need just one test here that
 
44
        self.assertEqual(b'foo\n',
 
45
                         self.run_bzr_subprocess(['cat', 'a'],
 
46
                                                 working_dir='branch')[0])
44
47
 
45
48
        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')
 
49
        self.assertEqual(
 
50
            'baz\n', self.run_bzr(['cat', 'a'], working_dir='branch')[0])
 
51
        self.assertEqual(
 
52
            'foo\n', self.run_bzr(['cat', 'a', '-r', '1'],
 
53
                                  working_dir='branch')[0])
 
54
        self.assertEqual(
 
55
            'baz\n', self.run_bzr(['cat', 'a', '-r', '-1'],
 
56
                                  working_dir='branch')[0])
53
57
 
54
58
        rev_id = tree.branch.last_revision()
55
59
 
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')
 
60
        self.assertEqual(
 
61
            'baz\n', self.run_bzr(
 
62
                ['cat', 'a', '-r', 'revid:%s' % rev_id.decode('utf-8')],
 
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' "
 
96
        self.run_bzr_error(["^brz: ERROR: u?'b-tree' "
99
97
                            "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')
 
101
        out, err = self.run_bzr('cat d-rev')
 
102
        self.assertEqual('', err)
104
103
        self.assertEqual('bar\n', out)
105
 
        self.assertEqual('', err)
106
104
 
107
105
        out, err = \
108
 
                self.run_bzr_subprocess('cat a-rev-tree --name-from-revision')
 
106
            self.run_bzr('cat a-rev-tree --name-from-revision')
109
107
        self.assertEqual('foo\n', out)
110
108
        self.assertEqual('', err)
111
109
 
112
 
        out, err = self.run_bzr_subprocess('cat a-rev-tree')
 
110
        out, err = self.run_bzr('cat a-rev-tree')
113
111
        self.assertEqual('baz\n', out)
114
112
        self.assertEqual('', 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')
 
115
        out, err = self.run_bzr('cat e-rev -rrevid:first')
118
116
        self.assertEqual('qux\n', out)
119
117
        self.assertEqual('', err)
120
118
 
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])
 
126
        out, err = self.run_bzr(['cat', url])
129
127
        self.assertEqual('contents of README\n', out)
130
128
 
131
129
    def test_cat_branch_revspec(self):
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'])
 
136
        out, err = self.run_bzr(['cat', '-r', 'branch:../a', 'README'],
 
137
                                working_dir='b')
141
138
        self.assertEqual('contents of a/README\n', out)
142
139
 
143
140
    def test_cat_filters(self):
148
145
        url = self.get_readonly_url() + '/README'
149
146
 
150
147
        # Test unfiltered output
151
 
        out, err = self.run_bzr_subprocess(['cat', url])
 
148
        out, err = self.run_bzr(['cat', url])
152
149
        self.assertEqual('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])
 
152
        out, err = self.run_bzr(['cat', '--filters', url])
156
153
        self.assertEqual('contents of README\n', out)
157
154
 
158
155
    def test_cat_filters_applied(self):
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')
174
168
        url = self.get_readonly_url() + '/README'
175
169
        real_content_filter_stack = Tree._content_filter_stack
 
170
 
176
171
        def _custom_content_filter_stack(tree, path=None, file_id=None):
177
172
            return _stack_2
178
173
        Tree._content_filter_stack = _custom_content_filter_stack
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)