--- /dev/null
+package org.apache.archiva.converter.artifact;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * ArtifactConversionException
+ *
+ * @version $Id$
+ */
+public class ArtifactConversionException
+ extends Exception
+{
+
+ public ArtifactConversionException()
+ {
+ }
+
+ public ArtifactConversionException( String message )
+ {
+ super( message );
+ }
+
+ public ArtifactConversionException( Throwable cause )
+ {
+ super( cause );
+ }
+
+ public ArtifactConversionException( String message, Throwable cause )
+ {
+ super( message, cause );
+ }
+}
--- /dev/null
+package org.apache.archiva.converter.artifact;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.repository.ArtifactRepository;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * ArtifactConverter
+ *
+ * @version $Id$
+ */
+public interface ArtifactConverter
+{
+ public static final String ROLE = ArtifactConverter.class.getName();
+
+ /**
+ * Convert an provided artifact, and place it into the destination repository.
+ *
+ * @param artifact the artifact to convert.
+ * @param destinationRepository the respository to send the artifact to.
+ * @throws ArtifactConversionException
+ */
+ void convert( Artifact artifact, ArtifactRepository destinationRepository )
+ throws ArtifactConversionException;
+
+ /**
+ * Get the map of accumulated warnings for the conversion.
+ *
+ * @return the {@link Map}<{@link Artifact}, {@link String}> warning messages.
+ */
+ Map<Artifact, List<String>> getWarnings();
+
+ /**
+ * Clear the list of warning messages.
+ */
+ void clearWarnings();
+}
--- /dev/null
+package org.apache.archiva.converter.artifact;
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.handler.ArtifactHandler;
+import org.apache.maven.artifact.metadata.ArtifactMetadata;
+import org.apache.maven.artifact.repository.ArtifactRepository;
+import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout;
+
+/**
+ * @author jdcasey
+ */
+public class LegacyRepositoryLayout
+ implements ArtifactRepositoryLayout
+{
+
+ private static final String PATH_SEPARATOR = "/";
+
+ public String getId()
+ {
+ return "legacy";
+ }
+
+ public String pathOf( Artifact artifact )
+ {
+ ArtifactHandler artifactHandler = artifact.getArtifactHandler();
+
+ StringBuilder path = new StringBuilder( 128 );
+
+ path.append( artifact.getGroupId() ).append( '/' );
+ path.append( artifactHandler.getDirectory() ).append( '/' );
+ path.append( artifact.getArtifactId() ).append( '-' ).append( artifact.getVersion() );
+
+ if ( artifact.hasClassifier() )
+ {
+ path.append( '-' ).append( artifact.getClassifier() );
+ }
+
+ if ( artifactHandler.getExtension() != null && artifactHandler.getExtension().length() > 0 )
+ {
+ path.append( '.' ).append( artifactHandler.getExtension() );
+ }
+
+ return path.toString();
+ }
+
+ public String pathOfLocalRepositoryMetadata( ArtifactMetadata metadata, ArtifactRepository repository )
+ {
+ return pathOfRepositoryMetadata( metadata, metadata.getLocalFilename( repository ) );
+ }
+
+ private String pathOfRepositoryMetadata( ArtifactMetadata metadata, String filename )
+ {
+ StringBuilder path = new StringBuilder( 128 );
+
+ path.append( metadata.getGroupId() ).append( PATH_SEPARATOR ).append( "poms" ).append( PATH_SEPARATOR );
+
+ path.append( filename );
+
+ return path.toString();
+ }
+
+ public String pathOfRemoteRepositoryMetadata( ArtifactMetadata metadata )
+ {
+ return pathOfRepositoryMetadata( metadata, metadata.getRemoteFilename() );
+ }
+
+}
--- /dev/null
+package org.apache.archiva.converter.artifact;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import org.apache.archiva.common.plexusbridge.DigesterUtils;
+import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
+import org.apache.archiva.common.plexusbridge.PlexusSisuBridgeException;
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.IOUtils;
+import org.apache.archiva.transaction.FileTransaction;
+import org.apache.archiva.transaction.TransactionException;
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.factory.ArtifactFactory;
+import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager;
+import org.apache.maven.artifact.repository.ArtifactRepository;
+import org.apache.maven.artifact.repository.metadata.ArtifactRepositoryMetadata;
+import org.apache.maven.artifact.repository.metadata.Metadata;
+import org.apache.maven.artifact.repository.metadata.RepositoryMetadata;
+import org.apache.maven.artifact.repository.metadata.Snapshot;
+import org.apache.maven.artifact.repository.metadata.SnapshotArtifactRepositoryMetadata;
+import org.apache.maven.artifact.repository.metadata.Versioning;
+import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Reader;
+import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Writer;
+import org.apache.maven.model.DistributionManagement;
+import org.apache.maven.model.Model;
+import org.apache.maven.model.Relocation;
+import org.apache.maven.model.converter.ModelConverter;
+import org.apache.maven.model.converter.PomTranslationException;
+import org.apache.maven.model.io.xpp3.MavenXpp3Writer;
+import org.codehaus.plexus.digest.Digester;
+import org.codehaus.plexus.digest.DigesterException;
+import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.PostConstruct;
+import javax.inject.Inject;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.regex.Matcher;
+
+/**
+ * LegacyToDefaultConverter
+ *
+ * @version $Id$
+ */
+@Service( "artifactConverter#legacy-to-default" )
+public class LegacyToDefaultConverter
+ implements ArtifactConverter
+{
+ /**
+ * {@link List}<{@link Digester}
+ *
+ */
+ private List<? extends Digester> digesters;
+
+ @Inject
+ private PlexusSisuBridge plexusSisuBridge;
+
+ @Inject
+ private DigesterUtils digesterUtils;
+
+ /**
+ *
+ */
+ private ModelConverter translator;
+
+ /**
+ *
+ */
+ private ArtifactFactory artifactFactory;
+
+ /**
+ *
+ */
+ private ArtifactHandlerManager artifactHandlerManager;
+
+ /**
+ * default-value="false"
+ */
+ private boolean force;
+
+ /**
+ * default-value="false"
+ */
+ private boolean dryrun;
+
+ private Map<Artifact, List<String>> warnings = new HashMap<Artifact, List<String>>();
+
+ @PostConstruct
+ public void initialize()
+ throws PlexusSisuBridgeException
+ {
+ this.digesters = digesterUtils.getAllDigesters();
+ translator = plexusSisuBridge.lookup( ModelConverter.class );
+ artifactFactory = plexusSisuBridge.lookup( ArtifactFactory.class );
+ artifactHandlerManager = plexusSisuBridge.lookup( ArtifactHandlerManager.class );
+ }
+
+ public void convert( Artifact artifact, ArtifactRepository targetRepository )
+ throws ArtifactConversionException
+ {
+ if ( artifact.getRepository().getUrl().equals( targetRepository.getUrl() ) )
+ {
+ throw new ArtifactConversionException( Messages.getString( "exception.repositories.match" ) ); //$NON-NLS-1$
+ }
+
+ if ( !validateMetadata( artifact ) )
+ {
+ addWarning( artifact, Messages.getString( "unable.to.validate.metadata" ) ); //$NON-NLS-1$
+ return;
+ }
+
+ FileTransaction transaction = new FileTransaction();
+
+ if ( !copyPom( artifact, targetRepository, transaction ) )
+ {
+ addWarning( artifact, Messages.getString( "unable.to.copy.pom" ) ); //$NON-NLS-1$
+ return;
+ }
+
+ if ( !copyArtifact( artifact, targetRepository, transaction ) )
+ {
+ addWarning( artifact, Messages.getString( "unable.to.copy.artifact" ) ); //$NON-NLS-1$
+ return;
+ }
+
+ Metadata metadata = createBaseMetadata( artifact );
+ Versioning versioning = new Versioning();
+ versioning.addVersion( artifact.getBaseVersion() );
+ metadata.setVersioning( versioning );
+ updateMetadata( new ArtifactRepositoryMetadata( artifact ), targetRepository, metadata, transaction );
+
+ metadata = createBaseMetadata( artifact );
+ metadata.setVersion( artifact.getBaseVersion() );
+ versioning = new Versioning();
+
+ Matcher matcher = Artifact.VERSION_FILE_PATTERN.matcher( artifact.getVersion() );
+ if ( matcher.matches() )
+ {
+ Snapshot snapshot = new Snapshot();
+ snapshot.setBuildNumber( Integer.parseInt( matcher.group( 3 ) ) );
+ snapshot.setTimestamp( matcher.group( 2 ) );
+ versioning.setSnapshot( snapshot );
+ }
+
+ // TODO: merge latest/release/snapshot from source instead
+ metadata.setVersioning( versioning );
+ updateMetadata( new SnapshotArtifactRepositoryMetadata( artifact ), targetRepository, metadata, transaction );
+
+ if ( !dryrun )
+ {
+ try
+ {
+ transaction.commit();
+ }
+ catch ( TransactionException e )
+ {
+ throw new ArtifactConversionException( Messages.getString( "transaction.failure", e.getMessage() ),
+ e ); //$NON-NLS-1$
+ }
+ }
+ }
+
+ @SuppressWarnings( "unchecked" )
+ private boolean copyPom( Artifact artifact, ArtifactRepository targetRepository, FileTransaction transaction )
+ throws ArtifactConversionException
+ {
+ Artifact pom = artifactFactory.createProjectArtifact( artifact.getGroupId(), artifact.getArtifactId(),
+ artifact.getVersion() );
+ pom.setBaseVersion( artifact.getBaseVersion() );
+ ArtifactRepository repository = artifact.getRepository();
+ File file = new File( repository.getBasedir(), repository.pathOf( pom ) );
+
+ boolean result = true;
+ if ( file.exists() )
+ {
+ File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pom ) );
+
+ String contents = null;
+ boolean checksumsValid = false;
+ try
+ {
+ if ( testChecksums( artifact, file ) )
+ {
+ checksumsValid = true;
+ }
+
+ // Even if the checksums for the POM are invalid we should still convert the POM
+ contents = FileUtils.readFileToString( file, null );
+ }
+ catch ( IOException e )
+ {
+ throw new ArtifactConversionException(
+ Messages.getString( "unable.to.read.source.pom", e.getMessage() ), e ); //$NON-NLS-1$
+ }
+
+ if ( checksumsValid && contents.indexOf( "modelVersion" ) >= 0 ) //$NON-NLS-1$
+ {
+ // v4 POM
+ try
+ {
+ boolean matching = false;
+ if ( !force && targetFile.exists() )
+ {
+ String targetContents = FileUtils.readFileToString( targetFile, null );
+ matching = targetContents.equals( contents );
+ }
+ if ( force || !matching )
+ {
+ transaction.createFile( contents, targetFile, digesters );
+ }
+ }
+ catch ( IOException e )
+ {
+ throw new ArtifactConversionException(
+ Messages.getString( "unable.to.write.target.pom", e.getMessage() ), e ); //$NON-NLS-1$
+ }
+ }
+ else
+ {
+ // v3 POM
+ StringReader stringReader = new StringReader( contents );
+ StringWriter writer = null;
+ try
+ {
+ org.apache.maven.model.v3_0_0.io.xpp3.MavenXpp3Reader v3Reader =
+ new org.apache.maven.model.v3_0_0.io.xpp3.MavenXpp3Reader();
+ org.apache.maven.model.v3_0_0.Model v3Model = v3Reader.read( stringReader );
+
+ if ( doRelocation( artifact, v3Model, targetRepository, transaction ) )
+ {
+ Artifact relocatedPom =
+ artifactFactory.createProjectArtifact( artifact.getGroupId(), artifact.getArtifactId(),
+ artifact.getVersion() );
+ targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( relocatedPom ) );
+ }
+
+ Model v4Model = translator.translate( v3Model );
+
+ translator.validateV4Basics( v4Model, v3Model.getGroupId(), v3Model.getArtifactId(),
+ v3Model.getVersion(), v3Model.getPackage() );
+
+ writer = new StringWriter();
+ MavenXpp3Writer Xpp3Writer = new MavenXpp3Writer();
+ Xpp3Writer.write( writer, v4Model );
+
+ transaction.createFile( writer.toString(), targetFile, digesters );
+
+ List<String> warnings = translator.getWarnings();
+
+ for ( String message : warnings )
+ {
+ addWarning( artifact, message );
+ }
+ }
+ catch ( XmlPullParserException e )
+ {
+ addWarning( artifact, Messages.getString( "invalid.source.pom", e.getMessage() ) ); //$NON-NLS-1$
+ result = false;
+ }
+ catch ( IOException e )
+ {
+ throw new ArtifactConversionException( Messages.getString( "unable.to.write.converted.pom" ),
+ e ); //$NON-NLS-1$
+ }
+ catch ( PomTranslationException e )
+ {
+ addWarning( artifact, Messages.getString( "invalid.source.pom", e.getMessage() ) ); //$NON-NLS-1$
+ result = false;
+ }
+ finally
+ {
+ IOUtils.closeQuietly( writer );
+ }
+ }
+ }
+ else
+ {
+ addWarning( artifact, Messages.getString( "warning.missing.pom" ) ); //$NON-NLS-1$
+ }
+ return result;
+ }
+
+ private boolean testChecksums( Artifact artifact, File file )
+ throws IOException
+ {
+ boolean result = true;
+ for ( Digester digester : digesters )
+ {
+ result &= verifyChecksum( file, file.getName() + "." + getDigesterFileExtension( digester ), digester,
+ //$NON-NLS-1$
+ artifact,
+ "failure.incorrect." + getDigesterFileExtension( digester ) ); //$NON-NLS-1$
+ }
+ return result;
+ }
+
+ private boolean verifyChecksum( File file, String fileName, Digester digester, Artifact artifact, String key )
+ throws IOException
+ {
+ boolean result = true;
+
+ File checksumFile = new File( file.getParentFile(), fileName );
+ if ( checksumFile.exists() )
+ {
+ String checksum = FileUtils.readFileToString( checksumFile, null );
+ try
+ {
+ digester.verify( file, checksum );
+ }
+ catch ( DigesterException e )
+ {
+ addWarning( artifact, Messages.getString( key ) );
+ result = false;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * File extension for checksums
+ * TODO should be moved to plexus-digester ?
+ */
+ private String getDigesterFileExtension( Digester digester )
+ {
+ return digester.getAlgorithm().toLowerCase().replaceAll( "-", "" ); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ private boolean copyArtifact( Artifact artifact, ArtifactRepository targetRepository, FileTransaction transaction )
+ throws ArtifactConversionException
+ {
+ File sourceFile = artifact.getFile();
+
+ if ( sourceFile.getAbsolutePath().indexOf( "/plugins/" ) > -1 ) //$NON-NLS-1$
+ {
+ artifact.setArtifactHandler( artifactHandlerManager.getArtifactHandler( "maven-plugin" ) ); //$NON-NLS-1$
+ }
+
+ File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+
+ boolean result = true;
+ try
+ {
+ boolean matching = false;
+ if ( !force && targetFile.exists() )
+ {
+ matching = FileUtils.contentEquals( sourceFile, targetFile );
+ if ( !matching )
+ {
+ addWarning( artifact, Messages.getString( "failure.target.already.exists" ) ); //$NON-NLS-1$
+ result = false;
+ }
+ }
+ if ( result )
+ {
+ if ( force || !matching )
+ {
+ if ( testChecksums( artifact, sourceFile ) )
+ {
+ transaction.copyFile( sourceFile, targetFile, digesters );
+ }
+ else
+ {
+ result = false;
+ }
+ }
+ }
+ }
+ catch ( IOException e )
+ {
+ throw new ArtifactConversionException( Messages.getString( "error.copying.artifact" ), e ); //$NON-NLS-1$
+ }
+ return result;
+ }
+
+ private Metadata createBaseMetadata( Artifact artifact )
+ {
+ Metadata metadata = new Metadata();
+ metadata.setArtifactId( artifact.getArtifactId() );
+ metadata.setGroupId( artifact.getGroupId() );
+ return metadata;
+ }
+
+ private Metadata readMetadata( File file )
+ throws ArtifactConversionException
+ {
+ Metadata metadata;
+ MetadataXpp3Reader reader = new MetadataXpp3Reader();
+ FileReader fileReader = null;
+ try
+ {
+ fileReader = new FileReader( file );
+ metadata = reader.read( fileReader );
+ }
+ catch ( FileNotFoundException e )
+ {
+ throw new ArtifactConversionException( Messages.getString( "error.reading.target.metadata" ),
+ e ); //$NON-NLS-1$
+ }
+ catch ( IOException e )
+ {
+ throw new ArtifactConversionException( Messages.getString( "error.reading.target.metadata" ),
+ e ); //$NON-NLS-1$
+ }
+ catch ( XmlPullParserException e )
+ {
+ throw new ArtifactConversionException( Messages.getString( "error.reading.target.metadata" ),
+ e ); //$NON-NLS-1$
+ }
+ finally
+ {
+ IOUtils.closeQuietly( fileReader );
+ }
+ return metadata;
+ }
+
+ private boolean validateMetadata( Artifact artifact )
+ throws ArtifactConversionException
+ {
+ ArtifactRepository repository = artifact.getRepository();
+
+ boolean result = true;
+
+ RepositoryMetadata repositoryMetadata = new ArtifactRepositoryMetadata( artifact );
+ File file =
+ new File( repository.getBasedir(), repository.pathOfRemoteRepositoryMetadata( repositoryMetadata ) );
+ if ( file.exists() )
+ {
+ Metadata metadata = readMetadata( file );
+ result = validateMetadata( metadata, repositoryMetadata, artifact );
+ }
+
+ repositoryMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
+ file = new File( repository.getBasedir(), repository.pathOfRemoteRepositoryMetadata( repositoryMetadata ) );
+ if ( file.exists() )
+ {
+ Metadata metadata = readMetadata( file );
+ result = result && validateMetadata( metadata, repositoryMetadata, artifact );
+ }
+
+ return result;
+ }
+
+ @SuppressWarnings( "unchecked" )
+ private boolean validateMetadata( Metadata metadata, RepositoryMetadata repositoryMetadata, Artifact artifact )
+ {
+ String groupIdKey;
+ String artifactIdKey = null;
+ String snapshotKey = null;
+ String versionKey = null;
+ String versionsKey = null;
+
+ if ( repositoryMetadata.storedInGroupDirectory() )
+ {
+ groupIdKey = "failure.incorrect.groupMetadata.groupId"; //$NON-NLS-1$
+ }
+ else if ( repositoryMetadata.storedInArtifactVersionDirectory() )
+ {
+ groupIdKey = "failure.incorrect.snapshotMetadata.groupId"; //$NON-NLS-1$
+ artifactIdKey = "failure.incorrect.snapshotMetadata.artifactId"; //$NON-NLS-1$
+ versionKey = "failure.incorrect.snapshotMetadata.version"; //$NON-NLS-1$
+ snapshotKey = "failure.incorrect.snapshotMetadata.snapshot"; //$NON-NLS-1$
+ }
+ else
+ {
+ groupIdKey = "failure.incorrect.artifactMetadata.groupId"; //$NON-NLS-1$
+ artifactIdKey = "failure.incorrect.artifactMetadata.artifactId"; //$NON-NLS-1$
+ versionsKey = "failure.incorrect.artifactMetadata.versions"; //$NON-NLS-1$
+ }
+
+ boolean result = true;
+
+ if ( metadata.getGroupId() == null || !metadata.getGroupId().equals( artifact.getGroupId() ) )
+ {
+ addWarning( artifact, Messages.getString( groupIdKey ) );
+ result = false;
+ }
+ if ( !repositoryMetadata.storedInGroupDirectory() )
+ {
+ if ( metadata.getGroupId() == null || !metadata.getArtifactId().equals( artifact.getArtifactId() ) )
+ {
+ addWarning( artifact, Messages.getString( artifactIdKey ) );
+ result = false;
+ }
+ if ( !repositoryMetadata.storedInArtifactVersionDirectory() )
+ {
+ // artifact metadata
+
+ boolean foundVersion = false;
+ if ( metadata.getVersioning() != null )
+ {
+ for ( String version : (List<String>) metadata.getVersioning().getVersions() )
+ {
+ if ( version.equals( artifact.getBaseVersion() ) )
+ {
+ foundVersion = true;
+ break;
+ }
+ }
+ }
+
+ if ( !foundVersion )
+ {
+ addWarning( artifact, Messages.getString( versionsKey ) );
+ result = false;
+ }
+ }
+ else
+ {
+ // snapshot metadata
+ if ( !artifact.getBaseVersion().equals( metadata.getVersion() ) )
+ {
+ addWarning( artifact, Messages.getString( versionKey ) );
+ result = false;
+ }
+
+ if ( artifact.isSnapshot() )
+ {
+ Matcher matcher = Artifact.VERSION_FILE_PATTERN.matcher( artifact.getVersion() );
+ if ( matcher.matches() )
+ {
+ boolean correct = false;
+ if ( metadata.getVersioning() != null && metadata.getVersioning().getSnapshot() != null )
+ {
+ Snapshot snapshot = metadata.getVersioning().getSnapshot();
+ int build = Integer.parseInt( matcher.group( 3 ) );
+ String ts = matcher.group( 2 );
+ if ( build == snapshot.getBuildNumber() && ts.equals( snapshot.getTimestamp() ) )
+ {
+ correct = true;
+ }
+ }
+
+ if ( !correct )
+ {
+ addWarning( artifact, Messages.getString( snapshotKey ) );
+ result = false;
+ }
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ private void updateMetadata( RepositoryMetadata artifactMetadata, ArtifactRepository targetRepository,
+ Metadata newMetadata, FileTransaction transaction )
+ throws ArtifactConversionException
+ {
+ File file = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
+
+ Metadata metadata;
+ boolean changed;
+
+ if ( file.exists() )
+ {
+ metadata = readMetadata( file );
+ changed = metadata.merge( newMetadata );
+ }
+ else
+ {
+ changed = true;
+ metadata = newMetadata;
+ }
+
+ if ( changed )
+ {
+ StringWriter writer = null;
+ try
+ {
+ writer = new StringWriter();
+
+ MetadataXpp3Writer mappingWriter = new MetadataXpp3Writer();
+
+ mappingWriter.write( writer, metadata );
+
+ transaction.createFile( writer.toString(), file, digesters );
+ }
+ catch ( IOException e )
+ {
+ throw new ArtifactConversionException( Messages.getString( "error.writing.target.metadata" ),
+ e ); //$NON-NLS-1$
+ }
+ finally
+ {
+ IOUtils.closeQuietly( writer );
+ }
+ }
+ }
+
+ private boolean doRelocation( Artifact artifact, org.apache.maven.model.v3_0_0.Model v3Model,
+ ArtifactRepository repository, FileTransaction transaction )
+ throws IOException
+ {
+ Properties properties = v3Model.getProperties();
+ if ( properties.containsKey( "relocated.groupId" ) || properties.containsKey( "relocated.artifactId" )
+ //$NON-NLS-1$ //$NON-NLS-2$
+ || properties.containsKey( "relocated.version" ) ) //$NON-NLS-1$
+ {
+ String newGroupId = properties.getProperty( "relocated.groupId", v3Model.getGroupId() ); //$NON-NLS-1$
+ properties.remove( "relocated.groupId" ); //$NON-NLS-1$
+
+ String newArtifactId =
+ properties.getProperty( "relocated.artifactId", v3Model.getArtifactId() ); //$NON-NLS-1$
+ properties.remove( "relocated.artifactId" ); //$NON-NLS-1$
+
+ String newVersion = properties.getProperty( "relocated.version", v3Model.getVersion() ); //$NON-NLS-1$
+ properties.remove( "relocated.version" ); //$NON-NLS-1$
+
+ String message = properties.getProperty( "relocated.message", "" ); //$NON-NLS-1$ //$NON-NLS-2$
+ properties.remove( "relocated.message" ); //$NON-NLS-1$
+
+ if ( properties.isEmpty() )
+ {
+ v3Model.setProperties( null );
+ }
+
+ writeRelocationPom( v3Model.getGroupId(), v3Model.getArtifactId(), v3Model.getVersion(), newGroupId,
+ newArtifactId, newVersion, message, repository, transaction );
+
+ v3Model.setGroupId( newGroupId );
+ v3Model.setArtifactId( newArtifactId );
+ v3Model.setVersion( newVersion );
+
+ artifact.setGroupId( newGroupId );
+ artifact.setArtifactId( newArtifactId );
+ artifact.setVersion( newVersion );
+
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ private void writeRelocationPom( String groupId, String artifactId, String version, String newGroupId,
+ String newArtifactId, String newVersion, String message,
+ ArtifactRepository repository, FileTransaction transaction )
+ throws IOException
+ {
+ Model pom = new Model();
+ pom.setGroupId( groupId );
+ pom.setArtifactId( artifactId );
+ pom.setVersion( version );
+
+ DistributionManagement dMngt = new DistributionManagement();
+
+ Relocation relocation = new Relocation();
+ relocation.setGroupId( newGroupId );
+ relocation.setArtifactId( newArtifactId );
+ relocation.setVersion( newVersion );
+ if ( message != null && message.length() > 0 )
+ {
+ relocation.setMessage( message );
+ }
+
+ dMngt.setRelocation( relocation );
+
+ pom.setDistributionManagement( dMngt );
+
+ Artifact artifact = artifactFactory.createBuildArtifact( groupId, artifactId, version, "pom" ); //$NON-NLS-1$
+ File pomFile = new File( repository.getBasedir(), repository.pathOf( artifact ) );
+
+ StringWriter strWriter = new StringWriter();
+ MavenXpp3Writer pomWriter = new MavenXpp3Writer();
+ pomWriter.write( strWriter, pom );
+
+ transaction.createFile( strWriter.toString(), pomFile, digesters );
+ }
+
+ private void addWarning( Artifact artifact, String message )
+ {
+ List<String> messages = warnings.get( artifact );
+ if ( messages == null )
+ {
+ messages = new ArrayList<String>();
+ }
+ messages.add( message );
+ warnings.put( artifact, messages );
+ }
+
+ public void clearWarnings()
+ {
+ warnings.clear();
+ }
+
+ public Map<Artifact, List<String>> getWarnings()
+ {
+ return warnings;
+ }
+
+
+ public List<? extends Digester> getDigesters()
+ {
+ return digesters;
+ }
+
+ public void setDigesters( List<Digester> digesters )
+ {
+ this.digesters = digesters;
+ }
+
+ public ModelConverter getTranslator()
+ {
+ return translator;
+ }
+
+ public void setTranslator( ModelConverter translator )
+ {
+ this.translator = translator;
+ }
+
+ public ArtifactFactory getArtifactFactory()
+ {
+ return artifactFactory;
+ }
+
+ public void setArtifactFactory( ArtifactFactory artifactFactory )
+ {
+ this.artifactFactory = artifactFactory;
+ }
+
+ public ArtifactHandlerManager getArtifactHandlerManager()
+ {
+ return artifactHandlerManager;
+ }
+
+ public void setArtifactHandlerManager( ArtifactHandlerManager artifactHandlerManager )
+ {
+ this.artifactHandlerManager = artifactHandlerManager;
+ }
+
+ public boolean isForce()
+ {
+ return force;
+ }
+
+ public void setForce( boolean force )
+ {
+ this.force = force;
+ }
+
+ public boolean isDryrun()
+ {
+ return dryrun;
+ }
+
+ public void setDryrun( boolean dryrun )
+ {
+ this.dryrun = dryrun;
+ }
+}
--- /dev/null
+package org.apache.archiva.converter.artifact;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.text.MessageFormat;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+
+/**
+ * Messages
+ *
+ * @version $Id$
+ */
+public class Messages
+{
+ private static final String BUNDLE_NAME = "org.apache.archiva.converter.artifact.messages"; //$NON-NLS-1$
+
+ private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle( BUNDLE_NAME );
+
+ private Messages()
+ {
+ // no op
+ }
+
+ public static String getString( String key )
+ {
+ try
+ {
+ return RESOURCE_BUNDLE.getString( key );
+ }
+ catch ( MissingResourceException e )
+ {
+ return '!' + key + '!';
+ }
+ }
+
+ public static String getString( String key, Object argument )
+ {
+ return getString( key, new Object[] { argument } );
+ }
+
+ public static String getString( String key, Object arguments[] )
+ {
+ try
+ {
+ String pattern = RESOURCE_BUNDLE.getString( key );
+ return MessageFormat.format( pattern, arguments );
+ }
+ catch ( MissingResourceException e )
+ {
+ return '!' + key + '!';
+ }
+ }
+}
default-lazy-init="true">
<context:annotation-config/>
- <context:component-scan base-package="org.apache.maven.archiva.converter.artifact"/>
+ <context:component-scan base-package="org.apache.archiva.converter.artifact"/>
</beans>
\ No newline at end of file
--- /dev/null
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+unable.to.validate.metadata=Unable to validate metadata
+unable.to.copy.pom=Unable to copy pom.
+unable.to.copy.artifact=Unable to copy artifact
+unable.to.read.source.pom=Unable to read source POM: {0}
+unable.to.write.target.pom=Unable to write target POM: {0}
+unable.to.write.converted.pom=Unable to write converted POM
+
+
+exception.repositories.match=Source repository of artifact, and target repository are the same. No conversion needed.
+transaction.failure=Transaction failure: {0}
+invalid.source.pom=Invalid source pom: {0}
+
+warning.missing.pom=The artifact had no POM in the source repository.
+
+error.copying.artifact=Error copying artifact
+error.reading.target.metadata=Error reading target metadata
+error.writing.target.metadata=Error writing target metadata
+
+failure.target.already.exists=The artifact could not be converted because it already exists.
+failure.incorrect.groupMetadata.groupId=The group ID in the source group metadata is incorrect.
+
+failure.incorrect.artifactMetadata.artifactId=The artifact ID in the source artifact metadata is incorrect.
+failure.incorrect.artifactMetadata.groupId=The group ID in the source artifact metadata is incorrect.
+failure.incorrect.artifactMetadata.versions=The version list in the source artifact metadata is incorrect.
+
+failure.incorrect.snapshotMetadata.artifactId=The artifact ID in the source artifact version metadata is incorrect.
+failure.incorrect.snapshotMetadata.groupId=The group ID in the source artifact version metadata is incorrect.
+failure.incorrect.snapshotMetadata.version=The version in the source artifact version metadata is incorrect.
+failure.incorrect.snapshotMetadata.snapshot=The snapshot information in the source artifact version metadata is incorrect.
+
+failure.incorrect.md5=The MD5 checksum value was incorrect.
+failure.incorrect.sha1=The SHA1 checksum value was incorrect.
+++ /dev/null
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-unable.to.validate.metadata=Unable to validate metadata
-unable.to.copy.pom=Unable to copy pom.
-unable.to.copy.artifact=Unable to copy artifact
-unable.to.read.source.pom=Unable to read source POM: {0}
-unable.to.write.target.pom=Unable to write target POM: {0}
-unable.to.write.converted.pom=Unable to write converted POM
-
-
-exception.repositories.match=Source repository of artifact, and target repository are the same. No conversion needed.
-transaction.failure=Transaction failure: {0}
-invalid.source.pom=Invalid source pom: {0}
-
-warning.missing.pom=The artifact had no POM in the source repository.
-
-error.copying.artifact=Error copying artifact
-error.reading.target.metadata=Error reading target metadata
-error.writing.target.metadata=Error writing target metadata
-
-failure.target.already.exists=The artifact could not be converted because it already exists.
-failure.incorrect.groupMetadata.groupId=The group ID in the source group metadata is incorrect.
-
-failure.incorrect.artifactMetadata.artifactId=The artifact ID in the source artifact metadata is incorrect.
-failure.incorrect.artifactMetadata.groupId=The group ID in the source artifact metadata is incorrect.
-failure.incorrect.artifactMetadata.versions=The version list in the source artifact metadata is incorrect.
-
-failure.incorrect.snapshotMetadata.artifactId=The artifact ID in the source artifact version metadata is incorrect.
-failure.incorrect.snapshotMetadata.groupId=The group ID in the source artifact version metadata is incorrect.
-failure.incorrect.snapshotMetadata.version=The version in the source artifact version metadata is incorrect.
-failure.incorrect.snapshotMetadata.snapshot=The snapshot information in the source artifact version metadata is incorrect.
-
-failure.incorrect.md5=The MD5 checksum value was incorrect.
-failure.incorrect.sha1=The SHA1 checksum value was incorrect.
--- /dev/null
+package org.apache.archiva.converter.artifact;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import junit.framework.TestCase;
+import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
+import org.apache.commons.io.FileUtils;
+import org.apache.maven.archiva.common.utils.FileUtil;
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.factory.ArtifactFactory;
+import org.apache.maven.artifact.metadata.ArtifactMetadata;
+import org.apache.maven.artifact.repository.ArtifactRepository;
+import org.apache.maven.artifact.repository.ArtifactRepositoryFactory;
+import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout;
+import org.apache.maven.artifact.repository.metadata.ArtifactRepositoryMetadata;
+import org.apache.maven.artifact.repository.metadata.SnapshotArtifactRepositoryMetadata;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.context.ApplicationContext;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import javax.inject.Inject;
+import java.io.File;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.regex.Matcher;
+
+/**
+ * LegacyToDefaultConverterTest
+ *
+ * @version $Id$
+ */
+@RunWith( SpringJUnit4ClassRunner.class )
+@ContextConfiguration( locations = { "classpath*:/META-INF/spring-context.xml", "classpath:/spring-context.xml" } )
+public class LegacyToDefaultConverterTest
+ extends TestCase
+{
+ private ArtifactRepository sourceRepository;
+
+ private ArtifactRepository targetRepository;
+
+ private ArtifactConverter artifactConverter;
+
+ private ArtifactFactory artifactFactory;
+
+ @Inject
+ private PlexusSisuBridge plexusSisuBridge;
+
+ @Inject
+ private ApplicationContext applicationContext;
+
+ private static final int SLEEP_MILLIS = 100;
+
+ @Before
+ public void init()
+ throws Exception
+ {
+ super.setUp();
+
+ ArtifactRepositoryFactory factory = plexusSisuBridge.lookup( ArtifactRepositoryFactory.class );
+
+ Map<String, ArtifactRepositoryLayout> layoutsMap = plexusSisuBridge.lookupMap( ArtifactRepositoryLayout.class );
+
+ System.out.println("hints " + layoutsMap.keySet().toString() );
+
+ ArtifactRepositoryLayout layout = plexusSisuBridge.lookup( ArtifactRepositoryLayout.class, "legacy" );
+
+ File sourceBase = getTestFile( "src/test/source-repository" );
+ sourceRepository =
+ factory.createArtifactRepository( "source", sourceBase.toURL().toString(), layout, null, null );
+
+ layout = plexusSisuBridge.lookup( ArtifactRepositoryLayout.class, "default" );
+
+ File targetBase = getTestFile( "target/test-target-repository" );
+ copyDirectoryStructure( getTestFile( "src/test/target-repository" ), targetBase );
+
+ targetRepository =
+ factory.createArtifactRepository( "target", targetBase.toURL().toString(), layout, null, null );
+
+ artifactConverter =
+ applicationContext.getBean( "artifactConverter#legacy-to-default", ArtifactConverter.class );
+
+ artifactConverter.clearWarnings();
+ artifactFactory = (ArtifactFactory) plexusSisuBridge.lookup( ArtifactFactory.class );
+ }
+
+ public static File getTestFile( String path )
+ {
+ return new File( FileUtil.getBasedir(), path );
+ }
+
+ private void copyDirectoryStructure( File sourceDirectory, File destinationDirectory )
+ throws IOException
+ {
+ if ( !sourceDirectory.exists() )
+ {
+ throw new IOException( "Source directory doesn't exists (" + sourceDirectory.getAbsolutePath() + ")." );
+ }
+
+ File[] files = sourceDirectory.listFiles();
+
+ String sourcePath = sourceDirectory.getAbsolutePath();
+
+ for ( int i = 0; i < files.length; i++ )
+ {
+ File file = files[i];
+
+ String dest = file.getAbsolutePath();
+
+ dest = dest.substring( sourcePath.length() + 1 );
+
+ File destination = new File( destinationDirectory, dest );
+
+ if ( file.isFile() )
+ {
+ destination = destination.getParentFile();
+
+ FileUtils.copyFileToDirectory( file, destination );
+ }
+ else if ( file.isDirectory() )
+ {
+ if ( !".svn".equals( file.getName() ) )
+ {
+ if ( !destination.exists() && !destination.mkdirs() )
+ {
+ throw new IOException(
+ "Could not create destination directory '" + destination.getAbsolutePath() + "'." );
+ }
+ copyDirectoryStructure( file, destination );
+ }
+ }
+ else
+ {
+ throw new IOException( "Unknown file type: " + file.getAbsolutePath() );
+ }
+ }
+ }
+
+ @Test
+ public void testV4PomConvert()
+ throws Exception
+ {
+ // test that it is copied as is
+
+ Artifact artifact = createArtifact( "test", "v4artifact", "1.0.0" );
+ ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
+ File artifactMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
+ artifactMetadataFile.delete();
+
+ ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
+ File versionMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
+ versionMetadataFile.delete();
+
+ File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ artifactFile.delete();
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkSuccess( artifactConverter );
+
+ assertTrue( "Check artifact created", artifactFile.exists() );
+ assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
+
+ artifact = createPomArtifact( artifact );
+ File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
+ assertTrue( "Check POM created", pomFile.exists() );
+
+ compareFiles( sourcePomFile, pomFile );
+
+ assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
+
+ File expectedMetadataFile = getTestFile( "src/test/expected-files/v4-artifact-metadata.xml" );
+
+ compareFiles( expectedMetadataFile, artifactMetadataFile );
+
+ assertTrue( "Check snapshot metadata created", versionMetadataFile.exists() );
+
+ expectedMetadataFile = getTestFile( "src/test/expected-files/v4-version-metadata.xml" );
+
+ compareFiles( expectedMetadataFile, versionMetadataFile );
+ }
+
+ @Test
+ public void testV3PomConvert()
+ throws Exception
+ {
+ // test that the pom is coverted
+
+ Artifact artifact = createArtifact( "test", "v3artifact", "1.0.0" );
+ ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
+ File artifactMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
+ artifactMetadataFile.delete();
+
+ ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
+ File versionMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
+ versionMetadataFile.delete();
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkSuccess( artifactConverter );
+
+ File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ assertTrue( "Check artifact created", artifactFile.exists() );
+ assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
+
+ artifact = createPomArtifact( artifact );
+ File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File expectedPomFile = getTestFile( "src/test/expected-files/converted-v3.pom" );
+ assertTrue( "Check POM created", pomFile.exists() );
+
+ compareFiles( expectedPomFile, pomFile );
+
+ assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
+
+ File expectedMetadataFile = getTestFile( "src/test/expected-files/v3-artifact-metadata.xml" );
+
+ compareFiles( expectedMetadataFile, artifactMetadataFile );
+
+ assertTrue( "Check snapshot metadata created", versionMetadataFile.exists() );
+
+ expectedMetadataFile = getTestFile( "src/test/expected-files/v3-version-metadata.xml" );
+
+ compareFiles( expectedMetadataFile, versionMetadataFile );
+ }
+
+ @Test
+ public void testV3PomConvertWithRelocation()
+ throws Exception
+ {
+ Artifact artifact = createArtifact( "test", "relocated-v3artifact", "1.0.0" );
+ ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
+ File artifactMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
+ artifactMetadataFile.delete();
+
+ ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
+ File versionMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
+ versionMetadataFile.delete();
+
+ artifactConverter.convert( artifact, targetRepository );
+ //checkSuccess(); --> commented until MNG-2100 is fixed
+
+ File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ assertTrue( "Check if relocated artifact created", artifactFile.exists() );
+ assertTrue( "Check if relocated artifact matches",
+ FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
+ Artifact pomArtifact = createArtifact( "relocated-test", "relocated-v3artifact", "1.0.0", "1.0.0", "pom" );
+ File pomFile = getTestFile( "src/test/expected-files/" + targetRepository.pathOf( pomArtifact ) );
+ File testFile = getTestFile( "target/test-target-repository/" + targetRepository.pathOf( pomArtifact ) );
+ compareFiles( pomFile, testFile );
+
+ Artifact orig = createArtifact( "test", "relocated-v3artifact", "1.0.0", "1.0.0", "pom" );
+ artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( orig ) );
+ assertTrue( "Check if relocation artifact pom is created", artifactFile.exists() );
+ testFile = getTestFile( "src/test/expected-files/" + targetRepository.pathOf( orig ) );
+ compareFiles( artifactFile, testFile );
+ }
+
+ @Test
+ public void testV3PomWarningsOnConvert()
+ throws Exception
+ {
+ // test that the pom is converted but that warnings are reported
+
+ Artifact artifact = createArtifact( "test", "v3-warnings-artifact", "1.0.0" );
+ ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
+ File artifactMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
+ artifactMetadataFile.delete();
+
+ ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
+ File versionMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
+ versionMetadataFile.delete();
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkWarnings( artifactConverter, 2 );
+
+ File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ assertTrue( "Check artifact created", artifactFile.exists() );
+ assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
+
+ artifact = createPomArtifact( artifact );
+ File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File expectedPomFile = getTestFile( "src/test/expected-files/converted-v3-warnings.pom" );
+ assertTrue( "Check POM created", pomFile.exists() );
+
+ compareFiles( expectedPomFile, pomFile );
+
+ // TODO: check 2 warnings (extend and versions) matched on i18n key
+ }
+
+ private void doTestV4SnapshotPomConvert( String version, String expectedMetadataFileName )
+ throws Exception
+ {
+ // test that it is copied as is
+
+ Artifact artifact = createArtifact( "test", "v4artifact", version );
+ ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
+ File artifactMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
+ artifactMetadataFile.delete();
+
+ ArtifactMetadata snapshotMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
+ File snapshotMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( snapshotMetadata ) );
+ snapshotMetadataFile.delete();
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkSuccess( artifactConverter );
+
+ File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ assertTrue( "Check artifact created", artifactFile.exists() );
+ assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
+
+ artifact = createPomArtifact( artifact );
+ File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
+ assertTrue( "Check POM created", pomFile.exists() );
+
+ compareFiles( sourcePomFile, pomFile );
+
+ assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
+
+ File expectedMetadataFile = getTestFile( "src/test/expected-files/v4-snapshot-artifact-metadata.xml" );
+
+ compareFiles( expectedMetadataFile, artifactMetadataFile );
+
+ assertTrue( "Check snapshot metadata created", snapshotMetadataFile.exists() );
+
+ expectedMetadataFile = getTestFile( expectedMetadataFileName );
+
+ compareFiles( expectedMetadataFile, snapshotMetadataFile );
+ }
+
+ @Test
+ public void testV3SnapshotPomConvert()
+ throws Exception
+ {
+ // test that the pom is coverted
+
+ Artifact artifact = createArtifact( "test", "v3artifact", "1.0.0-SNAPSHOT" );
+ ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
+ File artifactMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
+ artifactMetadataFile.delete();
+
+ ArtifactMetadata snapshotMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
+ File snapshotMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( snapshotMetadata ) );
+ snapshotMetadataFile.delete();
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkSuccess( artifactConverter );
+
+ File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ assertTrue( "Check artifact created", artifactFile.exists() );
+ assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
+
+ artifact = createPomArtifact( artifact );
+ File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File expectedPomFile = getTestFile( "src/test/expected-files/converted-v3-snapshot.pom" );
+ assertTrue( "Check POM created", pomFile.exists() );
+
+ compareFiles( expectedPomFile, pomFile );
+
+ assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
+
+ File expectedMetadataFile = getTestFile( "src/test/expected-files/v3-snapshot-artifact-metadata.xml" );
+
+ compareFiles( expectedMetadataFile, artifactMetadataFile );
+
+ assertTrue( "Check snapshot metadata created", snapshotMetadataFile.exists() );
+
+ expectedMetadataFile = getTestFile( "src/test/expected-files/v3-snapshot-metadata.xml" );
+
+ compareFiles( expectedMetadataFile, snapshotMetadataFile );
+ }
+
+ @Test
+ public void testV4SnapshotPomConvert()
+ throws Exception
+ {
+ doTestV4SnapshotPomConvert( "1.0.0-SNAPSHOT", "src/test/expected-files/v4-snapshot-metadata.xml" );
+
+ assertTrue( true );
+ }
+
+ @Test
+ public void testV4TimestampedSnapshotPomConvert()
+ throws Exception
+ {
+ doTestV4SnapshotPomConvert( "1.0.0-20060111.120115-1",
+ "src/test/expected-files/v4-timestamped-snapshot-metadata.xml" );
+
+ assertTrue( true );
+ }
+
+ @Test
+ public void testMavenOnePluginConversion()
+ throws Exception
+ {
+ Artifact artifact =
+ createArtifact( "org.apache.maven.plugins", "maven-foo-plugin", "1.0", "1.0", "maven-plugin" );
+ artifact.setFile(
+ new File( FileUtil.getBasedir(), "src/test/source-repository/test/plugins/maven-foo-plugin-1.0.jar" ) );
+ artifactConverter.convert( artifact, targetRepository );
+ // There is a warning but I can't figure out how to look at it. Eyeballing the results it appears
+ // the plugin is being coverted correctly.
+ //checkSuccess();
+
+ File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ assertTrue( "Check artifact created", artifactFile.exists() );
+ assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
+
+ /*
+ The POM isn't needed for Maven 1.x plugins but the raw conversion for
+
+ artifact = createPomArtifact( artifact );
+ File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File expectedPomFile = getTestFile( "src/test/expected-files/maven-foo-plugin-1.0.pom" );
+ assertTrue( "Check POM created", pomFile.exists() );
+ compareFiles( expectedPomFile, pomFile );
+ */
+ }
+
+ @Test
+ public void testV3TimestampedSnapshotPomConvert()
+ throws Exception
+ {
+ // test that the pom is coverted
+
+ Artifact artifact = createArtifact( "test", "v3artifact", "1.0.0-20060105.130101-3" );
+ ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
+ File artifactMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
+ artifactMetadataFile.delete();
+
+ ArtifactMetadata snapshotMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
+ File snapshotMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( snapshotMetadata ) );
+ snapshotMetadataFile.delete();
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkSuccess( artifactConverter );
+
+ File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ assertTrue( "Check artifact created", artifactFile.exists() );
+ assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
+
+ artifact = createPomArtifact( artifact );
+ File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File expectedPomFile = getTestFile( "src/test/expected-files/converted-v3-timestamped-snapshot.pom" );
+ assertTrue( "Check POM created", pomFile.exists() );
+
+ compareFiles( expectedPomFile, pomFile );
+
+ assertTrue( "Check artifact snapshotMetadata created", artifactMetadataFile.exists() );
+
+ File expectedMetadataFile = getTestFile( "src/test/expected-files/v3-snapshot-artifact-metadata.xml" );
+
+ compareFiles( expectedMetadataFile, artifactMetadataFile );
+
+ assertTrue( "Check snapshot snapshotMetadata created", snapshotMetadataFile.exists() );
+
+ expectedMetadataFile = getTestFile( "src/test/expected-files/v3-timestamped-snapshot-metadata.xml" );
+
+ compareFiles( expectedMetadataFile, snapshotMetadataFile );
+ }
+
+ @Test
+ public void testNoPomConvert()
+ throws Exception
+ {
+ // test that a POM is not created when there was none at the source
+
+ Artifact artifact = createArtifact( "test", "noPomArtifact", "1.0.0" );
+ artifactConverter.convert( artifact, targetRepository );
+ checkWarnings( artifactConverter, 1 );
+
+ assertHasWarningReason( artifactConverter, Messages.getString( "warning.missing.pom" ) );
+
+ File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ assertTrue( "Check artifact created", artifactFile.exists() );
+ assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
+
+ artifact = createPomArtifact( artifact );
+ File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
+
+ assertFalse( "Check no POM created", pomFile.exists() );
+ assertFalse( "No source POM", sourcePomFile.exists() );
+ }
+
+ @Test
+ public void testIncorrectSourceChecksumMd5()
+ throws Exception
+ {
+ // test that it fails when the source md5 is wrong
+
+ Artifact artifact = createArtifact( "test", "incorrectMd5Artifact", "1.0.0" );
+ File file = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ file.delete();
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkWarnings( artifactConverter, 2 );
+
+ assertHasWarningReason( artifactConverter, Messages.getString( "failure.incorrect.md5" ) );
+
+ assertFalse( "Check artifact not created", file.exists() );
+
+ ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
+ File metadataFile =
+ new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
+ assertFalse( "Check metadata not created", metadataFile.exists() );
+ }
+
+ @Test
+ public void testIncorrectSourceChecksumSha1()
+ throws Exception
+ {
+ // test that it fails when the source sha1 is wrong
+
+ Artifact artifact = createArtifact( "test", "incorrectSha1Artifact", "1.0.0" );
+ File file = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ file.delete();
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkWarnings( artifactConverter, 2 );
+
+ assertHasWarningReason( artifactConverter, Messages.getString( "failure.incorrect.sha1" ) );
+
+ assertFalse( "Check artifact not created", file.exists() );
+
+ ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
+ File metadataFile =
+ new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
+ assertFalse( "Check metadata not created", metadataFile.exists() );
+ }
+
+ @Test
+ public void testUnmodifiedArtifact()
+ throws Exception, InterruptedException
+ {
+ // test the unmodified artifact is untouched
+
+ Artifact artifact = createArtifact( "test", "unmodified-artifact", "1.0.0" );
+ Artifact pomArtifact = createPomArtifact( artifact );
+
+ File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
+ File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
+ File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
+
+ assertTrue( "Check target file exists", targetFile.exists() );
+ assertTrue( "Check target POM exists", targetPomFile.exists() );
+
+ sourceFile.setLastModified( System.currentTimeMillis() );
+ sourcePomFile.setLastModified( System.currentTimeMillis() );
+
+ long origTime = targetFile.lastModified();
+ long origPomTime = targetPomFile.lastModified();
+
+ // Need to guarantee last modified is not equal
+ Thread.sleep( SLEEP_MILLIS );
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkSuccess( artifactConverter );
+
+ compareFiles( sourceFile, targetFile );
+ compareFiles( sourcePomFile, targetPomFile );
+
+ assertEquals( "Check artifact unmodified", origTime, targetFile.lastModified() );
+ assertEquals( "Check POM unmodified", origPomTime, targetPomFile.lastModified() );
+ }
+
+ @Test
+ public void testModifedArtifactFails()
+ throws Exception
+ {
+ // test that it fails when the source artifact has changed and is different to the existing artifact in the
+ // target repository
+
+ Artifact artifact = createArtifact( "test", "modified-artifact", "1.0.0" );
+ Artifact pomArtifact = createPomArtifact( artifact );
+
+ File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
+ File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
+ File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
+
+ assertTrue( "Check target file exists", targetFile.exists() );
+ assertTrue( "Check target POM exists", targetPomFile.exists() );
+
+ sourceFile.setLastModified( System.currentTimeMillis() );
+ sourcePomFile.setLastModified( System.currentTimeMillis() );
+
+ long origTime = targetFile.lastModified();
+ long origPomTime = targetPomFile.lastModified();
+
+ // Need to guarantee last modified is not equal
+ Thread.sleep( SLEEP_MILLIS );
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkWarnings( artifactConverter, 2 );
+
+ assertHasWarningReason( artifactConverter, Messages.getString( "failure.target.already.exists" ) );
+
+ assertEquals( "Check unmodified", origTime, targetFile.lastModified() );
+ assertEquals( "Check unmodified", origPomTime, targetPomFile.lastModified() );
+
+ ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
+ File metadataFile =
+ new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
+ assertFalse( "Check metadata not created", metadataFile.exists() );
+ }
+
+ @Test
+ public void testForcedUnmodifiedArtifact()
+ throws Exception
+ {
+ // test unmodified artifact is still converted when set to force
+
+ artifactConverter =
+ applicationContext.getBean( "artifactConverter#force-repository-converter", ArtifactConverter.class );
+
+ Artifact artifact = createArtifact( "test", "unmodified-artifact", "1.0.0" );
+ Artifact pomArtifact = createPomArtifact( artifact );
+
+ File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
+ File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
+ File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
+
+ SimpleDateFormat dateFormat = new SimpleDateFormat( "yyyy-MM-dd", Locale.getDefault() );
+ long origTime = dateFormat.parse( "2006-03-03" ).getTime();
+ targetFile.setLastModified( origTime );
+ targetPomFile.setLastModified( origTime );
+
+ sourceFile.setLastModified( dateFormat.parse( "2006-01-01" ).getTime() );
+ sourcePomFile.setLastModified( dateFormat.parse( "2006-02-02" ).getTime() );
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkSuccess( artifactConverter );
+
+ compareFiles( sourceFile, targetFile );
+ compareFiles( sourcePomFile, targetPomFile );
+
+ assertFalse( "Check modified", origTime == targetFile.lastModified() );
+ assertFalse( "Check modified", origTime == targetPomFile.lastModified() );
+
+ ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
+ File metadataFile =
+ new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
+ assertTrue( "Check metadata created", metadataFile.exists() );
+ }
+
+ @Test
+ public void testDryRunSuccess()
+ throws Exception
+ {
+ // test dry run does nothing on a run that will be successful, and returns success
+
+ artifactConverter =
+ applicationContext.getBean( "artifactConverter#dryrun-repository-converter", ArtifactConverter.class );
+
+ Artifact artifact = createArtifact( "test", "dryrun-artifact", "1.0.0" );
+ Artifact pomArtifact = createPomArtifact( artifact );
+
+ File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
+ File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
+ File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkSuccess( artifactConverter );
+
+ assertTrue( "Check source file exists", sourceFile.exists() );
+ assertTrue( "Check source POM exists", sourcePomFile.exists() );
+
+ assertFalse( "Check target file doesn't exist", targetFile.exists() );
+ assertFalse( "Check target POM doesn't exist", targetPomFile.exists() );
+
+ ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
+ File metadataFile =
+ new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
+ assertFalse( "Check metadata not created", metadataFile.exists() );
+ }
+
+ @Test
+ public void testDryRunFailure()
+ throws Exception
+ {
+ // test dry run does nothing on a run that will fail, and returns failure
+
+ artifactConverter =
+ applicationContext.getBean( "artifactConverter#dryrun-repository-converter", ArtifactConverter.class );
+
+ Artifact artifact = createArtifact( "test", "modified-artifact", "1.0.0" );
+ Artifact pomArtifact = createPomArtifact( artifact );
+
+ File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
+ File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
+ File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
+
+ assertTrue( "Check target file exists", targetFile.exists() );
+ assertTrue( "Check target POM exists", targetPomFile.exists() );
+
+ sourceFile.setLastModified( System.currentTimeMillis() );
+ sourcePomFile.setLastModified( System.currentTimeMillis() );
+
+ long origTime = targetFile.lastModified();
+ long origPomTime = targetPomFile.lastModified();
+
+ // Need to guarantee last modified is not equal
+ Thread.sleep( SLEEP_MILLIS );
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkWarnings( artifactConverter, 2 );
+
+ assertHasWarningReason( artifactConverter, Messages.getString( "failure.target.already.exists" ) );
+
+ assertEquals( "Check unmodified", origTime, targetFile.lastModified() );
+ assertEquals( "Check unmodified", origPomTime, targetPomFile.lastModified() );
+
+ ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
+ File metadataFile =
+ new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
+ assertFalse( "Check metadata not created", metadataFile.exists() );
+ }
+
+ @Test
+ public void testRollbackArtifactCreated()
+ throws Exception
+ {
+ // test rollback can remove a created artifact, including checksums
+
+ Artifact artifact = createArtifact( "test", "rollback-created-artifact", "1.0.0" );
+ ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
+ File artifactMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
+ FileUtils.deleteDirectory( artifactMetadataFile.getParentFile() );
+
+ ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
+ File versionMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
+
+ File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkWarnings( artifactConverter, 2 );
+
+ boolean found = false;
+ String pattern = "^" + Messages.getString( "invalid.source.pom" ).replaceFirst( "\\{0\\}", ".*" ) + "$";
+ for ( List<String> messages : artifactConverter.getWarnings().values() )
+ {
+ for ( String message : messages )
+ {
+ if ( message.matches( pattern ) )
+ {
+ found = true;
+ break;
+ }
+ }
+
+ if ( found )
+ {
+ break;
+ }
+ }
+
+ assertTrue( "Check failure message.", found );
+
+ assertFalse( "check artifact rolled back", artifactFile.exists() );
+ assertFalse( "check metadata rolled back", artifactMetadataFile.exists() );
+ assertFalse( "check metadata rolled back", versionMetadataFile.exists() );
+ }
+
+ @Test
+ public void testMultipleArtifacts()
+ throws Exception
+ {
+ // test multiple artifacts are converted
+
+ List<Artifact> artifacts = new ArrayList<Artifact>();
+ artifacts.add( createArtifact( "test", "artifact-one", "1.0.0" ) );
+ artifacts.add( createArtifact( "test", "artifact-two", "1.0.0" ) );
+ artifacts.add( createArtifact( "test", "artifact-three", "1.0.0" ) );
+
+ for ( Artifact artifact : artifacts )
+ {
+ artifactConverter.convert( artifact, targetRepository );
+ checkSuccess( artifactConverter );
+ }
+
+ for ( Artifact artifact : artifacts )
+ {
+ File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ assertTrue( "Check artifact created", artifactFile.exists() );
+ assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
+
+ artifact = createPomArtifact( artifact );
+ File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File expectedPomFile =
+ getTestFile( "src/test/expected-files/converted-" + artifact.getArtifactId() + ".pom" );
+ assertTrue( "Check POM created", pomFile.exists() );
+
+ compareFiles( expectedPomFile, pomFile );
+ }
+ }
+
+ @Test
+ public void testInvalidSourceArtifactMetadata()
+ throws Exception
+ {
+ // test artifact is not converted when source metadata is invalid, and returns failure
+
+ createModernSourceRepository();
+
+ Artifact artifact = createArtifact( "test", "incorrectArtifactMetadata", "1.0.0" );
+ File file = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ file.delete();
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkWarnings( artifactConverter, 2 );
+
+ assertHasWarningReason( artifactConverter,
+ Messages.getString( "failure.incorrect.artifactMetadata.versions" ) );
+
+ assertFalse( "Check artifact not created", file.exists() );
+
+ ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
+ File metadataFile =
+ new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
+ assertFalse( "Check metadata not created", metadataFile.exists() );
+ }
+
+ @Test
+ public void testInvalidSourceSnapshotMetadata()
+ throws Exception
+ {
+ // test artifact is not converted when source snapshot metadata is invalid and returns failure
+
+ createModernSourceRepository();
+
+ Artifact artifact = createArtifact( "test", "incorrectSnapshotMetadata", "1.0.0-20060102.030405-6" );
+ File file = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ file.delete();
+
+ artifactConverter.convert( artifact, targetRepository );
+ checkWarnings( artifactConverter, 2 );
+
+ assertHasWarningReason( artifactConverter,
+ Messages.getString( "failure.incorrect.snapshotMetadata.snapshot" ) );
+
+ assertFalse( "Check artifact not created", file.exists() );
+
+ ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
+ File metadataFile =
+ new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
+ assertFalse( "Check metadata not created", metadataFile.exists() );
+ }
+
+ @Test
+ public void testMergeArtifactMetadata()
+ throws Exception
+ {
+ // test artifact level metadata is merged when it already exists on successful conversion
+
+ Artifact artifact = createArtifact( "test", "newversion-artifact", "1.0.1" );
+ artifactConverter.convert( artifact, targetRepository );
+ checkSuccess( artifactConverter );
+
+ File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ assertTrue( "Check artifact created", artifactFile.exists() );
+ assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
+
+ artifact = createPomArtifact( artifact );
+ File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
+ File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
+ assertTrue( "Check POM created", pomFile.exists() );
+
+ compareFiles( sourcePomFile, pomFile );
+
+ ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
+ File artifactMetadataFile = new File( targetRepository.getBasedir(),
+ targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
+ assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
+
+ File expectedMetadataFile = getTestFile( "src/test/expected-files/newversion-artifact-metadata.xml" );
+
+ compareFiles( expectedMetadataFile, artifactMetadataFile );
+ }
+
+ @Test
+ public void testSourceAndTargetRepositoriesMatch()
+ throws Exception
+ {
+ // test that it fails if the same
+
+ ArtifactRepositoryFactory factory = plexusSisuBridge.lookup( ArtifactRepositoryFactory.class );
+
+ sourceRepository =
+ factory.createArtifactRepository( "source", targetRepository.getUrl(), targetRepository.getLayout(), null,
+ null );
+
+ Artifact artifact = createArtifact( "test", "repository-artifact", "1.0" );
+
+ try
+ {
+ artifactConverter.convert( artifact, targetRepository );
+ fail( "Should have failed trying to convert within the same repository" );
+ }
+ catch ( ArtifactConversionException e )
+ {
+ // expected
+ assertEquals( "check message", Messages.getString( "exception.repositories.match" ), e.getMessage() );
+ assertNull( "Check no additional cause", e.getCause() );
+ }
+ }
+
+ private Artifact createArtifact( String groupId, String artifactId, String version )
+ {
+ Matcher matcher = Artifact.VERSION_FILE_PATTERN.matcher( version );
+ String baseVersion;
+ if ( matcher.matches() )
+ {
+ baseVersion = matcher.group( 1 ) + "-SNAPSHOT";
+ }
+ else
+ {
+ baseVersion = version;
+ }
+ return createArtifact( groupId, artifactId, baseVersion, version, "jar" );
+ }
+
+ private Artifact createArtifact( String groupId, String artifactId, String baseVersion, String version,
+ String type )
+ {
+ Artifact artifact = artifactFactory.createArtifact( groupId, artifactId, version, null, type );
+ artifact.setBaseVersion( baseVersion );
+ artifact.setRepository( sourceRepository );
+ artifact.setFile( new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) ) );
+ return artifact;
+ }
+
+ private Artifact createPomArtifact( Artifact artifact )
+ {
+ return createArtifact( artifact.getGroupId(), artifact.getArtifactId(), artifact.getBaseVersion(),
+ artifact.getVersion(), "pom" );
+ }
+
+ private static void compareFiles( File expectedPomFile, File pomFile )
+ throws IOException
+ {
+ String expectedContent =
+ normalizeString( org.apache.commons.io.FileUtils.readFileToString( expectedPomFile, null ) );
+ String targetContent = normalizeString( org.apache.commons.io.FileUtils.readFileToString( pomFile, null ) );
+ assertEquals( "Check file match between " + expectedPomFile + " and " + pomFile, expectedContent,
+ targetContent );
+ }
+
+ private static String normalizeString( String path )
+ {
+ return path.trim().replaceAll( "\r\n", "\n" ).replace( '\r', '\n' ).replaceAll( "<\\?xml .+\\?>",
+ "" ).replaceAll( "^\\s+", "" );
+ }
+
+ private void checkSuccess( ArtifactConverter converter )
+ {
+ assertNotNull( "Warnings should never be null.", converter.getWarnings() );
+ assertEquals( "Should have no warnings.", 0, countWarningMessages( converter ) );
+ }
+
+ private void checkWarnings( ArtifactConverter converter, int count )
+ {
+ assertNotNull( "Warnings should never be null.", converter.getWarnings() );
+ assertEquals( "Should have some warnings.", count, countWarningMessages( converter ) );
+ }
+
+ private int countWarningMessages( ArtifactConverter converter )
+ {
+ int count = 0;
+ for ( List<String> values : converter.getWarnings().values() )
+ {
+ count += values.size();
+ }
+ return count;
+ }
+
+ private void assertHasWarningReason( ArtifactConverter converter, String reason )
+ {
+ assertNotNull( "Warnings should never be null.", converter.getWarnings() );
+ assertTrue( "Expecting 1 or more Warnings", countWarningMessages( converter ) > 0 );
+
+ for ( List<String> messages : converter.getWarnings().values() )
+ {
+ if ( messages.contains( reason ) )
+ {
+ /* No need to check any further */
+ return;
+ }
+ }
+
+ /* didn't find it. */
+
+ for ( Map.Entry<Artifact, List<String>> entry : converter.getWarnings().entrySet() )
+ {
+ Artifact artifact = (Artifact) entry.getKey();
+ System.out.println(
+ "-Artifact: " + artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getVersion() );
+ List<String> messages = entry.getValue();
+ for ( String message : messages )
+ {
+ System.out.println( " " + message );
+ }
+ }
+ fail( "Unable to find message <" + reason + "> in warnings." );
+ }
+
+ private void createModernSourceRepository()
+ throws Exception
+ {
+ ArtifactRepositoryFactory factory = plexusSisuBridge.lookup( ArtifactRepositoryFactory.class );
+
+ ArtifactRepositoryLayout layout = plexusSisuBridge.lookup( ArtifactRepositoryLayout.class, "default" );
+
+ File sourceBase = getTestFile( "src/test/source-modern-repository" );
+ sourceRepository =
+ factory.createArtifactRepository( "source", sourceBase.toURL().toString(), layout, null, null );
+ }
+}
+++ /dev/null
-package org.apache.maven.archiva.converter.artifact;
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-import junit.framework.TestCase;
-import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
-import org.apache.commons.io.FileUtils;
-import org.apache.maven.archiva.common.utils.FileUtil;
-import org.apache.maven.artifact.Artifact;
-import org.apache.maven.artifact.factory.ArtifactFactory;
-import org.apache.maven.artifact.metadata.ArtifactMetadata;
-import org.apache.maven.artifact.repository.ArtifactRepository;
-import org.apache.maven.artifact.repository.ArtifactRepositoryFactory;
-import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout;
-import org.apache.maven.artifact.repository.metadata.ArtifactRepositoryMetadata;
-import org.apache.maven.artifact.repository.metadata.SnapshotArtifactRepositoryMetadata;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.springframework.context.ApplicationContext;
-import org.springframework.test.context.ContextConfiguration;
-import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
-
-import javax.inject.Inject;
-import java.io.File;
-import java.io.IOException;
-import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.regex.Matcher;
-
-/**
- * LegacyToDefaultConverterTest
- *
- * @version $Id$
- */
-@RunWith( SpringJUnit4ClassRunner.class )
-@ContextConfiguration( locations = { "classpath*:/META-INF/spring-context.xml", "classpath:/spring-context.xml" } )
-public class LegacyToDefaultConverterTest
- extends TestCase
-{
- private ArtifactRepository sourceRepository;
-
- private ArtifactRepository targetRepository;
-
- private ArtifactConverter artifactConverter;
-
- private ArtifactFactory artifactFactory;
-
- @Inject
- private PlexusSisuBridge plexusSisuBridge;
-
- @Inject
- private ApplicationContext applicationContext;
-
- private static final int SLEEP_MILLIS = 100;
-
- @Before
- public void init()
- throws Exception
- {
- super.setUp();
-
- ArtifactRepositoryFactory factory = plexusSisuBridge.lookup( ArtifactRepositoryFactory.class );
-
- Map<String, ArtifactRepositoryLayout> layoutsMap = plexusSisuBridge.lookupMap( ArtifactRepositoryLayout.class );
-
- System.out.println("hints " + layoutsMap.keySet().toString() );
-
- ArtifactRepositoryLayout layout = plexusSisuBridge.lookup( ArtifactRepositoryLayout.class, "legacy" );
-
- File sourceBase = getTestFile( "src/test/source-repository" );
- sourceRepository =
- factory.createArtifactRepository( "source", sourceBase.toURL().toString(), layout, null, null );
-
- layout = plexusSisuBridge.lookup( ArtifactRepositoryLayout.class, "default" );
-
- File targetBase = getTestFile( "target/test-target-repository" );
- copyDirectoryStructure( getTestFile( "src/test/target-repository" ), targetBase );
-
- targetRepository =
- factory.createArtifactRepository( "target", targetBase.toURL().toString(), layout, null, null );
-
- artifactConverter =
- applicationContext.getBean( "artifactConverter#legacy-to-default", ArtifactConverter.class );
-
- artifactConverter.clearWarnings();
- artifactFactory = (ArtifactFactory) plexusSisuBridge.lookup( ArtifactFactory.class );
- }
-
- public static File getTestFile( String path )
- {
- return new File( FileUtil.getBasedir(), path );
- }
-
- private void copyDirectoryStructure( File sourceDirectory, File destinationDirectory )
- throws IOException
- {
- if ( !sourceDirectory.exists() )
- {
- throw new IOException( "Source directory doesn't exists (" + sourceDirectory.getAbsolutePath() + ")." );
- }
-
- File[] files = sourceDirectory.listFiles();
-
- String sourcePath = sourceDirectory.getAbsolutePath();
-
- for ( int i = 0; i < files.length; i++ )
- {
- File file = files[i];
-
- String dest = file.getAbsolutePath();
-
- dest = dest.substring( sourcePath.length() + 1 );
-
- File destination = new File( destinationDirectory, dest );
-
- if ( file.isFile() )
- {
- destination = destination.getParentFile();
-
- FileUtils.copyFileToDirectory( file, destination );
- }
- else if ( file.isDirectory() )
- {
- if ( !".svn".equals( file.getName() ) )
- {
- if ( !destination.exists() && !destination.mkdirs() )
- {
- throw new IOException(
- "Could not create destination directory '" + destination.getAbsolutePath() + "'." );
- }
- copyDirectoryStructure( file, destination );
- }
- }
- else
- {
- throw new IOException( "Unknown file type: " + file.getAbsolutePath() );
- }
- }
- }
-
- @Test
- public void testV4PomConvert()
- throws Exception
- {
- // test that it is copied as is
-
- Artifact artifact = createArtifact( "test", "v4artifact", "1.0.0" );
- ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
- File artifactMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
- artifactMetadataFile.delete();
-
- ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
- File versionMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
- versionMetadataFile.delete();
-
- File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- artifactFile.delete();
-
- artifactConverter.convert( artifact, targetRepository );
- checkSuccess( artifactConverter );
-
- assertTrue( "Check artifact created", artifactFile.exists() );
- assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
-
- artifact = createPomArtifact( artifact );
- File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
- assertTrue( "Check POM created", pomFile.exists() );
-
- compareFiles( sourcePomFile, pomFile );
-
- assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
-
- File expectedMetadataFile = getTestFile( "src/test/expected-files/v4-artifact-metadata.xml" );
-
- compareFiles( expectedMetadataFile, artifactMetadataFile );
-
- assertTrue( "Check snapshot metadata created", versionMetadataFile.exists() );
-
- expectedMetadataFile = getTestFile( "src/test/expected-files/v4-version-metadata.xml" );
-
- compareFiles( expectedMetadataFile, versionMetadataFile );
- }
-
- @Test
- public void testV3PomConvert()
- throws Exception
- {
- // test that the pom is coverted
-
- Artifact artifact = createArtifact( "test", "v3artifact", "1.0.0" );
- ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
- File artifactMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
- artifactMetadataFile.delete();
-
- ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
- File versionMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
- versionMetadataFile.delete();
-
- artifactConverter.convert( artifact, targetRepository );
- checkSuccess( artifactConverter );
-
- File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- assertTrue( "Check artifact created", artifactFile.exists() );
- assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
-
- artifact = createPomArtifact( artifact );
- File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File expectedPomFile = getTestFile( "src/test/expected-files/converted-v3.pom" );
- assertTrue( "Check POM created", pomFile.exists() );
-
- compareFiles( expectedPomFile, pomFile );
-
- assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
-
- File expectedMetadataFile = getTestFile( "src/test/expected-files/v3-artifact-metadata.xml" );
-
- compareFiles( expectedMetadataFile, artifactMetadataFile );
-
- assertTrue( "Check snapshot metadata created", versionMetadataFile.exists() );
-
- expectedMetadataFile = getTestFile( "src/test/expected-files/v3-version-metadata.xml" );
-
- compareFiles( expectedMetadataFile, versionMetadataFile );
- }
-
- @Test
- public void testV3PomConvertWithRelocation()
- throws Exception
- {
- Artifact artifact = createArtifact( "test", "relocated-v3artifact", "1.0.0" );
- ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
- File artifactMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
- artifactMetadataFile.delete();
-
- ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
- File versionMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
- versionMetadataFile.delete();
-
- artifactConverter.convert( artifact, targetRepository );
- //checkSuccess(); --> commented until MNG-2100 is fixed
-
- File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- assertTrue( "Check if relocated artifact created", artifactFile.exists() );
- assertTrue( "Check if relocated artifact matches",
- FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
- Artifact pomArtifact = createArtifact( "relocated-test", "relocated-v3artifact", "1.0.0", "1.0.0", "pom" );
- File pomFile = getTestFile( "src/test/expected-files/" + targetRepository.pathOf( pomArtifact ) );
- File testFile = getTestFile( "target/test-target-repository/" + targetRepository.pathOf( pomArtifact ) );
- compareFiles( pomFile, testFile );
-
- Artifact orig = createArtifact( "test", "relocated-v3artifact", "1.0.0", "1.0.0", "pom" );
- artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( orig ) );
- assertTrue( "Check if relocation artifact pom is created", artifactFile.exists() );
- testFile = getTestFile( "src/test/expected-files/" + targetRepository.pathOf( orig ) );
- compareFiles( artifactFile, testFile );
- }
-
- @Test
- public void testV3PomWarningsOnConvert()
- throws Exception
- {
- // test that the pom is converted but that warnings are reported
-
- Artifact artifact = createArtifact( "test", "v3-warnings-artifact", "1.0.0" );
- ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
- File artifactMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
- artifactMetadataFile.delete();
-
- ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
- File versionMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
- versionMetadataFile.delete();
-
- artifactConverter.convert( artifact, targetRepository );
- checkWarnings( artifactConverter, 2 );
-
- File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- assertTrue( "Check artifact created", artifactFile.exists() );
- assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
-
- artifact = createPomArtifact( artifact );
- File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File expectedPomFile = getTestFile( "src/test/expected-files/converted-v3-warnings.pom" );
- assertTrue( "Check POM created", pomFile.exists() );
-
- compareFiles( expectedPomFile, pomFile );
-
- // TODO: check 2 warnings (extend and versions) matched on i18n key
- }
-
- private void doTestV4SnapshotPomConvert( String version, String expectedMetadataFileName )
- throws Exception
- {
- // test that it is copied as is
-
- Artifact artifact = createArtifact( "test", "v4artifact", version );
- ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
- File artifactMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
- artifactMetadataFile.delete();
-
- ArtifactMetadata snapshotMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
- File snapshotMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( snapshotMetadata ) );
- snapshotMetadataFile.delete();
-
- artifactConverter.convert( artifact, targetRepository );
- checkSuccess( artifactConverter );
-
- File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- assertTrue( "Check artifact created", artifactFile.exists() );
- assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
-
- artifact = createPomArtifact( artifact );
- File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
- assertTrue( "Check POM created", pomFile.exists() );
-
- compareFiles( sourcePomFile, pomFile );
-
- assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
-
- File expectedMetadataFile = getTestFile( "src/test/expected-files/v4-snapshot-artifact-metadata.xml" );
-
- compareFiles( expectedMetadataFile, artifactMetadataFile );
-
- assertTrue( "Check snapshot metadata created", snapshotMetadataFile.exists() );
-
- expectedMetadataFile = getTestFile( expectedMetadataFileName );
-
- compareFiles( expectedMetadataFile, snapshotMetadataFile );
- }
-
- @Test
- public void testV3SnapshotPomConvert()
- throws Exception
- {
- // test that the pom is coverted
-
- Artifact artifact = createArtifact( "test", "v3artifact", "1.0.0-SNAPSHOT" );
- ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
- File artifactMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
- artifactMetadataFile.delete();
-
- ArtifactMetadata snapshotMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
- File snapshotMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( snapshotMetadata ) );
- snapshotMetadataFile.delete();
-
- artifactConverter.convert( artifact, targetRepository );
- checkSuccess( artifactConverter );
-
- File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- assertTrue( "Check artifact created", artifactFile.exists() );
- assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
-
- artifact = createPomArtifact( artifact );
- File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File expectedPomFile = getTestFile( "src/test/expected-files/converted-v3-snapshot.pom" );
- assertTrue( "Check POM created", pomFile.exists() );
-
- compareFiles( expectedPomFile, pomFile );
-
- assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
-
- File expectedMetadataFile = getTestFile( "src/test/expected-files/v3-snapshot-artifact-metadata.xml" );
-
- compareFiles( expectedMetadataFile, artifactMetadataFile );
-
- assertTrue( "Check snapshot metadata created", snapshotMetadataFile.exists() );
-
- expectedMetadataFile = getTestFile( "src/test/expected-files/v3-snapshot-metadata.xml" );
-
- compareFiles( expectedMetadataFile, snapshotMetadataFile );
- }
-
- @Test
- public void testV4SnapshotPomConvert()
- throws Exception
- {
- doTestV4SnapshotPomConvert( "1.0.0-SNAPSHOT", "src/test/expected-files/v4-snapshot-metadata.xml" );
-
- assertTrue( true );
- }
-
- @Test
- public void testV4TimestampedSnapshotPomConvert()
- throws Exception
- {
- doTestV4SnapshotPomConvert( "1.0.0-20060111.120115-1",
- "src/test/expected-files/v4-timestamped-snapshot-metadata.xml" );
-
- assertTrue( true );
- }
-
- @Test
- public void testMavenOnePluginConversion()
- throws Exception
- {
- Artifact artifact =
- createArtifact( "org.apache.maven.plugins", "maven-foo-plugin", "1.0", "1.0", "maven-plugin" );
- artifact.setFile(
- new File( FileUtil.getBasedir(), "src/test/source-repository/test/plugins/maven-foo-plugin-1.0.jar" ) );
- artifactConverter.convert( artifact, targetRepository );
- // There is a warning but I can't figure out how to look at it. Eyeballing the results it appears
- // the plugin is being coverted correctly.
- //checkSuccess();
-
- File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- assertTrue( "Check artifact created", artifactFile.exists() );
- assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
-
- /*
- The POM isn't needed for Maven 1.x plugins but the raw conversion for
-
- artifact = createPomArtifact( artifact );
- File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File expectedPomFile = getTestFile( "src/test/expected-files/maven-foo-plugin-1.0.pom" );
- assertTrue( "Check POM created", pomFile.exists() );
- compareFiles( expectedPomFile, pomFile );
- */
- }
-
- @Test
- public void testV3TimestampedSnapshotPomConvert()
- throws Exception
- {
- // test that the pom is coverted
-
- Artifact artifact = createArtifact( "test", "v3artifact", "1.0.0-20060105.130101-3" );
- ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
- File artifactMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
- artifactMetadataFile.delete();
-
- ArtifactMetadata snapshotMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
- File snapshotMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( snapshotMetadata ) );
- snapshotMetadataFile.delete();
-
- artifactConverter.convert( artifact, targetRepository );
- checkSuccess( artifactConverter );
-
- File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- assertTrue( "Check artifact created", artifactFile.exists() );
- assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
-
- artifact = createPomArtifact( artifact );
- File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File expectedPomFile = getTestFile( "src/test/expected-files/converted-v3-timestamped-snapshot.pom" );
- assertTrue( "Check POM created", pomFile.exists() );
-
- compareFiles( expectedPomFile, pomFile );
-
- assertTrue( "Check artifact snapshotMetadata created", artifactMetadataFile.exists() );
-
- File expectedMetadataFile = getTestFile( "src/test/expected-files/v3-snapshot-artifact-metadata.xml" );
-
- compareFiles( expectedMetadataFile, artifactMetadataFile );
-
- assertTrue( "Check snapshot snapshotMetadata created", snapshotMetadataFile.exists() );
-
- expectedMetadataFile = getTestFile( "src/test/expected-files/v3-timestamped-snapshot-metadata.xml" );
-
- compareFiles( expectedMetadataFile, snapshotMetadataFile );
- }
-
- @Test
- public void testNoPomConvert()
- throws Exception
- {
- // test that a POM is not created when there was none at the source
-
- Artifact artifact = createArtifact( "test", "noPomArtifact", "1.0.0" );
- artifactConverter.convert( artifact, targetRepository );
- checkWarnings( artifactConverter, 1 );
-
- assertHasWarningReason( artifactConverter, Messages.getString( "warning.missing.pom" ) );
-
- File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- assertTrue( "Check artifact created", artifactFile.exists() );
- assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
-
- artifact = createPomArtifact( artifact );
- File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
-
- assertFalse( "Check no POM created", pomFile.exists() );
- assertFalse( "No source POM", sourcePomFile.exists() );
- }
-
- @Test
- public void testIncorrectSourceChecksumMd5()
- throws Exception
- {
- // test that it fails when the source md5 is wrong
-
- Artifact artifact = createArtifact( "test", "incorrectMd5Artifact", "1.0.0" );
- File file = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- file.delete();
-
- artifactConverter.convert( artifact, targetRepository );
- checkWarnings( artifactConverter, 2 );
-
- assertHasWarningReason( artifactConverter, Messages.getString( "failure.incorrect.md5" ) );
-
- assertFalse( "Check artifact not created", file.exists() );
-
- ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
- File metadataFile =
- new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
- assertFalse( "Check metadata not created", metadataFile.exists() );
- }
-
- @Test
- public void testIncorrectSourceChecksumSha1()
- throws Exception
- {
- // test that it fails when the source sha1 is wrong
-
- Artifact artifact = createArtifact( "test", "incorrectSha1Artifact", "1.0.0" );
- File file = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- file.delete();
-
- artifactConverter.convert( artifact, targetRepository );
- checkWarnings( artifactConverter, 2 );
-
- assertHasWarningReason( artifactConverter, Messages.getString( "failure.incorrect.sha1" ) );
-
- assertFalse( "Check artifact not created", file.exists() );
-
- ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
- File metadataFile =
- new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
- assertFalse( "Check metadata not created", metadataFile.exists() );
- }
-
- @Test
- public void testUnmodifiedArtifact()
- throws Exception, InterruptedException
- {
- // test the unmodified artifact is untouched
-
- Artifact artifact = createArtifact( "test", "unmodified-artifact", "1.0.0" );
- Artifact pomArtifact = createPomArtifact( artifact );
-
- File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
- File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
- File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
-
- assertTrue( "Check target file exists", targetFile.exists() );
- assertTrue( "Check target POM exists", targetPomFile.exists() );
-
- sourceFile.setLastModified( System.currentTimeMillis() );
- sourcePomFile.setLastModified( System.currentTimeMillis() );
-
- long origTime = targetFile.lastModified();
- long origPomTime = targetPomFile.lastModified();
-
- // Need to guarantee last modified is not equal
- Thread.sleep( SLEEP_MILLIS );
-
- artifactConverter.convert( artifact, targetRepository );
- checkSuccess( artifactConverter );
-
- compareFiles( sourceFile, targetFile );
- compareFiles( sourcePomFile, targetPomFile );
-
- assertEquals( "Check artifact unmodified", origTime, targetFile.lastModified() );
- assertEquals( "Check POM unmodified", origPomTime, targetPomFile.lastModified() );
- }
-
- @Test
- public void testModifedArtifactFails()
- throws Exception
- {
- // test that it fails when the source artifact has changed and is different to the existing artifact in the
- // target repository
-
- Artifact artifact = createArtifact( "test", "modified-artifact", "1.0.0" );
- Artifact pomArtifact = createPomArtifact( artifact );
-
- File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
- File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
- File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
-
- assertTrue( "Check target file exists", targetFile.exists() );
- assertTrue( "Check target POM exists", targetPomFile.exists() );
-
- sourceFile.setLastModified( System.currentTimeMillis() );
- sourcePomFile.setLastModified( System.currentTimeMillis() );
-
- long origTime = targetFile.lastModified();
- long origPomTime = targetPomFile.lastModified();
-
- // Need to guarantee last modified is not equal
- Thread.sleep( SLEEP_MILLIS );
-
- artifactConverter.convert( artifact, targetRepository );
- checkWarnings( artifactConverter, 2 );
-
- assertHasWarningReason( artifactConverter, Messages.getString( "failure.target.already.exists" ) );
-
- assertEquals( "Check unmodified", origTime, targetFile.lastModified() );
- assertEquals( "Check unmodified", origPomTime, targetPomFile.lastModified() );
-
- ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
- File metadataFile =
- new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
- assertFalse( "Check metadata not created", metadataFile.exists() );
- }
-
- @Test
- public void testForcedUnmodifiedArtifact()
- throws Exception
- {
- // test unmodified artifact is still converted when set to force
-
- artifactConverter =
- applicationContext.getBean( "artifactConverter#force-repository-converter", ArtifactConverter.class );
-
- Artifact artifact = createArtifact( "test", "unmodified-artifact", "1.0.0" );
- Artifact pomArtifact = createPomArtifact( artifact );
-
- File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
- File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
- File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
-
- SimpleDateFormat dateFormat = new SimpleDateFormat( "yyyy-MM-dd", Locale.getDefault() );
- long origTime = dateFormat.parse( "2006-03-03" ).getTime();
- targetFile.setLastModified( origTime );
- targetPomFile.setLastModified( origTime );
-
- sourceFile.setLastModified( dateFormat.parse( "2006-01-01" ).getTime() );
- sourcePomFile.setLastModified( dateFormat.parse( "2006-02-02" ).getTime() );
-
- artifactConverter.convert( artifact, targetRepository );
- checkSuccess( artifactConverter );
-
- compareFiles( sourceFile, targetFile );
- compareFiles( sourcePomFile, targetPomFile );
-
- assertFalse( "Check modified", origTime == targetFile.lastModified() );
- assertFalse( "Check modified", origTime == targetPomFile.lastModified() );
-
- ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
- File metadataFile =
- new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
- assertTrue( "Check metadata created", metadataFile.exists() );
- }
-
- @Test
- public void testDryRunSuccess()
- throws Exception
- {
- // test dry run does nothing on a run that will be successful, and returns success
-
- artifactConverter =
- applicationContext.getBean( "artifactConverter#dryrun-repository-converter", ArtifactConverter.class );
-
- Artifact artifact = createArtifact( "test", "dryrun-artifact", "1.0.0" );
- Artifact pomArtifact = createPomArtifact( artifact );
-
- File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
- File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
- File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
-
- artifactConverter.convert( artifact, targetRepository );
- checkSuccess( artifactConverter );
-
- assertTrue( "Check source file exists", sourceFile.exists() );
- assertTrue( "Check source POM exists", sourcePomFile.exists() );
-
- assertFalse( "Check target file doesn't exist", targetFile.exists() );
- assertFalse( "Check target POM doesn't exist", targetPomFile.exists() );
-
- ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
- File metadataFile =
- new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
- assertFalse( "Check metadata not created", metadataFile.exists() );
- }
-
- @Test
- public void testDryRunFailure()
- throws Exception
- {
- // test dry run does nothing on a run that will fail, and returns failure
-
- artifactConverter =
- applicationContext.getBean( "artifactConverter#dryrun-repository-converter", ArtifactConverter.class );
-
- Artifact artifact = createArtifact( "test", "modified-artifact", "1.0.0" );
- Artifact pomArtifact = createPomArtifact( artifact );
-
- File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
- File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
- File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
-
- assertTrue( "Check target file exists", targetFile.exists() );
- assertTrue( "Check target POM exists", targetPomFile.exists() );
-
- sourceFile.setLastModified( System.currentTimeMillis() );
- sourcePomFile.setLastModified( System.currentTimeMillis() );
-
- long origTime = targetFile.lastModified();
- long origPomTime = targetPomFile.lastModified();
-
- // Need to guarantee last modified is not equal
- Thread.sleep( SLEEP_MILLIS );
-
- artifactConverter.convert( artifact, targetRepository );
- checkWarnings( artifactConverter, 2 );
-
- assertHasWarningReason( artifactConverter, Messages.getString( "failure.target.already.exists" ) );
-
- assertEquals( "Check unmodified", origTime, targetFile.lastModified() );
- assertEquals( "Check unmodified", origPomTime, targetPomFile.lastModified() );
-
- ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
- File metadataFile =
- new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
- assertFalse( "Check metadata not created", metadataFile.exists() );
- }
-
- @Test
- public void testRollbackArtifactCreated()
- throws Exception
- {
- // test rollback can remove a created artifact, including checksums
-
- Artifact artifact = createArtifact( "test", "rollback-created-artifact", "1.0.0" );
- ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
- File artifactMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
- FileUtils.deleteDirectory( artifactMetadataFile.getParentFile() );
-
- ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
- File versionMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
-
- File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
-
- artifactConverter.convert( artifact, targetRepository );
- checkWarnings( artifactConverter, 2 );
-
- boolean found = false;
- String pattern = "^" + Messages.getString( "invalid.source.pom" ).replaceFirst( "\\{0\\}", ".*" ) + "$";
- for ( List<String> messages : artifactConverter.getWarnings().values() )
- {
- for ( String message : messages )
- {
- if ( message.matches( pattern ) )
- {
- found = true;
- break;
- }
- }
-
- if ( found )
- {
- break;
- }
- }
-
- assertTrue( "Check failure message.", found );
-
- assertFalse( "check artifact rolled back", artifactFile.exists() );
- assertFalse( "check metadata rolled back", artifactMetadataFile.exists() );
- assertFalse( "check metadata rolled back", versionMetadataFile.exists() );
- }
-
- @Test
- public void testMultipleArtifacts()
- throws Exception
- {
- // test multiple artifacts are converted
-
- List<Artifact> artifacts = new ArrayList<Artifact>();
- artifacts.add( createArtifact( "test", "artifact-one", "1.0.0" ) );
- artifacts.add( createArtifact( "test", "artifact-two", "1.0.0" ) );
- artifacts.add( createArtifact( "test", "artifact-three", "1.0.0" ) );
-
- for ( Artifact artifact : artifacts )
- {
- artifactConverter.convert( artifact, targetRepository );
- checkSuccess( artifactConverter );
- }
-
- for ( Artifact artifact : artifacts )
- {
- File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- assertTrue( "Check artifact created", artifactFile.exists() );
- assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
-
- artifact = createPomArtifact( artifact );
- File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File expectedPomFile =
- getTestFile( "src/test/expected-files/converted-" + artifact.getArtifactId() + ".pom" );
- assertTrue( "Check POM created", pomFile.exists() );
-
- compareFiles( expectedPomFile, pomFile );
- }
- }
-
- @Test
- public void testInvalidSourceArtifactMetadata()
- throws Exception
- {
- // test artifact is not converted when source metadata is invalid, and returns failure
-
- createModernSourceRepository();
-
- Artifact artifact = createArtifact( "test", "incorrectArtifactMetadata", "1.0.0" );
- File file = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- file.delete();
-
- artifactConverter.convert( artifact, targetRepository );
- checkWarnings( artifactConverter, 2 );
-
- assertHasWarningReason( artifactConverter,
- Messages.getString( "failure.incorrect.artifactMetadata.versions" ) );
-
- assertFalse( "Check artifact not created", file.exists() );
-
- ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
- File metadataFile =
- new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
- assertFalse( "Check metadata not created", metadataFile.exists() );
- }
-
- @Test
- public void testInvalidSourceSnapshotMetadata()
- throws Exception
- {
- // test artifact is not converted when source snapshot metadata is invalid and returns failure
-
- createModernSourceRepository();
-
- Artifact artifact = createArtifact( "test", "incorrectSnapshotMetadata", "1.0.0-20060102.030405-6" );
- File file = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- file.delete();
-
- artifactConverter.convert( artifact, targetRepository );
- checkWarnings( artifactConverter, 2 );
-
- assertHasWarningReason( artifactConverter,
- Messages.getString( "failure.incorrect.snapshotMetadata.snapshot" ) );
-
- assertFalse( "Check artifact not created", file.exists() );
-
- ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
- File metadataFile =
- new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
- assertFalse( "Check metadata not created", metadataFile.exists() );
- }
-
- @Test
- public void testMergeArtifactMetadata()
- throws Exception
- {
- // test artifact level metadata is merged when it already exists on successful conversion
-
- Artifact artifact = createArtifact( "test", "newversion-artifact", "1.0.1" );
- artifactConverter.convert( artifact, targetRepository );
- checkSuccess( artifactConverter );
-
- File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- assertTrue( "Check artifact created", artifactFile.exists() );
- assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
-
- artifact = createPomArtifact( artifact );
- File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
- File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
- assertTrue( "Check POM created", pomFile.exists() );
-
- compareFiles( sourcePomFile, pomFile );
-
- ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
- File artifactMetadataFile = new File( targetRepository.getBasedir(),
- targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
- assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
-
- File expectedMetadataFile = getTestFile( "src/test/expected-files/newversion-artifact-metadata.xml" );
-
- compareFiles( expectedMetadataFile, artifactMetadataFile );
- }
-
- @Test
- public void testSourceAndTargetRepositoriesMatch()
- throws Exception
- {
- // test that it fails if the same
-
- ArtifactRepositoryFactory factory = plexusSisuBridge.lookup( ArtifactRepositoryFactory.class );
-
- sourceRepository =
- factory.createArtifactRepository( "source", targetRepository.getUrl(), targetRepository.getLayout(), null,
- null );
-
- Artifact artifact = createArtifact( "test", "repository-artifact", "1.0" );
-
- try
- {
- artifactConverter.convert( artifact, targetRepository );
- fail( "Should have failed trying to convert within the same repository" );
- }
- catch ( ArtifactConversionException e )
- {
- // expected
- assertEquals( "check message", Messages.getString( "exception.repositories.match" ), e.getMessage() );
- assertNull( "Check no additional cause", e.getCause() );
- }
- }
-
- private Artifact createArtifact( String groupId, String artifactId, String version )
- {
- Matcher matcher = Artifact.VERSION_FILE_PATTERN.matcher( version );
- String baseVersion;
- if ( matcher.matches() )
- {
- baseVersion = matcher.group( 1 ) + "-SNAPSHOT";
- }
- else
- {
- baseVersion = version;
- }
- return createArtifact( groupId, artifactId, baseVersion, version, "jar" );
- }
-
- private Artifact createArtifact( String groupId, String artifactId, String baseVersion, String version,
- String type )
- {
- Artifact artifact = artifactFactory.createArtifact( groupId, artifactId, version, null, type );
- artifact.setBaseVersion( baseVersion );
- artifact.setRepository( sourceRepository );
- artifact.setFile( new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) ) );
- return artifact;
- }
-
- private Artifact createPomArtifact( Artifact artifact )
- {
- return createArtifact( artifact.getGroupId(), artifact.getArtifactId(), artifact.getBaseVersion(),
- artifact.getVersion(), "pom" );
- }
-
- private static void compareFiles( File expectedPomFile, File pomFile )
- throws IOException
- {
- String expectedContent =
- normalizeString( org.apache.commons.io.FileUtils.readFileToString( expectedPomFile, null ) );
- String targetContent = normalizeString( org.apache.commons.io.FileUtils.readFileToString( pomFile, null ) );
- assertEquals( "Check file match between " + expectedPomFile + " and " + pomFile, expectedContent,
- targetContent );
- }
-
- private static String normalizeString( String path )
- {
- return path.trim().replaceAll( "\r\n", "\n" ).replace( '\r', '\n' ).replaceAll( "<\\?xml .+\\?>",
- "" ).replaceAll( "^\\s+", "" );
- }
-
- private void checkSuccess( ArtifactConverter converter )
- {
- assertNotNull( "Warnings should never be null.", converter.getWarnings() );
- assertEquals( "Should have no warnings.", 0, countWarningMessages( converter ) );
- }
-
- private void checkWarnings( ArtifactConverter converter, int count )
- {
- assertNotNull( "Warnings should never be null.", converter.getWarnings() );
- assertEquals( "Should have some warnings.", count, countWarningMessages( converter ) );
- }
-
- private int countWarningMessages( ArtifactConverter converter )
- {
- int count = 0;
- for ( List<String> values : converter.getWarnings().values() )
- {
- count += values.size();
- }
- return count;
- }
-
- private void assertHasWarningReason( ArtifactConverter converter, String reason )
- {
- assertNotNull( "Warnings should never be null.", converter.getWarnings() );
- assertTrue( "Expecting 1 or more Warnings", countWarningMessages( converter ) > 0 );
-
- for ( List<String> messages : converter.getWarnings().values() )
- {
- if ( messages.contains( reason ) )
- {
- /* No need to check any further */
- return;
- }
- }
-
- /* didn't find it. */
-
- for ( Map.Entry<Artifact, List<String>> entry : converter.getWarnings().entrySet() )
- {
- Artifact artifact = (Artifact) entry.getKey();
- System.out.println(
- "-Artifact: " + artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getVersion() );
- List<String> messages = entry.getValue();
- for ( String message : messages )
- {
- System.out.println( " " + message );
- }
- }
- fail( "Unable to find message <" + reason + "> in warnings." );
- }
-
- private void createModernSourceRepository()
- throws Exception
- {
- ArtifactRepositoryFactory factory = plexusSisuBridge.lookup( ArtifactRepositoryFactory.class );
-
- ArtifactRepositoryLayout layout = plexusSisuBridge.lookup( ArtifactRepositoryLayout.class, "default" );
-
- File sourceBase = getTestFile( "src/test/source-modern-repository" );
- sourceRepository =
- factory.createArtifactRepository( "source", sourceBase.toURL().toString(), layout, null, null );
- }
-}
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
- <bean name="artifactConverter#force-repository-converter" class="org.apache.maven.archiva.converter.artifact.LegacyToDefaultConverter">
+ <bean name="artifactConverter#force-repository-converter" class="org.apache.archiva.converter.artifact.LegacyToDefaultConverter">
<property name="force" value="true"/>
<property name="dryrun" value="false"/>
</bean>
- <bean name="artifactConverter#dryrun-repository-converter" class="org.apache.maven.archiva.converter.artifact.LegacyToDefaultConverter">
+ <bean name="artifactConverter#dryrun-repository-converter" class="org.apache.archiva.converter.artifact.LegacyToDefaultConverter">
<property name="force" value="false"/>
<property name="dryrun" value="true"/>
</bean>
import org.apache.maven.archiva.consumers.AbstractMonitoredConsumer;
import org.apache.maven.archiva.consumers.ConsumerException;
import org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer;
-import org.apache.maven.archiva.converter.artifact.ArtifactConversionException;
-import org.apache.maven.archiva.converter.artifact.ArtifactConverter;
+import org.apache.archiva.converter.artifact.ArtifactConversionException;
+import org.apache.archiva.converter.artifact.ArtifactConverter;
import org.apache.maven.archiva.model.ArtifactReference;
import org.apache.maven.archiva.repository.ManagedRepositoryContent;
import org.apache.maven.archiva.repository.content.ManagedDefaultRepositoryContent;
projects / archiva.git / commitdiff