@ObservableState crashes snapshots with bad access

[aj2109]

Description

I am trying to write a unit test that will snapshot a View that has an observableState reducer, however doing so causes bad access. I have produced a simple example to reproduce this below:

View and Reducer:

public struct DummyViewCrashes: View {
    let store: StoreOf<DummyReducerCrashes>
    public init(store: StoreOf<DummyReducerCrashes>) {
        self.store = store
    }
    public var body: some View {
        return Text("")
    }
}
@Reducer
public struct DummyReducerCrashes {
    @ObservableState
    public struct State: Equatable {}
    public enum Action {}
    public var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            }
        }
    }
}

public struct DummyViewNoCrashes: View {
    let store: StoreOf<DummyReducerNoCrashes>
    public init(store: StoreOf<DummyReducerNoCrashes>){
        self.store = store
    }
    public var body: some View {
        return Text("")
    }    
}

@Reducer
public struct DummyReducerNoCrashes {
    
    public struct State: Equatable {}
    
    public enum Action {}
    public var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            }
        }
    }
}

Unit test:

    @MainActor
    func testCrash() async throws {
        let view = DummyViewCrashes(store: .init(initialState: .init(), reducer: {
            DummyReducerCrashes()
        }))
                
        assertSnapshot(of: view, as: .dump)
    }
    
    @MainActor
    func testNoCrash() async throws {
        let view = DummyViewNoCrashes(store: .init(initialState: .init(), reducer: {
            DummyReducerNoCrashes()
        }))
                
        assertSnapshot(of: view, as: .dump)
    }`
    
    
    By contrast, a vanilla Observable model and SwiftUI vanilla view, does not crash:
    
    View and model:
    `@available(iOS 17.0, *)
@Observable
public class ObservableModel {
    let someText = ""
}

@available(iOS 17.0, *)
public struct VanillaView: View {
    @State var observableModel: ObservableModel
    public init(observableModel: ObservableModel) {
        self.observableModel = observableModel
    }
    public var body: some View {
        return Text("")
    }
}

Test:

  @available(iOS 17.0, *)
   @MainActor
   func testVanillaObservable() async throws {
       let view = VanillaView(observableModel: .init())
               
       assertSnapshot(of: view, as: .dump)
   }

Checklist

• I have determined whether this bug is also reproducible in a vanilla SwiftUI project.
• If possible, I've reproduced the issue using the main branch of this package.
• This issue hasn't been addressed in an existing GitHub issue or discussion.

Expected behavior

The test runs and passes or fails

Actual behavior

The test crashes with Thread 1: EXC_BAD_ACCESS (code=2, address=0x16cbdbbe8) on let mirror = Mirror(reflecting: value) in private func snap<T>(_ value: T, name: String? = nil, indent: Int = 0) -> String {... in the Snapshotting class

Reproducing project

No response

The Composable Architecture version information

1.16.1

Destination operating system

iOS 18 iPhone 16 Pro sim

Xcode version information

Xcode 16.2

Swift Compiler version information

No response

[OguzYuuksel]

To anyone interested, the issue is caused by the following method in the Store class:

func subscribeToDidSet<T: ObservableState>(_ type: T.Type) -> AnyCancellable {
    let toState = toState as! PartialToState<T>
    return rootStore.didSet
        .compactMap { [weak rootStore] in
            rootStore.map { toState($0.state) }?._$id
        }
        .removeDuplicates()
        .dropFirst()
        .sink { [weak self] _ in
            guard let self else { return }
            self._$observationRegistrar.withMutation(of: self, keyPath: \.currentState) {}
        }
}

This method is only called when the state conforms to ObservableState. If you replace rootStore.didSet with CurrentValueSubject<Void, Never>(()), the crash no longer occurs.

The issue can be workaround by conforming CustomReflectable in the RootStore class and omitting didSet there, but I'm unsure if it is the best way to fix this, and I'm still investigating, but perhaps someone else might be able to resolve it more quickly.

[mbrandonw]

Hi @OguzYuuksel, can you explain a bit why you are trying to snapshot test a SwiftUI view struct with the .dump strategy? I don't think that tells you anything of interest about your feature. And also it seems that the memory address of the lock is not being scrubbed from the output, and so your test will never actually pass.

The crash seems to be an infinite loop, somehow related to the internals of the CurrentValueRelay publisher. We cannot simply swap that out for a CurrentValueSubject because that will cause incorrect behavior in the store.

While ideally we would fix this infinite loop, we don't really consider it a priority because we just don't think there is any value to snapshotting these objects with .dump. If you want to look into a fix we'd be happy to accept a PR. The fix would be in SnapshotTesting, not in this library.

Alternatively, it does not seem that our customDump (which is more modern than SnapshotTesting's .dump) has a problem with snapshotting this kind of view. And so you could build your own .customDump snapshot strategy that uses customDump(…) under the hood. That should work around the problem.

Since this isn't really a problem with this library I am going to convert it to a discussion. Feel free to discuss more over there!

[OguzYuuksel]

Hi @mbrandonw, I wanted to debug the issue to help @aj2109.
I didn't mean swapping CurrentValueRelay with CurrentValueSubject because I tried and the loop still exists in this case.
I just wanted to prove that the loop somehow related to that function and just replaced rootStore.didSet in the function with CurrentValueSubject<Void, Never>(()), I know this will break the whole logic. I feel referencing any publisher from rootStore in this function causes that infinite loop. E.g. I also tried creating a foo subject and replaced rootStore.didSet with rootStore.fooSubject it also caused infinite loop.

The infinite loop occurs in the snap function in the swift-snapshot-testing library.

private func snap<T>(_ value: T, name: String? = nil, indent: Int = 0) -> String {
  let indentation = String(repeating: " ", count: indent)
  let mirror = Mirror(reflecting: value)
  var children = mirror.children
  let count = children.count
  let bullet = count == 0 ? "-" : "▿"

  let description: String
  switch (value, mirror.displayStyle) {
  case (_, .collection?):
    description = count == 1 ? "1 element" : "\(count) elements"
  case (_, .dictionary?):
    description = count == 1 ? "1 key/value pair" : "\(count) key/value pairs"
    children = sort(children)
  case (_, .set?):
    description = count == 1 ? "1 member" : "\(count) members"
    children = sort(children)
  case (_, .tuple?):
    description = count == 1 ? "(1 element)" : "(\(count) elements)"
  case (_, .optional?):
    let subjectType = String(describing: mirror.subjectType)
      .replacingOccurrences(of: " #\\d+", with: "", options: .regularExpression)
    description = count == 0 ? "\(subjectType).none" : "\(subjectType)"
  case (let value as AnySnapshotStringConvertible, _) where type(of: value).renderChildren:
    description = value.snapshotDescription
  case (let value as AnySnapshotStringConvertible, _):
    return "\(indentation)- \(name.map { "\($0): " } ?? "")\(value.snapshotDescription)\n"
  case (let value as CustomStringConvertible, _):
    description = value.description
  case (_, .class?), (_, .struct?):
    description = String(describing: mirror.subjectType)
      .replacingOccurrences(of: " #\\d+", with: "", options: .regularExpression)
    children = sort(children)
  case (_, .enum?):
    let subjectType = String(describing: mirror.subjectType)
      .replacingOccurrences(of: " #\\d+", with: "", options: .regularExpression)
    description = count == 0 ? "\(subjectType).\(value)" : "\(subjectType)"
  case (let value, _):
    description = String(describing: value)
  }

  let lines =
    ["\(indentation)\(bullet) \(name.map { "\($0): " } ?? "")\(description)\n"]
    + children.map { snap($1, name: $0, indent: indent + 2) }

  return lines.joined()
}

private func sort(_ children: Mirror.Children) -> Mirror.Children {
  return .init(
    children
      .map({ (child: $0, snap: snap($0)) })
      .sorted(by: { $0.snap < $1.snap })
      .map({ $0.child })
  )
}

The code provided in the issue always goes into the case (_, .class?), (_, .struct?) block, and the sort function calls snap again, which leads to an infinite loop. However, with the changes I made, the infinite loop is no longer occurring. But I still don't know if conforming CustomReflectable is right way to fix it.

I couldn't fully understand how referencing rootStore.didSet causes an infinite loop in this case.

  case (_, .class?), (_, .struct?):
    description = String(describing: mirror.subjectType)
      .replacingOccurrences(of: " #\\d+", with: "", options: .regularExpression)
    children = sort(children)

[OguzYuuksel]

Finally find out the issue CurrentValueRelay holds CurrentValueRelay.Subscription in private var subscriptions = ContiguousArray<Subscription>() and CurrentValueRelay.Subscription holds CurrentValueRelay in private var upstream: CurrentValueRelay? so when Mirrored basically Children are pointing each other and since snap function recursively check for Children, it goes infinite loop.

One fix is conforming CustomReflectable from CurrentValueRelay.Subscription and define customMirror, this will break the cycle. Still don't know if this would be most organic way to fix that.

[mbrandonw]

Sorry @OguzYuuksel, I mixed up who started the thread! Thanks for looking more into the issue. Will read your responses in depth soon.

[OguzYuuksel]

No worries @mbrandonw, thank you for your response.
I also created a PR to the snapshotting library pointfreeco/swift-snapshot-testing#942
Hi @aj2109, this PR would solve your problem.