Migrate from XCTest to Swift Testing (#382)

Migrating `swift-log` from XCTest to Swift Testing

### Motivation

Swift Testing is a modern alternative to XCTest. Swift Server Ecosystem
packages should serve as reference implementations for modern Swift
features and best practices.

### Modifications

- 1-to-1 migration of test suites, tests, and assertions to Swift
Testing syntax with XCTest import removed
- XCTest references removed from documentation
- `.trace` log level added to relevant tests
- `GlobalLoggerTest` suite serialized to handle global `LoggingSystem`
access (XCTest runs tests serially by default; Swift Testing runs in
parallel, so serializing this suite avoids requiring `swift test
--no-parallel` across all CI and development environments)

### Result

Successfully executes 52 tests with `swift test --disable-xctest`.

Author: kukushechkin

CONTRIBUTING.md

@@ -62,34 +62,42 @@ We require that your commit messages match our template. The easiest way to do t
 
 ### Make sure Tests work on Linux
 
-SwiftLog uses XCTest to run tests on both macOS and Linux. While the macOS version of XCTest is able to use the Objective-C runtime to discover tests at execution time, the Linux version is not.
-For this reason, whenever you add new tests **you have to run a script** that generates the hooks needed to run those tests on Linux, or our CI will complain that the tests are not all present on Linux. To do this, merely execute `ruby ./scripts/generate_linux_tests.rb` at the root of the package and check the changes it made.
+SwiftLog uses Swift Testing to run tests on all supported platforms.
 
-### Run `./scripts/soundness.sh`
+### Run CI checks locally
 
-The scripts directory contains a [soundness.sh script](https://github.com/apple/swift-log/blob/main/scripts/soundness.sh) 
-that enforces additional checks, like license headers and formatting style.
+You can run the Github Actions workflows locally using
+[act](https://github.com/nektos/act). To run all the jobs that run on a pull
+request, use the following command:
 
-Please make sure to `./scripts/soundness.sh` before pushing a change upstream, otherwise it is likely the PR validation will fail
-on minor changes such as a missing `self.` or similar formatting issues.
+```
+% act pull_request
+```
 
-> The script also executes the above mentioned `generate_linux_tests.rb`.
+To run just a single job, use `workflow_call -j <job>`, and specify the inputs
+the job expects. For example, to run just shellcheck:
 
-For frequent contributors, we recommend adding the script as a [git pre-push hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks), which you can do via executing the following command in the project root directory: 
+```
+% act workflow_call -j soundness --input shell_check_enabled=true
+```
 
-```bash
-cat << EOF > .git/hooks/pre-push
-#!/bin/bash
+To bind-mount the working directory to the container, rather than a copy, use
+`--bind`. For example, to run just the formatting, and have the results
+reflected in your working directory:
 
-if [[ -f "scripts/soundness.sh" ]]; then
-  scripts/soundness.sh
-fi
-EOF
+```
+% act --bind workflow_call -j soundness --input format_check_enabled=true
 ```
 
-Which makes the script execute, and only allow the `git push` to complete if the check has passed.
+If you'd like `act` to always run with certain flags, these can be be placed in
+an `.actrc` file either in the current working directory or your home
+directory, for example:
 
-In the case of formatting issues, you can then `git add` the formatting changes, and attempt the push again. 
+```
+--container-architecture=linux/amd64
+--remote-name upstream
+--action-offline-mode
+```
 
 ## How to contribute your work
 

NOTICE.txt

@@ -26,15 +26,6 @@ components that this product depends on.
 
 -------------------------------------------------------------------------------
 
-This product contains a derivation of the Tony Stone's 'process_test_files.rb'.
-
-  * LICENSE (Apache License 2.0):
-    * https://www.apache.org/licenses/LICENSE-2.0
-  * HOMEPAGE:
-    * https://codegists.com/snippet/ruby/generate_xctest_linux_runnerrb_tonystone_ruby
-
----
-
 This product contains a derivation of the lock implementation and various
 scripts from SwiftNIO.
 

Tests/LoggingTests/CompatibilityTest.swift

@@ -14,11 +14,11 @@
 
 // Not testable
 import Logging
-import XCTest
+import Testing
 
-final class CompatibilityTest: XCTestCase {
+struct CompatibilityTest {
     @available(*, deprecated, message: "Testing deprecated functionality")
-    func testAllLogLevelsWorkWithOldSchoolLogHandlerWorks() {
+    @Test func allLogLevelsWorkWithOldSchoolLogHandlerWorks() {
         let testLogging = OldSchoolTestLogging()
 
         var logger = Logger(label: "\(#function)", factory: { testLogging.make(label: $0) })

Tests/LoggingTests/GlobalLoggingTest.swift

@@ -13,18 +13,21 @@
 //===----------------------------------------------------------------------===//
 
 import Dispatch
-import XCTest
+import Testing
 
 @testable import Logging
 
-class GlobalLoggerTest: XCTestCase {
-    func test1() throws {
+/// This is the only test suite allowed to use global LoggingSystem bootstrapping,
+/// tests in the suite are executed one by one
+@Suite(.serialized)
+struct GlobalLoggerTest {
+    @Test func traceAndAbove() throws {
         // bootstrap with our test logging impl
         let logging = TestLogging()
         LoggingSystem.bootstrapInternal { logging.make(label: $0) }
 
-        // change test logging config to log traces and above
-        logging.config.set(value: Logger.Level.debug)
+        // change test logging config to log trace and above
+        logging.config.set(value: Logger.Level.trace)
         // run our program
         Struct1().doSomething()
         // test results
@@ -40,12 +43,16 @@ class GlobalLoggerTest: XCTestCase {
         logging.history.assertExist(level: .debug, message: "Struct3::doSomethingElse::Local", metadata: ["baz": "qux"])
         logging.history.assertExist(level: .debug, message: "Struct3::doSomethingElse::end")
         logging.history.assertExist(level: .debug, message: "Struct3::doSomething::end")
+        logging.history.assertExist(level: .trace, message: "Struct3::doSomething::end::lastLine")
         logging.history.assertExist(level: .debug, message: "Struct2::doSomethingElse::end")
+        logging.history.assertExist(level: .trace, message: "Struct2::doSomethingElse::end::lastLine")
         logging.history.assertExist(level: .debug, message: "Struct1::doSomethingElse::end")
         logging.history.assertExist(level: .debug, message: "Struct1::doSomething::end")
+        logging.history.assertExist(level: .trace, message: "Struct1::doSomething::end::lastLine")
+
     }
 
-    func test2() throws {
+    @Test func errorAndAbove() throws {
         // bootstrap with our test logging impl
         let logging = TestLogging()
         LoggingSystem.bootstrapInternal { logging.make(label: $0) }
@@ -75,12 +82,15 @@ class GlobalLoggerTest: XCTestCase {
         )
         logging.history.assertNotExist(level: .debug, message: "Struct3::doSomethingElse::end")
         logging.history.assertNotExist(level: .debug, message: "Struct3::doSomething::end")
+        logging.history.assertNotExist(level: .trace, message: "Struct3::doSomething::end::lastLine")
         logging.history.assertNotExist(level: .debug, message: "Struct2::doSomethingElse::end")
+        logging.history.assertNotExist(level: .trace, message: "Struct2::doSomethingElse::end::lastLine")
         logging.history.assertNotExist(level: .debug, message: "Struct1::doSomethingElse::end")
         logging.history.assertNotExist(level: .debug, message: "Struct1::doSomething::end")
+        logging.history.assertNotExist(level: .trace, message: "Struct1::doSomething::end::lastLine")
     }
 
-    func test3() throws {
+    @Test func warningAndAbove() throws {
         // bootstrap with our test logging impl
         let logging = TestLogging()
         LoggingSystem.bootstrapInternal { logging.make(label: $0) }
@@ -114,6 +124,96 @@ class GlobalLoggerTest: XCTestCase {
     }
 }
 
+/// MetadataProvider tests relying on the global state
+extension GlobalLoggerTest {
+    @Test func loggingMergesOneOffMetadataWithProvidedMetadataFromExplicitlyPassed() throws {
+        let logging = TestLogging()
+
+        LoggingSystem.bootstrapInternal(
+            { logging.makeWithMetadataProvider(label: $0, metadataProvider: $1) },
+            metadataProvider: .init {
+                ["common": "initial"]
+            }
+        )
+
+        let logger = Logger(
+            label: #function,
+            metadataProvider: .init {
+                [
+                    "common": "provider",
+                    "provider": "42",
+                ]
+            }
+        )
+
+        logger.log(level: .info, "test", metadata: ["one-off": "42", "common": "one-off"])
+
+        logging.history.assertExist(
+            level: .info,
+            message: "test",
+            metadata: ["common": "one-off", "one-off": "42", "provider": "42"]
+        )
+    }
+
+    @Test func loggerWithoutFactoryOverrideDefaultsToUsingLoggingSystemMetadataProvider() {
+        let logging = TestLogging()
+        LoggingSystem.bootstrapInternal(
+            { logging.makeWithMetadataProvider(label: $0, metadataProvider: $1) },
+            metadataProvider: .init { ["provider": "42"] }
+        )
+
+        let logger = Logger(label: #function)
+
+        logger.log(level: .info, "test", metadata: ["one-off": "42"])
+
+        logging.history.assertExist(
+            level: .info,
+            message: "test",
+            metadata: ["provider": "42", "one-off": "42"]
+        )
+    }
+
+    @Test func loggerWithPredefinedLibraryMetadataProvider() {
+        let logging = TestLogging()
+        LoggingSystem.bootstrapInternal(
+            { logging.makeWithMetadataProvider(label: $0, metadataProvider: $1) },
+            metadataProvider: .exampleProvider
+        )
+
+        let logger = Logger(label: #function)
+
+        logger.log(level: .info, "test", metadata: ["one-off": "42"])
+
+        logging.history.assertExist(
+            level: .info,
+            message: "test",
+            metadata: ["example": "example-value", "one-off": "42"]
+        )
+    }
+
+    @Test func loggerWithFactoryOverrideDefaultsToUsingLoggingSystemMetadataProvider() {
+        let logging = TestLogging()
+        LoggingSystem.bootstrapInternal(
+            { logging.makeWithMetadataProvider(label: $0, metadataProvider: $1) },
+            metadataProvider: .init { ["provider": "42"] }
+        )
+
+        let logger = Logger(
+            label: #function,
+            factory: { label in
+                logging.makeWithMetadataProvider(label: label, metadataProvider: LoggingSystem.metadataProvider)
+            }
+        )
+        logger.log(level: .info, "test", metadata: ["one-off": "42"])
+
+        logging.history.assertExist(
+            level: .info,
+            message: "test",
+            metadata: ["provider": "42", "one-off": "42"]
+        )
+    }
+}
+
 private struct Struct1 {
     private let logger = Logger(label: "GlobalLoggerTest::Struct1")
 
@@ -127,6 +227,7 @@ private struct Struct1 {
         self.logger.debug("Struct1::doSomethingElse")
         Struct2().doSomething()
         self.logger.debug("Struct1::doSomethingElse::end")
+        self.logger.trace("Struct1::doSomething::end::lastLine")
     }
 }
 
@@ -143,6 +244,7 @@ private struct Struct2 {
         self.logger.info("Struct2::doSomethingElse")
         Struct3().doSomething()
         self.logger.debug("Struct2::doSomethingElse::end")
+        self.logger.trace("Struct2::doSomethingElse::end::lastLine")
     }
 }
 
@@ -154,6 +256,7 @@ private struct Struct3 {
         self.logger.error("Struct3::doSomething")
         self.doSomethingElse()
         self.logger.debug("Struct3::doSomething::end")
+        self.logger.trace("Struct3::doSomething::end::lastLine")
     }
 
     private func doSomethingElse() {