init

Author: 0xLeif

.github/workflows/CI.yml

@@ -0,0 +1,23 @@
+# This workflow will build a Swift project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-swift
+
+name: CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: macos-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Build
+      run: swift build -v
+    - name: Run tests
+      run: swift test -v
+

.github/workflows/docc.yml

@@ -0,0 +1,38 @@
+name: docc
+on:
+  push:
+    branches: ["main"]
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+jobs:
+  pages:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: macos-12
+    steps:
+      - name: git checkout
+        uses: actions/checkout@v3
+      - name: docbuild
+        run: |
+          xcodebuild docbuild -scheme Test \
+            -derivedDataPath /tmp/docbuild \
+            -destination 'generic/platform=iOS';
+          $(xcrun --find docc) process-archive \
+            transform-for-static-hosting /tmp/docbuild/Build/Products/Debug-iphoneos/Test.doccarchive \
+            --hosting-base-path Test \
+            --output-path docs;
+          echo "<script>window.location.href += \"/documentation/test\"</script>" > docs/index.html;
+      - name: artifacts
+        uses: actions/upload-pages-artifact@v1
+        with:
+          path: 'docs'
+      - name: deploy
+        id: deployment
+        uses: actions/deploy-pages@v1
+

.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/
+DerivedData/
+.swiftpm/config/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

Package.resolved

@@ -0,0 +1,38 @@
+// swift-tools-version: 5.7
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "Test",
+    platforms: [
+        .iOS(.v14),
+        .macOS(.v11),
+        .watchOS(.v7),
+        .tvOS(.v14)
+    ],
+    products: [
+        .library(
+            name: "Test",
+            targets: ["Test"]),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/0xOpenBytes/t", from: "1.0.0"),
+        .package(url: "https://github.com/0xLeif/Scribe", from: "1.3.0"),
+        .package(url: "https://github.com/0xLeif/Plugin", from: "2.0.0")
+    ],
+    targets: [
+        .target(
+            name: "Test",
+            dependencies: [
+                "t",
+                "Scribe",
+                "Plugin"
+            ]
+        ),
+        .testTarget(
+            name: "TestTests",
+            dependencies: ["Test"]
+        )
+    ]
+)

Package.swift

@@ -0,0 +1,47 @@
+# Test
+
+*Expect and assert*
+
+## What is `Test`?
+
+`Test` is a simple testing function that allows you to create test suites with multiple steps, expectations, and assertions. You can specify a name for the test suite, an instance of the `Tester` class to be used for running the tests, and a closure that contains the test steps.
+
+## Where can `Test` be used?
+
+`Test` can be used anywhere! `Test` can be used to test quickly inside a function to make sure something is working as expected. It is especially useful when you want to test a complex piece of code with multiple steps and assertions. `Test` can even be used for your unit tests!
+
+## Examples
+
+### Simple test with assertions
+
+```swift
+try await Test(named: "Test someMethod()") { tester in
+    try tester.assert(SomeClass.someMethod())
+    try await tester.assertNoThrows(try await SomeClass.someOtherMethod())
+    try tester.assert(SomeClass.someBooleanValue, isEqualTo: false)
+}
+```
+
+### Test with expectations
+
+```swift
+try Test(named: "Test someMethod() with expectations") { tester in
+    try Expect("First step should succeed") {
+        try SomeClass.someMethod()
+    }
+    
+    tester.logInfo("Just finished first step")
+
+    try Expect("Second step should succeed") {
+        try SomeClass.someOtherMethod()
+    }
+            
+    tester.logWarning("Something unexpected happened during the second step")
+
+    try Expect("Final assertion should be true") {
+        try tester.assert(SomeClass.someBooleanValue)
+    }
+    
+    tester.logSuccess("All steps and assertions passed!")
+}
+```

README.md

@@ -0,0 +1,29 @@
+import t
+
+/**
+ The `Expect` function is used to define a test expectation within a `Test` function. The expectation closure contains the code that should succeed and produce the expected result.
+
+ - Parameters:
+    - description: A string describing the expectation.
+    - expectation: A closure that contains the code to test the expectation.
+ */
+public func Expect(
+    _ description: String? = nil,
+    expectation: @escaping () throws -> Void
+) throws {
+    try t.expect(description, expectation: expectation)
+}
+
+/**
+ The `Expect` function is used to define a test expectation within a `Test` function. The expectation closure contains the code that should succeed and produce the expected result.
+
+ - Parameters:
+    - description: A string describing the expectation.
+    - expectation: A closure that contains the code to test the expectation.
+ */
+public func Expect(
+    _ description: String? = nil,
+    expectation: @escaping () async throws -> Void
+) async throws {
+    try await t.expect(description, expectation: expectation)
+}

Sources/Test/Expect.swift

@@ -0,0 +1,45 @@
+import t
+import Scribe
+
+/**
+ The `TestConfiguration` enum provides a global configuration for tests.
+
+ Use this enum to customize the logger and scribe for the test framework.
+
+ Example usage:
+
+ TestConfiguration.logger = { print($0) }
+ TestConfiguration.scribe = Scribe(label: "Custom Scribe")
+
+ */
+public enum TestConfiguration {
+    /**
+     A closure that receives a string and logs it. This is used by the framework to log messages when tests run.
+
+     By default, the logger is set to `t.logger` from the `t` library.
+
+     - Note: To change the logger, set `TestConfiguration.logger`.
+
+     Example usage:
+
+            TestConfiguration.logger = { print($0) }
+     */
+    public static var logger: (String) -> Void {
+        get { t.logger }
+        set { t.logger = newValue }
+    }
+
+    /**
+     The scribe used by the test framework.
+
+     By default, the scribe is set to a new instance of `Scribe` with a label of "Test.Scribe".
+
+     - Note: To change the scribe, set `TestConfiguration.scribe`.
+
+     Example usage:
+
+         TestConfiguration.scribe = Scribe(label: "Custom Scribe")
+
+    */
+    public static var scribe: Scribe = Scribe(label: "Test.Scribe")
+}

Sources/Test/Interface/TestConfiguration.swift

@@ -0,0 +1,10 @@
+import Plugin
+
+/**
+ The `TestPlugin` protocol defines a contract for plugins that can be used to extend the behavior of the `Tester` class.
+
+ `TestPlugin` extends the `ImmutablePlugin` protocol, which allows the plugin to be treated as an immutable object.
+
+ `TestPlugin` is used for conveince when creating a `Plugin` for a `Tester`.
+ */
+public protocol TestPlugin: ImmutablePlugin { }