/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: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

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'
 
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'
39
47
                ))
40
 
        self.assertEqual(set(['./rootdir',
41
 
                          'randomfile*',
42
 
                          'path/from/ro?t',
 
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'
 
64
        ignored = ignores.parse_ignore_file(BytesIO(
 
65
                b'utf8filename_a\n'
 
66
                b'invalid utf8\x80\n'
 
67
                b'utf8filename_b\n'
60
68
                ))
61
 
        self.assertEqual(set([
62
 
                        'utf8filename_a',
63
 
                        'utf8filename_b',
64
 
                       ]), ignored)
 
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
 
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
 
 
174
    def assertPatternsEquals(self, patterns):
 
175
        with open(".bzrignore", "rb") as f:
 
176
            contents = f.read().decode("utf-8").splitlines()
 
177
        self.assertEqual(sorted(patterns), sorted(contents))
 
178
 
169
179
    def test_new_file(self):
170
180
        tree = self.make_branch_and_tree(".")
171
 
        ignores.tree_ignores_add_patterns(tree, ["myentry"])
 
181
        ignores.tree_ignores_add_patterns(tree, [u"myentry"])
172
182
        self.assertTrue(tree.has_filename(".bzrignore"))
173
 
        self.assertEquals("myentry\n",
174
 
                          open(".bzrignore", 'r').read())
 
183
        self.assertPatternsEquals(["myentry"])
175
184
 
176
185
    def test_add_to_existing(self):
177
186
        tree = self.make_branch_and_tree(".")
178
 
        self.build_tree_contents([('.bzrignore', "myentry1\n")])
 
187
        self.build_tree_contents([('.bzrignore', b"myentry1\n")])
 
188
        tree.add([".bzrignore"])
 
189
        ignores.tree_ignores_add_patterns(tree, [u"myentry2", u"foo"])
 
190
        self.assertPatternsEquals(["myentry1", "myentry2", "foo"])
 
191
 
 
192
    def test_adds_ending_newline(self):
 
193
        tree = self.make_branch_and_tree(".")
 
194
        self.build_tree_contents([('.bzrignore', b"myentry1")])
 
195
        tree.add([".bzrignore"])
 
196
        ignores.tree_ignores_add_patterns(tree, [u"myentry2"])
 
197
        self.assertPatternsEquals(["myentry1", "myentry2"])
 
198
        with open(".bzrignore") as f:
 
199
            text = f.read()
 
200
        self.assertTrue(text.endswith(('\r\n', '\n', '\r')))
 
201
 
 
202
    def test_does_not_add_dupe(self):
 
203
        tree = self.make_branch_and_tree(".")
 
204
        self.build_tree_contents([('.bzrignore', b"myentry\n")])
 
205
        tree.add([".bzrignore"])
 
206
        ignores.tree_ignores_add_patterns(tree, [u"myentry"])
 
207
        self.assertPatternsEquals(["myentry"])
 
208
 
 
209
    def test_non_ascii(self):
 
210
        tree = self.make_branch_and_tree(".")
 
211
        self.build_tree_contents([('.bzrignore',
 
212
                                   u"myentry\u1234\n".encode('utf-8'))])
 
213
        tree.add([".bzrignore"])
 
214
        ignores.tree_ignores_add_patterns(tree, [u"myentry\u5678"])
 
215
        self.assertPatternsEquals([u"myentry\u1234", u"myentry\u5678"])
 
216
 
 
217
    def test_crlf(self):
 
218
        tree = self.make_branch_and_tree(".")
 
219
        self.build_tree_contents([('.bzrignore', b"myentry1\r\n")])
179
220
        tree.add([".bzrignore"])
180
221
        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
 
 
 
222
        with open('.bzrignore') as f:
 
223
            self.assertEqual(f.read(), 'myentry1\r\nmyentry2\r\nfoo\r\n')
 
224
        self.assertPatternsEquals(["myentry1", "myentry2", "foo"])