You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by mi...@apache.org on 2020/11/11 19:37:51 UTC

[maven-integration-testing] branch mng-6754-version-timestamp-in-multimodule-build updated (28f21b0 -> 7e4874f)

This is an automated email from the ASF dual-hosted git repository.

michaelo pushed a change to branch mng-6754-version-timestamp-in-multimodule-build
in repository https://gitbox.apache.org/repos/asf/maven-integration-testing.git.


 discard 28f21b0  [MNG-6754] Set the same timestamp in multi module builds (2/2)
     new 7e4874f  [MNG-6754] Set the same timestamp in multi module builds (2/2)

This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version.  This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:

 * -- * -- B -- O -- O -- O   (28f21b0)
            \
             N -- N -- N   refs/heads/mng-6754-version-timestamp-in-multimodule-build (7e4874f)

You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.

Any revisions marked "omit" are not gone; other references still
refer to them.  Any revisions marked "discard" are gone forever.

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 ...avenITmng6754TimestampInMultimoduleProject.java | 30 +++++++++++-----------
 1 file changed, 15 insertions(+), 15 deletions(-)


[maven-integration-testing] 01/01: [MNG-6754] Set the same timestamp in multi module builds (2/2)

Posted by mi...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

michaelo pushed a commit to branch mng-6754-version-timestamp-in-multimodule-build
in repository https://gitbox.apache.org/repos/asf/maven-integration-testing.git

commit 7e4874f065d1da677443bc28641303ae754411d6
Author: Michael Osipov <mi...@apache.org>
AuthorDate: Wed Nov 11 19:01:39 2020 +0100

    [MNG-6754] Set the same timestamp in multi module builds (2/2)
    
    Verify snapshot versions also with all deployed artifact files.
---
 core-it-suite/pom.xml                              |  41 +++--
 ...avenITmng6754TimestampInMultimoduleProject.java | 198 +++++++++++++++------
 2 files changed, 170 insertions(+), 69 deletions(-)

diff --git a/core-it-suite/pom.xml b/core-it-suite/pom.xml
index 926e116..f6e3a10 100644
--- a/core-it-suite/pom.xml
+++ b/core-it-suite/pom.xml
@@ -36,34 +36,34 @@ under the License.
 
   <!--
   By default, the project just packages the tests in an artifact. To actually run them, activate the profile "run-its":
-  
+
     mvn clean test -Prun-its
-  
+
   This will subject the Maven version running the build to the integration tests. If you would like to test a different
   Maven distribution, you can use the system property "mavenHome" to specify the path of the Maven distribution to test:
-  
+
     mvn clean test -Prun-its -DmavenHome=<maven-under-test>
-  
+
   Alternatively, you can just specify the version of a previously installed/deployed Maven distribution which will be
   downloaded, unpacked and tested:
 
     mvn clean test -Prun-its -DmavenVersion=2.2.1
-  
+
   It's also possible to point the ITs at an already downloaded Maven distribution:
-  
+
     mvn clean test -Prun-its -DmavenDistro=<path-to-bin-archive>
-  
+
   To run the ITs using embedded Maven 3.x, additionally activate the profile "embedded".
-  
+
   ITs that don't require to fork Maven can also be run from the IDE using the Maven projects from the workspace if the
   Maven dependencies are added to the test class path.
 
   To test with the maven wrapper, you should add the wrapperDistroDir too.
 
     mvn clean test -Prun-its -Dmaven.repo.local=<path-to-local-repo>  -DmavenDistro=<path-to-bin-archive> -DwrapperDistroDir=<path-to-wrapper-distro-directory> -DmavenWrapper=<path-to-wrapper-jar>
-	
+
   Tests can pick up the maven.wrapper.distrodir system property to unpack it into their testDir to verify the wrapper.
-  
+
   If you're behind a proxy, use the system properties proxy.host, proxy.port, proxy.user, proxy.pass and
   proxy.nonProxyHosts to specify the required proxy setup for the ITs. Alternatively, set the system property
   maven.it.central to a URL of a local repository manager (anonymous authentication only) that proxies the
@@ -74,7 +74,7 @@ under the License.
     <surefireMemory>-Xmx384m</surefireMemory>
     <!-- The original Maven distribution to test. -->
     <mavenHome>${maven.home}</mavenHome>
-    <!-- The (possibly instrumented copy of the) Maven distribution we actually 
+    <!-- The (possibly instrumented copy of the) Maven distribution we actually
       use for the tests. -->
     <preparedMavenHome>${mavenHome}</preparedMavenHome>
     <!-- default properties used to filter the global settings -->
@@ -106,20 +106,20 @@ under the License.
     <dependency>
       <groupId>org.codehaus.plexus</groupId>
       <artifactId>plexus-utils</artifactId>
-      <version>1.5.8</version>
+      <version>3.3.0</version>
       <!-- NOTE: Use compile scope for transitivity. -->
     </dependency>
     <dependency>
       <groupId>org.apache.maven.its</groupId>
       <artifactId>maven-it-helper</artifactId>
       <version>2.1-SNAPSHOT</version>
-      <!-- TODO: not transitive in tests artifact, so must be left in main 
+      <!-- TODO: not transitive in tests artifact, so must be left in main
         scope <scope>test</scope> -->
     </dependency>
     <dependency>
       <groupId>org.apache.maven.shared</groupId>
       <artifactId>maven-verifier</artifactId>
-      <!-- TODO: not transitive in tests artifact, so must be left in main 
+      <!-- TODO: not transitive in tests artifact, so must be left in main
         scope <scope>test</scope> -->
     </dependency>
     <dependency>
@@ -158,6 +158,11 @@ under the License.
       <version>0.3.4</version>
       <scope>provided</scope>
     </dependency>
+    <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-repository-metadata</artifactId>
+      <version>3.6.3</version>
+    </dependency>
   </dependencies>
 
   <build>
@@ -283,7 +288,7 @@ under the License.
             <configuration>
               <systemProperties combine.children="append">
                 <property>
-                  <!-- Pass this through to the tests (if set!) to have them 
+                  <!-- Pass this through to the tests (if set!) to have them
                     pick the right repository -->
                   <name>maven.repo.local</name>
                   <value>${maven.repo.local}</value>
@@ -308,7 +313,7 @@ under the License.
             <configuration>
               <systemProperties combine.children="append">
                 <property>
-                  <!-- Pass this through to the tests (if set!) to have them 
+                  <!-- Pass this through to the tests (if set!) to have them
                     pick the right repository layout -->
                   <name>maven.repo.local.layout</name>
                   <value>${maven.repo.local.layout}</value>
@@ -327,7 +332,7 @@ under the License.
       <properties>
          <surefireMemory>-Xmx384m -XX:MaxPermSize=192m</surefireMemory>
       </properties>
-    </profile> 
+    </profile>
     <profile>
       <id>embedded</id>
       <build>
@@ -339,7 +344,7 @@ under the License.
               <forkMode>once</forkMode>
               <argLine>${surefireMemory}
                 -Dcom.sun.management.jmxremote=true</argLine>
-              <!-- NOTE: Maven plugins have access to the system class path 
+              <!-- NOTE: Maven plugins have access to the system class path
                 so keep it clean -->
               <useSystemClassLoader>false</useSystemClassLoader>
               <systemProperties combine.children="append">
diff --git a/core-it-suite/src/test/java/org/apache/maven/it/MavenITmng6754TimestampInMultimoduleProject.java b/core-it-suite/src/test/java/org/apache/maven/it/MavenITmng6754TimestampInMultimoduleProject.java
index 247050a..9427db2 100644
--- a/core-it-suite/src/test/java/org/apache/maven/it/MavenITmng6754TimestampInMultimoduleProject.java
+++ b/core-it-suite/src/test/java/org/apache/maven/it/MavenITmng6754TimestampInMultimoduleProject.java
@@ -19,26 +19,27 @@ package org.apache.maven.it;
  * under the License.
  */
 
-import org.apache.maven.it.util.ResourceExtractor;
+import static java.util.Arrays.asList;
 
 import java.io.File;
 import java.io.IOException;
-import java.nio.charset.Charset;
+import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.List;
 import java.util.Properties;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
-import static java.util.Arrays.asList;
+import org.apache.maven.artifact.repository.metadata.Metadata;
+import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Reader;
+import org.apache.maven.it.util.ResourceExtractor;
+
+import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
 
 public class MavenITmng6754TimestampInMultimoduleProject
         extends AbstractMavenIntegrationTestCase
 {
-    private static final Pattern LAST_UPDATED_LINE = Pattern.compile( "<lastUpdated>(\\d*)</lastUpdated>" );
     private static final String RESOURCE_PATH = "/mng-6754-version-timestamp-in-multimodule-build";
+    private static final String VERSION = "1.0-SNAPSHOT";
 
 
     public MavenITmng6754TimestampInMultimoduleProject()
@@ -61,64 +62,159 @@ public class MavenITmng6754TimestampInMultimoduleProject
         verifier.verifyErrorFreeLog();
 
         final Properties props = verifier.loadProperties( "target/timestamp.properties" );
+        // Reference timestamp
         final String mavenBuildTimestamp = props.getProperty( "project.properties.timestamp" );
 
-        final String parentLastUpdatedLocal = getLastUpdatedFromMetadata( getLocalMetadataPath( localRepoDir, "parent" ) );
-        final String aLastUpdatedLocal = getLastUpdatedFromMetadata( getLocalMetadataPath( localRepoDir, "child-a" ) );
-        final String bLastUpdatedLocal = getLastUpdatedFromMetadata( getLocalMetadataPath( localRepoDir, "child-b" ) );
-
-        final String parentLastUpdatedRemote = getLastUpdatedFromMetadata( getRemoteMetadataPath( remoteRepoDir, "parent" ) );
-        final String aLastUpdatedRemote = getLastUpdatedFromMetadata( getRemoteMetadataPath( remoteRepoDir, "child-a" ) );
-        final String bLastUpdatedRemote = getLastUpdatedFromMetadata( getRemoteMetadataPath( remoteRepoDir, "child-b" ) );
-
-        assertEquals( "Installed child modules should have equal lastUpdated in maven-metadata-local.xml",
-                aLastUpdatedLocal, bLastUpdatedLocal );
-        assertEquals( "Installed parent module should have equal lastUpdated in maven-metadata-local.xml as their children",
-                aLastUpdatedLocal, parentLastUpdatedLocal );
-        assertEquals( "Deployed child modules should have equal lastUpdated in maven-metadata.xml",
-                aLastUpdatedRemote, bLastUpdatedRemote );
-        assertEquals( "Deployed parent module should have equal lastUpdated in maven-metadata.xml as their children",
-                aLastUpdatedRemote, parentLastUpdatedRemote );
-        assertEquals( "Installed parent module should have equal lastUpdated as deployed counterparts",
-                parentLastUpdatedLocal, parentLastUpdatedRemote );
-        assertEquals( "Installed child-a module should have equal lastUpdated as deployed counterparts",
-                aLastUpdatedLocal, aLastUpdatedRemote );
-        assertEquals( "Installed child-b module should have equal lastUpdated as deployed counterparts",
-                bLastUpdatedLocal, bLastUpdatedRemote );
-        assertEquals( "Installed parent module should have equal lastUpdated as the Maven build timestamp",
-                parentLastUpdatedLocal, mavenBuildTimestamp );
-        assertEquals( "Deployed parent module should have equal lastUpdated as the Maven build timestamp",
-                parentLastUpdatedRemote, mavenBuildTimestamp );
+        final Metadata parentMetadataLocal = getMetadata( getLocalMetadataPath( localRepoDir, "parent", null ) );
+        final Metadata aMetadataLocal = getMetadata( getLocalMetadataPath( localRepoDir, "child-a", null ) );
+        final Metadata bMetadataLocal = getMetadata( getLocalMetadataPath( localRepoDir, "child-b", null ) );
+
+        final String parentLastUpdatedLocal = parentMetadataLocal.getVersioning().getLastUpdated();
+        final String aLastUpdatedLocal = aMetadataLocal.getVersioning().getLastUpdated();
+        final String bLastUpdatedLocal = bMetadataLocal.getVersioning().getLastUpdated();
+
+        assertEquals ( "parent", "local", "lastUpdated", mavenBuildTimestamp, parentLastUpdatedLocal );
+        assertEquals ( "child-a", "local", "lastUpdated", mavenBuildTimestamp, aLastUpdatedLocal );
+        assertEquals ( "child-b", "local", "lastUpdated", mavenBuildTimestamp, bLastUpdatedLocal );
+
+        final Metadata parentVersionedMetadataLocal = getMetadata( getLocalMetadataPath( localRepoDir, "parent", VERSION ) );
+        final Metadata aVersionedMetadataLocal = getMetadata( getLocalMetadataPath( localRepoDir, "child-a", VERSION ) );
+        final Metadata bVersionedMetadataLocal = getMetadata( getLocalMetadataPath( localRepoDir, "child-b", VERSION ) );
+
+        final String parentVersionedLastUpdatedLocal = parentVersionedMetadataLocal.getVersioning().getLastUpdated();
+        final String parentVersionedSnapshotVersionUpdatedLocal = parentVersionedMetadataLocal.getVersioning().getSnapshotVersions().get( 0 ).getUpdated();
+        final String aLastVersionedUpdatedLocal = aVersionedMetadataLocal.getVersioning().getLastUpdated();
+        final String aVersionedSnapshotVersionUpdated1Local = aVersionedMetadataLocal.getVersioning().getSnapshotVersions().get( 0 ).getUpdated();
+        final String aVersionedSnapshotVersionUpdated2Local = aVersionedMetadataLocal.getVersioning().getSnapshotVersions().get( 1 ).getUpdated();
+        final String bLastVersionedUpdatedLocal = bVersionedMetadataLocal.getVersioning().getLastUpdated();
+        final String bVersionedSnapshotVersionUpdated1Local = bVersionedMetadataLocal.getVersioning().getSnapshotVersions().get( 0 ).getUpdated();
+        final String bVersionedSnapshotVersionUpdated2Local = bVersionedMetadataLocal.getVersioning().getSnapshotVersions().get( 1 ).getUpdated();
+
+        assertEquals ( "parent", "local", "lastUpdated", mavenBuildTimestamp, parentVersionedLastUpdatedLocal );
+        assertEquals ( "parent", "local", "snapshotVersion[0]/updated", mavenBuildTimestamp, parentVersionedSnapshotVersionUpdatedLocal );
+        assertEquals ( "child-a", "local", "lastUpdated", mavenBuildTimestamp, aLastVersionedUpdatedLocal );
+        assertEquals ( "child-a", "local", "snapshotVersion[0]/updated", mavenBuildTimestamp, aVersionedSnapshotVersionUpdated1Local );
+        assertEquals ( "child-a", "local", "snapshotVersion[1]/updated", mavenBuildTimestamp, aVersionedSnapshotVersionUpdated2Local );
+        assertEquals ( "child-b", "local", "lastUpdated", mavenBuildTimestamp, bLastVersionedUpdatedLocal );
+        assertEquals ( "child-b", "local", "snapshotVersion[0]/updated", mavenBuildTimestamp, bVersionedSnapshotVersionUpdated1Local );
+        assertEquals ( "child-b", "local", "snapshotVersion[1]/updated", mavenBuildTimestamp, bVersionedSnapshotVersionUpdated2Local );
+
+        final Metadata parentMetadataRemote = getMetadata( getRemoteMetadataPath( remoteRepoDir, "parent", null ) );
+        final Metadata aMetadataRemote = getMetadata( getRemoteMetadataPath( remoteRepoDir, "child-a", null ) );
+        final Metadata bMetadataRemote = getMetadata( getRemoteMetadataPath( remoteRepoDir, "child-b", null ) );
+
+        final String parentLastUpdatedRemote = parentMetadataRemote.getVersioning().getLastUpdated();
+        final String aLastUpdatedRemote = aMetadataRemote.getVersioning().getLastUpdated();
+        final String bLastUpdatedRemote = bMetadataRemote.getVersioning().getLastUpdated();
+
+        assertEquals ( "parent", "remote", "lastUpdated", mavenBuildTimestamp, parentLastUpdatedRemote );
+        assertEquals ( "child-a", "remote", "lastUpdated", mavenBuildTimestamp, aLastUpdatedRemote );
+        assertEquals ( "child-b", "remote", "lastUpdated", mavenBuildTimestamp, bLastUpdatedRemote );
+
+        final Metadata parentVersionedMetadataRemote = getMetadata( getRemoteMetadataPath( remoteRepoDir, "parent", VERSION ) );
+        final Metadata aVersionedMetadataRemote = getMetadata( getRemoteMetadataPath( remoteRepoDir, "child-a", VERSION ) );
+        final Metadata bVersionedMetadataRemote = getMetadata( getRemoteMetadataPath( remoteRepoDir, "child-b", VERSION ) );
+
+        final String parentVersionedLastUpdatedRemote = parentVersionedMetadataRemote.getVersioning().getLastUpdated();
+        final String parentVersionedSnapshotTimestamp = parentVersionedMetadataRemote.getVersioning().getSnapshot().getTimestamp().replace( ".", "" );
+        final String parentVersionedSnapshotVersionUpdatedRemote = parentVersionedMetadataRemote.getVersioning().getSnapshotVersions().get( 0 ).getUpdated();
+        final String parentVersionedSnapshotVersionValueRemote = parentVersionedMetadataRemote.getVersioning().getSnapshotVersions().get( 0 ).getVersion();
+        final String aLastVersionedUpdatedRemote = aVersionedMetadataRemote.getVersioning().getLastUpdated();
+        final String aVersionedSnapshotTimestamp = aVersionedMetadataRemote.getVersioning().getSnapshot().getTimestamp().replace( ".", "" );
+        final String aVersionedSnapshotVersionUpdated1Remote = aVersionedMetadataRemote.getVersioning().getSnapshotVersions().get( 0 ).getUpdated();
+        final String aVersionedSnapshotVersionValue1Remote = aVersionedMetadataRemote.getVersioning().getSnapshotVersions().get( 0 ).getVersion();
+        final String aVersionedSnapshotVersionUpdated2Remote = aVersionedMetadataRemote.getVersioning().getSnapshotVersions().get( 1 ).getUpdated();
+        final String aVersionedSnapshotVersionValue2Remote = aVersionedMetadataRemote.getVersioning().getSnapshotVersions().get( 1 ).getVersion();
+        final String bLastVersionedUpdatedRemote = bVersionedMetadataRemote.getVersioning().getLastUpdated();
+        final String bVersionedSnapshotTimestamp = bVersionedMetadataRemote.getVersioning().getSnapshot().getTimestamp().replace( ".", "" );
+        final String bVersionedSnapshotVersionUpdated1Remote = bVersionedMetadataRemote.getVersioning().getSnapshotVersions().get( 0 ).getUpdated();
+        final String bVersionedSnapshotVersionValue1Remote = bVersionedMetadataRemote.getVersioning().getSnapshotVersions().get( 0 ).getVersion();
+        final String bVersionedSnapshotVersionUpdated2Remote = bVersionedMetadataRemote.getVersioning().getSnapshotVersions().get( 1 ).getUpdated();
+        final String bVersionedSnapshotVersionValue2Remote = bVersionedMetadataRemote.getVersioning().getSnapshotVersions().get( 1 ).getVersion();
+
+        assertEquals ( "parent", "remote", "lastUpdated", mavenBuildTimestamp, parentVersionedLastUpdatedRemote );
+        assertEquals ( "parent", "remote", "snapshot/timestamp", mavenBuildTimestamp, parentVersionedSnapshotTimestamp );
+        assertEquals ( "parent", "remote", "snapshotVersion[0]/updated", mavenBuildTimestamp, parentVersionedSnapshotVersionUpdatedRemote );
+        assertEquals ( "parent", "remote", "snapshotVersion[0]/value", mavenBuildTimestamp, parentVersionedSnapshotVersionValueRemote.substring( 4, 19 ).replace( ".", "" ) );
+        assertEquals ( "child-a", "remote", "lastUpdated", mavenBuildTimestamp, aLastVersionedUpdatedRemote );
+        assertEquals ( "child-a", "remote", "snapshot/timestamp", mavenBuildTimestamp, aVersionedSnapshotTimestamp );
+        assertEquals ( "child-a", "remote", "snapshotVersion[0]/updated", mavenBuildTimestamp, aVersionedSnapshotVersionUpdated1Remote );
+        assertEquals ( "child-a", "remote", "snapshotVersion[0]/value", mavenBuildTimestamp, aVersionedSnapshotVersionValue1Remote.substring( 4, 19 ).replace( ".", "" ) );
+        assertEquals ( "child-a", "remote", "snapshotVersion[1]/updated", mavenBuildTimestamp, aVersionedSnapshotVersionUpdated2Remote );
+        assertEquals ( "child-a", "remote", "snapshotVersion[1]/value", mavenBuildTimestamp, aVersionedSnapshotVersionValue2Remote.substring( 4, 19 ).replace( ".", "" ) );
+        assertEquals ( "child-b", "remote", "lastUpdated", mavenBuildTimestamp, bLastVersionedUpdatedRemote );
+        assertEquals ( "child-b", "remote", "snapshot/timestamp", mavenBuildTimestamp, bVersionedSnapshotTimestamp );
+        assertEquals ( "child-b", "remote", "snapshotVersion[0]/updated", mavenBuildTimestamp, bVersionedSnapshotVersionUpdated1Remote );
+        assertEquals ( "child-b", "remote", "snapshotVersion[0]/value", mavenBuildTimestamp, bVersionedSnapshotVersionValue1Remote.substring( 4, 19 ).replace( ".", "" ) );
+        assertEquals ( "child-b", "remote", "snapshotVersion[1]/updated", mavenBuildTimestamp, bVersionedSnapshotVersionUpdated2Remote );
+        assertEquals ( "child-b", "remote", "snapshotVersion[1]/value", mavenBuildTimestamp, bVersionedSnapshotVersionValue2Remote.substring( 4, 19 ).replace( ".", "" ) );
+        assertPathExists( remoteRepoDir, "parent", "remote", VERSION, "parent-" + parentVersionedSnapshotVersionValueRemote + ".pom" );
+        assertPathExists( remoteRepoDir, "child-a", "remote", VERSION, "child-a-" + aVersionedSnapshotVersionValue1Remote + ".pom" );
+        assertPathExists( remoteRepoDir, "child-a", "remote", VERSION, "child-a-" + aVersionedSnapshotVersionValue2Remote + ".jar" );
+        assertPathExists( remoteRepoDir, "child-b", "remote", VERSION, "child-b-" + bVersionedSnapshotVersionValue1Remote + ".pom" );
+        assertPathExists( remoteRepoDir, "child-b", "remote", VERSION, "child-b-" + bVersionedSnapshotVersionValue2Remote + ".jar" );
     }
 
-    private Path getLocalMetadataPath( final Path repoDir, final String moduleName )
+    private Path getLocalMetadataPath( final Path repoDir, final String moduleName, String version )
     {
-        final Path mng6754Path = Paths.get( "org", "apache", "maven", "its", "mng6754" );
-        final Path modulePath = repoDir.resolve( mng6754Path.resolve( moduleName ) );
-        return modulePath.resolve( "maven-metadata-local.xml" );
+        return getRepoFile(repoDir, moduleName, version, "maven-metadata-local.xml" );
     }
 
-    private Path getRemoteMetadataPath( final Path repoDir, final String moduleName )
+    private Path getRemoteMetadataPath( final Path repoDir, final String moduleName, String version )
+    {
+        return getRepoFile(repoDir, moduleName, version, "maven-metadata.xml" );
+    }
+
+    private Path getRepoFile( final Path repoDir, final String moduleName, String version, String fileName )
     {
         final Path mng6754Path = Paths.get( "org", "apache", "maven", "its", "mng6754" );
-        final Path modulePath = repoDir.resolve( mng6754Path.resolve( moduleName ) );
-        return modulePath.resolve( "maven-metadata.xml" );
+        Path modulePath = repoDir.resolve( mng6754Path.resolve( moduleName ) );
+        if ( version != null )
+        {
+            modulePath = modulePath.resolve( version );
+        }
+        return modulePath.resolve( fileName );
+    }
+
+    private Metadata getMetadata( final Path metadataFile ) throws IOException, XmlPullParserException
+    {
+        MetadataXpp3Reader r = new MetadataXpp3Reader();
+        try ( InputStream is = Files.newInputStream( metadataFile ) )
+        {
+            return r.read( is );
+        }
     }
 
-    private String getLastUpdatedFromMetadata( final Path metadataFile ) throws IOException
+    private void assertEquals( String moduleName, String location, String field, String expected, String actual )
     {
-        final List<String> lines = Files.readAllLines( metadataFile, Charset.defaultCharset() );
-        for (final String line : lines )
+        String phase = null;
+        switch ( location )
         {
-            final Matcher matcher = LAST_UPDATED_LINE.matcher( line );
-            if ( matcher.find() )
-            {
-                return matcher.group(1);
-            }
+        case "local":
+            phase = "Installed";
+            break;
+        case "remote":
+            phase = "Deployed";
+            break;
         }
+        assertEquals( String.format( "%s %s module should have equal %s %s with the Maven build timestamp",
+                 phase, moduleName, location, field ), expected, actual );
+    }
 
-        // just in case, make sure the test will fail if there's no <lastUpdated>
-        // inside "maven-metadata.xml"
-        return "";
+    private void assertPathExists( Path repoDir, String moduleName, String location, String version, String fileName )
+    {
+        String phase = null;
+        switch ( location )
+        {
+        case "local":
+            phase = "Installed";
+            break;
+        case "remote":
+            phase = "Deployed";
+            break;
+        }
+        Path file = getRepoFile( repoDir, moduleName, version, fileName );
+        assertTrue( String.format( "%s %s module %s file %s should exist",
+                 phase, moduleName, location, file ), Files.exists( file ) );
     }
 }