Added test suite

Author: minuscorp

Tests/MiniSwiftTests/RxTests/PrimitiveSequenceTypeTests.swift

@@ -1,5 +1,6 @@
 import Foundation
 @testable import MiniPromises
+@testable import MiniTasks
 import Nimble
 import RxBlocking
 import RxSwift
@@ -25,47 +26,73 @@ private func equalAction<A: Action & Equatable>(_ by: A) -> Predicate<A> {
 final class PrimitiveSequenceTypeTests: XCTestCase {
     fileprivate enum Error: Swift.Error { case dummy }
 
-    class TestCompletableAction: CompletableAction, Equatable {
-        typealias Payload = Int
+    // MARK: - Promises test actions.
 
-        let counter: Promise<Payload>
+    struct PromisesTestCompletableAction: MiniPromises.CompletableAction, Equatable {
+        typealias Payload = Int
 
-        required init(promise: Promise<Payload>) {
-            counter = promise
-        }
+        let promise: Promise<Payload>
 
-        static func == (lhs: TestCompletableAction, rhs: TestCompletableAction) -> Bool {
-            lhs.counter == rhs.counter
+        static func == (lhs: PromisesTestCompletableAction, rhs: PromisesTestCompletableAction) -> Bool {
+            lhs.promise == rhs.promise
         }
     }
 
-    class TestKeyedCompletableAction: KeyedCompletableAction, Equatable {
+    struct PromisesTestKeyedCompletableAction: MiniPromises.KeyedCompletableAction, Equatable {
         typealias Payload = Int
         typealias Key = String
 
-        let counterMap: [Key: Promise<Payload>]
+        let promise: [Key: Promise<Payload>]
 
-        required init(promise: [Key: Promise<Payload>]) {
-            counterMap = promise
+        static func == (lhs: PromisesTestKeyedCompletableAction, rhs: PromisesTestKeyedCompletableAction) -> Bool {
+            lhs.promise == rhs.promise
         }
+    }
+
+    struct PromisesTestEmptyAction: MiniPromises.EmptyAction, Equatable {
+        let promise: Promise<Void>
 
-        static func == (lhs: TestKeyedCompletableAction, rhs: TestKeyedCompletableAction) -> Bool {
-            lhs.counterMap == rhs.counterMap
+        static func == (_: PromisesTestEmptyAction, _: PromisesTestEmptyAction) -> Bool {
+            true
         }
     }
 
-    class TestEmptyAction: EmptyAction, Equatable {
-        let promise: Promise<Void>
+    // MARK: - Tasks test actions.
+
+    struct TasksTestCompletableAction: MiniTasks.CompletableAction, Equatable {
+        typealias Payload = Int
+
+        let task: AnyTask
+        let payload: Payload?
 
-        required init(promise: Promise<Void>) {
-            self.promise = promise
+        static func == (lhs: TasksTestCompletableAction, rhs: TasksTestCompletableAction) -> Bool {
+            lhs.payload == rhs.payload && lhs.task.status == rhs.task.status
         }
+    }
 
-        static func == (_: TestEmptyAction, _: TestEmptyAction) -> Bool {
-            true
+    struct TasksTestKeyedCompletableAction: MiniTasks.KeyedCompletableAction, Equatable {
+        typealias Payload = Int
+        typealias Key = String
+
+        let task: AnyTask
+        let payload: Int?
+        let key: Key
+
+        static func == (lhs: TasksTestKeyedCompletableAction, rhs: TasksTestKeyedCompletableAction) -> Bool {
+            lhs.key == rhs.key && lhs.payload == rhs.payload && lhs.task.status == rhs.task.status
         }
     }
 
+    struct TasksTestEmptyAction: MiniTasks.EmptyAction, Equatable {
+        let task: AnyTask
+
+        static func == (lhs: TasksTestEmptyAction, rhs: TasksTestEmptyAction) -> Bool {
+            lhs.task.status == rhs.task.status
+        }
+    }
+
+    // MARK: - Common
+
     var dispatcher: Dispatcher!
     var disposeBag: DisposeBag!
     var testMiddleware: TestMiddleware!
@@ -79,99 +106,199 @@ final class PrimitiveSequenceTypeTests: XCTestCase {
         dispatcher.add(middleware: testMiddleware)
     }
 
-    func test_completable_action_dispatch() {
+    // MARK: - Promises tests
+
+    func test_promises_completable_action_dispatch() {
+        Single
+            .just(1)
+            .dispatch(action: PromisesTestCompletableAction.self, on: dispatcher)
+            .disposed(by: disposeBag)
+
+        expect(
+            self.testMiddleware.actions(of: PromisesTestCompletableAction.self).count
+        ).toEventually(be(1))
+    }
+
+    func test_promises_completable_action_dispatch_error() {
+        Single
+            .error(Error.dummy)
+            .dispatch(action: PromisesTestCompletableAction.self, on: dispatcher)
+            .disposed(by: disposeBag)
+
+        expect(
+            self.testMiddleware.actions(of: PromisesTestCompletableAction.self).count
+        ).toEventually(be(1))
+
+        expect(
+            self.testMiddleware.action(of: PromisesTestCompletableAction.self) {
+                $0.promise == .error(Error.dummy)
+            }
+        ).toEventually(beTrue())
+    }
+
+    func test_promises_keyed_completable_action_dispatch() {
+        Single
+            .just(1)
+            .dispatch(action: PromisesTestKeyedCompletableAction.self, key: "hello", on: dispatcher)
+            .disposed(by: disposeBag)
+
+        expect(
+            self.testMiddleware
+                .action(of: PromisesTestKeyedCompletableAction.self) {
+                    $0.promise == ["hello": .value(1)]
+                }
+        ).toEventually(beTrue())
+    }
+
+    func test_promises_keyed_completable_action_dispatch_error() {
+        Single
+            .error(Error.dummy)
+            .dispatch(action: PromisesTestKeyedCompletableAction.self, key: "hello", on: dispatcher)
+            .disposed(by: disposeBag)
+
+        expect(
+            self.testMiddleware
+                .action(of: PromisesTestKeyedCompletableAction.self) {
+                    $0.promise == ["hello": .error(Error.dummy)]
+                }
+        ).toEventually(beTrue())
+    }
+
+    func test_promises_completable_action_action() throws {
+        guard let action =
+            try Single
+            .just(1)
+            .action(PromisesTestCompletableAction.self)
+            .toBlocking(timeout: 5.0).first() else { fatalError() }
+
+        expect(action).to(equalAction(PromisesTestCompletableAction(promise: .value(1))))
+    }
+
+    func test_promises_empty_action_dispatch() {
+        Completable
+            .empty()
+            .dispatch(action: PromisesTestEmptyAction.self, on: dispatcher)
+            .disposed(by: disposeBag)
+
+        expect(
+            self.testMiddleware.actions(of: PromisesTestEmptyAction.self).count
+        ).toEventually(be(1))
+
+        expect(self.testMiddleware.actions(of: PromisesTestEmptyAction.self).first?.promise.isResolved) == true
+    }
+
+    func test_promises_empty_action_dispatch_error() {
+        Completable
+            .error(Error.dummy)
+            .dispatch(action: PromisesTestEmptyAction.self, on: dispatcher)
+            .disposed(by: disposeBag)
+
+        expect(
+            self.testMiddleware.actions(of: PromisesTestEmptyAction.self).count
+        ).toEventually(be(1))
+
+        expect(self.testMiddleware.actions(of: PromisesTestEmptyAction.self).first?.promise.isResolved) == true
+
+        expect(self.testMiddleware.actions(of: PromisesTestEmptyAction.self).first?.promise.isCompleted) == true
+
+        expect(self.testMiddleware.actions(of: PromisesTestEmptyAction.self).first?.promise.isRejected) == true
+    }
+
+    // MARK: - Tasks tests
+
+    func test_tasks_completable_action_dispatch() {
         Single
             .just(1)
-            .dispatch(action: TestCompletableAction.self, on: dispatcher)
+            .dispatch(action: TasksTestCompletableAction.self, on: dispatcher)
             .disposed(by: disposeBag)
 
         expect(
-            self.testMiddleware.actions(of: TestCompletableAction.self).count
+            self.testMiddleware.actions(of: TasksTestCompletableAction.self).count
         ).toEventually(be(1))
     }
 
-    func test_completable_action_dispatch_error() {
+    func test_tasks_completable_action_dispatch_error() {
         Single
             .error(Error.dummy)
-            .dispatch(action: TestCompletableAction.self, on: dispatcher)
+            .dispatch(action: TasksTestCompletableAction.self, on: dispatcher)
             .disposed(by: disposeBag)
 
         expect(
-            self.testMiddleware.actions(of: TestCompletableAction.self).count
+            self.testMiddleware.actions(of: TasksTestCompletableAction.self).count
         ).toEventually(be(1))
 
         expect(
-            self.testMiddleware.action(of: TestCompletableAction.self) {
-                $0.counter == .error(Error.dummy)
+            self.testMiddleware.action(of: TasksTestCompletableAction.self) {
+                $0.task.error as? Error == Error.dummy
             }
         ).toEventually(beTrue())
     }
 
-    func test_keyed_completable_action_dispatch() {
+    func test_tasks_keyed_completable_action_dispatch() {
         Single
             .just(1)
-            .dispatch(action: TestKeyedCompletableAction.self, key: "hello", on: dispatcher)
+            .dispatch(action: TasksTestKeyedCompletableAction.self, key: "hello", on: dispatcher)
             .disposed(by: disposeBag)
 
         expect(
             self.testMiddleware
-                .action(of: TestKeyedCompletableAction.self) {
-                    $0.counterMap == ["hello": .value(1)]
+                .action(of: TasksTestKeyedCompletableAction.self) {
+                    $0.payload == 1 && $0.key == "hello" && $0.task.status == .success
                 }
         ).toEventually(beTrue())
     }
 
-    func test_keyed_completable_action_dispatch_error() {
+    func test_tasks_keyed_completable_action_dispatch_error() {
         Single
             .error(Error.dummy)
-            .dispatch(action: TestKeyedCompletableAction.self, key: "hello", on: dispatcher)
+            .dispatch(action: TasksTestKeyedCompletableAction.self, key: "hello", on: dispatcher)
             .disposed(by: disposeBag)
 
         expect(
             self.testMiddleware
-                .action(of: TestKeyedCompletableAction.self) {
-                    $0.counterMap == ["hello": .error(Error.dummy)]
+                .action(of: TasksTestKeyedCompletableAction.self) {
+                    $0.payload == nil && $0.key == "hello" && $0.task.status == .error
                 }
         ).toEventually(beTrue())
     }
 
-    func test_completable_action_action() throws {
+    func test_tasks_completable_action_action() throws {
         guard let action =
             try Single
             .just(1)
-            .action(TestCompletableAction.self)
+            .action(TasksTestCompletableAction.self)
             .toBlocking(timeout: 5.0).first() else { fatalError() }
 
-        expect(action).to(equalAction(TestCompletableAction(promise: .value(1))))
+        expect(action).to(equalAction(TasksTestCompletableAction(task: .success(), payload: 1)))
     }
 
-    func test_empty_action_dispatch() {
+    func test_tasks_empty_action_dispatch() {
         Completable
             .empty()
-            .dispatch(action: TestEmptyAction.self, on: dispatcher)
+            .dispatch(action: TasksTestEmptyAction.self, on: dispatcher)
             .disposed(by: disposeBag)
 
         expect(
-            self.testMiddleware.actions(of: TestEmptyAction.self).count
+            self.testMiddleware.actions(of: TasksTestEmptyAction.self).count
         ).toEventually(be(1))
 
-        expect(self.testMiddleware.actions(of: TestEmptyAction.self).first?.promise.isResolved) == true
+        expect(self.testMiddleware.actions(of: TasksTestEmptyAction.self).first?.task.isCompleted) == true
     }
 
-    func test_empty_action_dispatch_error() {
+    func test_tasks_empty_action_dispatch_error() {
         Completable
             .error(Error.dummy)
-            .dispatch(action: TestEmptyAction.self, on: dispatcher)
+            .dispatch(action: TasksTestEmptyAction.self, on: dispatcher)
             .disposed(by: disposeBag)
 
         expect(
-            self.testMiddleware.actions(of: TestEmptyAction.self).count
+            self.testMiddleware.actions(of: TasksTestEmptyAction.self).count
         ).toEventually(be(1))
 
-        expect(self.testMiddleware.actions(of: TestEmptyAction.self).first?.promise.isResolved) == true
+        expect(self.testMiddleware.actions(of: TasksTestEmptyAction.self).first?.task.isRunning) == false
 
-        expect(self.testMiddleware.actions(of: TestEmptyAction.self).first?.promise.isCompleted) == true
+        expect(self.testMiddleware.actions(of: TasksTestEmptyAction.self).first?.task.isCompleted) == true
 
-        expect(self.testMiddleware.actions(of: TestEmptyAction.self).first?.promise.isRejected) == true
+        expect(self.testMiddleware.actions(of: TasksTestEmptyAction.self).first?.task.isFailure) == true
     }
 }

Tests/MiniSwiftTests/XCTestManifests.swift

@@ -71,13 +71,20 @@
     //   `swift test --generate-linuxmain`
         // to regenerate.
         static let __allTests__PrimitiveSequenceTypeTests = [
-            ("test_completable_action_action", test_completable_action_action),
-            ("test_completable_action_dispatch", test_completable_action_dispatch),
-            ("test_completable_action_dispatch_error", test_completable_action_dispatch_error),
-            ("test_empty_action_dispatch", test_empty_action_dispatch),
-            ("test_empty_action_dispatch_error", test_empty_action_dispatch_error),
-            ("test_keyed_completable_action_dispatch", test_keyed_completable_action_dispatch),
-            ("test_keyed_completable_action_dispatch_error", test_keyed_completable_action_dispatch_error),
+            ("test_promises_completable_action_action", test_promises_completable_action_action),
+            ("test_promises_completable_action_dispatch", test_promises_completable_action_dispatch),
+            ("test_promises_completable_action_dispatch_error", test_promises_completable_action_dispatch_error),
+            ("test_promises_empty_action_dispatch", test_promises_empty_action_dispatch),
+            ("test_promises_empty_action_dispatch_error", test_promises_empty_action_dispatch_error),
+            ("test_promises_keyed_completable_action_dispatch", test_promises_keyed_completable_action_dispatch),
+            ("test_promises_keyed_completable_action_dispatch_error", test_promises_keyed_completable_action_dispatch_error),
+            ("test_tasks_completable_action_action", test_tasks_completable_action_action),
+            ("test_tasks_completable_action_dispatch", test_tasks_completable_action_dispatch),
+            ("test_tasks_completable_action_dispatch_error", test_tasks_completable_action_dispatch_error),
+            ("test_tasks_empty_action_dispatch", test_tasks_empty_action_dispatch),
+            ("test_tasks_empty_action_dispatch_error", test_tasks_empty_action_dispatch_error),
+            ("test_tasks_keyed_completable_action_dispatch", test_tasks_keyed_completable_action_dispatch),
+            ("test_tasks_keyed_completable_action_dispatch_error", test_tasks_keyed_completable_action_dispatch_error),
         ]
     }