/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: Gustav Hartvigsson
  • Date: 2021-01-09 21:36:27 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210109213627-h1xwcutzy9m7a99b
Added 'Case Preserving Working Tree Use Cases' from Canonical Wiki

* Addod a page from the Canonical Bazaar wiki
  with information on the scmeatics of case
  perserving filesystems an a case insensitive
  filesystem works.
  
  * Needs re-work, but this will do as it is the
    same inforamoton as what was on the linked
    page in the currint documentation.

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