/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/test_ignores.py

  • Committer: Jelmer Vernooij
  • Date: 2020-09-02 11:51:19 UTC
  • mto: (7490.40.109 work)
  • mto: This revision was merged to the branch mainline in revision 7526.
  • Revision ID: jelmer@jelmer.uk-20200902115119-otuspc349t9rmhua
add test for git file merge.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_ignores.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2016 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Tests for handling of ignore files"""
18
18
 
19
 
from cStringIO import StringIO
 
19
import os
20
20
 
21
 
from bzrlib import config, errors, ignores
22
 
from bzrlib.tests import TestCase, TestCaseInTempDir, TestCaseWithTransport
 
21
from .. import (
 
22
    bedding,
 
23
    ignores,
 
24
    )
 
25
from ..sixish import (
 
26
    BytesIO,
 
27
    )
 
28
from . import (
 
29
    TestCase,
 
30
    TestCaseInTempDir,
 
31
    TestCaseWithTransport,
 
32
    )
23
33
 
24
34
 
25
35
class TestParseIgnoreFile(TestCase):
26
36
 
27
37
    def test_parse_fancy(self):
28
 
        ignored = ignores.parse_ignore_file(StringIO(
29
 
                './rootdir\n'
30
 
                'randomfile*\n'
31
 
                'path/from/ro?t\n'
32
 
                'unicode\xc2\xb5\n' # u'\xb5'.encode('utf8')
33
 
                'dos\r\n'
34
 
                '\n' # empty line
35
 
                '#comment\n'
36
 
                ' xx \n' # whitespace
37
 
                '!RE:^\.z.*\n'
38
 
                '!!./.zcompdump\n'
39
 
                ))
40
 
        self.assertEqual(set(['./rootdir',
41
 
                          'randomfile*',
42
 
                          'path/from/ro?t',
 
38
        ignored = ignores.parse_ignore_file(BytesIO(
 
39
            b'./rootdir\n'
 
40
            b'randomfile*\n'
 
41
            b'path/from/ro?t\n'
 
42
            b'unicode\xc2\xb5\n'  # u'\xb5'.encode('utf8')
 
43
            b'dos\r\n'
 
44
            b'\n'  # empty line
 
45
            b'#comment\n'
 
46
            b' xx \n'  # whitespace
 
47
            b'!RE:^\\.z.*\n'
 
48
            b'!!./.zcompdump\n'
 
49
            ))
 
50
        self.assertEqual({u'./rootdir',
 
51
                          u'randomfile*',
 
52
                          u'path/from/ro?t',
43
53
                          u'unicode\xb5',
44
 
                          'dos',
45
 
                          ' xx ',
46
 
                          '!RE:^\.z.*',
47
 
                          '!!./.zcompdump',
48
 
                         ]), ignored)
 
54
                          u'dos',
 
55
                          u' xx ',
 
56
                          u'!RE:^\\.z.*',
 
57
                          u'!!./.zcompdump',
 
58
                          }, ignored)
49
59
 
50
60
    def test_parse_empty(self):
51
 
        ignored = ignores.parse_ignore_file(StringIO(''))
 
61
        ignored = ignores.parse_ignore_file(BytesIO(b''))
52
62
        self.assertEqual(set([]), ignored)
53
 
        
 
63
 
54
64
    def test_parse_non_utf8(self):
55
65
        """Lines with non utf 8 characters should be discarded."""
56
 
        ignored = ignores.parse_ignore_file(StringIO(
57
 
                'utf8filename_a\n'
58
 
                'invalid utf8\x80\n'
59
 
                'utf8filename_b\n'
60
 
                ))
61
 
        self.assertEqual(set([
62
 
                        'utf8filename_a',
63
 
                        'utf8filename_b',
64
 
                       ]), ignored)
 
66
        ignored = ignores.parse_ignore_file(BytesIO(
 
67
            b'utf8filename_a\n'
 
68
            b'invalid utf8\x80\n'
 
69
            b'utf8filename_b\n'
 
70
            ))
 
71
        self.assertEqual({
 
72
            u'utf8filename_a',
 
73
            u'utf8filename_b',
 
74
            }, ignored)
65
75
 
66
76
 
67
77
class TestUserIgnores(TestCaseInTempDir):
68
78
 
69
79
    def test_create_if_missing(self):
70
80
        # $HOME should be set to '.'
71
 
        ignore_path = config.user_ignore_config_filename()
72
 
        self.failIfExists(ignore_path)
 
81
        ignore_path = bedding.user_ignore_config_path()
 
82
        self.assertPathDoesNotExist(ignore_path)
73
83
        user_ignores = ignores.get_user_ignores()
74
84
        self.assertEqual(set(ignores.USER_DEFAULTS), user_ignores)
75
85
 
76
 
        self.failUnlessExists(ignore_path)
77
 
        f = open(ignore_path, 'rb')
78
 
        try:
 
86
        self.assertPathExists(ignore_path)
 
87
        with open(ignore_path, 'rb') as f:
79
88
            entries = ignores.parse_ignore_file(f)
80
 
        finally:
81
 
            f.close()
82
89
        self.assertEqual(set(ignores.USER_DEFAULTS), entries)
83
90
 
 
91
    def test_create_with_intermediate_missing(self):
 
92
        # $HOME should be set to '.'
 
93
        ignore_path = bedding.user_ignore_config_path()
 
94
        self.assertPathDoesNotExist(ignore_path)
 
95
        os.mkdir('empty-home')
 
96
 
 
97
        config_path = os.path.join(
 
98
            self.test_dir, 'empty-home', 'foo', '.config')
 
99
        self.overrideEnv('BRZ_HOME', config_path)
 
100
        self.assertPathDoesNotExist(config_path)
 
101
 
 
102
        user_ignores = ignores.get_user_ignores()
 
103
        self.assertEqual(set(ignores.USER_DEFAULTS), user_ignores)
 
104
 
 
105
        ignore_path = bedding.user_ignore_config_path()
 
106
        self.assertPathDoesNotExist(ignore_path)
 
107
 
84
108
    def test_use_existing(self):
85
 
        patterns = ['*.o', '*.py[co]', u'\xe5*']
 
109
        patterns = [u'*.o', u'*.py[co]', u'\xe5*']
86
110
        ignores._set_user_ignores(patterns)
87
111
 
88
112
        user_ignores = ignores.get_user_ignores()
90
114
 
91
115
    def test_use_empty(self):
92
116
        ignores._set_user_ignores([])
93
 
        ignore_path = config.user_ignore_config_filename()
94
 
        self.check_file_contents(ignore_path, '')
 
117
        ignore_path = bedding.user_ignore_config_path()
 
118
        self.check_file_contents(ignore_path, b'')
95
119
 
96
120
        self.assertEqual(set([]), ignores.get_user_ignores())
97
121
 
122
146
 
123
147
        in_patterns = ['foo/', 'bar/', 'baz\\']
124
148
        added = ignores.add_unique_user_ignores(in_patterns)
125
 
        out_patterns = [ x.rstrip('/\\') for x in in_patterns ]
 
149
        out_patterns = [x.rstrip('/\\') for x in in_patterns]
126
150
        self.assertEqual(out_patterns, added)
127
151
        self.assertEqual(set(out_patterns), ignores.get_user_ignores())
128
152
 
134
158
        added = ignores.add_unique_user_ignores(
135
159
            ['xxx', './bar', 'xxx', 'dir1/', 'dir2/', 'dir3\\'])
136
160
        self.assertEqual(['xxx', 'dir2'], added)
137
 
        self.assertEqual(set(['foo', './bar', u'b\xe5z',
138
 
                              'xxx', 'dir1', 'dir2', 'dir3']),
 
161
        self.assertEqual({'foo', './bar', u'b\xe5z',
 
162
                          'xxx', 'dir1', 'dir2', 'dir3'},
139
163
                         ignores.get_user_ignores())
140
164
 
141
165
 
142
166
class TestRuntimeIgnores(TestCase):
143
167
 
144
168
    def setUp(self):
145
 
        TestCase.setUp(self)
 
169
        super(TestRuntimeIgnores, self).setUp()
146
170
 
147
171
        # For the purposes of these tests, we must have no
148
172
        # runtime ignores
153
177
        self.assertEqual(set(), ignores.get_runtime_ignores())
154
178
 
155
179
        ignores.add_runtime_ignores(['foo'])
156
 
        self.assertEqual(set(['foo']), ignores.get_runtime_ignores())
 
180
        self.assertEqual({'foo'}, ignores.get_runtime_ignores())
157
181
 
158
182
    def test_add_duplicate(self):
159
183
        """Adding the same ignore twice shouldn't add a new entry."""
160
184
        ignores.add_runtime_ignores(['foo', 'bar'])
161
 
        self.assertEqual(set(['foo', 'bar']), ignores.get_runtime_ignores())
 
185
        self.assertEqual({'foo', 'bar'}, ignores.get_runtime_ignores())
162
186
 
163
187
        ignores.add_runtime_ignores(['bar'])
164
 
        self.assertEqual(set(['foo', 'bar']), ignores.get_runtime_ignores())
 
188
        self.assertEqual({'foo', 'bar'}, ignores.get_runtime_ignores())
165
189
 
166
190
 
167
191
class TestTreeIgnores(TestCaseWithTransport):
168
192
 
 
193
    def assertPatternsEquals(self, patterns):
 
194
        with open(".bzrignore", "rb") as f:
 
195
            contents = f.read().decode("utf-8").splitlines()
 
196
        self.assertEqual(sorted(patterns), sorted(contents))
 
197
 
169
198
    def test_new_file(self):
170
199
        tree = self.make_branch_and_tree(".")
171
 
        ignores.tree_ignores_add_patterns(tree, ["myentry"])
 
200
        ignores.tree_ignores_add_patterns(tree, [u"myentry"])
172
201
        self.assertTrue(tree.has_filename(".bzrignore"))
173
 
        self.assertEquals("myentry\n",
174
 
                          open(".bzrignore", 'r').read())
 
202
        self.assertPatternsEquals(["myentry"])
175
203
 
176
204
    def test_add_to_existing(self):
177
205
        tree = self.make_branch_and_tree(".")
178
 
        self.build_tree_contents([('.bzrignore', "myentry1\n")])
 
206
        self.build_tree_contents([('.bzrignore', b"myentry1\n")])
 
207
        tree.add([".bzrignore"])
 
208
        ignores.tree_ignores_add_patterns(tree, [u"myentry2", u"foo"])
 
209
        self.assertPatternsEquals(["myentry1", "myentry2", "foo"])
 
210
 
 
211
    def test_adds_ending_newline(self):
 
212
        tree = self.make_branch_and_tree(".")
 
213
        self.build_tree_contents([('.bzrignore', b"myentry1")])
 
214
        tree.add([".bzrignore"])
 
215
        ignores.tree_ignores_add_patterns(tree, [u"myentry2"])
 
216
        self.assertPatternsEquals(["myentry1", "myentry2"])
 
217
        with open(".bzrignore") as f:
 
218
            text = f.read()
 
219
        self.assertTrue(text.endswith(('\r\n', '\n', '\r')))
 
220
 
 
221
    def test_does_not_add_dupe(self):
 
222
        tree = self.make_branch_and_tree(".")
 
223
        self.build_tree_contents([('.bzrignore', b"myentry\n")])
 
224
        tree.add([".bzrignore"])
 
225
        ignores.tree_ignores_add_patterns(tree, [u"myentry"])
 
226
        self.assertPatternsEquals(["myentry"])
 
227
 
 
228
    def test_non_ascii(self):
 
229
        tree = self.make_branch_and_tree(".")
 
230
        self.build_tree_contents([('.bzrignore',
 
231
                                   u"myentry\u1234\n".encode('utf-8'))])
 
232
        tree.add([".bzrignore"])
 
233
        ignores.tree_ignores_add_patterns(tree, [u"myentry\u5678"])
 
234
        self.assertPatternsEquals([u"myentry\u1234", u"myentry\u5678"])
 
235
 
 
236
    def test_crlf(self):
 
237
        tree = self.make_branch_and_tree(".")
 
238
        self.build_tree_contents([('.bzrignore', b"myentry1\r\n")])
179
239
        tree.add([".bzrignore"])
180
240
        ignores.tree_ignores_add_patterns(tree, ["myentry2", "foo"])
181
 
        self.assertEquals("myentry1\nmyentry2\nfoo\n",
182
 
                          open(".bzrignore", 'r').read())
183
 
 
184
 
    def test_adds_ending_newline(self):
185
 
        tree = self.make_branch_and_tree(".")
186
 
        self.build_tree_contents([('.bzrignore', "myentry1")])
187
 
        tree.add([".bzrignore"])
188
 
        ignores.tree_ignores_add_patterns(tree, ["myentry2"])
189
 
        self.assertEquals("myentry1\nmyentry2\n",
190
 
                          open(".bzrignore", 'r').read())
191
 
 
 
241
        with open('.bzrignore', 'rb') as f:
 
242
            self.assertEqual(f.read(), b'myentry1\r\nmyentry2\r\nfoo\r\n')
 
243
        self.assertPatternsEquals(["myentry1", "myentry2", "foo"])