Tighten TestStore equality expectations (#1091)

* Add tests for TestStore equality assertions

* Change TestStore to require a state change if a closure is given

* Update a use of TestStore that described a change unnecessarily

* Remove unused mainQueue

Author: rcarver

Sources/ComposableArchitecture/TestSupport/TestStore.swift

@@ -337,7 +337,7 @@
       _ action: LocalAction,
       file: StaticString = #file,
       line: UInt = #line,
-      _ update: @escaping (inout LocalState) throws -> Void = { _ in }
+      _ update: ((inout LocalState) throws -> Void)? = nil
     ) {
       if !self.receivedActions.isEmpty {
         var actions = ""
@@ -355,7 +355,12 @@
       var expectedState = self.toLocalState(self.snapshotState)
       self.store.send(.init(origin: .send(action), file: file, line: line))
       do {
-        try update(&expectedState)
+        try self.expectedStateShouldChange(
+          expected: &expectedState,
+          update: update,
+          file: file,
+          line: line
+        )
       } catch {
         XCTFail("Threw error: \(error)", file: file, line: line)
       }
@@ -370,6 +375,27 @@
       }
     }
 
+    private func expectedStateShouldChange(
+      expected: inout LocalState,
+      update: ((inout LocalState) throws -> Void)? = nil,
+      file: StaticString,
+      line: UInt
+    ) throws {
+      guard let update = update else { return }
+      let current = expected
+      try update(&expected)
+      if expected == current {
+        XCTFail(
+          """
+          Expected to modify the expected state, but no change occurred.
+
+          Ensure that the state was modified or remove the closure to assert no change.
+          """,
+          file: file, line: line
+        )
+      }
+    }
+
     private func expectedStateShouldMatch(
       expected: LocalState,
       actual: LocalState,
@@ -406,7 +432,7 @@
       _ expectedAction: Action,
       file: StaticString = #file,
       line: UInt = #line,
-      _ update: @escaping (inout LocalState) throws -> Void = { _ in }
+      _ update: ((inout LocalState) throws -> Void)? = nil
     ) {
       guard !self.receivedActions.isEmpty else {
         XCTFail(
@@ -441,7 +467,12 @@
       }
       var expectedState = self.toLocalState(self.snapshotState)
       do {
-        try update(&expectedState)
+        try self.expectedStateShouldChange(
+          expected: &expectedState,
+          update: update,
+          file: file,
+          line: line
+        )
       } catch {
         XCTFail("Threw error: \(error)", file: file, line: line)
       }

Tests/ComposableArchitectureTests/ComposableArchitectureTests.swift

@@ -150,7 +150,7 @@ final class ComposableArchitectureTests: XCTestCase {
 
     store.send(.incr) { $0 = 1 }
     scheduler.advance()
-    store.receive(.response(1)) { $0 = 1 }
+    store.receive(.response(1))
 
     store.send(.incr) { $0 = 2 }
     store.send(.cancel)

Tests/ComposableArchitectureTests/TestStoreTests.swift

@@ -57,4 +57,92 @@ class TestStoreTests: XCTestCase {
 
     store.send(.d)
   }
+  func testExpectedStateEquality() {
+    struct State: Equatable {
+      var count: Int = 0
+      var isChanging: Bool = false
+    }
+
+    enum Action: Equatable {
+      case increment, changed(from: Int, to: Int)
+    }
+
+    let reducer = Reducer<State, Action, Void> { state, action, scheduler in
+      switch action {
+      case .increment:
+        state.isChanging = true
+        return Effect(value: .changed(from: state.count, to: state.count + 1))
+      case .changed(let from, let to):
+        state.isChanging = false
+        if state.count == from {
+          state.count = to
+        }
+        return .none
+      }
+    }
+
+    let store = TestStore(
+      initialState: State(),
+      reducer: reducer,
+      environment: ()
+    )
+
+    store.send(.increment) {
+      $0.isChanging = true
+    }
+    store.receive(.changed(from: 0, to: 1)) {
+      $0.isChanging = false
+      $0.count = 1
+    }
+
+    XCTExpectFailure {
+      store.send(.increment) {
+        $0.isChanging = false
+      }
+    }
+    XCTExpectFailure {
+      store.receive(.changed(from: 1, to: 2)) {
+        $0.isChanging = true
+        $0.count = 1100
+      }
+    }
+  }
+  func testExpectedStateEqualityMustModify() {
+    struct State: Equatable {
+      var count: Int = 0
+    }
+
+    enum Action: Equatable {
+      case noop, finished
+    }
+
+    let reducer = Reducer<State, Action, Void> { state, action, scheduler in
+      switch action {
+      case .noop:
+        return Effect(value: .finished)
+      case .finished:
+        return .none
+      }
+    }
+
+    let store = TestStore(
+      initialState: State(),
+      reducer: reducer,
+      environment: ()
+    )
+
+    store.send(.noop)
+    store.receive(.finished)
+
+    XCTExpectFailure {
+      store.send(.noop) {
+        $0.count = 0
+      }
+    }
+    XCTExpectFailure {
+      store.receive(.finished) {
+        $0.count = 0
+      }
+    }
+  }
 }