Move issue reporting for invalid fixedSeed usage to TestScope itself

Author: x-sheep

Sources/PropertyBased/FixedSeedTrait.swift

@@ -21,13 +21,16 @@ public struct FixedSeedTrait: TestTrait, TestScoping {
     let sourceLocation: SourceLocation
 
     @TaskLocal
-    static var fixedRandom: (rng: Xoshiro?, location: SourceLocation)?
+    static var fixedRandom: (rng: Xoshiro, location: SourceLocation)?
 
     public func provideScope(for test: Test, testCase: Test.Case?, performing function: () async throws -> Void) async throws {
         if let existing = Self.fixedRandom {
             Issue.record("Two different fixed seeds are used in the same test.", sourceLocation: existing.location)
-            
-            try await function()
+            return
+        }
+        
+        guard let rng else {
+            Issue.record("An invalid seed was provided. Remove the fixedSeed Trait from the Test.", sourceLocation: sourceLocation)
             return
         }
 
@@ -39,15 +42,15 @@ public struct FixedSeedTrait: TestTrait, TestScoping {
 
 extension Trait where Self == FixedSeedTrait {
     /// Override the seed used by all property checks within this Test.
-    /// 
+    ///
     /// If one of your property checks fails intermittently, apply this trait to reliably reproduce the issue.
-    /// 
+    ///
     /// > Important: Do not commit usages of this trait into version control. Applying this trait will always report an issue regardless of the existence of any failures within the test.
-    /// 
+    ///
     /// - Parameters:
     ///   - seed: The seed to use.
     ///   - sourceLocation: The source location of the trait.
-    /// 
+    ///
     /// - Returns: An instance of ``FixedSeedTrait``.
     public static func fixedSeed(_ seed: StaticString, sourceLocation: SourceLocation = #_sourceLocation) -> Self {
         return Self(seed.description, sourceLocation)

Sources/PropertyBased/PropertyCheck.swift

@@ -82,11 +82,6 @@ public func propertyCheck<each Value>(isolation: isolated (any Actor)? = #isolat
 
     let fixedRng = FixedSeedTrait.fixedRandom
 
-    if let fixedRng, fixedRng.rng == nil {
-        Issue.record("An invalid seed was provided. Remove the fixedSeed Trait from the Test.", sourceLocation: fixedRng.location)
-        return
-    }
-    
     let actualCount = fixedRng != nil ? 1 : count
 
     for _ in 0..<actualCount {

Tests/PropertyBasedTests/FixedSeedTests.swift

@@ -10,27 +10,50 @@ import PropertyBased
 import Gen
 
 @Suite struct FixedSeedTests {
-    @Test(.fixedSeed("qwert"))
-    func testInvalidSeed() async {
+    @Test func testInvalidSeed() async throws {
+        let trait = FixedSeedTrait.fixedSeed("qwert")
+        let scope = try #require(trait.scopeProvider(for: Test.current!, testCase: Test.Case.current))
+        
         let issues = await gatherIssues {
-            await propertyCheck(input: .bool) { _ in }
+            try await scope.provideScope(for: Test.current!, testCase: Test.Case.current) {
+                try #require(Bool(false), "block must not be called")
+            }
+        }
+        #expect(issues.count == 1)
+        #expect(issues.contains(where: {
+            $0.contains("invalid seed")
+        }))
+    }
+    
+    @Test func testDuplicateSeeds() async throws {
+        let trait1 = FixedSeedTrait.fixedSeed("INXoBVnaU+VA/a0Vu3WfVCmT1mBMK0ZrXJb24K4vLVY=")
+        let trait2 = FixedSeedTrait.fixedSeed("I9kE/glCt1MIxbFsddPUSiKFAAJBGKPHSre93c+Wz9E=")
+        
+        let issues = await gatherIssues {
+            try await trait1.provideScope(for: Test.current!, testCase: Test.Case.current) {
+                try await trait2.provideScope(for: Test.current!, testCase: Test.Case.current) {
+                    try #require(Bool(false), "block must not be called")
+                }
+            }
         }
         #expect(issues.count == 1)
         #expect(issues.contains(where: {
-            $0.description.contains("invalid seed")
+            $0.contains("different fixed seeds")
         }))
     }
 
-    @Test(.fixedSeed("4tPCyvymNncnc+napVCI0T4Jc6IYw1lXOQbXlIqyHck="))
-    func testIdenticalInputs() async throws {
+    @Test func testIdenticalInputs() async throws {
+        let trait = FixedSeedTrait.fixedSeed("4tPCyvymNncnc+napVCI0T4Jc6IYw1lXOQbXlIqyHck=")
         let issues = await gatherIssues {
-            await propertyCheck(input: .int(in: 0...1000000)) { n in
-                #expect(n == 480813)
+            try await trait.provideScope(for: Test.current!, testCase: Test.Case.current) {
+                await propertyCheck(input: .int(in: 0...1000000)) { n in
+                    #expect(n == 480813)
+                }
             }
         }
         #expect(issues.count == 1)
         #expect(issues.contains(where: {
-            $0.description.contains("no expectation failure")
+            $0.contains("no expectation failure")
         }))
     }
 

Tests/PropertyBasedTests/PropertyCheckTests.swift

@@ -50,14 +50,14 @@ import Testing
         }
 
         #expect(issues.contains(where: {
-            $0.description.contains("> 20")
+            $0.contains("> 20")
         }))
         #expect(issues.contains(where: {
-            $0.description.contains("to reproduce this issue")
+            $0.contains("to reproduce this issue")
         }))
 
         #expect(!issues.contains(where: {
-            $0.description.contains("> 50")
+            $0.contains("> 50")
         }))
     }
 }

Tests/PropertyBasedTests/Utils.swift

@@ -8,14 +8,18 @@
 import Testing
 @testable import PropertyBased
 
-func gatherIssues(block: @Sendable () async -> Void) async -> [Issue] {
-    let mutex = Mutex([] as [Issue])
-
+func gatherIssues(block: @Sendable () async throws -> Void) async -> [String] {
+    let mutex = Mutex([] as [String])
+    
     // No way to stop issues from still being recorded. Ignore those for now.
-    await withKnownIssue {
-        await block()
+    await withKnownIssue(isIntermittent: true) {
+        do {
+            try await block()
+        } catch {
+            Issue.record(error)
+        }
     } matching: { issue in
-        mutex.withLock { $0.append(issue) }
+        mutex.withLock { $0.append(issue.description) }
         return true
     }