View Javadoc

1   package org.apache.maven.wagon;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
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 }