Get rid of Action isEqual(to: ) pain

Author: minuscorp

Package.resolved

@@ -15,6 +15,7 @@
  */
 
 import Foundation
+#if canImport(Mini)
 import Mini
 
 public class LoggingService: Service {
@@ -28,3 +29,4 @@ public class LoggingService: Service {
 
     public init() {}
 }
+#endif

Sources/LoggingService/LoggingService.swift

@@ -20,11 +20,7 @@ import Foundation
  Protocol that has to be conformed by any object that can be dispatcher
  by a `Dispatcher` object.
  */
-public protocol Action {
-    /// Equality function between `Action` objects
-    /// - Returns: If an `Action` is the same as other.
-    func isEqual(to other: Action) -> Bool
-}
+public protocol Action { }
 
 extension Action {
     /// String used as tag of the given Action based on his name.
@@ -44,21 +40,3 @@ extension Action {
         return tag.components(separatedBy: ".")[0]
     }
 }
-
-extension Action {
-    /// Equality operator between `Action` objects.
-    /// - Returns: If the `Action`s are equal or not.
-    public static func == (lhs: Self, rhs: Self) -> Bool {
-        return lhs.isEqual(to: rhs)
-    }
-}
-
-extension Action where Self: Equatable {
-    /// Convenience `isEqual` implementation when the `Action` object
-    /// implements `Equatable`.
-    /// - Returns: Whether the `Action` object is the same as other.
-    public func isEqual(to other: Action) -> Bool {
-        guard let action = other as? Self else { return false }
-        return self == action
-    }
-}

Sources/Mini/Action.swift

@@ -15,14 +15,11 @@
  */
 
 import Foundation
+#if canImport(Mini)
 import Mini
 
 /// Action for testing purposes.
-public class TestOnlyAction: Action {
-    public func isEqual(to _: Action) -> Bool {
-        return true
-    }
-}
+public class TestOnlyAction: Action { }
 
 /// Interceptor class for testing purposes which mute all the received actions.
 public class TestMiddleware: Middleware {
@@ -39,26 +36,21 @@ public class TestMiddleware: Middleware {
 
     public init() {}
 
-    /// Check if a given action have been intercepted before by the Middleware.
-    ///
-    /// - Parameter action: action to be checked
-    /// - Returns: returns true if an action with the same params have been intercepted before.
-    public func contains(action: Action) -> Bool {
-        return interceptedActions.contains(where: {
-            action.isEqual(to: $0)
-        })
-    }
-
     /// Check for actions of certain type being intercepted.
     ///
     /// - Parameter kind: Action type to be checked against the intercepted actions.
     /// - Returns: Array of actions of `kind` being intercepted.
     public func actions<T: Action>(of _: T.Type) -> [T] {
         return interceptedActions.compactMap { $0 as? T }
     }
+    
+    public func action<T: Action>(of _: T.Type, where params: (T) -> Bool) -> Bool {
+        interceptedActions.compactMap { $0 as? T }.compactMap(params).first ?? false
+    }
 
     /// Clear all the intercepted actions
     public func clear() {
         interceptedActions.removeAll()
     }
 }
+#endif

Sources/TestMiddleware/TestMiddleware.swift

@@ -0,0 +1,10 @@
+@testable import Mini
+import XCTest
+
+final class ActionTests: XCTestCase {
+    func test_action_tag() {
+        let action = SetCounterAction(counter: 1)
+        
+        XCTAssertEqual(String(describing: type(of: action)), SetCounterAction.tag)
+    }
+}

Tests/MiniSwiftTests/ActionTests.swift

@@ -3,17 +3,12 @@ import XCTest
 
 final class ChainTests: XCTestCase {
     func test_forwarding_chain_forwards_action() {
-        class TestAction: Action, Equatable {
+        class TestAction: Action {
             var mutableProperty: Int
 
             init(property: Int) {
                 mutableProperty = property
             }
-
-            func isEqual(to other: Action) -> Bool {
-                guard let action = other as? TestAction else { return false }
-                return mutableProperty == action.mutableProperty
-            }
         }
 
         let forwardingChain = ForwardingChain { action in

Tests/MiniSwiftTests/ChainTests.swift

@@ -7,7 +7,7 @@ import RxTest
 @testable import TestMiddleware
 import XCTest
 
-private func equalAction<A: Action>(_ by: A) -> Predicate<A> {
+private func equalAction<A: Action & Equatable>(_ by: A) -> Predicate<A> {
     return Predicate { expression in
         guard let action = try expression.evaluate() else {
             return PredicateResult(status: .fail,
@@ -25,22 +25,21 @@ private func equalAction<A: Action>(_ by: A) -> Predicate<A> {
 final class PrimitiveSequenceTypeTests: XCTestCase {
     fileprivate enum Error: Swift.Error { case dummy }
 
-    class TestCompletableAction: CompletableAction {
+    class TestCompletableAction: CompletableAction, Equatable {
         typealias Payload = Int
 
         let counter: Promise<Payload>
 
         required init(promise: Promise<Payload>) {
             counter = promise
         }
-
-        func isEqual(to other: Action) -> Bool {
-            guard let action = other as? TestCompletableAction else { return false }
-            return counter == action.counter
+        
+        static func == (lhs: TestCompletableAction, rhs: TestCompletableAction) -> Bool {
+            lhs.counter == rhs.counter
         }
     }
 
-    class TestKeyedCompletableAction: KeyedCompletableAction {
+    class TestKeyedCompletableAction: KeyedCompletableAction, Equatable {
         typealias Payload = Int
         typealias Key = String
 
@@ -49,23 +48,21 @@ final class PrimitiveSequenceTypeTests: XCTestCase {
         required init(promise: [Key: Promise<Payload>]) {
             counterMap = promise
         }
-
-        func isEqual(to other: Action) -> Bool {
-            guard let action = other as? TestKeyedCompletableAction else { return false }
-            return counterMap == action.counterMap
+        
+        static func == (lhs: TestKeyedCompletableAction, rhs: TestKeyedCompletableAction) -> Bool {
+            lhs.counterMap == rhs.counterMap
         }
     }
 
-    class TestEmptyAction: EmptyAction {
+    class TestEmptyAction: EmptyAction, Equatable {
         let promise: Promise<Void>
 
         required init(promise: Promise<Void>) {
             self.promise = promise
         }
-
-        func isEqual(to other: Action) -> Bool {
-            guard let action = other as? TestEmptyAction else { return false }
-            return promise == action.promise
+        
+        static func == (lhs: TestEmptyAction, rhs: TestEmptyAction) -> Bool {
+            true
         }
     }
 
@@ -103,7 +100,9 @@ final class PrimitiveSequenceTypeTests: XCTestCase {
             self.testMiddleware.actions(of: TestCompletableAction.self).count
         ).toEventually(be(1))
 
-        expect(self.testMiddleware.contains(action: TestCompletableAction(promise: .error(Error.dummy)))
+        expect(self.testMiddleware.action(of: TestCompletableAction.self) {
+                $0.counter == .error(Error.dummy)
+            }
         ).toEventually(beTrue())
     }
 
@@ -115,7 +114,9 @@ final class PrimitiveSequenceTypeTests: XCTestCase {
 
         expect(
             self.testMiddleware
-                .contains(action: TestKeyedCompletableAction(promise: ["hello": .value(1)]))
+                .action(of: TestKeyedCompletableAction.self) {
+                    $0.counterMap == ["hello": .value(1)]
+                }
         ).toEventually(beTrue())
     }
 
@@ -127,7 +128,9 @@ final class PrimitiveSequenceTypeTests: XCTestCase {
 
         expect(
             self.testMiddleware
-                .contains(action: TestKeyedCompletableAction(promise: ["hello": .error(Error.dummy)]))
+                .action(of: TestKeyedCompletableAction.self) {
+                $0.counterMap == ["hello": .error(Error.dummy)]
+            }
         ).toEventually(beTrue())
     }