/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: 2019-03-05 07:32:38 UTC
  • mto: (7290.1.21 work)
  • mto: This revision was merged to the branch mainline in revision 7311.
  • Revision ID: jelmer@jelmer.uk-20190305073238-zlqn981opwnqsmzi
Add appveyor configuration.

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
20
 
 
21
 
from bzrlib import config, errors, ignores
22
 
from bzrlib.tests import TestCase, TestCaseInTempDir, TestCaseWithTransport
 
19
from .. import (
 
20
    config,
 
21
    ignores,
 
22
    )
 
23
from ..sixish import (
 
24
    BytesIO,
 
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):
69
77
    def test_create_if_missing(self):
70
78
        # $HOME should be set to '.'
71
79
        ignore_path = config.user_ignore_config_filename()
72
 
        self.failIfExists(ignore_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
 
84
89
    def test_use_existing(self):
85
 
        patterns = ['*.o', '*.py[co]', u'\xe5*']
 
90
        patterns = [u'*.o', u'*.py[co]', u'\xe5*']
86
91
        ignores._set_user_ignores(patterns)
87
92
 
88
93
        user_ignores = ignores.get_user_ignores()
91
96
    def test_use_empty(self):
92
97
        ignores._set_user_ignores([])
93
98
        ignore_path = config.user_ignore_config_filename()
94
 
        self.check_file_contents(ignore_path, '')
 
99
        self.check_file_contents(ignore_path, b'')
95
100
 
96
101
        self.assertEqual(set([]), ignores.get_user_ignores())
97
102
 
122
127
 
123
128
        in_patterns = ['foo/', 'bar/', 'baz\\']
124
129
        added = ignores.add_unique_user_ignores(in_patterns)
125
 
        out_patterns = [ x.rstrip('/\\') for x in in_patterns ]
 
130
        out_patterns = [x.rstrip('/\\') for x in in_patterns]
126
131
        self.assertEqual(out_patterns, added)
127
132
        self.assertEqual(set(out_patterns), ignores.get_user_ignores())
128
133
 
134
139
        added = ignores.add_unique_user_ignores(
135
140
            ['xxx', './bar', 'xxx', 'dir1/', 'dir2/', 'dir3\\'])
136
141
        self.assertEqual(['xxx', 'dir2'], added)
137
 
        self.assertEqual(set(['foo', './bar', u'b\xe5z',
138
 
                              'xxx', 'dir1', 'dir2', 'dir3']),
 
142
        self.assertEqual({'foo', './bar', u'b\xe5z',
 
143
                          'xxx', 'dir1', 'dir2', 'dir3'},
139
144
                         ignores.get_user_ignores())
140
145
 
141
146
 
142
147
class TestRuntimeIgnores(TestCase):
143
148
 
144
149
    def setUp(self):
145
 
        TestCase.setUp(self)
 
150
        super(TestRuntimeIgnores, self).setUp()
146
151
 
147
152
        # For the purposes of these tests, we must have no
148
153
        # runtime ignores
153
158
        self.assertEqual(set(), ignores.get_runtime_ignores())
154
159
 
155
160
        ignores.add_runtime_ignores(['foo'])
156
 
        self.assertEqual(set(['foo']), ignores.get_runtime_ignores())
 
161
        self.assertEqual({'foo'}, ignores.get_runtime_ignores())
157
162
 
158
163
    def test_add_duplicate(self):
159
164
        """Adding the same ignore twice shouldn't add a new entry."""
160
165
        ignores.add_runtime_ignores(['foo', 'bar'])
161
 
        self.assertEqual(set(['foo', 'bar']), ignores.get_runtime_ignores())
 
166
        self.assertEqual({'foo', 'bar'}, ignores.get_runtime_ignores())
162
167
 
163
168
        ignores.add_runtime_ignores(['bar'])
164
 
        self.assertEqual(set(['foo', 'bar']), ignores.get_runtime_ignores())
 
169
        self.assertEqual({'foo', 'bar'}, ignores.get_runtime_ignores())
165
170
 
166
171
 
167
172
class TestTreeIgnores(TestCaseWithTransport):
168
 
    
 
173
 
169
174
    def assertPatternsEquals(self, patterns):
170
 
        contents = open(".bzrignore", 'rU').read().strip().split('\n')
171
 
        self.assertEquals(sorted(patterns), sorted(contents))
 
175
        with open(".bzrignore", "rb") as f:
 
176
            contents = f.read().decode("utf-8").splitlines()
 
177
        self.assertEqual(sorted(patterns), sorted(contents))
172
178
 
173
179
    def test_new_file(self):
174
180
        tree = self.make_branch_and_tree(".")
175
 
        ignores.tree_ignores_add_patterns(tree, ["myentry"])
 
181
        ignores.tree_ignores_add_patterns(tree, [u"myentry"])
176
182
        self.assertTrue(tree.has_filename(".bzrignore"))
177
183
        self.assertPatternsEquals(["myentry"])
178
184
 
179
185
    def test_add_to_existing(self):
180
186
        tree = self.make_branch_and_tree(".")
181
 
        self.build_tree_contents([('.bzrignore', "myentry1\n")])
 
187
        self.build_tree_contents([('.bzrignore', b"myentry1\n")])
182
188
        tree.add([".bzrignore"])
183
 
        ignores.tree_ignores_add_patterns(tree, ["myentry2", "foo"])
 
189
        ignores.tree_ignores_add_patterns(tree, [u"myentry2", u"foo"])
184
190
        self.assertPatternsEquals(["myentry1", "myentry2", "foo"])
185
191
 
186
192
    def test_adds_ending_newline(self):
187
193
        tree = self.make_branch_and_tree(".")
188
 
        self.build_tree_contents([('.bzrignore', "myentry1")])
 
194
        self.build_tree_contents([('.bzrignore', b"myentry1")])
189
195
        tree.add([".bzrignore"])
190
 
        ignores.tree_ignores_add_patterns(tree, ["myentry2"])
 
196
        ignores.tree_ignores_add_patterns(tree, [u"myentry2"])
191
197
        self.assertPatternsEquals(["myentry1", "myentry2"])
192
 
        text = open(".bzrignore", 'r').read()
193
 
        self.assertTrue(text.endswith('\r\n') or
194
 
                        text.endswith('\n') or
195
 
                        text.endswith('\r'))
 
198
        with open(".bzrignore") as f:
 
199
            text = f.read()
 
200
        self.assertTrue(text.endswith(('\r\n', '\n', '\r')))
196
201
 
197
202
    def test_does_not_add_dupe(self):
198
203
        tree = self.make_branch_and_tree(".")
199
 
        self.build_tree_contents([('.bzrignore', "myentry\n")])
 
204
        self.build_tree_contents([('.bzrignore', b"myentry\n")])
200
205
        tree.add([".bzrignore"])
201
 
        ignores.tree_ignores_add_patterns(tree, ["myentry"])
 
206
        ignores.tree_ignores_add_patterns(tree, [u"myentry"])
202
207
        self.assertPatternsEquals(["myentry"])
203
208
 
204
209
    def test_non_ascii(self):
207
212
                                   u"myentry\u1234\n".encode('utf-8'))])
208
213
        tree.add([".bzrignore"])
209
214
        ignores.tree_ignores_add_patterns(tree, [u"myentry\u5678"])
210
 
        self.assertPatternsEquals([u"myentry\u1234".encode('utf-8'),
211
 
                                   u"myentry\u5678".encode('utf-8')])
 
215
        self.assertPatternsEquals([u"myentry\u1234", u"myentry\u5678"])
212
216
 
213
217
    def test_crlf(self):
214
218
        tree = self.make_branch_and_tree(".")
215
 
        self.build_tree_contents([('.bzrignore', "myentry1\r\n")])
 
219
        self.build_tree_contents([('.bzrignore', b"myentry1\r\n")])
216
220
        tree.add([".bzrignore"])
217
221
        ignores.tree_ignores_add_patterns(tree, ["myentry2", "foo"])
218
 
        self.assertEquals(open('.bzrignore', 'rb').read(), 'myentry1\r\nmyentry2\r\nfoo\r\n')
 
222
        with open('.bzrignore', 'rb') as f:
 
223
            self.assertEqual(f.read(), b'myentry1\r\nmyentry2\r\nfoo\r\n')
219
224
        self.assertPatternsEquals(["myentry1", "myentry2", "foo"])