Presentable allowStepWhenDismissed is ignored and overridden with parent flow (#196)

Co-authored-by: Mikhail Markin <[email protected]>

Thanks for your contribution!

Author: mashe

CHANGELOG.md

@@ -1,4 +1,5 @@
 ** *Unreleased* **:
+- fix: presentable `allowStepWhenDismissed` now are not ignored and not overridden by parent flow
 - fix: `displayed` and `rxVisible` now do not assume UIViewController starts not visible
 
 ** Version 2.13.0 **:

RxFlow/FlowCoordinator.swift

@@ -97,7 +97,7 @@ public final class FlowCoordinator: NSObject {
             // the FlowContributor is not related to a new Flow but to a Presentable/Stepper
             // this new Stepper will contribute to the current Flow.
             .flatMap { [weak self] in
-                self?.steps(from: $0, within: flow, allowStepWhenDismissed: allowStepWhenDismissed) ?? Signal.empty()
+                self?.steps(from: $0) ?? Signal.empty()
             }
             .asObservable()
             .take(until: allowStepWhenDismissed ? .empty() : flow.rxDismissed.asObservable())
@@ -172,18 +172,19 @@ public final class FlowCoordinator: NSObject {
     /// retrieve Steps from the combination presentable/stepper
     ///
     /// - Parameter nextPresentableAndStepper: the combination presentable/stepper that will generate new Steps
-    /// - Parameter flow: the Flow in which the stepper emits new steps
     /// - Returns: the reactive sequence of Steps from the combination presentable/stepper
-    private func steps (from nextPresentableAndStepper: PresentableAndStepper,
-                        within flow: Flow,
-                        allowStepWhenDismissed: Bool = false) -> Signal<Step> {
+    private func steps(from nextPresentableAndStepper: PresentableAndStepper) -> Signal<Step> {
         var stepStream = nextPresentableAndStepper
             .stepper
             .steps
             .do(onSubscribed: { nextPresentableAndStepper.stepper.readyToEmitSteps() })
             .startWith(nextPresentableAndStepper.stepper.initialStep)
             .filter { !($0 is NoneStep) }
-            .take(until: allowStepWhenDismissed ? .empty() : nextPresentableAndStepper.presentable.rxDismissed.asObservable())
+            .take(
+                until: nextPresentableAndStepper.allowStepWhenDismissed
+                ? .empty()
+                : nextPresentableAndStepper.presentable.rxDismissed.asObservable()
+            )
 
         // by default we cannot accept steps from a presentable that is not visible
         if nextPresentableAndStepper.allowStepWhenNotPresented == false {

RxFlowTests/FlowCoordinatorTests.swift

@@ -230,6 +230,36 @@ final class TestLeakingFlow: Flow {
     }
 }
 
+final class TestChildLeakingFlow: Flow {
+    final class ChildViewController: UIViewController {
+        var onDeinit: (() -> Void)? = nil
+        
+        deinit {
+            onDeinit?()
+        }
+    }
+    
+    var root: Presentable = UIViewController()
+    weak var childViewController: ChildViewController? = nil
+    
+    func navigate(to step: Step) -> FlowContributors {
+        guard let step = step as? TestSteps else { return .none }
+
+        switch step {
+        case .one:
+            let viewController = ChildViewController()
+            childViewController = viewController
+            let flowContributor = FlowContributor.contribute(
+                withNextPresentable: viewController,
+                withNextStepper: DefaultStepper()
+            )
+            return .one(flowContributor: flowContributor)
+        default:
+            return .none
+        }
+    }
+}
+
 final class FlowCoordinatorTests: XCTestCase {
 
     func testCoordinateWithOneStepper() {
@@ -368,6 +398,33 @@ final class FlowCoordinatorTests: XCTestCase {
 
         XCTAssertNil(leakingFlowReference)
     }
+    
+    func testChildViewControllerIsNotLeakingWhenParentFlowAllowsStepWhenDismissed() throws {
+        let exp = expectation(description: "Flow when ready")
+        let flowCoordinator = FlowCoordinator()
+        let parentFlow = TestChildLeakingFlow()
+        
+        flowCoordinator.coordinate(flow: parentFlow,
+                                   with: OneStepper(withSingleStep: TestSteps.one),
+                                   allowStepWhenDismissed: true)
+        
+        Flows.use(parentFlow, when: .created) { (_) in
+            exp.fulfill()
+        }
+
+        waitForExpectations(timeout: 1)
+        
+        XCTAssertNotNil(parentFlow.childViewController)
+        
+        let deallocExp = expectation(description: "Child view controller deallocated")
+        parentFlow.childViewController?.onDeinit = { deallocExp.fulfill() }
+
+        try XCTUnwrap(parentFlow.childViewController).didMove(toParent: nil)
+        
+        waitForExpectations(timeout: 1)
+            
+        XCTAssertNil(parentFlow.childViewController)
+    }
 
     func testNavigate_executes_on_mainThread() {
         class ThreadRecorderFlow: Flow {