Subscript 'subscript(dynamicMember:)' requires that 'SyncUpFormReducer.Action' conform to 'CasePathable'

[anthony1810]

Hi everyone,

I'm following the Point-Free SyncUps Tutorial and I've become stuck while writing a test for the SyncUpsList feature. I'm trying to test the flow of adding a new SyncUp, which involves a presented SyncUpFormReducer.

I'm getting the following error on my store.send call:

Subscript 'subscript(dynamicMember:)' requires that 'SyncUpFormReducer.Action' conform to 'CasePathable'

This happens when I try to update the syncUp state within the presented form reducer.

Here is the test I've written so far:

import ComposableArchitecture
import Testing
@testable import SyncUps

@MainActor
struct SyncUpsListStoreTests {  
  @Test func addSyncUpButtonTapped() async throws {
      let store = TestStore(
          initialState: SyncUpsListReducer.State(syncUps: []),
          reducer: { SyncUpsListReducer() },
          withDependencies: {
              $0.uuid = .incrementing
          }
      )
      
      await store.send(.addSyncUpButtonTapped) {
          $0.addSyncUp = SyncUpFormReducer.State(syncUp: SyncUp(id: SyncUp.ID(0)))
      }
      
      let editedSyncUp: SyncUp = SyncUp(
          id: SyncUp.ID(0),
          attendees: [
              Attendee(id: Attendee.ID(), name: "Quang"),
              Attendee(id: Attendee.ID(), name: "Anthony")
          ],
          title: "Point-free morning sync"
      )
      
      // 🛑 STUCK HERE with the error
      await store.send(\.showSyncUpForm.binding.syncUp, editedSyncUp) {
          $0.addSyncUp?.syncUp = editedSyncUp
      }
  }
}
@Reducer
struct SyncUpsListReducer {
  
  @Dependency(\.uuid) var uuid
  
  @ObservableState
  struct State: Equatable {
      @Presents var addSyncUp: SyncUpFormReducer.State?
      var syncUps: IdentifiedArrayOf<SyncUp> = []
  }
  
  enum Action {
      case addSyncUpButtonTapped
      case onDeleteSyncUp(IndexSet)
      case syncUptapped(id: SyncUp.ID)
      case showSyncUpForm(PresentationAction<SyncUpFormReducer.Action>)
      case discardSyncUpFormButtonTapped
      case addSyncUpFormButtonTapped
  }
  
  var body: some ReducerOf<Self> {
      Reduce { state, action in
          switch action {
          case .showSyncUpForm:
              return .none
          case .addSyncUpButtonTapped:
              state.addSyncUp = SyncUpFormReducer.State(syncUp: SyncUp(id: uuid()))
              return .none
              
          case let .onDeleteSyncUp(indexSet):
              state.syncUps.remove(atOffsets: indexSet)
              return .none
              
          case .syncUptapped:
              // Handle sync up tapped action if needed
              return .none
              
          case .discardSyncUpFormButtonTapped:
              state.addSyncUp = nil
              return .none
          case .addSyncUpFormButtonTapped:
              guard let newSyncUp = state.addSyncUp?.syncUp else { return .none }
              state.syncUps.append(newSyncUp)
              state.addSyncUp = nil
              return .none
          }
      }
      .ifLet(\.$addSyncUp, action: \.showSyncUpForm) {
          SyncUpFormReducer()
      }
  }
}
@Reducer
struct SyncUpFormReducer {
  @Dependency(\.uuid) var uuid
  
  var body: some ReducerOf<Self> {
      BindingReducer()
      
      Reduce { state, action in
          switch action {
          case .binding(_):
              return .none
          case .addNewAttendeeButtonTapped:
              let newAttendee = Attendee(id: uuid())
              state.syncUp.attendees.append(newAttendee)
              state.focus = .attendee(id: newAttendee.id)
              return .none
          case .deleteAttendee(let atOffsets):
              state.syncUp.attendees.remove(atOffsets: atOffsets)
              
              if state.syncUp.attendees.isEmpty {
                  return .run { send in
                      await send(.addNewAttendeeButtonTapped)
                  }
              } else if let lastAttendee = state.syncUp.attendees.last {
                  state.focus = .attendee(id: lastAttendee.id)
              }
              
              return .none
          }
      }
  }
}

extension SyncUpFormReducer {
  @ObservableState
  struct State: Equatable, Sendable {
      enum Field: Hashable {
          case title
          case attendee(id: Attendee.ID)
      }
      
      var syncUp: SyncUp
      var focus: Field? = .title
      
      init(syncUp: SyncUp, focus: Field? = .title) {
          self.syncUp = syncUp
          self.focus = focus
      }
  }
  
  enum Action: BindableAction, Equatable, Sendable {
      case binding(BindingAction<State>)
      case addNewAttendeeButtonTapped
      case deleteAttendee(atOffsets: IndexSet)
  }
}