Name test runners consistently

The xctest extension means we won’t conflict with anything else (based on how our existing rules for names are enforced).

Author: mxcl

Sources/PackageType/Product.swift

@@ -34,10 +34,11 @@ public class Product {
                 return "lib\(name).so"
             #endif
         case .Test:
+            let base = "\(name).xctest"
             #if os(OSX)
-                return "\(name).xctest/Contents/MacOS/\(name)"
+                return "\(base)/Contents/MacOS/\(name)"
             #else
-                return "test-\(name)"
+                return base
             #endif
         }
     }

Sources/swift-test/Error.swift

@@ -19,7 +19,7 @@ extension Error: CustomStringConvertible {
         case .DebugYAMLNotFound:
             return "build the package using `swift build` before running tests"
         case .TestsExecutableNotFound:
-            return "no tests found to execute, create a test-module in `Tests` directory"
+            return "no tests found to execute, create a module in your `Tests' directory"
         }
     }
 }

Sources/swift-test/main.swift

@@ -22,13 +22,30 @@ do {
     case .Run(let xctestArg):
         let dir = try directories()
 
-        //FIXME find a reliable name to detect the name of the root test Package
-        let testPackageName = dir.root.basename
+        func determineTestPath() -> String {
+
+            //FIXME better, ideally without parsing manifest since
+            // that makes us depend on the whole Manifest system
+
+            let packageName = dir.root.basename  //FIXME probably not true
+            let maybePath = Path.join(dir.build, "\(packageName).xctest")
+
+            if maybePath.exists {
+                return maybePath
+            } else {
+                return walk(dir.build).filter{
+                    $0.basename != "Package.xctest" &&   // this was our hardcoded name, may still exist if no clean
+                    $0.hasSuffix(".xctest")
+                }.first!
+            }
+        }
+
         let yamlPath = Path.join(dir.build, "debug.yaml")
         guard yamlPath.exists else { throw Error.DebugYAMLNotFound }
 
         try build(YAMLPath: yamlPath, target: "test")
-        let success = try test(dir.build, "debug", testPackageName: testPackageName, xctestArg: xctestArg)
+
+        let success = try test(path: determineTestPath(), xctestArg: xctestArg)
         exit(success ? 0 : 1)
     }
 } catch {

Sources/swift-test/test.swift

@@ -11,40 +11,36 @@
 import PackageType
 import Utility
 
-func test(path: String..., testPackageName: String, xctestArg: String? = nil) throws -> Bool {
-    let path = Path.join(path)
-    var args: [String] = []
-    let testsPath: String
+func test(path path: String, xctestArg: String? = nil) throws -> Bool {
+
+    guard path.isValidTest else {
+        throw Error.TestsExecutableNotFound
+    }
 
+    var args: [String] = []
 #if os(OSX)
-    testsPath = Path.join(path, "\(testPackageName).xctest")
     args = ["xcrun", "xctest"]
     if let xctestArg = xctestArg {
         args += ["-XCTest", xctestArg]
     }
-    args += [testsPath]
+    args += [path]
 #else
-    testsPath = Path.join(path, "test-\(testPackageName)")
-    args += [testsPath]
+    args += [path]
     if let xctestArg = xctestArg {
         args += [xctestArg]
     }
 #endif
 
-    guard testsPath.testExecutableExists else {
-        throw Error.TestsExecutableNotFound
-    }
-
     let result: Void? = try? system(args)
     return result != nil
 }
 
 private extension String {
-    var testExecutableExists: Bool {
+    var isValidTest: Bool {
         #if os(OSX)
-            return self.isDirectory //Package.xctest is dir on OSX
+            return isDirectory  // ${foo}.xctest is dir on OSX
         #else
-            return self.isFile //test-Package is executable on OSX
+            return isFile       // otherwise ${foo}.xctest is executable file
         #endif
     }
 }