test: use Spectre to improve test readability/debuggability

Tricks:

* (compact results) `env SPECTRE_REPORTER=dot swift test`
* (test only file) `env SPECTRE_ADDOPTS=Tests/Cases/tests/draft2020-12/allOf.json swift test`

Author: kylef

Package.resolved

@@ -12,9 +12,10 @@ let package = Package(
   ],
   dependencies: [
     .package(url: "https://github.com/kylef/PathKit.git", .upToNextMajor(from: "1.0.0")),
+    .package(url: "https://github.com/kylef/Spectre.git", .revision("d02129a9af77729de049d328dd61e530b6f2bb2b"))
   ],
   targets: [
     .target(name: "JSONSchema", dependencies: [], path: "Sources"),
-    .testTarget(name: "JSONSchemaTests", dependencies: ["JSONSchema", "PathKit"]),
+    .testTarget(name: "JSONSchemaTests", dependencies: ["JSONSchema", "Spectre", "PathKit"]),
   ]
 )

Package.swift

@@ -1,77 +1,75 @@
-import XCTest
+import Spectre
 @testable import JSONSchema
 
 
-class DurationTests: XCTestCase {
-  // dur-date
+public let testDurationFormat: ((ContextType) -> Void) = {
+  $0.describe("dur-date") {
+    $0.it("allows day duration") {
+      try expect(isValidDuration("P3D")).to.beTrue()
+    }
 
-  func testDay() {
-    XCTAssertTrue(isValidDuration("P3D"))
-  }
-
-  func testMonth() {
-    XCTAssertTrue(isValidDuration("P2M"))
-  }
+    $0.it("allows month duration") {
+      try expect(isValidDuration("P2M")).to.beTrue()
+    }
 
-  func testMonthDay() {
-    XCTAssertTrue(isValidDuration("P2M1D"))
-  }
+    $0.it("allows month and day duration") {
+      try expect(isValidDuration("P2M1D")).to.beTrue()
+    }
 
-  func testYear() {
-    XCTAssertTrue(isValidDuration("P5Y"))
-  }
-
-  func testYearMonth() {
-    XCTAssertTrue(isValidDuration("P5Y2M"))
-  }
+    $0.it("allows year duration") {
+      try expect(isValidDuration("P5Y")).to.beTrue()
+    }
 
-  func testYearMonthDay() {
-    XCTAssertTrue(isValidDuration("P5Y2M1D"))
-  }
+    $0.it("allows year and month duration") {
+      try expect(isValidDuration("P5Y2M")).to.beTrue()
+    }
 
-  func testDateTime() {
-    XCTAssertTrue(isValidDuration("P1DT5M"))
+    $0.it("allows year, month and day duration") {
+      try expect(isValidDuration("P5Y2M1D")).to.beTrue()
+    }
   }
 
-  // dur-time
+  $0.describe("dur-time") {
+    $0.it("allows hour duration") {
+      try expect(isValidDuration("PT1H")).to.beTrue()
+    }
 
-  func testHour() {
-    XCTAssertTrue(isValidDuration("PT1H"))
-  }
+    $0.it("allows hour duration with minutes") {
+      try expect(isValidDuration("PT1H5M")).to.beTrue()
+    }
 
-  func testHourMinute() {
-    XCTAssertTrue(isValidDuration("PT1H5M"))
-  }
+    $0.it("allows hour duration with minutes and seconds") {
+      try expect(isValidDuration("PT1H5M20S")).to.beTrue()
+    }
 
-  func testHourMinuteSecond() {
-    XCTAssertTrue(isValidDuration("PT1H5M20S"))
-  }
+    $0.it("allows minute duration") {
+      try expect(isValidDuration("PT1M")).to.beTrue()
+    }
 
-  func testMinute() {
-    XCTAssertTrue(isValidDuration("PT1M"))
-  }
+    $0.it("allows minute duration with seconds") {
+      try expect(isValidDuration("PT5M10S")).to.beTrue()
+    }
 
-  func testMinuteSecond() {
-    XCTAssertTrue(isValidDuration("PT5M10S"))
+    $0.it("allows second duration") {
+      try expect(isValidDuration("PT1S")).to.beTrue()
+    }
   }
 
-  func testSecond() {
-    XCTAssertTrue(isValidDuration("PT1S"))
+  $0.describe("dur-week") {
+    $0.it("allows weeb duration") {
+      try expect(isValidDuration("P1W")).to.beTrue()
+    }
   }
 
-  // dur-week
-
-  func testWeek() {
-    XCTAssertTrue(isValidDuration("P1W"))
+  $0.it("allows date and time duration") {
+    try expect(isValidDuration("P1DT5M")).to.beTrue()
   }
 
-  // Negative
-
-  func testMissingDuration() {
-    XCTAssertFalse(isValidDuration("P"))
+  $0.it("fails validation without duration") {
+    try expect(isValidDuration("P")).to.beFalse()
   }
 
-  func testMissingTime() {
-    XCTAssertFalse(isValidDuration("PT"))
+  $0.it("fails validation with empty time") {
+    try expect(isValidDuration("PT")).to.beFalse()
   }
 }

Tests/JSONSchemaTests/Format/TestDuration.swift

@@ -1,4 +1,5 @@
-import XCTest
+import Foundation
+import Spectre
 @testable import JSONSchema
 
 
@@ -17,114 +18,116 @@ fileprivate let document: [String: Any] = [
 ]
 
 
-class JSONPointerTests: XCTestCase {
+public let testJSONPointer: ((ContextType) -> Void) = {
   // Resolution (https://tools.ietf.org/html/rfc6901#section-5)
 
-  func testResolveWholeDocument() {
+  $0.it("can resoleve entire document") {
     let pointer = JSONPointer(path: "")
 
-    XCTAssertEqual(pointer.resolve(document: document) as? NSDictionary, document as NSDictionary)
+    try expect(pointer.resolve(document: document) as? NSDictionary) == document as NSDictionary
   }
 
-  func testResolveObjectValue() {
+  $0.it("can resolve object value") {
     let pointer = JSONPointer(path: "/foo")
 
-    XCTAssertEqual(pointer.resolve(document: document) as? [String], ["bar", "baz"])
+    try expect(pointer.resolve(document: document) as? [String]) == ["bar", "baz"]
   }
 
-  func testResolveArrayIndex() {
+  $0.it("can resolve array index") {
     let pointer = JSONPointer(path: "/foo/0")
 
-    XCTAssertEqual(pointer.resolve(document: document) as? String, "bar")
+    try expect(pointer.resolve(document: document) as? String) == "bar"
 
     let pointer1 = JSONPointer(path: "/foo/1")
 
-    XCTAssertEqual(pointer1.resolve(document: document) as? String, "baz")
+    try expect(pointer1.resolve(document: document) as? String) == "baz"
   }
 
-  func testResolveObjectValueKeyEmptyString() {
+  $0.it("can resolve object value via empty key") {
     let pointer = JSONPointer(path: "/")
 
-    XCTAssertEqual(pointer.resolve(document: document) as? Int, 0)
+    try expect(pointer.resolve(document: document) as? Int) == 0
   }
 
-  func testResolveObjectValueKeyEscapedForwardSlash() {
+  $0.it("can resolve object value with escaped slash in key") {
     let pointer = JSONPointer(path: "/a~1b")
 
-    XCTAssertEqual(pointer.resolve(document: document) as? Int, 1)
+    try expect(pointer.resolve(document: document) as? Int) == 1
   }
 
-  func testResolveObjectValueKeyPercent() {
+  $0.it("can resolve object value with percent in key") {
     let pointer = JSONPointer(path: "/c%d")
 
-    XCTAssertEqual(pointer.resolve(document: document) as? Int, 2)
+    try expect(pointer.resolve(document: document) as? Int) == 2
   }
 
-  func testResolveObjectValueKeyCarot() {
+  $0.it("can resolve object value with carot in key") {
     let pointer = JSONPointer(path: "/e^f")
 
-    XCTAssertEqual(pointer.resolve(document: document) as? Int, 3)
+    try expect(pointer.resolve(document: document) as? Int) == 3
   }
 
-  func testResolveObjectValueKeyPipe() {
+  $0.it("can resolve object value with pipe in key") {
     let pointer = JSONPointer(path: "/g|h")
 
-    XCTAssertEqual(pointer.resolve(document: document) as? Int, 4)
+    try expect(pointer.resolve(document: document) as? Int) == 4
   }
 
-  func testResolveObjectValueBackslace() {
+  $0.it("can resolve object value with backslash in key") {
     let pointer = JSONPointer(path: "/i\\j")
 
-    XCTAssertEqual(pointer.resolve(document: document) as? Int, 5)
+    try expect(pointer.resolve(document: document) as? Int) == 5
   }
 
-  func testResolveObjectValueDoubleQuote() {
+  $0.it("can resolve object value with double quote in key") {
     let pointer = JSONPointer(path: "/k\"l")
 
-    XCTAssertEqual(pointer.resolve(document: document) as? Int, 6)
+    try expect(pointer.resolve(document: document) as? Int) == 6
   }
 
-  func testResolveObjectValueSpace() {
+  $0.it("can resolve object value with double space in key") {
     let pointer = JSONPointer(path: "/ ")
 
-    XCTAssertEqual(pointer.resolve(document: document) as? Int, 7)
+    try expect(pointer.resolve(document: document) as? Int) == 7
   }
 
-  func testResolveObjectValueEscapedTilde() {
+  $0.it("can resolve object value with escaped tilde in key") {
     let pointer = JSONPointer(path: "/m~0n")
 
-    XCTAssertEqual(pointer.resolve(document: document) as? Int, 8)
+    try expect(pointer.resolve(document: document) as? Int) == 8
   }
 
   // Resolve (negative cases)
 
-  func testResolveArrayIndexOutOfBounds() {
+  $0.it("can resolve out of bounds array index") {
     let pointer = JSONPointer(path: "/foo/2")
 
-    XCTAssertNil(pointer.resolve(document: document))
+    try expect(pointer.resolve(document: document)).to.beNil()
   }
 
-  func testResolveArrayIndexNegative() {
+  $0.it("can resolve negative array index") {
     let pointer = JSONPointer(path: "/foo/-1")
 
-    XCTAssertNil(pointer.resolve(document: document))
+    try expect(pointer.resolve(document: document)).to.beNil()
   }
 
-  func testResolveObjectMissingKey() {
+  $0.it("can resolve missing key in object") {
     let pointer = JSONPointer(path: "/test")
 
-    XCTAssertNil(pointer.resolve(document: document))
+    try expect(pointer.resolve(document: document)).to.beNil()
   }
 
   // MARK: - #path
 
-  func testPath() {
-    let pointer = JSONPointer(path: "/foo")
-    XCTAssertEqual(pointer.path, "/foo")
-  }
+  $0.describe("#path") {
+    $0.it("returns a string representation of path") {
+      let pointer = JSONPointer(path: "/foo")
+      try expect(pointer.path) == "/foo"
+    }
 
-  func testPathWithSlash() {
-    let pointer = JSONPointer(path: "/a~1b")
-    XCTAssertEqual(pointer.path, "/a~1b")
+    $0.it("returns a string representation of path escaping slashes") {
+      let pointer = JSONPointer(path: "/a~1b")
+      try expect(pointer.path) == "/a~1b"
+    }
   }
 }