/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

Support user.signingkey configuration variable in .git/config.

Merged from https://code.launchpad.net/~jelmer/brz/local-git-key/+merge/381000

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
 
169
192
    def assertPatternsEquals(self, patterns):
170
 
        contents = open(".bzrignore", 'rU').read().strip().split('\n')
171
 
        self.assertEquals(sorted(patterns), sorted(contents))
 
193
        with open(".bzrignore", "rb") as f:
 
194
            contents = f.read().decode("utf-8").splitlines()
 
195
        self.assertEqual(sorted(patterns), sorted(contents))
172
196
 
173
197
    def test_new_file(self):
174
198
        tree = self.make_branch_and_tree(".")
175
 
        ignores.tree_ignores_add_patterns(tree, ["myentry"])
 
199
        ignores.tree_ignores_add_patterns(tree, [u"myentry"])
176
200
        self.assertTrue(tree.has_filename(".bzrignore"))
177
201
        self.assertPatternsEquals(["myentry"])
178
202
 
179
203
    def test_add_to_existing(self):
180
204
        tree = self.make_branch_and_tree(".")
181
 
        self.build_tree_contents([('.bzrignore', "myentry1\n")])
 
205
        self.build_tree_contents([('.bzrignore', b"myentry1\n")])
182
206
        tree.add([".bzrignore"])
183
 
        ignores.tree_ignores_add_patterns(tree, ["myentry2", "foo"])
 
207
        ignores.tree_ignores_add_patterns(tree, [u"myentry2", u"foo"])
184
208
        self.assertPatternsEquals(["myentry1", "myentry2", "foo"])
185
209
 
186
210
    def test_adds_ending_newline(self):
187
211
        tree = self.make_branch_and_tree(".")
188
 
        self.build_tree_contents([('.bzrignore', "myentry1")])
 
212
        self.build_tree_contents([('.bzrignore', b"myentry1")])
189
213
        tree.add([".bzrignore"])
190
 
        ignores.tree_ignores_add_patterns(tree, ["myentry2"])
 
214
        ignores.tree_ignores_add_patterns(tree, [u"myentry2"])
191
215
        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'))
 
216
        with open(".bzrignore") as f:
 
217
            text = f.read()
 
218
        self.assertTrue(text.endswith(('\r\n', '\n', '\r')))
196
219
 
197
220
    def test_does_not_add_dupe(self):
198
221
        tree = self.make_branch_and_tree(".")
199
 
        self.build_tree_contents([('.bzrignore', "myentry\n")])
 
222
        self.build_tree_contents([('.bzrignore', b"myentry\n")])
200
223
        tree.add([".bzrignore"])
201
 
        ignores.tree_ignores_add_patterns(tree, ["myentry"])
 
224
        ignores.tree_ignores_add_patterns(tree, [u"myentry"])
202
225
        self.assertPatternsEquals(["myentry"])
203
226
 
204
227
    def test_non_ascii(self):
207
230
                                   u"myentry\u1234\n".encode('utf-8'))])
208
231
        tree.add([".bzrignore"])
209
232
        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')])
 
233
        self.assertPatternsEquals([u"myentry\u1234", u"myentry\u5678"])
212
234
 
213
235
    def test_crlf(self):
214
236
        tree = self.make_branch_and_tree(".")
215
 
        self.build_tree_contents([('.bzrignore', "myentry1\r\n")])
 
237
        self.build_tree_contents([('.bzrignore', b"myentry1\r\n")])
216
238
        tree.add([".bzrignore"])
217
239
        ignores.tree_ignores_add_patterns(tree, ["myentry2", "foo"])
218
 
        self.assertEquals(open('.bzrignore', 'rb').read(), 'myentry1\r\nmyentry2\r\nfoo\r\n')
 
240
        with open('.bzrignore', 'rb') as f:
 
241
            self.assertEqual(f.read(), b'myentry1\r\nmyentry2\r\nfoo\r\n')
219
242
        self.assertPatternsEquals(["myentry1", "myentry2", "foo"])