Assert environment change between two receives

[ericlewis]

Is this possible or am I doing something wrong? Unsure if you can perform actions between receives.

func testLogin_Success() {
    let csrfStorage = CSRFStorageServiceMock()
    var accountCenterClient = AccountCenterClient.failing

    accountCenterClient.csrf = {
        Effect(value: mockCsrfResponse)
    }

    accountCenterClient.authenticate = { _ in
        Effect(value: mockAuthenticationResponse)
    }

    let store = TestStore(
        initialState: .initialState,
        reducer: loginReducer,
        environment: .mock(
            environment: (),
            mainQueue: .immediate,
            csrfTokenService: csrfStorage,
            seedService: accountCenterClient
        )
    )

    store.send(.set(\.$email, "[email protected]")) {
        $0.email = "[email protected]"
        $0.isValid = false
        $0.isSubmitDisabled = true
    }
    store.send(.set(\.$password, "password123")) {
        $0.password = "password123"
        $0.isValid = true
        $0.isSubmitDisabled = false
    }
    store.send(.pressedLogin) {
        $0.isRequestInFlight = true
        $0.isSubmitDisabled = false
    }
    store.receive(.fetchCsrf) {
        $0.isSubmitDisabled = true
    }
    store.receive(.fetchCsrfFinished(mockCsrfResponse)) // <-- this sets csrfStorage to 'First_Token', then sends .login
    XCTAssertEqual(csrfStorage.setCalledCount, 1) // <-- PROBLEM! This assertion fails
    XCTAssertEqual(csrfStorage.csrf, "First_Token") // <-- PROBLEM! This assertion fails, because csrf is Final_Token
    store.receive(.login) {
        $0.isSubmitDisabled = true
        $0.isRequestInFlight = true
    }
    store.receive(.loginFinished(mockAuthenticationResponse)) // <-- this sets csrfStorage to 'Final_Token'
    XCTAssertEqual(csrfStorage.setCalledCount, 2)
    XCTAssertEqual(csrfStorage.csrf, "Final_Token") // <-- this assertion is fine
}

[ericlewis]

Note: I guess it is being called 2 times, which is good. But I would like to assert that the correct intermediate value is set.

[mbrandonw]

You cannot make assertions on what happens between .receives. This is because internally the TestStore accumulates all the emissions of effects into an array, and .receive just pops the first element off that array in order to assert against it.

The only way to thread logic in between .receives would be to apply a scheduler to the effects so that you can control when they execute. You could even do that right in the test where you over ride accountCenterClient's endpoints.

Also, I'm going to convert this to a discussion since it is not an issue with the library.

[iampatbrown]

Adding to what @mbrandonw said about using a scheduler, you're currently using an .immediate scheduler, changing this to a .test scheduler and manually advancing it might be what you need. You can see this in some of the Example projects. eg:

swift-composable-architecture/Examples/Search/SearchTests/SearchTests.swift

Lines 7 to 33 in 313dd21

	class SearchTests: XCTestCase {
	let scheduler = DispatchQueue.test
	func testSearchAndClearQuery() {
	let store = TestStore(
	initialState: .init(),
	reducer: searchReducer,
	environment: SearchEnvironment(
	weatherClient: .failing,
	mainQueue: self.scheduler.eraseToAnyScheduler()
	)
	)
	store.environment.weatherClient.searchLocation = { _ in Effect(value: mockLocations) }
	store.send(.searchQueryChanged("S")) {
	$0.searchQuery = "S"
	}
	self.scheduler.advance(by: 0.3)
	store.receive(.locationsResponse(.success(mockLocations))) {
	$0.locations = mockLocations
	}
	store.send(.searchQueryChanged("")) {
	$0.locations = []
	$0.searchQuery = ""
	}
	}