Rename expect(worker:producingOutput:) to be more clear

amayers · amayers · commit a5f55922ee5c · 2025-03-06T12:38:39.000-05:00
When I first saw tests that used this function, I thought it was asserting that the `worker` passed in, matches the `workflow.worker` (which it does do), but then I thought it was asserting that `producingOutput == workflow.worker.output` (which it does NOT do). Instead, neither of the workers are ever run. The `producingOutput` is used as mock output. So renaming these to make it more clear what is going on.
diff --git a/MigrationGuide_v1.0.md b/MigrationGuide_v1.0.md
@@ -120,9 +120,9 @@ NameLoadingWorkflow()
 // After
 NameLoadingWorkflow()
     .renderTester(initialState: .init(state: .loading, token: "user-token"))
-    .expect(
-        worker: LoadingWorker(token: "user-token"),
-        producingOutput: .success("Ben Cochran")
+    .mockWorker(
+        expectedWorker: LoadingWorker(token: "user-token"),
+        mockingOutput: .success("Ben Cochran")
     )
     .render { rendering in 
         XCTAssertEqual(rendering.title, "Loading")
diff --git a/Samples/TicTacToe/Tests/AuthenticationWorkflowTests.swift b/Samples/TicTacToe/Tests/AuthenticationWorkflowTests.swift
@@ -218,8 +218,8 @@ class AuthenticationWorkflowTests: XCTestCase {
                     onLoginTapped: {}
                 )
             )
-            .expect(
-                worker: AuthenticationWorkflow.AuthorizingEmailPasswordWorker(
+            .mockWorker(
+                expectedWorker: AuthenticationWorkflow.AuthorizingEmailPasswordWorker(
                     authenticationService: authenticationService,
                     email: "reza@example.com",
                     password: "password"
@@ -252,8 +252,8 @@ class AuthenticationWorkflowTests: XCTestCase {
                     onLoginTapped: {}
                 )
             )
-            .expect(
-                worker: AuthenticationWorkflow.AuthorizingTwoFactorWorker(
+            .mockWorker(
+                expectedWorker: AuthenticationWorkflow.AuthorizingTwoFactorWorker(
                     authenticationService: authenticationService,
                     intermediateToken: "intermediateSession",
                     twoFactorCode: "twoFactorCode"
diff --git a/Samples/Tutorial/Tutorial5.md b/Samples/Tutorial/Tutorial5.md
@@ -334,9 +334,9 @@ workflow
         producingRendering: ChildScreen(),
         producingOutput: .closed
     )
-    .expect(
-        worker: TestWorker(),
-        producingOutput: .finished
+    .mockWorker(
+        expectedWorker: TestWorker(),
+        mockingOutput: .finished
     )
     .render { rendering in
         XCTAssertEqual("expected text on rendering", rendering.text)
diff --git a/WorkflowCombine/Testing/WorkerTesting.swift b/WorkflowCombine/Testing/WorkerTesting.swift
@@ -21,29 +21,49 @@ import XCTest
 @testable import WorkflowCombine
 
 extension RenderTester {
-    /// Expect the given worker. It will be checked for `isEquivalent(to:)` with the requested worker.
+    /// Mock the given worker's output, and assert that the workflow's worker `isEquivalent(to:)` the `worker`.
     ///
     /// - Parameters:
-    ///   - worker: The worker to be expected
-    ///   - producingOutput: An output that will be returned when this worker is requested, if any.
+    ///   - worker: The worker that we expect was created by the workflow. Will be compared using
+    ///             `isEquivalent(to:)` to assert that the workflow's worker matches.
+    ///   - producingOutput: The output to be used instead of actually running the worker.
+    ///                      If the workflow never tries to run the worker, then this won't be used.
     ///   - key: Key to expect this `Workflow` to be rendered with.
+    @available(*, deprecated, renamed: "mockWorker", message: "This method's name & parameter names were unclear. It has been renamed to mockWorker.")
     public func expect<ExpectedWorkerType: Worker>(
         worker: ExpectedWorkerType,
         producingOutput output: ExpectedWorkerType.Output? = nil,
         key: String = "",
         file: StaticString = #file, line: UInt = #line
+    ) -> RenderTester<WorkflowType> {
+        mockWorker(expectedWorker: worker, mockingOutput: output, key: key, file: file, line: line)
+    }
+
+    /// Mock the given worker's output, and assert that the workflow's worker `isEquivalent(to:)` the `expectedWorker`.
+    ///
+    /// - Parameters:
+    ///   - expectedWorker: The worker that we expect was created by the workflow. Will be compared using
+    ///                     `isEquivalent(to:)` to assert that the workflow's worker matches.
+    ///   - mockingOutput: The output to be used instead of actually running the worker.
+    ///                    If the workflow never tries to run the worker, then this won't be used.
+    ///   - key: Key to expect this `Workflow` to be rendered with.
+    public func mockWorker<ExpectedWorkerType: Worker>(
+        expectedWorker: ExpectedWorkerType,
+        mockingOutput output: ExpectedWorkerType.Output? = nil,
+        key: String = "",
+        file: StaticString = #file, line: UInt = #line
     ) -> RenderTester<WorkflowType> {
         expectWorkflow(
             type: WorkerWorkflow<ExpectedWorkerType>.self,
             key: key,
             producingRendering: (),
             producingOutput: output,
             assertions: { workflow in
-                guard !workflow.worker.isEquivalent(to: worker) else {
+                guard !workflow.worker.isEquivalent(to: expectedWorker) else {
                     return
                 }
                 XCTFail(
-                    "Workers of type \(ExpectedWorkerType.self) not equivalent. Expected: \(worker). Got: \(workflow.worker)",
+                    "Workers of type \(ExpectedWorkerType.self) not equivalent. Expected: \(expectedWorker). Got: \(workflow.worker)",
                     file: file,
                     line: line
                 )
diff --git a/WorkflowCombine/TestingTests/TestingTests.swift b/WorkflowCombine/TestingTests/TestingTests.swift
@@ -27,7 +27,7 @@ class WorkflowCombineTestingTests: XCTestCase {
             .renderTester(initialState: .init(mode: .worker(input: "otherText"), output: ""))
 
         renderTester
-            .expect(worker: TestWorker(input: "otherText"))
+            .mockWorker(expectedWorker: TestWorker(input: "otherText"))
             .render { _ in }
     }
 
@@ -36,9 +36,9 @@ class WorkflowCombineTestingTests: XCTestCase {
             .renderTester(initialState: .init(mode: .worker(input: "otherText"), output: ""))
 
         renderTester
-            .expect(
-                worker: TestWorker(input: "otherText"),
-                producingOutput: "otherText"
+            .mockWorker(
+                expectedWorker: TestWorker(input: "otherText"),
+                mockingOutput: "otherText"
             )
             .render { _ in }
             .verifyState { state in
@@ -49,8 +49,8 @@ class WorkflowCombineTestingTests: XCTestCase {
     func test_worker_missing() {
         let tester = TestWorkflow()
             .renderTester()
-            .expect(
-                worker: TestWorker(input: "input")
+            .mockWorker(
+                expectedWorker: TestWorker(input: "input")
             )
 
         expectingFailure(#"Expected child workflow of type: WorkerWorkflow<TestWorker>, key: """#) {
@@ -61,8 +61,8 @@ class WorkflowCombineTestingTests: XCTestCase {
     func test_worker_mismatch() {
         let tester = TestWorkflow()
             .renderTester(initialState: .init(mode: .worker(input: "test"), output: ""))
-            .expect(
-                worker: TestWorker(input: "not-test")
+            .mockWorker(
+                expectedWorker: TestWorker(input: "not-test")
             )
 
         expectingFailures([
diff --git a/WorkflowConcurrency/Testing/WorkerTesting.swift b/WorkflowConcurrency/Testing/WorkerTesting.swift
@@ -21,29 +21,49 @@ import XCTest
 @testable import WorkflowConcurrency
 
 extension RenderTester {
-    /// Expect the given worker. It will be checked for `isEquivalent(to:)` with the requested worker.
+    /// Mock the given worker's output, and assert that the workflow's worker `isEquivalent(to:)` the `worker`.
     ///
     /// - Parameters:
-    ///   - worker: The worker to be expected
-    ///   - producingOutput: An output that will be returned when this worker is requested, if any.
+    ///   - worker: The worker that we expect was created by the workflow. Will be compared using
+    ///             `isEquivalent(to:)` to assert that the workflow's worker matches.
+    ///   - producingOutput: The output to be used instead of actually running the worker.
+    ///                      If the workflow never tries to run the worker, then this won't be used.
     ///   - key: Key to expect this `Workflow` to be rendered with.
+    @available(*, deprecated, renamed: "mockWorker", message: "This method's name & parameter names were unclear. It has been renamed to mockWorker.")
     public func expect<ExpectedWorkerType: Worker>(
         worker: ExpectedWorkerType,
         producingOutput output: ExpectedWorkerType.Output? = nil,
         key: String = "",
         file: StaticString = #file, line: UInt = #line
+    ) -> RenderTester<WorkflowType> {
+        mockWorker(expectedWorker: worker, mockingOutput: output, key: key, file: file, line: line)
+    }
+
+    /// Mock the given worker's output, and assert that the workflow's worker `isEquivalent(to:)` the `expectedWorker`.
+    ///
+    /// - Parameters:
+    ///   - expectedWorker: The worker that we expect was created by the workflow. Will be compared using
+    ///                     `isEquivalent(to:)` to assert that the workflow's worker matches.
+    ///   - mockingOutput: The output to be used instead of actually running the worker.
+    ///                    If the workflow never tries to run the worker, then this won't be used.
+    ///   - key: Key to expect this `Workflow` to be rendered with.
+    public func mockWorker<ExpectedWorkerType: Worker>(
+        expectedWorker: ExpectedWorkerType,
+        mockingOutput output: ExpectedWorkerType.Output? = nil,
+        key: String = "",
+        file: StaticString = #file, line: UInt = #line
     ) -> RenderTester<WorkflowType> {
         expectWorkflow(
             type: WorkerWorkflow<ExpectedWorkerType>.self,
             key: key,
             producingRendering: (),
             producingOutput: output,
             assertions: { workflow in
-                guard !workflow.worker.isEquivalent(to: worker) else {
+                guard !workflow.worker.isEquivalent(to: expectedWorker) else {
                     return
                 }
                 XCTFail(
-                    "Workers of type \(ExpectedWorkerType.self) not equivalent. Expected: \(worker). Got: \(workflow.worker)",
+                    "Workers of type \(ExpectedWorkerType.self) not equivalent. Expected: \(expectedWorker). Got: \(workflow.worker)",
                     file: file,
                     line: line
                 )
diff --git a/WorkflowConcurrency/TestingTests/TestingTests.swift b/WorkflowConcurrency/TestingTests/TestingTests.swift
@@ -26,7 +26,7 @@ class WorkflowConcurrencyTestingTests: XCTestCase {
             .renderTester(initialState: .init(mode: .worker(input: "otherText"), output: ""))
 
         renderTester
-            .expect(worker: TestWorker(input: "otherText"))
+            .mockWorker(expectedWorker: TestWorker(input: "otherText"))
             .render { _ in }
     }
 
@@ -35,9 +35,9 @@ class WorkflowConcurrencyTestingTests: XCTestCase {
             .renderTester(initialState: .init(mode: .worker(input: "otherText"), output: ""))
 
         renderTester
-            .expect(
-                worker: TestWorker(input: "otherText"),
-                producingOutput: "otherText"
+            .mockWorker(
+                expectedWorker: TestWorker(input: "otherText"),
+                mockingOutput: "otherText"
             )
             .render { _ in }
             .verifyState { state in
@@ -48,8 +48,8 @@ class WorkflowConcurrencyTestingTests: XCTestCase {
     func test_worker_missing() {
         let tester = TestWorkflow()
             .renderTester()
-            .expect(
-                worker: TestWorker(input: "input")
+            .mockWorker(
+                expectedWorker: TestWorker(input: "input")
             )
 
         expectingFailure(#"Expected child workflow of type: WorkerWorkflow<TestWorker>, key: """#) {
@@ -60,8 +60,8 @@ class WorkflowConcurrencyTestingTests: XCTestCase {
     func test_worker_mismatch() {
         let tester = TestWorkflow()
             .renderTester(initialState: .init(mode: .worker(input: "test"), output: ""))
-            .expect(
-                worker: TestWorker(input: "not-test")
+            .mockWorker(
+                expectedWorker: TestWorker(input: "not-test")
             )
 
         expectingFailures([
diff --git a/WorkflowReactiveSwift/Testing/WorkerTesting.swift b/WorkflowReactiveSwift/Testing/WorkerTesting.swift
@@ -21,29 +21,49 @@ import XCTest
 @testable import WorkflowReactiveSwift
 
 extension RenderTester {
-    /// Expect the given worker. It will be checked for `isEquivalent(to:)` with the requested worker.
+    /// Mock the given worker's output, and assert that the workflow's worker `isEquivalent(to:)` the `worker`.
     ///
     /// - Parameters:
-    ///   - worker: The worker to be expected
-    ///   - producingOutput: An output that will be returned when this worker is requested, if any.
+    ///   - worker: The worker that we expect was created by the workflow. Will be compared using
+    ///             `isEquivalent(to:)` to assert that the workflow's worker matches.
+    ///   - producingOutput: The output to be used instead of actually running the worker.
+    ///                      If the workflow never tries to run the worker, then this won't be used.
     ///   - key: Key to expect this `Workflow` to be rendered with.
+    @available(*, deprecated, renamed: "mockWorker", message: "This method's name & parameter names were unclear. It has been renamed to mockWorker.")
     public func expect<ExpectedWorkerType: Worker>(
         worker: ExpectedWorkerType,
         producingOutput output: ExpectedWorkerType.Output? = nil,
         key: String = "",
         file: StaticString = #file, line: UInt = #line
+    ) -> RenderTester<WorkflowType> {
+        mockWorker(expectedWorker: worker, mockingOutput: output, key: key, file: file, line: line)
+    }
+
+    /// Mock the given worker's output, and assert that the workflow's worker `isEquivalent(to:)` the `expectedWorker`.
+    ///
+    /// - Parameters:
+    ///   - expectedWorker: The worker that we expect was created by the workflow. Will be compared using
+    ///                     `isEquivalent(to:)` to assert that the workflow's worker matches.
+    ///   - mockingOutput: The output to be used instead of actually running the worker.
+    ///                    If the workflow never tries to run the worker, then this won't be used.
+    ///   - key: Key to expect this `Workflow` to be rendered with.
+    public func mockWorker<ExpectedWorkerType: Worker>(
+        expectedWorker: ExpectedWorkerType,
+        mockingOutput output: ExpectedWorkerType.Output? = nil,
+        key: String = "",
+        file: StaticString = #file, line: UInt = #line
     ) -> RenderTester<WorkflowType> {
         expectWorkflow(
             type: WorkerWorkflow<ExpectedWorkerType>.self,
             key: key,
             producingRendering: (),
             producingOutput: output,
             assertions: { workflow in
-                guard !workflow.worker.isEquivalent(to: worker) else {
+                guard !workflow.worker.isEquivalent(to: expectedWorker) else {
                     return
                 }
                 XCTFail(
-                    "Workers of type \(ExpectedWorkerType.self) not equivalent. Expected: \(worker). Got: \(workflow.worker)",
+                    "Workers of type \(ExpectedWorkerType.self) not equivalent. Expected: \(expectedWorker). Got: \(workflow.worker)",
                     file: file,
                     line: line
                 )
diff --git a/WorkflowReactiveSwift/TestingTests/TestingTests.swift b/WorkflowReactiveSwift/TestingTests/TestingTests.swift
@@ -27,7 +27,7 @@ class WorkflowReactiveSwiftTestingTests: XCTestCase {
             .renderTester(initialState: .init(mode: .worker(input: "otherText"), output: ""))
 
         renderTester
-            .expect(worker: TestWorker(input: "otherText"))
+            .mockWorker(expectedWorker: TestWorker(input: "otherText"))
             .render { _ in }
     }
 
@@ -36,9 +36,9 @@ class WorkflowReactiveSwiftTestingTests: XCTestCase {
             .renderTester(initialState: .init(mode: .worker(input: "otherText"), output: ""))
 
         renderTester
-            .expect(
-                worker: TestWorker(input: "otherText"),
-                producingOutput: "otherText"
+            .mockWorker(
+                expectedWorker: TestWorker(input: "otherText"),
+                mockingOutput: "otherText"
             )
             .render { _ in }
             .verifyState { state in
@@ -49,8 +49,8 @@ class WorkflowReactiveSwiftTestingTests: XCTestCase {
     func test_worker_missing() {
         let tester = TestWorkflow()
             .renderTester()
-            .expect(
-                worker: TestWorker(input: "input")
+            .mockWorker(
+                expectedWorker: TestWorker(input: "input")
             )
 
         expectingFailure(#"Expected child workflow of type: WorkerWorkflow<TestWorker>, key: """#) {
@@ -61,8 +61,8 @@ class WorkflowReactiveSwiftTestingTests: XCTestCase {
     func test_worker_mismatch() {
         let tester = TestWorkflow()
             .renderTester(initialState: .init(mode: .worker(input: "test"), output: ""))
-            .expect(
-                worker: TestWorker(input: "not-test")
+            .mockWorker(
+                expectedWorker: TestWorker(input: "not-test")
             )
 
         expectingFailures([
diff --git a/WorkflowRxSwift/Testing/WorkerTesting.swift b/WorkflowRxSwift/Testing/WorkerTesting.swift
diff --git a/WorkflowRxSwift/TestingTests/TestingTests.swift b/WorkflowRxSwift/TestingTests/TestingTests.swift
diff --git a/WorkflowTesting/Sources/WorkflowRenderTester.swift b/WorkflowTesting/Sources/WorkflowRenderTester.swift

Original file line number	Diff line number	Diff line change
`@@ -218,8 +218,8 @@ class AuthenticationWorkflowTests: XCTestCase {`
`218`	`218`	`onLoginTapped: {}`
`219`	`219`	`)`
`220`	`220`	`)`
`221`		`- .expect(`
`222`		`- worker: AuthenticationWorkflow.AuthorizingEmailPasswordWorker(`
	`221`	`+ .mockWorker(`
	`222`	`+ expectedWorker: AuthenticationWorkflow.AuthorizingEmailPasswordWorker(`
`223`	`223`	`authenticationService: authenticationService,`
`224`	`224`	`email: "[email protected]",`
`225`	`225`	`password: "password"`
`@@ -252,8 +252,8 @@ class AuthenticationWorkflowTests: XCTestCase {`
`252`	`252`	`onLoginTapped: {}`
`253`	`253`	`)`
`254`	`254`	`)`
`255`		`- .expect(`
`256`		`- worker: AuthenticationWorkflow.AuthorizingTwoFactorWorker(`
	`255`	`+ .mockWorker(`
	`256`	`+ expectedWorker: AuthenticationWorkflow.AuthorizingTwoFactorWorker(`
`257`	`257`	`authenticationService: authenticationService,`
`258`	`258`	`intermediateToken: "intermediateSession",`
`259`	`259`	`twoFactorCode: "twoFactorCode"`
Original file line number	Diff line number	Diff line change
`@@ -334,9 +334,9 @@ workflow`
`334`	`334`	`producingRendering: ChildScreen(),`
`335`	`335`	`producingOutput: .closed`
`336`	`336`	`)`
`337`		`- .expect(`
`338`		`- worker: TestWorker(),`
`339`		`- producingOutput: .finished`
	`337`	`+ .mockWorker(`
	`338`	`+ expectedWorker: TestWorker(),`
	`339`	`+ mockingOutput: .finished`
`340`	`340`	`)`
`341`	`341`	`.render { rendering in`
`342`	`342`	`XCTAssertEqual("expected text on rendering", rendering.text)`