1
2
3
4
5
6
7
8
9
10
11
12
13 package org.eclipse.jgit.transport;
14
15 import static org.junit.Assert.assertEquals;
16 import static org.junit.Assert.assertFalse;
17 import static org.junit.Assert.assertNotNull;
18 import static org.junit.Assert.assertNotSame;
19 import static org.junit.Assert.assertNull;
20 import static org.junit.Assert.assertSame;
21 import static org.junit.Assert.assertTrue;
22
23 import org.eclipse.jgit.lib.ObjectIdRef;
24 import org.eclipse.jgit.lib.Ref;
25 import org.eclipse.jgit.transport.RefSpec.WildcardMode;
26 import org.junit.Test;
27
28 public class RefSpecTest {
29 @Test
30 public void testMasterMaster() {
31 final String sn = "refs/heads/master";
32 final RefSpec rs = new RefSpec(sn + ":" + sn);
33 assertFalse(rs.isForceUpdate());
34 assertFalse(rs.isWildcard());
35 assertEquals(sn, rs.getSource());
36 assertEquals(sn, rs.getDestination());
37 assertEquals(sn + ":" + sn, rs.toString());
38 assertEquals(rs, new RefSpec(rs.toString()));
39
40 Ref r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, sn, null);
41 assertTrue(rs.matchSource(r));
42 assertTrue(rs.matchDestination(r));
43 assertSame(rs, rs.expandFromSource(r));
44
45 r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, sn + "-and-more", null);
46 assertFalse(rs.matchSource(r));
47 assertFalse(rs.matchDestination(r));
48 }
49
50 @Test
51 public void testSplitLastColon() {
52 final String lhs = ":m:a:i:n:t";
53 final String rhs = "refs/heads/maint";
54 final RefSpec rs = new RefSpec(lhs + ":" + rhs);
55 assertFalse(rs.isForceUpdate());
56 assertFalse(rs.isWildcard());
57 assertEquals(lhs, rs.getSource());
58 assertEquals(rhs, rs.getDestination());
59 assertEquals(lhs + ":" + rhs, rs.toString());
60 assertEquals(rs, new RefSpec(rs.toString()));
61 }
62
63 @Test
64 public void testForceMasterMaster() {
65 final String sn = "refs/heads/master";
66 final RefSpec rs = new RefSpec("+" + sn + ":" + sn);
67 assertTrue(rs.isForceUpdate());
68 assertFalse(rs.isWildcard());
69 assertEquals(sn, rs.getSource());
70 assertEquals(sn, rs.getDestination());
71 assertEquals("+" + sn + ":" + sn, rs.toString());
72 assertEquals(rs, new RefSpec(rs.toString()));
73
74 Ref r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, sn, null);
75 assertTrue(rs.matchSource(r));
76 assertTrue(rs.matchDestination(r));
77 assertSame(rs, rs.expandFromSource(r));
78
79 r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, sn + "-and-more", null);
80 assertFalse(rs.matchSource(r));
81 assertFalse(rs.matchDestination(r));
82 }
83
84 @Test
85 public void testMaster() {
86 final String sn = "refs/heads/master";
87 final RefSpec rs = new RefSpec(sn);
88 assertFalse(rs.isForceUpdate());
89 assertFalse(rs.isWildcard());
90 assertEquals(sn, rs.getSource());
91 assertNull(rs.getDestination());
92 assertEquals(sn, rs.toString());
93 assertEquals(rs, new RefSpec(rs.toString()));
94
95 Ref r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, sn, null);
96 assertTrue(rs.matchSource(r));
97 assertFalse(rs.matchDestination(r));
98 assertSame(rs, rs.expandFromSource(r));
99
100 r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, sn + "-and-more", null);
101 assertFalse(rs.matchSource(r));
102 assertFalse(rs.matchDestination(r));
103 }
104
105 @Test
106 public void testForceMaster() {
107 final String sn = "refs/heads/master";
108 final RefSpec rs = new RefSpec("+" + sn);
109 assertTrue(rs.isForceUpdate());
110 assertFalse(rs.isWildcard());
111 assertEquals(sn, rs.getSource());
112 assertNull(rs.getDestination());
113 assertEquals("+" + sn, rs.toString());
114 assertEquals(rs, new RefSpec(rs.toString()));
115
116 Ref r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, sn, null);
117 assertTrue(rs.matchSource(r));
118 assertFalse(rs.matchDestination(r));
119 assertSame(rs, rs.expandFromSource(r));
120
121 r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, sn + "-and-more", null);
122 assertFalse(rs.matchSource(r));
123 assertFalse(rs.matchDestination(r));
124 }
125
126 @Test
127 public void testDeleteMaster() {
128 final String sn = "refs/heads/master";
129 final RefSpec rs = new RefSpec(":" + sn);
130 assertFalse(rs.isForceUpdate());
131 assertFalse(rs.isWildcard());
132 assertNull(rs.getSource());
133 assertEquals(sn, rs.getDestination());
134 assertEquals(":" + sn, rs.toString());
135 assertEquals(rs, new RefSpec(rs.toString()));
136
137 Ref r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, sn, null);
138 assertFalse(rs.matchSource(r));
139 assertTrue(rs.matchDestination(r));
140 assertSame(rs, rs.expandFromSource(r));
141
142 r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, sn + "-and-more", null);
143 assertFalse(rs.matchSource(r));
144 assertFalse(rs.matchDestination(r));
145 }
146
147 @Test
148 public void testForceRemotesOrigin() {
149 final String srcn = "refs/heads/*";
150 final String dstn = "refs/remotes/origin/*";
151 final RefSpec rs = new RefSpec("+" + srcn + ":" + dstn);
152 assertTrue(rs.isForceUpdate());
153 assertTrue(rs.isWildcard());
154 assertEquals(srcn, rs.getSource());
155 assertEquals(dstn, rs.getDestination());
156 assertEquals("+" + srcn + ":" + dstn, rs.toString());
157 assertEquals(rs, new RefSpec(rs.toString()));
158
159 Ref r;
160 RefSpec expanded;
161
162 r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, "refs/heads/master", null);
163 assertTrue(rs.matchSource(r));
164 assertFalse(rs.matchDestination(r));
165 expanded = rs.expandFromSource(r);
166 assertNotSame(rs, expanded);
167 assertTrue(expanded.isForceUpdate());
168 assertFalse(expanded.isWildcard());
169 assertEquals(r.getName(), expanded.getSource());
170 assertEquals("refs/remotes/origin/master", expanded.getDestination());
171
172 r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, "refs/remotes/origin/next", null);
173 assertFalse(rs.matchSource(r));
174 assertTrue(rs.matchDestination(r));
175
176 r = new ObjectIdRef.Unpeeled(Ref.Storage.LOOSE, "refs/tags/v1.0", null);
177 assertFalse(rs.matchSource(r));
178 assertFalse(rs.matchDestination(r));
179 }
180
181 @Test
182 public void testCreateEmpty() {
183 final RefSpec rs = new RefSpec();
184 assertFalse(rs.isForceUpdate());
185 assertFalse(rs.isWildcard());
186 assertEquals("HEAD", rs.getSource());
187 assertNull(rs.getDestination());
188 assertEquals("HEAD", rs.toString());
189 }
190
191 @Test
192 public void testSetForceUpdate() {
193 final String s = "refs/heads/*:refs/remotes/origin/*";
194 final RefSpec a = new RefSpec(s);
195 assertFalse(a.isForceUpdate());
196 RefSpec b = a.setForceUpdate(true);
197 assertNotSame(a, b);
198 assertFalse(a.isForceUpdate());
199 assertTrue(b.isForceUpdate());
200 assertEquals(s, a.toString());
201 assertEquals("+" + s, b.toString());
202 }
203
204 @Test
205 public void testSetSource() {
206 final RefSpec a = new RefSpec();
207 final RefSpec b = a.setSource("refs/heads/master");
208 assertNotSame(a, b);
209 assertEquals("HEAD", a.toString());
210 assertEquals("refs/heads/master", b.toString());
211 }
212
213 @Test
214 public void testSetDestination() {
215 final RefSpec a = new RefSpec();
216 final RefSpec b = a.setDestination("refs/heads/master");
217 assertNotSame(a, b);
218 assertEquals("HEAD", a.toString());
219 assertEquals("HEAD:refs/heads/master", b.toString());
220 }
221
222 @Test
223 public void testSetDestination_SourceNull() {
224 final RefSpec a = new RefSpec();
225 RefSpec b;
226
227 b = a.setDestination("refs/heads/master");
228 b = b.setSource(null);
229 assertNotSame(a, b);
230 assertEquals("HEAD", a.toString());
231 assertEquals(":refs/heads/master", b.toString());
232 }
233
234 @Test
235 public void testSetSourceDestination() {
236 final RefSpec a = new RefSpec();
237 final RefSpec b;
238 b = a.setSourceDestination("refs/heads/*", "refs/remotes/origin/*");
239 assertNotSame(a, b);
240 assertEquals("HEAD", a.toString());
241 assertEquals("refs/heads/*:refs/remotes/origin/*", b.toString());
242 }
243
244 @Test
245 public void testExpandFromDestination_NonWildcard() {
246 final String src = "refs/heads/master";
247 final String dst = "refs/remotes/origin/master";
248 final RefSpec a = new RefSpec(src + ":" + dst);
249 final RefSpec r = a.expandFromDestination(dst);
250 assertSame(a, r);
251 assertFalse(r.isWildcard());
252 assertEquals(src, r.getSource());
253 assertEquals(dst, r.getDestination());
254 }
255
256 @Test
257 public void testExpandFromDestination_Wildcard() {
258 final String src = "refs/heads/master";
259 final String dst = "refs/remotes/origin/master";
260 final RefSpec a = new RefSpec("refs/heads/*:refs/remotes/origin/*");
261 final RefSpec r = a.expandFromDestination(dst);
262 assertNotSame(a, r);
263 assertFalse(r.isWildcard());
264 assertEquals(src, r.getSource());
265 assertEquals(dst, r.getDestination());
266 }
267
268 @Test
269 public void isWildcardShouldWorkForWildcardSuffixAndComponent() {
270 assertTrue(RefSpec.isWildcard("refs/heads/*"));
271 assertTrue(RefSpec.isWildcard("refs/pull/*/head"));
272 assertFalse(RefSpec.isWildcard("refs/heads/a"));
273 }
274
275 @Test
276 public void testWildcardInMiddleOfSource() {
277 RefSpec a = new RefSpec("+refs/pull/*/head:refs/remotes/origin/pr/*");
278 assertTrue(a.isWildcard());
279 assertTrue(a.matchSource("refs/pull/a/head"));
280 assertTrue(a.matchSource("refs/pull/foo/head"));
281 assertTrue(a.matchSource("refs/pull/foo/bar/head"));
282 assertFalse(a.matchSource("refs/pull/foo"));
283 assertFalse(a.matchSource("refs/pull/head"));
284 assertFalse(a.matchSource("refs/pull/foo/head/more"));
285 assertFalse(a.matchSource("refs/pullx/head"));
286
287 RefSpec b = a.expandFromSource("refs/pull/foo/head");
288 assertEquals("refs/remotes/origin/pr/foo", b.getDestination());
289 RefSpec c = a.expandFromDestination("refs/remotes/origin/pr/foo");
290 assertEquals("refs/pull/foo/head", c.getSource());
291 }
292
293 @Test
294 public void testWildcardInMiddleOfDestionation() {
295 RefSpec a = new RefSpec("+refs/heads/*:refs/remotes/origin/*/head");
296 assertTrue(a.isWildcard());
297 assertTrue(a.matchDestination("refs/remotes/origin/a/head"));
298 assertTrue(a.matchDestination("refs/remotes/origin/foo/head"));
299 assertTrue(a.matchDestination("refs/remotes/origin/foo/bar/head"));
300 assertFalse(a.matchDestination("refs/remotes/origin/foo"));
301 assertFalse(a.matchDestination("refs/remotes/origin/head"));
302 assertFalse(a.matchDestination("refs/remotes/origin/foo/head/more"));
303 assertFalse(a.matchDestination("refs/remotes/originx/head"));
304
305 RefSpec b = a.expandFromSource("refs/heads/foo");
306 assertEquals("refs/remotes/origin/foo/head", b.getDestination());
307 RefSpec c = a.expandFromDestination("refs/remotes/origin/foo/head");
308 assertEquals("refs/heads/foo", c.getSource());
309 }
310
311 @Test
312 public void testWildcardAfterText1() {
313 RefSpec a = new RefSpec("refs/heads/*/for-linus:refs/remotes/mine/*-blah");
314 assertTrue(a.isWildcard());
315 assertTrue(a.matchDestination("refs/remotes/mine/x-blah"));
316 assertTrue(a.matchDestination("refs/remotes/mine/foo-blah"));
317 assertTrue(a.matchDestination("refs/remotes/mine/foo/x-blah"));
318 assertFalse(a.matchDestination("refs/remotes/origin/foo/x-blah"));
319
320 RefSpec b = a.expandFromSource("refs/heads/foo/for-linus");
321 assertEquals("refs/remotes/mine/foo-blah", b.getDestination());
322 RefSpec c = a.expandFromDestination("refs/remotes/mine/foo-blah");
323 assertEquals("refs/heads/foo/for-linus", c.getSource());
324 }
325
326 @Test
327 public void testWildcardAfterText2() {
328 RefSpec a = new RefSpec("refs/heads*/for-linus:refs/remotes/mine/*");
329 assertTrue(a.isWildcard());
330 assertTrue(a.matchSource("refs/headsx/for-linus"));
331 assertTrue(a.matchSource("refs/headsfoo/for-linus"));
332 assertTrue(a.matchSource("refs/headsx/foo/for-linus"));
333 assertFalse(a.matchSource("refs/headx/for-linus"));
334
335 RefSpec b = a.expandFromSource("refs/headsx/for-linus");
336 assertEquals("refs/remotes/mine/x", b.getDestination());
337 RefSpec c = a.expandFromDestination("refs/remotes/mine/x");
338 assertEquals("refs/headsx/for-linus", c.getSource());
339
340 RefSpec d = a.expandFromSource("refs/headsx/foo/for-linus");
341 assertEquals("refs/remotes/mine/x/foo", d.getDestination());
342 RefSpec e = a.expandFromDestination("refs/remotes/mine/x/foo");
343 assertEquals("refs/headsx/foo/for-linus", e.getSource());
344 }
345
346 @Test
347 public void testWildcardMirror() {
348 RefSpec a = new RefSpec("*:*");
349 assertTrue(a.isWildcard());
350 assertTrue(a.matchSource("a"));
351 assertTrue(a.matchSource("foo"));
352 assertTrue(a.matchSource("foo/bar"));
353 assertTrue(a.matchDestination("a"));
354 assertTrue(a.matchDestination("foo"));
355 assertTrue(a.matchDestination("foo/bar"));
356
357 RefSpec b = a.expandFromSource("refs/heads/foo");
358 assertEquals("refs/heads/foo", b.getDestination());
359 RefSpec c = a.expandFromDestination("refs/heads/foo");
360 assertEquals("refs/heads/foo", c.getSource());
361 }
362
363 @Test
364 public void testWildcardAtStart() {
365 RefSpec a = new RefSpec("*/head:refs/heads/*");
366 assertTrue(a.isWildcard());
367 assertTrue(a.matchSource("a/head"));
368 assertTrue(a.matchSource("foo/head"));
369 assertTrue(a.matchSource("foo/bar/head"));
370 assertFalse(a.matchSource("/head"));
371 assertFalse(a.matchSource("a/head/extra"));
372
373 RefSpec b = a.expandFromSource("foo/head");
374 assertEquals("refs/heads/foo", b.getDestination());
375 RefSpec c = a.expandFromDestination("refs/heads/foo");
376 assertEquals("foo/head", c.getSource());
377 }
378
379 @Test(expected = IllegalArgumentException.class)
380 public void invalidWhenSourceEndsWithSlash() {
381 assertNotNull(new RefSpec("refs/heads/"));
382 }
383
384 @Test(expected = IllegalArgumentException.class)
385 public void invalidWhenDestinationEndsWithSlash() {
386 assertNotNull(new RefSpec("refs/heads/master:refs/heads/"));
387 }
388
389 @Test(expected = IllegalArgumentException.class)
390 public void invalidWhenSourceOnlyAndWildcard() {
391 assertNotNull(new RefSpec("refs/heads/*"));
392 }
393
394 @Test(expected = IllegalArgumentException.class)
395 public void invalidWhenDestinationOnlyAndWildcard() {
396 assertNotNull(new RefSpec(":refs/heads/*"));
397 }
398
399 @Test(expected = IllegalArgumentException.class)
400 public void invalidWhenOnlySourceWildcard() {
401 assertNotNull(new RefSpec("refs/heads/*:refs/heads/foo"));
402 }
403
404 @Test(expected = IllegalArgumentException.class)
405 public void invalidWhenOnlyDestinationWildcard() {
406 assertNotNull(new RefSpec("refs/heads/foo:refs/heads/*"));
407 }
408
409 @Test(expected = IllegalArgumentException.class)
410 public void invalidWhenMoreThanOneWildcardInSource() {
411 assertNotNull(new RefSpec("refs/heads/*/*:refs/heads/*"));
412 }
413
414 @Test(expected = IllegalArgumentException.class)
415 public void invalidWhenMoreThanOneWildcardInDestination() {
416 assertNotNull(new RefSpec("refs/heads/*:refs/heads/*/*"));
417 }
418
419 @Test(expected = IllegalArgumentException.class)
420 public void invalidSourceDoubleSlashes() {
421 assertNotNull(new RefSpec("refs/heads//wrong"));
422 }
423
424 @Test(expected = IllegalArgumentException.class)
425 public void invalidSlashAtStart() {
426 assertNotNull(new RefSpec("/foo:/foo"));
427 }
428
429 @Test(expected = IllegalArgumentException.class)
430 public void invalidDestinationDoubleSlashes() {
431 assertNotNull(new RefSpec(":refs/heads//wrong"));
432 }
433
434 @Test(expected = IllegalArgumentException.class)
435 public void invalidSetSource() {
436 RefSpec a = new RefSpec("refs/heads/*:refs/remotes/origin/*");
437 a.setSource("refs/heads/*/*");
438 }
439
440 @Test(expected = IllegalArgumentException.class)
441 public void invalidSetDestination() {
442 RefSpec a = new RefSpec("refs/heads/*:refs/remotes/origin/*");
443 a.setDestination("refs/remotes/origin/*/*");
444 }
445
446 @Test
447 public void sourceOnlywithWildcard() {
448 RefSpec a = new RefSpec("refs/heads/*",
449 WildcardMode.ALLOW_MISMATCH);
450 assertTrue(a.matchSource("refs/heads/master"));
451 assertNull(a.getDestination());
452 }
453
454 @Test
455 public void destinationWithWildcard() {
456 RefSpec a = new RefSpec("refs/heads/master:refs/heads/*",
457 WildcardMode.ALLOW_MISMATCH);
458 assertTrue(a.matchSource("refs/heads/master"));
459 assertTrue(a.matchDestination("refs/heads/master"));
460 assertTrue(a.matchDestination("refs/heads/foo"));
461 }
462
463 @Test
464 public void onlyWildCard() {
465 RefSpec a = new RefSpec("*", WildcardMode.ALLOW_MISMATCH);
466 assertTrue(a.matchSource("refs/heads/master"));
467 assertNull(a.getDestination());
468 }
469 }