Refactor controller view connection backward compatibility

Author: kmcbride

MobiusCore/Source/MobiusController.swift

@@ -132,20 +132,16 @@ public final class MobiusController<Model, Event, Effect> {
     /// The view should also return a `Connection` that accepts models and renders them. Disposing the connection should
     /// make the view stop emitting events.
     ///
+    /// - Parameter connectable: The view to connect.
     /// - Returns: An identifier that can be used to disconnect the view.
     /// - Attention: Fails via `MobiusHooks.errorHandler` if the loop is running.
     @discardableResult
     public func connectView<ViewConnectable: Connectable>(
         _ connectable: ViewConnectable
     ) -> UUID where ViewConnectable.Input == Model, ViewConnectable.Output == Event {
         do {
-            var uuid = Self.viewConnectableID
+            let uuid = UUID()
             try state.mutate { stoppedState in
-                if stoppedState.viewConnectables[uuid] != nil {
-                    // For backwards compatibility with id-less `disconnectView()` usage, we default
-                    // to the reserved connection id and generate a new one when needed.
-                    uuid = UUID()
-                }
                 stoppedState.viewConnectables[uuid] = AsyncDispatchQueueConnectable(connectable, acceptQueue: viewQueue)
             }
 
@@ -168,10 +164,21 @@ public final class MobiusController<Model, Event, Effect> {
     /// disconnect
     public func disconnectView(id: UUID? = nil) {
         do {
-            let uuid = id ?? Self.viewConnectableID
             try state.mutate { stoppedState in
+                guard !stoppedState.viewConnectables.isEmpty else {
+                    throw ErrorMessage(message: "\(Self.debugTag): no view connected, cannot disconnect")
+                }
+
+                // For backwards compatibility, only require an id when there is more than 1 connection
+                guard
+                    id != nil || stoppedState.viewConnectables.count == 1,
+                    let uuid = id ?? stoppedState.viewConnectables.keys.first
+                else {
+                    throw ErrorMessage(message: "\(Self.debugTag): missing view connection id, cannot disconnect")
+                }
+
                 guard stoppedState.viewConnectables[uuid] != nil else {
-                    throw ErrorMessage(message: "\(Self.debugTag): invalid view connection id, cannot disconnect")
+                    throw ErrorMessage(message: "\(Self.debugTag): invalid view connection, cannot disconnect")
                 }
 
                 stoppedState.viewConnectables[uuid] = nil
@@ -289,11 +296,6 @@ public final class MobiusController<Model, Event, Effect> {
         }
     }
 
-    /// Reserves a special identifier for the primary view connectable
-    private static var viewConnectableID: UUID {
-        return UUID(uuid: (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
-    }
-
     /// Simple error that just carries an error message out of a closure for us
     private struct ErrorMessage: Error {
         let message: String

MobiusCore/Test/MobiusControllerTests.swift

@@ -224,16 +224,27 @@ class MobiusControllerTests: QuickSpec {
                     }
                     it("should not allow disconnecting without a connection") {
                         controller.connectView(view)
+                        controller.disconnectView()
+                        expect(controller.disconnectView()).to(raiseError())
+                    }
 
-                        let secondaryView = RecordingTestConnectable(expectedQueue: self.viewQueue)
-                        let secondaryConnectionID = controller.connectView(secondaryView)
+                    describe("multiple view connections") {
+                        it("should not allow disconnecting without a connection id") {
+                            let secondaryView = RecordingTestConnectable(expectedQueue: self.viewQueue)
 
-                        controller.disconnectView()
-                        controller.disconnectView(id: secondaryConnectionID)
+                            controller.connectView(view)
+                            controller.connectView(secondaryView)
 
-                        expect(controller.disconnectView()).to(raiseError())
-                        expect(controller.disconnectView(id: secondaryConnectionID)).to(raiseError())
-                        expect(controller.disconnectView(id: UUID())).to(raiseError())
+                            expect(controller.disconnectView()).to(raiseError())
+                        }
+                        it("should not allow disconnecting an invalid connection id") {
+                            let secondaryView = RecordingTestConnectable(expectedQueue: self.viewQueue)
+
+                            controller.connectView(view)
+                            controller.connectView(secondaryView)
+
+                            expect(controller.disconnectView(id: UUID())).to(raiseError())
+                        }
                     }
                 }
                 #endif