/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-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

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(self.test_dir, 'empty-home', '.config')
 
98
        self.overrideEnv('BRZ_HOME', config_path)
 
99
        self.assertPathDoesNotExist(config_path)
 
100
 
 
101
        user_ignores = ignores.get_user_ignores()
 
102
        self.assertEqual(set(ignores.USER_DEFAULTS), user_ignores)
 
103
 
 
104
        ignore_path = bedding.user_ignore_config_path()
 
105
        self.assertPathDoesNotExist(ignore_path)
 
106
 
84
107
    def test_use_existing(self):
85
 
        patterns = ['*.o', '*.py[co]', u'\xe5*']
 
108
        patterns = [u'*.o', u'*.py[co]', u'\xe5*']
86
109
        ignores._set_user_ignores(patterns)
87
110
 
88
111
        user_ignores = ignores.get_user_ignores()
90
113
 
91
114
    def test_use_empty(self):
92
115
        ignores._set_user_ignores([])
93
 
        ignore_path = config.user_ignore_config_filename()
94
 
        self.check_file_contents(ignore_path, '')
 
116
        ignore_path = bedding.user_ignore_config_path()
 
117
        self.check_file_contents(ignore_path, b'')
95
118
 
96
119
        self.assertEqual(set([]), ignores.get_user_ignores())
97
120
 
122
145
 
123
146
        in_patterns = ['foo/', 'bar/', 'baz\\']
124
147
        added = ignores.add_unique_user_ignores(in_patterns)
125
 
        out_patterns = [ x.rstrip('/\\') for x in in_patterns ]
 
148
        out_patterns = [x.rstrip('/\\') for x in in_patterns]
126
149
        self.assertEqual(out_patterns, added)
127
150
        self.assertEqual(set(out_patterns), ignores.get_user_ignores())
128
151
 
134
157
        added = ignores.add_unique_user_ignores(
135
158
            ['xxx', './bar', 'xxx', 'dir1/', 'dir2/', 'dir3\\'])
136
159
        self.assertEqual(['xxx', 'dir2'], added)
137
 
        self.assertEqual(set(['foo', './bar', u'b\xe5z',
138
 
                              'xxx', 'dir1', 'dir2', 'dir3']),
 
160
        self.assertEqual({'foo', './bar', u'b\xe5z',
 
161
                          'xxx', 'dir1', 'dir2', 'dir3'},
139
162
                         ignores.get_user_ignores())
140
163
 
141
164
 
142
165
class TestRuntimeIgnores(TestCase):
143
166
 
144
167
    def setUp(self):
145
 
        TestCase.setUp(self)
 
168
        super(TestRuntimeIgnores, self).setUp()
146
169
 
147
170
        # For the purposes of these tests, we must have no
148
171
        # runtime ignores
153
176
        self.assertEqual(set(), ignores.get_runtime_ignores())
154
177
 
155
178
        ignores.add_runtime_ignores(['foo'])
156
 
        self.assertEqual(set(['foo']), ignores.get_runtime_ignores())
 
179
        self.assertEqual({'foo'}, ignores.get_runtime_ignores())
157
180
 
158
181
    def test_add_duplicate(self):
159
182
        """Adding the same ignore twice shouldn't add a new entry."""
160
183
        ignores.add_runtime_ignores(['foo', 'bar'])
161
 
        self.assertEqual(set(['foo', 'bar']), ignores.get_runtime_ignores())
 
184
        self.assertEqual({'foo', 'bar'}, ignores.get_runtime_ignores())
162
185
 
163
186
        ignores.add_runtime_ignores(['bar'])
164
 
        self.assertEqual(set(['foo', 'bar']), ignores.get_runtime_ignores())
 
187
        self.assertEqual({'foo', 'bar'}, ignores.get_runtime_ignores())
165
188
 
166
189
 
167
190
class TestTreeIgnores(TestCaseWithTransport):
168
191
 
 
192
    def assertPatternsEquals(self, patterns):
 
193
        with open(".bzrignore", "rb") as f:
 
194
            contents = f.read().decode("utf-8").splitlines()
 
195
        self.assertEqual(sorted(patterns), sorted(contents))
 
196
 
169
197
    def test_new_file(self):
170
198
        tree = self.make_branch_and_tree(".")
171
 
        ignores.tree_ignores_add_patterns(tree, ["myentry"])
 
199
        ignores.tree_ignores_add_patterns(tree, [u"myentry"])
172
200
        self.assertTrue(tree.has_filename(".bzrignore"))
173
 
        self.assertEquals("myentry\n",
174
 
                          open(".bzrignore", 'r').read())
 
201
        self.assertPatternsEquals(["myentry"])
175
202
 
176
203
    def test_add_to_existing(self):
177
204
        tree = self.make_branch_and_tree(".")
178
 
        self.build_tree_contents([('.bzrignore', "myentry1\n")])
 
205
        self.build_tree_contents([('.bzrignore', b"myentry1\n")])
 
206
        tree.add([".bzrignore"])
 
207
        ignores.tree_ignores_add_patterns(tree, [u"myentry2", u"foo"])
 
208
        self.assertPatternsEquals(["myentry1", "myentry2", "foo"])
 
209
 
 
210
    def test_adds_ending_newline(self):
 
211
        tree = self.make_branch_and_tree(".")
 
212
        self.build_tree_contents([('.bzrignore', b"myentry1")])
 
213
        tree.add([".bzrignore"])
 
214
        ignores.tree_ignores_add_patterns(tree, [u"myentry2"])
 
215
        self.assertPatternsEquals(["myentry1", "myentry2"])
 
216
        with open(".bzrignore") as f:
 
217
            text = f.read()
 
218
        self.assertTrue(text.endswith(('\r\n', '\n', '\r')))
 
219
 
 
220
    def test_does_not_add_dupe(self):
 
221
        tree = self.make_branch_and_tree(".")
 
222
        self.build_tree_contents([('.bzrignore', b"myentry\n")])
 
223
        tree.add([".bzrignore"])
 
224
        ignores.tree_ignores_add_patterns(tree, [u"myentry"])
 
225
        self.assertPatternsEquals(["myentry"])
 
226
 
 
227
    def test_non_ascii(self):
 
228
        tree = self.make_branch_and_tree(".")
 
229
        self.build_tree_contents([('.bzrignore',
 
230
                                   u"myentry\u1234\n".encode('utf-8'))])
 
231
        tree.add([".bzrignore"])
 
232
        ignores.tree_ignores_add_patterns(tree, [u"myentry\u5678"])
 
233
        self.assertPatternsEquals([u"myentry\u1234", u"myentry\u5678"])
 
234
 
 
235
    def test_crlf(self):
 
236
        tree = self.make_branch_and_tree(".")
 
237
        self.build_tree_contents([('.bzrignore', b"myentry1\r\n")])
179
238
        tree.add([".bzrignore"])
180
239
        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
 
 
 
240
        with open('.bzrignore', 'rb') as f:
 
241
            self.assertEqual(f.read(), b'myentry1\r\nmyentry2\r\nfoo\r\n')
 
242
        self.assertPatternsEquals(["myentry1", "myentry2", "foo"])