1 package org.apache.maven.wagon;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.io.File;
23 import java.io.IOException;
24 import java.io.InputStream;
25 import java.text.SimpleDateFormat;
26
27 import junit.framework.TestCase;
28
29 import org.apache.maven.wagon.authentication.AuthenticationException;
30 import org.apache.maven.wagon.authorization.AuthorizationException;
31 import org.apache.maven.wagon.events.TransferEvent;
32 import org.apache.maven.wagon.events.TransferListener;
33 import org.apache.maven.wagon.repository.Repository;
34 import org.apache.maven.wagon.resource.Resource;
35 import org.codehaus.plexus.util.FileUtils;
36 import org.codehaus.plexus.util.IOUtil;
37 import org.codehaus.plexus.util.StringInputStream;
38 import org.codehaus.plexus.util.StringOutputStream;
39 import org.easymock.MockControl;
40
41 public class StreamWagonTest
42 extends TestCase
43 {
44 private static class TestWagon
45 extends StreamWagon
46 {
47 public void closeConnection()
48 throws ConnectionException
49 {
50 }
51
52 public void fillInputData( InputData inputData )
53 throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException
54 {
55 }
56
57 public void fillOutputData( OutputData outputData )
58 throws TransferFailedException
59 {
60 }
61
62 protected void openConnectionInternal()
63 throws ConnectionException, AuthenticationException
64 {
65 }
66 }
67
68 private Repository repository = new Repository( "id", "url" );
69
70 public void testNullInputStream()
71 throws Exception
72 {
73 StreamingWagon wagon = new TestWagon()
74 {
75 public void fillInputData( InputData inputData )
76 {
77 inputData.setInputStream( null );
78 }
79 };
80
81 MockControl control = MockControl.createControl( TransferListener.class );
82 TransferListener listener = (TransferListener) control.getMock();
83 listener.transferInitiated( null );
84 control.setMatcher( MockControl.ALWAYS_MATCHER );
85 TransferEvent transferEvent =
86 new TransferEvent( wagon, new Resource( "resource" ), new TransferFailedException( "" ),
87 TransferEvent.REQUEST_GET );
88 listener.transferError( transferEvent );
89 control.replay();
90
91 wagon.connect( repository );
92 wagon.addTransferListener( listener );
93 try
94 {
95 wagon.getToStream( "resource", new StringOutputStream() );
96 fail();
97 }
98 catch ( TransferFailedException e )
99 {
100 assertTrue( true );
101 }
102 finally
103 {
104 wagon.disconnect();
105 }
106
107 control.verify();
108 }
109
110 public void testNullOutputStream()
111 throws Exception
112 {
113 StreamingWagon wagon = new TestWagon()
114 {
115 public void fillOutputData( OutputData inputData )
116 {
117 inputData.setOutputStream( null );
118 }
119 };
120
121 MockControl control = MockControl.createControl( TransferListener.class );
122 TransferListener listener = (TransferListener) control.getMock();
123 listener.transferInitiated( null );
124 control.setMatcher( MockControl.ALWAYS_MATCHER );
125 TransferEvent transferEvent =
126 new TransferEvent( wagon, new Resource( "resource" ), new TransferFailedException( "" ),
127 TransferEvent.REQUEST_PUT );
128 listener.transferError( transferEvent );
129 control.replay();
130
131 wagon.connect( repository );
132 wagon.addTransferListener( listener );
133 try
134 {
135 wagon.putFromStream( new StringInputStream( "" ), "resource" );
136 fail();
137 }
138 catch ( TransferFailedException e )
139 {
140 assertTrue( true );
141 }
142 finally
143 {
144 wagon.disconnect();
145 }
146
147 control.verify();
148 }
149
150 public void testTransferFailedExceptionOnInput()
151 throws Exception
152 {
153 try
154 {
155 runTestTransferError( new TransferFailedException( "" ) );
156 fail();
157 }
158 catch ( TransferFailedException e )
159 {
160 assertTrue( true );
161 }
162 }
163
164 public void testTransferFailedExceptionOnOutput()
165 throws Exception
166 {
167 StreamingWagon wagon = new TestWagon()
168 {
169 public void fillOutputData( OutputData inputData )
170 throws TransferFailedException
171 {
172 throw (TransferFailedException) new TransferFailedException( "" );
173 }
174 };
175
176 MockControl control = MockControl.createControl( TransferListener.class );
177 TransferListener listener = (TransferListener) control.getMock();
178 listener.transferInitiated( null );
179 control.setMatcher( MockControl.ALWAYS_MATCHER );
180 TransferEvent transferEvent =
181 new TransferEvent( wagon, new Resource( "resource" ), new TransferFailedException( "" ),
182 TransferEvent.REQUEST_PUT );
183 listener.transferError( transferEvent );
184 control.replay();
185
186 wagon.connect( repository );
187 wagon.addTransferListener( listener );
188 try
189 {
190 wagon.putFromStream( new StringInputStream( "" ), "resource" );
191 fail();
192 }
193 catch ( TransferFailedException e )
194 {
195 assertTrue( true );
196 }
197 finally
198 {
199 wagon.disconnect();
200 control.verify();
201 }
202 }
203
204 public void testResourceDoesNotExistException()
205 throws Exception
206 {
207 try
208 {
209 runTestTransferError( new ResourceDoesNotExistException( "" ) );
210 fail();
211 }
212 catch ( ResourceDoesNotExistException e )
213 {
214 assertTrue( true );
215 }
216 }
217
218 public void testAuthorizationException()
219 throws Exception
220 {
221 try
222 {
223 runTestTransferError( new AuthorizationException( "" ) );
224 fail();
225 }
226 catch ( AuthorizationException e )
227 {
228 assertTrue( true );
229 }
230 }
231
232 private void runTestTransferError( final WagonException exception )
233 throws ConnectionException, AuthenticationException, ResourceDoesNotExistException, AuthorizationException,
234 TransferFailedException
235 {
236 StreamingWagon wagon = new TestWagon()
237 {
238 public void fillInputData( InputData inputData )
239 throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException
240 {
241 if ( exception instanceof TransferFailedException )
242 {
243 throw (TransferFailedException) exception;
244 }
245 if ( exception instanceof ResourceDoesNotExistException )
246 {
247 throw (ResourceDoesNotExistException) exception;
248 }
249 if ( exception instanceof AuthorizationException )
250 {
251 throw (AuthorizationException) exception;
252 }
253 }
254 };
255
256 MockControl control = MockControl.createControl( TransferListener.class );
257 TransferListener listener = (TransferListener) control.getMock();
258 listener.transferInitiated( null );
259 control.setMatcher( MockControl.ALWAYS_MATCHER );
260 TransferEvent transferEvent =
261 new TransferEvent( wagon, new Resource( "resource" ), exception, TransferEvent.REQUEST_GET );
262 listener.transferError( transferEvent );
263 control.replay();
264
265 wagon.connect( repository );
266 wagon.addTransferListener( listener );
267 try
268 {
269 wagon.getToStream( "resource", new StringOutputStream() );
270 fail();
271 }
272 finally
273 {
274 wagon.disconnect();
275 control.verify();
276 }
277 }
278
279 public void testGetIfNewerWithNewerResource()
280 throws Exception
281 {
282 long resourceTime = System.currentTimeMillis();
283 long comparisonTime = new SimpleDateFormat( "yyyy-MM-dd" ).parse( "2008-01-01" ).getTime();
284 assertTrue( runTestGetIfNewer( resourceTime, comparisonTime ) );
285 }
286
287 public void testGetIfNewerWithOlderResource()
288 throws Exception
289 {
290 long comparisonTime = System.currentTimeMillis();
291 long resourceTime = new SimpleDateFormat( "yyyy-MM-dd" ).parse( "2008-01-01" ).getTime();
292 assertFalse( runTestGetIfNewer( resourceTime, comparisonTime ) );
293 }
294
295 public void testGetIfNewerWithSameTimeResource()
296 throws Exception
297 {
298 long resourceTime = new SimpleDateFormat( "yyyy-MM-dd" ).parse( "2008-01-01" ).getTime();
299 assertFalse( runTestGetIfNewer( resourceTime, resourceTime ) );
300 }
301
302 private boolean runTestGetIfNewer( final long resourceTime, long comparisonTime )
303 throws IOException, ConnectionException, AuthenticationException, TransferFailedException,
304 ResourceDoesNotExistException, AuthorizationException
305 {
306 StreamingWagon wagon = new TestWagon()
307 {
308 public void fillInputData( InputData inputData )
309 {
310 inputData.setInputStream( new StringInputStream( "" ) );
311 inputData.getResource().setLastModified( resourceTime );
312 }
313 };
314
315 File tempFile = File.createTempFile( "wagon", "tmp" );
316 tempFile.deleteOnExit();
317
318 wagon.connect( repository );
319 try
320 {
321 return wagon.getIfNewer( "resource", tempFile, comparisonTime );
322 }
323 finally
324 {
325 wagon.disconnect();
326 tempFile.delete();
327 }
328 }
329
330 public void testGetToStream()
331 throws Exception
332 {
333 final String content = "the content to return";
334 final long comparisonTime = new SimpleDateFormat( "yyyy-MM-dd" ).parse( "2008-01-01" ).getTime();
335 StreamingWagon wagon = new TestWagon()
336 {
337 public void fillInputData( InputData inputData )
338 {
339 inputData.setInputStream( new StringInputStream( content ) );
340 inputData.getResource().setLastModified( comparisonTime );
341 }
342 };
343
344 wagon.connect( repository );
345 try
346 {
347 StringOutputStream out = new StringOutputStream();
348 wagon.getToStream( "resource", out );
349 assertEquals( content, out.toString() );
350 }
351 finally
352 {
353 wagon.disconnect();
354 }
355 }
356
357 public void testGet()
358 throws Exception
359 {
360 final String content = "the content to return";
361 final long comparisonTime = new SimpleDateFormat( "yyyy-MM-dd" ).parse( "2008-01-01" ).getTime();
362 StreamingWagon wagon = new TestWagon()
363 {
364 public void fillInputData( InputData inputData )
365 {
366 inputData.setInputStream( new StringInputStream( content ) );
367 inputData.getResource().setLastModified( comparisonTime );
368 }
369 };
370
371 File tempFile = File.createTempFile( "wagon", "tmp" );
372 tempFile.deleteOnExit();
373
374 wagon.connect( repository );
375 try
376 {
377 wagon.get( "resource", tempFile );
378 assertEquals( content, FileUtils.fileRead( tempFile ) );
379 }
380 finally
381 {
382 wagon.disconnect();
383 tempFile.delete();
384 }
385 }
386
387 public void testGetIfNewerToStreamWithNewerResource()
388 throws Exception
389 {
390 long resourceTime = System.currentTimeMillis();
391 long comparisonTime = new SimpleDateFormat( "yyyy-MM-dd" ).parse( "2008-01-01" ).getTime();
392 assertTrue( runTestGetIfNewerToStream( resourceTime, comparisonTime ) );
393 }
394
395 public void testGetIfNewerToStreamWithOlderResource()
396 throws Exception
397 {
398 long comparisonTime = System.currentTimeMillis();
399 long resourceTime = new SimpleDateFormat( "yyyy-MM-dd" ).parse( "2008-01-01" ).getTime();
400 assertFalse( runTestGetIfNewerToStream( resourceTime, comparisonTime ) );
401 }
402
403 public void testGetIfNewerToStreamWithSameTimeResource()
404 throws Exception
405 {
406 long resourceTime = new SimpleDateFormat( "yyyy-MM-dd" ).parse( "2008-01-01" ).getTime();
407 assertFalse( runTestGetIfNewerToStream( resourceTime, resourceTime ) );
408 }
409
410 private boolean runTestGetIfNewerToStream( final long resourceTime, long comparisonTime )
411 throws IOException, ConnectionException, AuthenticationException, TransferFailedException,
412 ResourceDoesNotExistException, AuthorizationException
413 {
414 StreamingWagon wagon = new TestWagon()
415 {
416 public void fillInputData( InputData inputData )
417 {
418 inputData.setInputStream( new StringInputStream( "" ) );
419 inputData.getResource().setLastModified( resourceTime );
420 }
421 };
422
423 wagon.connect( repository );
424 try
425 {
426 return wagon.getIfNewerToStream( "resource", new StringOutputStream(), comparisonTime );
427 }
428 finally
429 {
430 wagon.disconnect();
431 }
432 }
433
434 public void testPutFromStream()
435 throws Exception
436 {
437 final String content = "the content to return";
438
439 final StringOutputStream out = new StringOutputStream();
440 StreamingWagon wagon = new TestWagon()
441 {
442 public void fillOutputData( OutputData outputData )
443 {
444 assertEquals( "resource", outputData.getResource().getName() );
445 assertEquals( -1, outputData.getResource().getContentLength() );
446 assertEquals( 0, outputData.getResource().getLastModified() );
447 outputData.setOutputStream( out );
448 }
449 };
450
451 wagon.connect( repository );
452 try
453 {
454 wagon.putFromStream( new StringInputStream( content ), "resource" );
455 assertEquals( content, out.toString() );
456 }
457 finally
458 {
459 wagon.disconnect();
460 }
461 }
462
463 public void testPutFromStreamWithResourceInformation()
464 throws Exception
465 {
466 final String content = "the content to return";
467 final long lastModified = System.currentTimeMillis();
468
469 final StringOutputStream out = new StringOutputStream();
470 StreamingWagon wagon = new TestWagon()
471 {
472 public void fillOutputData( OutputData outputData )
473 {
474 assertEquals( "resource", outputData.getResource().getName() );
475 assertEquals( content.length(), outputData.getResource().getContentLength() );
476 assertEquals( lastModified, outputData.getResource().getLastModified() );
477 outputData.setOutputStream( out );
478 }
479 };
480
481 wagon.connect( repository );
482 try
483 {
484 wagon.putFromStream( new StringInputStream( content ), "resource", content.length(), lastModified );
485 assertEquals( content, out.toString() );
486 }
487 finally
488 {
489 wagon.disconnect();
490 }
491 }
492
493 public void testPut()
494 throws Exception
495 {
496 final String content = "the content to return";
497
498 final File tempFile = File.createTempFile( "wagon", "tmp" );
499 FileUtils.fileWrite( tempFile.getAbsolutePath(), content );
500 tempFile.deleteOnExit();
501
502 final StringOutputStream out = new StringOutputStream();
503 Wagon wagon = new TestWagon()
504 {
505 public void fillOutputData( OutputData outputData )
506 {
507 assertEquals( "resource", outputData.getResource().getName() );
508 assertEquals( content.length(), outputData.getResource().getContentLength() );
509 assertEquals( tempFile.lastModified(), outputData.getResource().getLastModified() );
510 outputData.setOutputStream( out );
511 }
512 };
513
514 wagon.connect( repository );
515 try
516 {
517 wagon.put( tempFile, "resource" );
518 assertEquals( content, out.toString() );
519 }
520 finally
521 {
522 wagon.disconnect();
523 tempFile.delete();
524 }
525 }
526
527 public void testPutFileDoesntExist()
528 throws Exception
529 {
530 final File tempFile = File.createTempFile( "wagon", "tmp" );
531 tempFile.delete();
532 assertFalse( tempFile.exists() );
533
534 Wagon wagon = new TestWagon();
535
536 wagon.connect( repository );
537 try
538 {
539 wagon.put( tempFile, "resource" );
540 fail();
541 }
542 catch ( TransferFailedException e )
543 {
544 assertTrue( true );
545 }
546 finally
547 {
548 wagon.disconnect();
549 }
550 }
551
552 }