[Tests] Split to independent executables

Author: tonyfreeman

Package.swift

@@ -4,25 +4,85 @@ import PackageDescription
 let package = Package(
     name: "JavaScriptCore",
     products: [
-        .library(name: "SJavaScriptCore", targets: ["SJavaScriptCore"]),
+        .library(
+            name: "SJavaScriptCore",
+            targets: ["SJavaScriptCore"]),
     ],
     dependencies: [
-        .package(
-            url: "https://github.com/swiftstack/javascript.git",
-            .branch("dev")),
-        .package(
-            url: "https://github.com/swiftstack/test.git",
-            .branch("dev"))
+        .package(name: "JavaScript"),
+        .package(name: "Test"),
     ],
     targets: [
         .target(
             name: "CJavaScriptCore",
             dependencies: []),
         .target(
             name: "SJavaScriptCore",
-            dependencies: ["CJavaScriptCore", "JavaScript"]),
-        .testTarget(
-            name: "SJavaScriptCoreTests",
-            dependencies: ["Test", "SJavaScriptCore"]),
+            dependencies: ["CJavaScriptCore", "JavaScript"])
     ]
 )
+
+// MARK: - tests
+
+testTarget("SJavaScriptCore") { test in
+    test("JavaScript")
+    test("JSValue")
+}
+
+func testTarget(_ target: String, task: ((String) -> Void) -> Void) {
+    task { test in addTest(target: target, name: test) }
+}
+
+func addTest(target: String, name: String) {
+    package.targets.append(
+        .executableTarget(
+            name: "Tests/\(target)/\(name)",
+            dependencies: ["Test", "SJavaScriptCore"],
+            path: "Tests/\(target)/\(name)"))
+}
+
+// MARK: - custom package source
+
+#if canImport(ObjectiveC)
+import Darwin.C
+#else
+import Glibc
+#endif
+
+extension Package.Dependency {
+    enum Source: String {
+        case local, remote, github
+
+        static var `default`: Self { .github }
+
+        var baseUrl: String {
+            switch self {
+            case .local: return "../"
+            case .remote: return "https://swiftstack.io/"
+            case .github: return "https://github.com/swiftstack/"
+            }
+        }
+
+        func url(for name: String) -> String {
+            return self == .local
+                ? baseUrl + name.lowercased()
+                : baseUrl + name.lowercased() + ".git"
+        }
+    }
+
+    static func package(name: String) -> Package.Dependency {
+        guard let pointer = getenv("SWIFTSTACK") else {
+            return .package(name: name, source: .default)
+        }
+        guard let source = Source(rawValue: String(cString: pointer)) else {
+            fatalError("Invalid source. Use local, remote or github")
+        }
+        return .package(name: name, source: source)
+    }
+
+    static func package(name: String, source: Source) -> Package.Dependency {
+        return source == .local
+            ? .package(name: name, path: source.url(for: name))
+            : .package(name: name, url: source.url(for: name), .branch("dev"))
+    }
+}

Tests/LinuxMain.swift

@@ -0,0 +1,85 @@
+import Test
+@testable import SJavaScriptCore
+
+test.case("isUndefined") {
+    let context = JSContext()
+
+    let result = try context.evaluate("undefined")
+    expect(result.isUndefined)
+    expect(!result.isNull)
+    expect(!result.isBool)
+    expect(!result.isNumber)
+    expect(!result.isString)
+    expect(try result.toString() == "undefined")
+}
+
+test.case("isNull") {
+    let context = JSContext()
+    let result = try context.evaluate("null")
+    expect(!result.isUndefined)
+    expect(result.isNull)
+    expect(!result.isBool)
+    expect(!result.isNumber)
+    expect(!result.isString)
+    expect(try result.toString() == "null")
+}
+
+test.case("isBool") {
+    let context = JSContext()
+    let result = try context.evaluate("true")
+    expect(!result.isUndefined)
+    expect(!result.isNull)
+    expect(result.isBool)
+    expect(!result.isNumber)
+    expect(!result.isString)
+    expect(try result.toString() == "true")
+    expect(result.toBool() == true)
+}
+
+test.case("isNumber") {
+    let context = JSContext()
+    let result = try context.evaluate("3.14")
+    expect(!result.isUndefined)
+    expect(!result.isNull)
+    expect(!result.isBool)
+    expect(result.isNumber)
+    expect(!result.isString)
+    expect(try result.toString() == "3.14")
+    expect(try result.toDouble() == 3.14)
+}
+
+test.case("isString") {
+    let context = JSContext()
+    let result = try context.evaluate("'success'")
+    expect(!result.isUndefined)
+    expect(!result.isNull)
+    expect(!result.isBool)
+    expect(!result.isNumber)
+    expect(result.isString)
+    expect(try result.toString() == "success")
+}
+
+test.case("toInt()") {
+    let context = JSContext()
+    let result = try context.evaluate("40 + 2")
+    expect(try result.toInt() == 42)
+}
+
+test.case("toString()") {
+    let context = JSContext()
+    let result = try context.evaluate("40 + 2")
+    expect(try result.toString() == "42")
+}
+
+test.case("property") {
+    let context = JSContext()
+    let result = try context.evaluate("""
+        (function(){
+            return { property: 'test' }
+        })()
+        """)
+
+    expect(try result["property"]?.toString() == "test")
+}
+
+test.run()

Tests/SJavaScriptCore/JSValue/main.swift

@@ -0,0 +1,112 @@
+import Test
+@testable import SJavaScriptCore
+
+test.case("evaluate") {
+    let context = JSContext()
+    _ = try context.evaluate("40 + 2")
+}
+
+test.case("exception") {
+    let context = JSContext()
+    expect(throws: JSError("Can't find variable: x")) {
+        try context.evaluate("x()")
+    }
+
+    expect(throws: JSError("Unexpected end of script")) {
+        try context.evaluate("{")
+    }
+}
+
+test.case("function") {
+    let context = JSContext()
+    try context.createFunction(name: "test") { (_) -> Value in
+        return .string("success")
+    }
+    let result = try context.evaluate("test()")
+    expect(try result.toString() == "success")
+}
+
+test.case("closure") {
+    let context = JSContext()
+
+    try context.createFunction(name: "testUndefined") {
+        return .undefined
+    }
+    let undefinedResult = try context.evaluate("testUndefined()")
+    expect(undefinedResult.isUndefined)
+
+    try context.createFunction(name: "testNull") {
+        return .null
+    }
+    let nullResult = try context.evaluate("testNull()")
+    expect(nullResult.isNull)
+
+    try context.createFunction(name: "testBool") {
+        return .bool(true)
+    }
+    let boolResult = try context.evaluate("testBool()")
+    expect(boolResult.isBool)
+
+    try context.createFunction(name: "testNumber") {
+        return .number(3.14)
+    }
+    let numberResult = try context.evaluate("testNumber()")
+    expect(numberResult.isNumber)
+
+    try context.createFunction(name: "testString") {
+        return .string("success")
+    }
+    let stringResult = try context.evaluate("testString()")
+    expect(stringResult.isString)
+}
+
+test.case("capture") {
+    let context = JSContext()
+
+    var captured = false
+    try context.createFunction(name: "test") { (_) -> Value in
+        captured = true
+        return .string("captured")
+    }
+    let result = try context.evaluate("test()")
+    expect(captured)
+    expect("\(result)" == "captured")
+}
+
+test.case("arguments") {
+    let context = JSContext()
+    try context.createFunction(name: "test") { (arguments) -> Void in
+        expect(arguments.count == 2)
+        expect(try arguments.first?.toString() == "one")
+        expect(try arguments.last?.toInt() == 42)
+    }
+    try context.evaluate("test('one', 42)")
+}
+
+test.case("persistent context") {
+    let context = JSContext()
+    try context.evaluate("result = 'success'")
+    expect(try context.evaluate("result").toString() == "success")
+
+    try context.createFunction(name: "test") { (arguments) -> Value in
+        return .string("test ok")
+    }
+
+    expect(try context.evaluate("result").toString() == "success")
+}
+
+test.case("sandbox") {
+    try {
+        let context = JSContext()
+        try context.evaluate("test = 'hello'")
+        let result = try context.evaluate("test")
+        expect(try result.toString() == "hello")
+    }()
+
+    let context = JSContext()
+    expect(throws: JSError("Can\'t find variable: test")) {
+        try context.evaluate("test")
+    }
+}
+
+test.run()