Merge pull request #15 from Nordstrom/pr/add-target-platform

Enable clients to modify path; add unit tests

Author: sbabcoc

src/main/java/com/nordstrom/common/file/PathUtils.java

@@ -27,18 +27,18 @@
  * <b>Example usage of {@code getNextPath}</b>
  * <pre>
  *     ...
- *     
+ *
  *     /*
  *      * This example gets the next path in sequence for base name `artifact`
  *      * and extension `txt` in the TestNG output directory.
- *      * 
- *      * For purposes of this example, the output directory already contains 
+ *      *
+ *      * For purposes of this example, the output directory already contains
  *      * the following files: `artifact.txt`, `artifact-3.txt`
  *      *&#47;
- * 
+ *
  *     Path collectionPath = Paths.get(testContext.getOutputDirectory());
  *     // =&gt; C:\git\my-project\test-output\Default suite
- * 
+ *
  *     Path artifactPath;
  *     try {
  *         artifactPath = PathUtils.getNextPath(collectionPath, "artifact", "txt");
@@ -47,7 +47,7 @@
  *         provider.getLogger().info("Unable to get output path; no artifact was captured", e);
  *         return;
  *     }
- *     
+ *
  *     ...
  * </pre>
  */
@@ -56,15 +56,15 @@ public final class PathUtils {
     private PathUtils() {
         throw new AssertionError("PathUtils is a static utility class that cannot be instantiated");
     }
-    
+
     private static final String SUREFIRE_PATH = "surefire-reports";
     private static final String FAILSAFE_PATH = "failsafe-reports";
-    
+
     /**
      * This enumeration contains methods to help build proxy subclass names and select reports directories.
      */
     public enum ReportsDirectory {
-        
+
         SUREFIRE_1("(Test)(.*)", SUREFIRE_PATH),
         SUREFIRE_2("(.*)(Test)", SUREFIRE_PATH),
         SUREFIRE_3("(.*)(Tests)", SUREFIRE_PATH),
@@ -73,45 +73,46 @@ public enum ReportsDirectory {
         FAILSAFE_2("(.*)(IT)", FAILSAFE_PATH),
         FAILSAFE_3("(.*)(ITCase)", FAILSAFE_PATH),
         ARTIFACT(".*", "artifact-capture");
-        
+
         private String regex;
         private String folder;
-        
+
         ReportsDirectory(String regex, String folder) {
             this.regex = regex;
             this.folder = folder;
         }
-        
+
         /**
          * Get the regular expression that matches class names for this constant.
-         * 
+         *
          * @return class-matching regular expression string
          */
         public String getRegEx() {
             return regex;
         }
-        
+
         /**
          * Get the name of the folder associated with this constant.
-         * 
+         *
          * @return class-related folder name
          */
         public String getFolder() {
             return folder;
         }
-        
+
         /**
          * Get the resolved Maven-derived path associated with this constant.
-         * 
+         *
+         * @param subdirs optional sub-path
          * @return Maven folder path
          */
-        public Path getPath() {
-            return getTargetPath().resolve(folder);
+        public Path getPath(String... subdirs) {
+            return getTargetPath().resolve(Paths.get(folder, subdirs));
         }
-        
+
         /**
          * Get the reports directory constant for the specified test class object.
-         * 
+         *
          * @param obj test class object
          * @return reports directory constant
          */
@@ -124,31 +125,35 @@ public static ReportsDirectory fromObject(Object obj) {
             }
             throw new IllegalStateException("Someone removed the 'default' pattern from this enumeration");
         }
-        
+
         /**
          * Get reports directory path for the specified test class object.
-         * 
+         *
          * @param obj test class object
          * @return reports directory path
          */
         public static Path getPathForObject(Object obj) {
-            ReportsDirectory constant = fromObject(obj);
-            return getTargetPath().resolve(constant.folder);
+            String[] subdirs = {};
+            if (obj instanceof PathModifier) {
+            	String message = String.format("Null path modifier returned by: %s", obj.getClass().getName());
+                subdirs = Objects.requireNonNull(((PathModifier) obj).getSubPath(), message);
+            }
+            return fromObject(obj).getPath(subdirs);
         }
-        
+
         /**
          * Get the path for the 'target' folder of the current project.
-         * 
+         *
          * @return path for project 'target' folder
          */
         private static Path getTargetPath() {
-            return Paths.get(getBaseDir(), "target");
+            return Paths.get(getBaseDir()).resolve("target");
         }
     }
 
     /**
      * Get the next available path in sequence for the specified base name and extension in the specified folder.
-     * 
+     *
      * @param targetPath path to target directory for the next available path in sequence
      * @param baseName base name for the path sequence
      * @param extension extension for the path sequence
@@ -159,7 +164,7 @@ public static Path getNextPath(Path targetPath, String baseName, String extensio
         Objects.requireNonNull(targetPath, "[targetPath] must be non-null");
         Objects.requireNonNull(baseName, "[baseName] must be non-null");
         Objects.requireNonNull(extension, "[extension] must be non-null");
-        
+
         File targetFile = targetPath.toFile();
         if ( ! (targetFile.exists() && targetFile.isDirectory())) {
             throw new IllegalArgumentException("[targetPath] must specify an existing directory");
@@ -170,16 +175,16 @@ public static Path getNextPath(Path targetPath, String baseName, String extensio
         if (extension.isEmpty()) {
             throw new IllegalArgumentException("[extension] must specify a non-empty string");
         }
-        
+
         Visitor visitor = new Visitor(baseName, extension);
         Files.walkFileTree(targetPath, EnumSet.noneOf(FileVisitOption.class), 1, visitor);
-        
+
         return targetPath.resolve(visitor.getNewName());
     }
 
     /**
      * Get project base directory.
-     * 
+     *
      * @return project base directory
      */
     public static String getBaseDir() {
@@ -188,7 +193,7 @@ public static String getBaseDir() {
     }
 
     private static class Visitor implements FileVisitor<Path> {
-        
+
         private String baseName;
         private String extension;
         private int base, ext;
@@ -202,7 +207,7 @@ private static class Visitor implements FileVisitor<Path> {
             this.ext = extension.length() + 1;
             this.pathMatcher = FileSystems.getDefault().getPathMatcher("regex:\\Q" + baseName + "\\E(-\\d+)?\\." + extension);
         }
-        
+
         @Override
         public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
             return FileVisitResult.CONTINUE;
@@ -228,18 +233,65 @@ public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOExce
         public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
             return FileVisitResult.CONTINUE;
         }
-        
+
         public String getNewName() {
             String newName;
-            
+
             if (intList.isEmpty()) {
                 newName = baseName + "." + extension;
             } else {
                 Collections.sort(intList, Collections.reverseOrder());
                 newName = baseName + "-" + intList.get(0) + "." + extension;
             }
-            
+
             return newName;
         }
     }
+
+    /**
+     * Prepend the specified string to the indicated array.
+     *
+     * @param prefix string to be prepended
+     * @param strings target string array
+     * @return target array prefixed with the specified string
+     */
+    public static String[] prepend(String prefix, String... strings) {
+        int len = strings.length;
+        String[] temp = new String[len + 1];
+        if (len > 0) System.arraycopy(strings, 0, temp, 1, len);
+        temp[0] = prefix;
+        return temp;
+    }
+
+    /**
+     * Append the specified string to the indicated array.
+     *
+     * @param suffix string to be appended
+     * @param strings target string array
+     * @return target array with the specified string appended
+     */
+    public static String[] append(String suffix, String... strings) {
+        int len = strings.length;
+        String[] temp = new String[len + 1];
+        if (len > 0) System.arraycopy(strings, 0, temp, 0, len);
+        temp[len] = suffix;
+        return temp;
+    }
+
+    /**
+     * Classes that implement this interface are called to supply additional elements for the path returned by
+     * {@link ReportsDirectory#getPathForObject(Object)}. This enables the implementing class to partition artifacts
+     * based on scenario-specific criteria.
+     */
+    public interface PathModifier {
+
+        /**
+         * Get scenario-specific path modifier for {@link ReportsDirectory#getPathForObject(Object)}.
+         *
+         * @return scenario-specific path modifier
+         */
+        public String[] getSubPath();
+
+    }
+
 }

src/test/java/com/nordstrom/common/file/OSInfoTest.java

@@ -15,7 +15,16 @@ public class OSInfoTest {
     @Test
     public void testDefaultMapping() {
         OSInfo<OSType> osUtils = OSInfo.getDefault();
-        OSType expected = (osName.startsWith("windows")) ? OSType.WINDOWS : OSType.UNIX;
+        
+        OSType expected;
+        if (osName.startsWith("windows")) {
+        	expected = OSType.WINDOWS;
+        } else if (osName.startsWith("mac")) {
+        	expected = OSType.MACINTOSH;
+        } else {
+        	expected = OSType.UNIX;
+        }
+        
         assertEquals(osUtils.getType(), expected, "Reported OS type doesn't match expected type");
     }
 

src/test/java/com/nordstrom/common/file/PathUtilsTest.java

@@ -17,7 +17,7 @@
 import org.testng.annotations.Test;
 
 public class PathUtilsTest {
-    
+
     @Test
     public void testNextPath() throws IOException {
         Path outputDir = getOutputPath();
@@ -29,26 +29,54 @@ public void testNextPath() throws IOException {
         } else {
             Files.createDirectories(targetPath);
         }
-        
+
         Path path1 = PathUtils.getNextPath(targetPath, "testNextPath", "txt");
         assertEquals(path1.getFileName().toString(), "testNextPath.txt");
-        
+
         path1.toFile().createNewFile();
-        
+
         Path path2 = PathUtils.getNextPath(targetPath, "testNextPath", "txt");
         assertEquals(path2.getFileName().toString(), "testNextPath-1.txt");
-        
+
         path2.toFile().createNewFile();
         targetPath.resolve("testNextPath-9.txt").toFile().createNewFile();
         targetPath.resolve("testNextPath-10.txt").toFile().createNewFile();
-        
+
         Path path3 = PathUtils.getNextPath(targetPath, "testNextPath", "txt");
         assertEquals(path3.getFileName().toString(), "testNextPath-11.txt");
-        
+
         Path path4 = PathUtils.getNextPath(targetPath, "test", "txt");
         assertEquals(path4.getFileName().toString(), "test.txt");
     }
 
+    @Test
+    public void testPrepend() {
+        String[] actual = PathUtils.prepend("one", "two", "three");
+        String[] expect = {"one", "two", "three"};
+        assertEquals(actual, expect);
+    }
+
+    @Test
+    public void testAppend() {
+        String[] actual = PathUtils.append("three", "one", "two");
+        String[] expect = {"one", "two", "three"};
+        assertEquals(actual, expect);
+    }
+
+    @Test
+    public void testBaseDir() {
+        String actual = PathUtils.getBaseDir();
+        String expect = getBasePath().toString();
+        assertEquals(actual, expect);
+    }
+
+    @Test
+    public void testPathForObject() {
+        Path actual = PathUtils.ReportsDirectory.getPathForObject(this);
+        Path expect = getBasePath().resolve("target").resolve("surefire-reports");
+        assertEquals(actual, expect);
+    }
+
     private Path getOutputPath() {
         ITestResult testResult = Reporter.getCurrentTestResult();
         ITestContext testContext = testResult.getTestContext();
@@ -57,30 +85,34 @@ private Path getOutputPath() {
         return outputDir;
     }
 
+    private Path getBasePath() {
+        return Paths.get(System.getProperty("user.dir")).toAbsolutePath();
+    }
+
     @Test(expectedExceptions = {AssertionError.class},
                     expectedExceptionsMessageRegExp = "PathUtils is a static utility class that cannot be instantiated")
     public void testPrivateConstructor() throws Throwable {
-        
+
         Constructor<?>[] ctors;
         ctors = PathUtils.class.getDeclaredConstructors();
         assertEquals(ctors.length, 1, "PathUtils must have exactly one constructor");
         assertEquals(ctors[0].getModifiers() & Modifier.PRIVATE, Modifier.PRIVATE,
                         "PathUtils constructor must be private");
         assertEquals(ctors[0].getParameterTypes().length, 0, "PathUtils constructor must have no arguments");
-        
+
         try {
             ctors[0].setAccessible(true);
             ctors[0].newInstance();
         } catch (InvocationTargetException e) {
             throw e.getCause();
         }
     }
-    
+
     @Test(expectedExceptions = {NullPointerException.class})
     public void testNullPath() throws IOException {
         PathUtils.getNextPath(null, "test", "txt");
     }
-    
+
     @Test(expectedExceptions = {IllegalArgumentException.class})
     public void testNonExistentPath() throws IOException {
         PathUtils.getNextPath(Paths.get("foobar"), "test", "txt");