gvsig-scripting / org.gvsig.scripting / trunk / org.gvsig.scripting / org.gvsig.scripting.app / org.gvsig.scripting.app.mainplugin / src / main / resources-plugin / scripting / lib / dulwich / tests / test_refs.py @ 959
History | View | Annotate | Download (20.5 KB)
1 |
# test_refs.py -- tests for refs.py
|
---|---|
2 |
# encoding: utf-8
|
3 |
# Copyright (C) 2013 Jelmer Vernooij <jelmer@samba.org>
|
4 |
#
|
5 |
# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
|
6 |
# General Public License as public by the Free Software Foundation; version 2.0
|
7 |
# or (at your option) any later version. You can redistribute it and/or
|
8 |
# modify it under the terms of either of these two licenses.
|
9 |
#
|
10 |
# Unless required by applicable law or agreed to in writing, software
|
11 |
# distributed under the License is distributed on an "AS IS" BASIS,
|
12 |
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
13 |
# See the License for the specific language governing permissions and
|
14 |
# limitations under the License.
|
15 |
#
|
16 |
# You should have received a copy of the licenses; if not, see
|
17 |
# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
|
18 |
# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
|
19 |
# License, Version 2.0.
|
20 |
#
|
21 |
|
22 |
"""Tests for dulwich.refs."""
|
23 |
|
24 |
from io import BytesIO |
25 |
import os |
26 |
import sys |
27 |
import tempfile |
28 |
|
29 |
from dulwich import errors |
30 |
from dulwich.file import ( |
31 |
GitFile, |
32 |
) |
33 |
from dulwich.objects import ZERO_SHA |
34 |
from dulwich.refs import ( |
35 |
DictRefsContainer, |
36 |
InfoRefsContainer, |
37 |
check_ref_format, |
38 |
_split_ref_line, |
39 |
read_packed_refs_with_peeled, |
40 |
read_packed_refs, |
41 |
write_packed_refs, |
42 |
) |
43 |
from dulwich.repo import Repo |
44 |
|
45 |
from dulwich.tests import ( |
46 |
SkipTest, |
47 |
TestCase, |
48 |
) |
49 |
|
50 |
from dulwich.tests.utils import ( |
51 |
open_repo, |
52 |
tear_down_repo, |
53 |
) |
54 |
|
55 |
|
56 |
class CheckRefFormatTests(TestCase): |
57 |
"""Tests for the check_ref_format function.
|
58 |
|
59 |
These are the same tests as in the git test suite.
|
60 |
"""
|
61 |
|
62 |
def test_valid(self): |
63 |
self.assertTrue(check_ref_format(b'heads/foo')) |
64 |
self.assertTrue(check_ref_format(b'foo/bar/baz')) |
65 |
self.assertTrue(check_ref_format(b'refs///heads/foo')) |
66 |
self.assertTrue(check_ref_format(b'foo./bar')) |
67 |
self.assertTrue(check_ref_format(b'heads/foo@bar')) |
68 |
self.assertTrue(check_ref_format(b'heads/fix.lock.error')) |
69 |
|
70 |
def test_invalid(self): |
71 |
self.assertFalse(check_ref_format(b'foo')) |
72 |
self.assertFalse(check_ref_format(b'heads/foo/')) |
73 |
self.assertFalse(check_ref_format(b'./foo')) |
74 |
self.assertFalse(check_ref_format(b'.refs/foo')) |
75 |
self.assertFalse(check_ref_format(b'heads/foo..bar')) |
76 |
self.assertFalse(check_ref_format(b'heads/foo?bar')) |
77 |
self.assertFalse(check_ref_format(b'heads/foo.lock')) |
78 |
self.assertFalse(check_ref_format(b'heads/v@{ation')) |
79 |
self.assertFalse(check_ref_format(b'heads/foo\bar')) |
80 |
|
81 |
|
82 |
ONES = b'1' * 40 |
83 |
TWOS = b'2' * 40 |
84 |
THREES = b'3' * 40 |
85 |
FOURS = b'4' * 40 |
86 |
|
87 |
class PackedRefsFileTests(TestCase): |
88 |
|
89 |
def test_split_ref_line_errors(self): |
90 |
self.assertRaises(errors.PackedRefsException, _split_ref_line,
|
91 |
b'singlefield')
|
92 |
self.assertRaises(errors.PackedRefsException, _split_ref_line,
|
93 |
b'badsha name')
|
94 |
self.assertRaises(errors.PackedRefsException, _split_ref_line,
|
95 |
ONES + b' bad/../refname')
|
96 |
|
97 |
def test_read_without_peeled(self): |
98 |
f = BytesIO(b'\n'.join([
|
99 |
b'# comment',
|
100 |
ONES + b' ref/1',
|
101 |
TWOS + b' ref/2']))
|
102 |
self.assertEqual([(ONES, b'ref/1'), (TWOS, b'ref/2')], |
103 |
list(read_packed_refs(f)))
|
104 |
|
105 |
def test_read_without_peeled_errors(self): |
106 |
f = BytesIO(b'\n'.join([
|
107 |
ONES + b' ref/1',
|
108 |
b'^' + TWOS]))
|
109 |
self.assertRaises(errors.PackedRefsException, list, read_packed_refs(f)) |
110 |
|
111 |
def test_read_with_peeled(self): |
112 |
f = BytesIO(b'\n'.join([
|
113 |
ONES + b' ref/1',
|
114 |
TWOS + b' ref/2',
|
115 |
b'^' + THREES,
|
116 |
FOURS + b' ref/4']))
|
117 |
self.assertEqual([
|
118 |
(ONES, b'ref/1', None), |
119 |
(TWOS, b'ref/2', THREES),
|
120 |
(FOURS, b'ref/4', None), |
121 |
], list(read_packed_refs_with_peeled(f)))
|
122 |
|
123 |
def test_read_with_peeled_errors(self): |
124 |
f = BytesIO(b'\n'.join([
|
125 |
b'^' + TWOS,
|
126 |
ONES + b' ref/1']))
|
127 |
self.assertRaises(errors.PackedRefsException, list, read_packed_refs(f)) |
128 |
|
129 |
f = BytesIO(b'\n'.join([
|
130 |
ONES + b' ref/1',
|
131 |
b'^' + TWOS,
|
132 |
b'^' + THREES]))
|
133 |
self.assertRaises(errors.PackedRefsException, list, read_packed_refs(f)) |
134 |
|
135 |
def test_write_with_peeled(self): |
136 |
f = BytesIO() |
137 |
write_packed_refs(f, {b'ref/1': ONES, b'ref/2': TWOS}, |
138 |
{b'ref/1': THREES})
|
139 |
self.assertEqual(
|
140 |
b'\n'.join([b'# pack-refs with: peeled', |
141 |
ONES + b' ref/1',
|
142 |
b'^' + THREES,
|
143 |
TWOS + b' ref/2']) + b'\n', |
144 |
f.getvalue()) |
145 |
|
146 |
def test_write_without_peeled(self): |
147 |
f = BytesIO() |
148 |
write_packed_refs(f, {b'ref/1': ONES, b'ref/2': TWOS}) |
149 |
self.assertEqual(b'\n'.join([ONES + b' ref/1', |
150 |
TWOS + b' ref/2']) + b'\n', |
151 |
f.getvalue()) |
152 |
|
153 |
|
154 |
# Dict of refs that we expect all RefsContainerTests subclasses to define.
|
155 |
_TEST_REFS = { |
156 |
b'HEAD': b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
157 |
b'refs/heads/40-char-ref-aaaaaaaaaaaaaaaaaa': b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
158 |
b'refs/heads/master': b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
159 |
b'refs/heads/packed': b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
160 |
b'refs/tags/refs-0.1': b'df6800012397fb85c56e7418dd4eb9405dee075c', |
161 |
b'refs/tags/refs-0.2': b'3ec9c43c84ff242e3ef4a9fc5bc111fd780a76a8', |
162 |
} |
163 |
|
164 |
|
165 |
class RefsContainerTests(object): |
166 |
|
167 |
def test_keys(self): |
168 |
actual_keys = set(self._refs.keys()) |
169 |
self.assertEqual(set(self._refs.allkeys()), actual_keys) |
170 |
# ignore the symref loop if it exists
|
171 |
actual_keys.discard(b'refs/heads/loop')
|
172 |
self.assertEqual(set(_TEST_REFS.keys()), actual_keys) |
173 |
|
174 |
actual_keys = self._refs.keys(b'refs/heads') |
175 |
actual_keys.discard(b'loop')
|
176 |
self.assertEqual(
|
177 |
[b'40-char-ref-aaaaaaaaaaaaaaaaaa', b'master', b'packed'], |
178 |
sorted(actual_keys))
|
179 |
self.assertEqual([b'refs-0.1', b'refs-0.2'], |
180 |
sorted(self._refs.keys(b'refs/tags'))) |
181 |
|
182 |
def test_as_dict(self): |
183 |
# refs/heads/loop does not show up even if it exists
|
184 |
self.assertEqual(_TEST_REFS, self._refs.as_dict()) |
185 |
|
186 |
def test_setitem(self): |
187 |
self._refs[b'refs/some/ref'] = b'42d06bd4b77fed026b154d16493e5deab78f02ec' |
188 |
self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
189 |
self._refs[b'refs/some/ref']) |
190 |
self.assertRaises(
|
191 |
errors.RefFormatError, self._refs.__setitem__,
|
192 |
b'notrefs/foo', b'42d06bd4b77fed026b154d16493e5deab78f02ec') |
193 |
|
194 |
def test_set_if_equals(self): |
195 |
nines = b'9' * 40 |
196 |
self.assertFalse(self._refs.set_if_equals(b'HEAD', b'c0ffee', nines)) |
197 |
self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
198 |
self._refs[b'HEAD']) |
199 |
|
200 |
self.assertTrue(self._refs.set_if_equals( |
201 |
b'HEAD', b'42d06bd4b77fed026b154d16493e5deab78f02ec', nines)) |
202 |
self.assertEqual(nines, self._refs[b'HEAD']) |
203 |
|
204 |
self.assertTrue(self._refs.set_if_equals(b'refs/heads/master', None, |
205 |
nines)) |
206 |
self.assertEqual(nines, self._refs[b'refs/heads/master']) |
207 |
|
208 |
self.assertTrue(self._refs.set_if_equals( |
209 |
b'refs/heads/nonexistant', ZERO_SHA, nines))
|
210 |
self.assertEqual(nines, self._refs[b'refs/heads/nonexistant']) |
211 |
|
212 |
def test_add_if_new(self): |
213 |
nines = b'9' * 40 |
214 |
self.assertFalse(self._refs.add_if_new(b'refs/heads/master', nines)) |
215 |
self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
216 |
self._refs[b'refs/heads/master']) |
217 |
|
218 |
self.assertTrue(self._refs.add_if_new(b'refs/some/ref', nines)) |
219 |
self.assertEqual(nines, self._refs[b'refs/some/ref']) |
220 |
|
221 |
def test_set_symbolic_ref(self): |
222 |
self._refs.set_symbolic_ref(b'refs/heads/symbolic', |
223 |
b'refs/heads/master')
|
224 |
self.assertEqual(b'ref: refs/heads/master', |
225 |
self._refs.read_loose_ref(b'refs/heads/symbolic')) |
226 |
self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
227 |
self._refs[b'refs/heads/symbolic']) |
228 |
|
229 |
def test_set_symbolic_ref_overwrite(self): |
230 |
nines = b'9' * 40 |
231 |
self.assertFalse(b'refs/heads/symbolic' in self._refs) |
232 |
self._refs[b'refs/heads/symbolic'] = nines |
233 |
self.assertEqual(nines,
|
234 |
self._refs.read_loose_ref(b'refs/heads/symbolic')) |
235 |
self._refs.set_symbolic_ref(b'refs/heads/symbolic', |
236 |
b'refs/heads/master')
|
237 |
self.assertEqual(b'ref: refs/heads/master', |
238 |
self._refs.read_loose_ref(b'refs/heads/symbolic')) |
239 |
self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
240 |
self._refs[b'refs/heads/symbolic']) |
241 |
|
242 |
def test_check_refname(self): |
243 |
self._refs._check_refname(b'HEAD') |
244 |
self._refs._check_refname(b'refs/stash') |
245 |
self._refs._check_refname(b'refs/heads/foo') |
246 |
|
247 |
self.assertRaises(errors.RefFormatError, self._refs._check_refname, |
248 |
b'refs')
|
249 |
self.assertRaises(errors.RefFormatError, self._refs._check_refname, |
250 |
b'notrefs/foo')
|
251 |
|
252 |
def test_contains(self): |
253 |
self.assertTrue(b'refs/heads/master' in self._refs) |
254 |
self.assertFalse(b'refs/heads/bar' in self._refs) |
255 |
|
256 |
def test_delitem(self): |
257 |
self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
258 |
self._refs[b'refs/heads/master']) |
259 |
del self._refs[b'refs/heads/master'] |
260 |
self.assertRaises(KeyError, lambda: self._refs[b'refs/heads/master']) |
261 |
|
262 |
def test_remove_if_equals(self): |
263 |
self.assertFalse(self._refs.remove_if_equals(b'HEAD', b'c0ffee')) |
264 |
self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
265 |
self._refs[b'HEAD']) |
266 |
self.assertTrue(self._refs.remove_if_equals( |
267 |
b'refs/tags/refs-0.2', b'3ec9c43c84ff242e3ef4a9fc5bc111fd780a76a8')) |
268 |
self.assertTrue(self._refs.remove_if_equals( |
269 |
b'refs/tags/refs-0.2', ZERO_SHA))
|
270 |
self.assertFalse(b'refs/tags/refs-0.2' in self._refs) |
271 |
|
272 |
|
273 |
class DictRefsContainerTests(RefsContainerTests, TestCase): |
274 |
|
275 |
def setUp(self): |
276 |
TestCase.setUp(self)
|
277 |
self._refs = DictRefsContainer(dict(_TEST_REFS)) |
278 |
|
279 |
def test_invalid_refname(self): |
280 |
# FIXME: Move this test into RefsContainerTests, but requires
|
281 |
# some way of injecting invalid refs.
|
282 |
self._refs._refs[b'refs/stash'] = b'00' * 20 |
283 |
expected_refs = dict(_TEST_REFS)
|
284 |
expected_refs[b'refs/stash'] = b'00' * 20 |
285 |
self.assertEqual(expected_refs, self._refs.as_dict()) |
286 |
|
287 |
|
288 |
class DiskRefsContainerTests(RefsContainerTests, TestCase): |
289 |
|
290 |
def setUp(self): |
291 |
TestCase.setUp(self)
|
292 |
self._repo = open_repo('refs.git') |
293 |
self.addCleanup(tear_down_repo, self._repo) |
294 |
self._refs = self._repo.refs |
295 |
|
296 |
def test_get_packed_refs(self): |
297 |
self.assertEqual({
|
298 |
b'refs/heads/packed': b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
299 |
b'refs/tags/refs-0.1': b'df6800012397fb85c56e7418dd4eb9405dee075c', |
300 |
}, self._refs.get_packed_refs())
|
301 |
|
302 |
def test_get_peeled_not_packed(self): |
303 |
# not packed
|
304 |
self.assertEqual(None, self._refs.get_peeled(b'refs/tags/refs-0.2')) |
305 |
self.assertEqual(b'3ec9c43c84ff242e3ef4a9fc5bc111fd780a76a8', |
306 |
self._refs[b'refs/tags/refs-0.2']) |
307 |
|
308 |
# packed, known not peelable
|
309 |
self.assertEqual(self._refs[b'refs/heads/packed'], |
310 |
self._refs.get_peeled(b'refs/heads/packed')) |
311 |
|
312 |
# packed, peeled
|
313 |
self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
314 |
self._refs.get_peeled(b'refs/tags/refs-0.1')) |
315 |
|
316 |
def test_setitem(self): |
317 |
RefsContainerTests.test_setitem(self)
|
318 |
f = open(os.path.join(self._refs.path, 'refs', 'some', 'ref'), 'rb') |
319 |
self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
320 |
f.read()[:40])
|
321 |
f.close() |
322 |
|
323 |
def test_setitem_symbolic(self): |
324 |
ones = b'1' * 40 |
325 |
self._refs[b'HEAD'] = ones |
326 |
self.assertEqual(ones, self._refs[b'HEAD']) |
327 |
|
328 |
# ensure HEAD was not modified
|
329 |
f = open(os.path.join(self._refs.path, 'HEAD'), 'rb') |
330 |
v = next(iter(f)).rstrip(b'\n\r') |
331 |
f.close() |
332 |
self.assertEqual(b'ref: refs/heads/master', v) |
333 |
|
334 |
# ensure the symbolic link was written through
|
335 |
f = open(os.path.join(self._refs.path, 'refs', 'heads', 'master'), 'rb') |
336 |
self.assertEqual(ones, f.read()[:40]) |
337 |
f.close() |
338 |
|
339 |
def test_set_if_equals(self): |
340 |
RefsContainerTests.test_set_if_equals(self)
|
341 |
|
342 |
# ensure symref was followed
|
343 |
self.assertEqual(b'9' * 40, self._refs[b'refs/heads/master']) |
344 |
|
345 |
# ensure lockfile was deleted
|
346 |
self.assertFalse(os.path.exists(
|
347 |
os.path.join(self._refs.path, 'refs', 'heads', 'master.lock'))) |
348 |
self.assertFalse(os.path.exists(
|
349 |
os.path.join(self._refs.path, 'HEAD.lock'))) |
350 |
|
351 |
def test_add_if_new_packed(self): |
352 |
# don't overwrite packed ref
|
353 |
self.assertFalse(self._refs.add_if_new(b'refs/tags/refs-0.1', |
354 |
b'9' * 40)) |
355 |
self.assertEqual(b'df6800012397fb85c56e7418dd4eb9405dee075c', |
356 |
self._refs[b'refs/tags/refs-0.1']) |
357 |
|
358 |
def test_add_if_new_symbolic(self): |
359 |
# Use an empty repo instead of the default.
|
360 |
repo_dir = os.path.join(tempfile.mkdtemp(), 'test')
|
361 |
os.makedirs(repo_dir) |
362 |
repo = Repo.init(repo_dir) |
363 |
self.addCleanup(tear_down_repo, repo)
|
364 |
refs = repo.refs |
365 |
|
366 |
nines = b'9' * 40 |
367 |
self.assertEqual(b'ref: refs/heads/master', refs.read_ref(b'HEAD')) |
368 |
self.assertFalse(b'refs/heads/master' in refs) |
369 |
self.assertTrue(refs.add_if_new(b'HEAD', nines)) |
370 |
self.assertEqual(b'ref: refs/heads/master', refs.read_ref(b'HEAD')) |
371 |
self.assertEqual(nines, refs[b'HEAD']) |
372 |
self.assertEqual(nines, refs[b'refs/heads/master']) |
373 |
self.assertFalse(refs.add_if_new(b'HEAD', b'1' * 40)) |
374 |
self.assertEqual(nines, refs[b'HEAD']) |
375 |
self.assertEqual(nines, refs[b'refs/heads/master']) |
376 |
|
377 |
def test_follow(self): |
378 |
self.assertEqual(([b'HEAD', b'refs/heads/master'], |
379 |
b'42d06bd4b77fed026b154d16493e5deab78f02ec'),
|
380 |
self._refs.follow(b'HEAD')) |
381 |
self.assertEqual(([b'refs/heads/master'], |
382 |
b'42d06bd4b77fed026b154d16493e5deab78f02ec'),
|
383 |
self._refs.follow(b'refs/heads/master')) |
384 |
self.assertRaises(KeyError, self._refs.follow, b'refs/heads/loop') |
385 |
|
386 |
def test_delitem(self): |
387 |
RefsContainerTests.test_delitem(self)
|
388 |
ref_file = os.path.join(self._refs.path, 'refs', 'heads', 'master') |
389 |
self.assertFalse(os.path.exists(ref_file))
|
390 |
self.assertFalse(b'refs/heads/master' in self._refs.get_packed_refs()) |
391 |
|
392 |
def test_delitem_symbolic(self): |
393 |
self.assertEqual(b'ref: refs/heads/master', |
394 |
self._refs.read_loose_ref(b'HEAD')) |
395 |
del self._refs[b'HEAD'] |
396 |
self.assertRaises(KeyError, lambda: self._refs[b'HEAD']) |
397 |
self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
398 |
self._refs[b'refs/heads/master']) |
399 |
self.assertFalse(os.path.exists(os.path.join(self._refs.path, 'HEAD'))) |
400 |
|
401 |
def test_remove_if_equals_symref(self): |
402 |
# HEAD is a symref, so shouldn't equal its dereferenced value
|
403 |
self.assertFalse(self._refs.remove_if_equals( |
404 |
b'HEAD', b'42d06bd4b77fed026b154d16493e5deab78f02ec')) |
405 |
self.assertTrue(self._refs.remove_if_equals( |
406 |
b'refs/heads/master', b'42d06bd4b77fed026b154d16493e5deab78f02ec')) |
407 |
self.assertRaises(KeyError, lambda: self._refs[b'refs/heads/master']) |
408 |
|
409 |
# HEAD is now a broken symref
|
410 |
self.assertRaises(KeyError, lambda: self._refs[b'HEAD']) |
411 |
self.assertEqual(b'ref: refs/heads/master', |
412 |
self._refs.read_loose_ref(b'HEAD')) |
413 |
|
414 |
self.assertFalse(os.path.exists(
|
415 |
os.path.join(self._refs.path, 'refs', 'heads', 'master.lock'))) |
416 |
self.assertFalse(os.path.exists(
|
417 |
os.path.join(self._refs.path, 'HEAD.lock'))) |
418 |
|
419 |
def test_remove_packed_without_peeled(self): |
420 |
refs_file = os.path.join(self._repo.path, 'packed-refs') |
421 |
f = GitFile(refs_file) |
422 |
refs_data = f.read() |
423 |
f.close() |
424 |
f = GitFile(refs_file, 'wb')
|
425 |
f.write(b'\n'.join(l for l in refs_data.split(b'\n') |
426 |
if not l or l[0] not in b'#^')) |
427 |
f.close() |
428 |
self._repo = Repo(self._repo.path) |
429 |
refs = self._repo.refs
|
430 |
self.assertTrue(refs.remove_if_equals(
|
431 |
b'refs/heads/packed', b'42d06bd4b77fed026b154d16493e5deab78f02ec')) |
432 |
|
433 |
def test_remove_if_equals_packed(self): |
434 |
# test removing ref that is only packed
|
435 |
self.assertEqual(b'df6800012397fb85c56e7418dd4eb9405dee075c', |
436 |
self._refs[b'refs/tags/refs-0.1']) |
437 |
self.assertTrue(
|
438 |
self._refs.remove_if_equals(
|
439 |
b'refs/tags/refs-0.1',
|
440 |
b'df6800012397fb85c56e7418dd4eb9405dee075c'))
|
441 |
self.assertRaises(KeyError, lambda: self._refs[b'refs/tags/refs-0.1']) |
442 |
|
443 |
def test_read_ref(self): |
444 |
self.assertEqual(b'ref: refs/heads/master', self._refs.read_ref(b'HEAD')) |
445 |
self.assertEqual(b'42d06bd4b77fed026b154d16493e5deab78f02ec', |
446 |
self._refs.read_ref(b'refs/heads/packed')) |
447 |
self.assertEqual(None, self._refs.read_ref(b'nonexistant')) |
448 |
|
449 |
def test_non_ascii(self): |
450 |
try:
|
451 |
encoded_ref = u'refs/tags/schön'.encode(sys.getfilesystemencoding())
|
452 |
except UnicodeEncodeError: |
453 |
raise SkipTest("filesystem encoding doesn't support special character") |
454 |
p = os.path.join(self._repo.path, 'refs', 'tags', u'schön') |
455 |
with open(p, 'w') as f: |
456 |
f.write('00' * 20) |
457 |
|
458 |
expected_refs = dict(_TEST_REFS)
|
459 |
expected_refs[encoded_ref] = b'00' * 20 |
460 |
|
461 |
self.assertEqual(expected_refs, self._repo.get_refs()) |
462 |
|
463 |
|
464 |
_TEST_REFS_SERIALIZED = ( |
465 |
b'42d06bd4b77fed026b154d16493e5deab78f02ec\trefs/heads/40-char-ref-aaaaaaaaaaaaaaaaaa\n'
|
466 |
b'42d06bd4b77fed026b154d16493e5deab78f02ec\trefs/heads/master\n'
|
467 |
b'42d06bd4b77fed026b154d16493e5deab78f02ec\trefs/heads/packed\n'
|
468 |
b'df6800012397fb85c56e7418dd4eb9405dee075c\trefs/tags/refs-0.1\n'
|
469 |
b'3ec9c43c84ff242e3ef4a9fc5bc111fd780a76a8\trefs/tags/refs-0.2\n')
|
470 |
|
471 |
|
472 |
class InfoRefsContainerTests(TestCase): |
473 |
|
474 |
def test_invalid_refname(self): |
475 |
text = _TEST_REFS_SERIALIZED + b'00' * 20 + b'\trefs/stash\n' |
476 |
refs = InfoRefsContainer(BytesIO(text)) |
477 |
expected_refs = dict(_TEST_REFS)
|
478 |
del expected_refs[b'HEAD'] |
479 |
expected_refs[b'refs/stash'] = b'00' * 20 |
480 |
self.assertEqual(expected_refs, refs.as_dict())
|
481 |
|
482 |
def test_keys(self): |
483 |
refs = InfoRefsContainer(BytesIO(_TEST_REFS_SERIALIZED)) |
484 |
actual_keys = set(refs.keys())
|
485 |
self.assertEqual(set(refs.allkeys()), actual_keys) |
486 |
# ignore the symref loop if it exists
|
487 |
actual_keys.discard(b'refs/heads/loop')
|
488 |
expected_refs = dict(_TEST_REFS)
|
489 |
del expected_refs[b'HEAD'] |
490 |
self.assertEqual(set(expected_refs.keys()), actual_keys) |
491 |
|
492 |
actual_keys = refs.keys(b'refs/heads')
|
493 |
actual_keys.discard(b'loop')
|
494 |
self.assertEqual(
|
495 |
[b'40-char-ref-aaaaaaaaaaaaaaaaaa', b'master', b'packed'], |
496 |
sorted(actual_keys))
|
497 |
self.assertEqual([b'refs-0.1', b'refs-0.2'], |
498 |
sorted(refs.keys(b'refs/tags'))) |
499 |
|
500 |
def test_as_dict(self): |
501 |
refs = InfoRefsContainer(BytesIO(_TEST_REFS_SERIALIZED)) |
502 |
# refs/heads/loop does not show up even if it exists
|
503 |
expected_refs = dict(_TEST_REFS)
|
504 |
del expected_refs[b'HEAD'] |
505 |
self.assertEqual(expected_refs, refs.as_dict())
|
506 |
|
507 |
def test_contains(self): |
508 |
refs = InfoRefsContainer(BytesIO(_TEST_REFS_SERIALIZED)) |
509 |
self.assertTrue(b'refs/heads/master' in refs) |
510 |
self.assertFalse(b'refs/heads/bar' in refs) |
511 |
|
512 |
def test_get_peeled(self): |
513 |
refs = InfoRefsContainer(BytesIO(_TEST_REFS_SERIALIZED)) |
514 |
# refs/heads/loop does not show up even if it exists
|
515 |
self.assertEqual(
|
516 |
_TEST_REFS[b'refs/heads/master'],
|
517 |
refs.get_peeled(b'refs/heads/master'))
|