View Javadoc
1   package org.apache.maven.plugins.assembly.archive.archiver;
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 static org.hamcrest.Matchers.is;
23  import static org.junit.Assert.assertEquals;
24  import static org.junit.Assert.assertNotNull;
25  import static org.junit.Assert.assertThat;
26  import static org.junit.Assert.assertTrue;
27  import static org.mockito.Mockito.mock;
28  import static org.mockito.Mockito.verify;
29  import static org.mockito.Mockito.when;
30  
31  import java.io.File;
32  import java.io.IOException;
33  import java.nio.charset.StandardCharsets;
34  import java.nio.file.Files;
35  import java.util.ArrayList;
36  import java.util.Arrays;
37  import java.util.List;
38  
39  import javax.annotation.Nonnull;
40  
41  import org.codehaus.plexus.archiver.Archiver;
42  import org.codehaus.plexus.archiver.ArchiverException;
43  import org.codehaus.plexus.archiver.FileSet;
44  import org.codehaus.plexus.archiver.diags.TrackingArchiver;
45  import org.codehaus.plexus.archiver.jar.JarArchiver;
46  import org.codehaus.plexus.archiver.util.DefaultFileSet;
47  import org.codehaus.plexus.components.io.fileselectors.FileInfo;
48  import org.codehaus.plexus.components.io.fileselectors.FileSelector;
49  import org.codehaus.plexus.components.io.functions.InputStreamTransformer;
50  import org.codehaus.plexus.logging.Logger;
51  import org.codehaus.plexus.logging.console.ConsoleLogger;
52  import org.junit.Rule;
53  import org.junit.Test;
54  import org.junit.rules.TemporaryFolder;
55  import org.junit.runner.RunWith;
56  import org.mockito.ArgumentCaptor;
57  import org.mockito.junit.MockitoJUnitRunner;
58  
59  @RunWith( MockitoJUnitRunner.class )
60  public class AssemblyProxyArchiverTest
61  {
62      @Rule
63      public TemporaryFolder temporaryFolder = new TemporaryFolder();
64      
65      private static final Logger logger = new ConsoleLogger( Logger.LEVEL_DEBUG, "test" );
66  
67      @Test( timeout = 5000 )
68      public void addFileSet_SkipWhenSourceIsAssemblyWorkDir()
69          throws IOException, ArchiverException
70      {
71          final File sources = temporaryFolder.getRoot();
72  
73          final File workdir = new File( sources, "workdir" );
74  
75          final TrackingArchiver tracker = new TrackingArchiver();
76          final AssemblyProxyArchiver archiver =
77              new AssemblyProxyArchiver( "", tracker, null, null, null, workdir, logger );
78  
79          archiver.setForced( true );
80  
81          final DefaultFileSet fs = new DefaultFileSet();
82          fs.setDirectory( workdir );
83  
84          archiver.addFileSet( fs );
85  
86          assertTrue( tracker.added.isEmpty() );
87      }
88  
89      @Test( timeout = 5000 )
90      public void addFileSet_addExcludeWhenSourceContainsAssemblyWorkDir()
91          throws IOException, ArchiverException
92      {
93          final File sources = temporaryFolder.getRoot();
94  
95          final File workdir = new File( sources, "workdir" );
96          workdir.mkdir();
97  
98          Files.write( sources.toPath().resolve( "test-included.txt" ), Arrays.asList( "This is included" ),
99                       StandardCharsets.UTF_8 );
100         Files.write( workdir.toPath().resolve( "test-excluded.txt" ), Arrays.asList( "This is excluded" ),
101                      StandardCharsets.UTF_8 );
102 
103         final TrackingArchiver tracker = new TrackingArchiver();
104         final AssemblyProxyArchiver archiver =
105             new AssemblyProxyArchiver( "", tracker, null, null, null, workdir, logger );
106 
107         archiver.setForced( true );
108 
109         final DefaultFileSet fs = new DefaultFileSet();
110         fs.setDirectory( sources );
111 
112         archiver.addFileSet( fs );
113 
114         assertEquals( 1, tracker.added.size() );
115 
116         final TrackingArchiver.Addition addition = tracker.added.get( 0 );
117         assertNotNull( addition.excludes );
118         assertEquals( 1, addition.excludes.length );
119         assertEquals( workdir.getName(), addition.excludes[0] );
120     }
121 
122     @Test
123     public void addFile_NoPerms_CallAcceptFilesOnlyOnce()
124         throws IOException, ArchiverException
125     {
126         final Archiver delegate = mock( Archiver.class );
127 
128         final CounterSelector counter = new CounterSelector( true );
129         final List<FileSelector> selectors = new ArrayList<>();
130         selectors.add( counter );
131 
132         final AssemblyProxyArchiver archiver =
133             new AssemblyProxyArchiver( "", delegate, null, selectors, null, new File( "." ),
134                                        new ConsoleLogger( Logger.LEVEL_DEBUG, "test" ) );
135         archiver.setForced( true );
136 
137         final File inputFile = temporaryFolder.newFile();
138         archiver.addFile( inputFile, "file.txt" );
139 
140         assertEquals( 1, counter.getCount() );
141         verify( delegate ).addFile( inputFile, "file.txt" );
142         verify( delegate ).setForced( true );
143     }
144 
145     @Test
146     public void addDirectory_NoPerms_CallAcceptFilesOnlyOnce()
147         throws IOException, ArchiverException
148     {
149         final Archiver delegate = new JarArchiver();
150 
151         final File output = temporaryFolder.newFile();
152 
153         delegate.setDestFile( output );
154 
155         final CounterSelector counter = new CounterSelector( true );
156         final List<FileSelector> selectors = new ArrayList<>();
157         selectors.add( counter );
158 
159         final AssemblyProxyArchiver archiver =
160             new AssemblyProxyArchiver( "", delegate, null, selectors, null, new File( "." ),
161                                        new ConsoleLogger( Logger.LEVEL_DEBUG, "test" ) );
162 
163         archiver.setForced( true );
164 
165         final File dir = temporaryFolder.newFolder();
166         Files.write( dir.toPath().resolve( "file.txt" ), Arrays.asList( "This is a test." ), StandardCharsets.UTF_8 );
167 
168         archiver.addDirectory( dir );
169 
170         archiver.createArchive();
171 
172         assertEquals( 1, counter.getCount() );
173     }
174     
175     @Test
176     public void assemblyWorkDir() 
177     {
178         final Archiver delegate = mock( Archiver.class );
179         final List<FileSelector> selectors = new ArrayList<>();
180 
181         final AssemblyProxyArchiver archiver =
182             new AssemblyProxyArchiver( "prefix", delegate, null, selectors, null,
183                                        new File( temporaryFolder.getRoot(), "module1" ),
184                                        new ConsoleLogger( Logger.LEVEL_DEBUG, "test" ) );
185         
186         FileSet fileSet = mock( FileSet.class );
187         when( fileSet.getDirectory() ).thenReturn( temporaryFolder.getRoot() ); 
188         when( fileSet.getStreamTransformer() ).thenReturn( mock( InputStreamTransformer.class ) );
189         
190         archiver.addFileSet( fileSet );
191 
192         ArgumentCaptor<FileSet> delFileSet = ArgumentCaptor.forClass( FileSet.class );
193         verify( delegate ).addFileSet( delFileSet.capture() );
194         
195         assertThat( delFileSet.getValue().getDirectory(), is( fileSet.getDirectory() ) );
196         assertThat( delFileSet.getValue().getExcludes(), is( new String[] { "module1" } ) );
197         assertThat( delFileSet.getValue().getFileMappers(), is( fileSet.getFileMappers() ) );
198         assertThat( delFileSet.getValue().getFileSelectors(), is( fileSet.getFileSelectors() ) );
199         assertThat( delFileSet.getValue().getIncludes(), is(  new String[0] ) );
200         assertThat( delFileSet.getValue().getPrefix(), is( "prefix/" ) );
201         assertThat( delFileSet.getValue().getStreamTransformer(), is( fileSet.getStreamTransformer() ) );
202     }
203     
204 
205     private static final class CounterSelector
206         implements FileSelector
207     {
208 
209         private int count = 0;
210 
211         private boolean answer = false;
212 
213         public CounterSelector( final boolean answer )
214         {
215             this.answer = answer;
216         }
217 
218         public int getCount()
219         {
220             return count;
221         }
222 
223         public boolean isSelected( final @Nonnull FileInfo fileInfo )
224             throws IOException
225         {
226             if ( fileInfo.isFile() )
227             {
228                 count++;
229                 System.out.println( "Counting file: " + fileInfo.getName() + ". Current count: " + count );
230             }
231 
232             return answer;
233         }
234 
235     }
236 
237 }