Improved test suite

Author: minuscorp

Tests/MiniSwiftTests/ActionTests.swift

@@ -1,10 +1,24 @@
 @testable import Mini
+@testable import MiniTasks
+import Nimble
 import XCTest
 
 final class ActionTests: XCTestCase {
+    struct TasksTestEmptyAction: MiniTasks.EmptyAction {
+        let task: AnyTask
+    }
+
     func test_action_tag() {
         let action = SetCounterAction(counter: 1)
 
         XCTAssertEqual(String(describing: type(of: action)), SetCounterAction.tag)
     }
+
+    #if !SWIFT_PACKAGE
+        func test_empty_action_fatal_error_initializer() {
+            expect {
+                _ = TasksTestEmptyAction(task: .success(), payload: nil)
+            }.to(throwAssertion())
+        }
+    #endif
 }

Tests/MiniSwiftTests/RxTests/PrimitiveSequenceTypeTests.swift

@@ -119,6 +119,19 @@ final class PrimitiveSequenceTypeTests: XCTestCase {
         ).toEventually(be(1))
     }
 
+    func test_promises_completable_action_dispatch_fill_on_error() {
+        Single
+            .error(Error.dummy)
+            .dispatch(action: PromisesTestCompletableAction.self, on: dispatcher, fillOnError: 1)
+            .disposed(by: disposeBag)
+
+        expect(
+            self.testMiddleware.actions(of: PromisesTestCompletableAction.self).count
+        ).toEventually(be(1))
+
+        expect(self.testMiddleware.actions(of: PromisesTestCompletableAction.self).first?.promise.value) == 1
+    }
+
     func test_promises_completable_action_dispatch_error() {
         Single
             .error(Error.dummy)
@@ -150,6 +163,20 @@ final class PrimitiveSequenceTypeTests: XCTestCase {
         ).toEventually(beTrue())
     }
 
+    func test_promises_keyed_completable_action_dispatch_fill_on_error() {
+        Single
+            .error(Error.dummy)
+            .dispatch(action: PromisesTestKeyedCompletableAction.self, key: "hello", on: dispatcher, fillOnError: 1)
+            .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)
@@ -174,6 +201,46 @@ final class PrimitiveSequenceTypeTests: XCTestCase {
         expect(action).to(equalAction(PromisesTestCompletableAction(promise: .value(1))))
     }
 
+    func test_promises_completable_action_action_fill_on_error() throws {
+        guard let action =
+            try Single
+            .error(Error.dummy)
+            .action(PromisesTestCompletableAction.self, fillOnError: 1)
+            .toBlocking(timeout: 5.0).first() else { fatalError() }
+
+        expect(action).to(equalAction(PromisesTestCompletableAction(promise: .value(1))))
+    }
+
+    func test_promises_completable_action_action_error() throws {
+        guard let action =
+            try Single
+            .error(Error.dummy)
+            .action(PromisesTestCompletableAction.self)
+            .toBlocking(timeout: 5.0).first() else { fatalError() }
+
+        expect(action).to(equalAction(PromisesTestCompletableAction(promise: .error(Error.dummy))))
+    }
+
+    func test_promises_empty_action_action() throws {
+        guard let action =
+            try Completable
+            .empty()
+            .action(PromisesTestEmptyAction.self)
+            .toBlocking(timeout: 5.0).first() else { fatalError() }
+
+        expect(action).to(equalAction(PromisesTestEmptyAction(promise: .empty())))
+    }
+
+    func test_promises_empty_action_action_error() throws {
+        guard let action =
+            try Completable
+            .error(Error.dummy)
+            .action(PromisesTestEmptyAction.self)
+            .toBlocking(timeout: 5.0).first() else { fatalError() }
+
+        expect(action).to(equalAction(PromisesTestEmptyAction(promise: .error(Error.dummy))))
+    }
+
     func test_promises_empty_action_dispatch() {
         Completable
             .empty()
@@ -217,6 +284,19 @@ final class PrimitiveSequenceTypeTests: XCTestCase {
         ).toEventually(be(1))
     }
 
+    func test_tasks_completable_action_dispatch_fill_on_error() {
+        Single
+            .error(Error.dummy)
+            .dispatch(action: TasksTestCompletableAction.self, on: dispatcher, fillOnError: 1)
+            .disposed(by: disposeBag)
+
+        expect(
+            self.testMiddleware.actions(of: TasksTestCompletableAction.self).count
+        ).toEventually(be(1))
+
+        expect(self.testMiddleware.actions(of: TasksTestCompletableAction.self).first?.payload) == 1
+    }
+
     func test_tasks_completable_action_dispatch_error() {
         Single
             .error(Error.dummy)
@@ -248,6 +328,20 @@ final class PrimitiveSequenceTypeTests: XCTestCase {
         ).toEventually(beTrue())
     }
 
+    func test_tasks_keyed_completable_action_dispatch_fill_on_error() {
+        Single
+            .error(Error.dummy)
+            .dispatch(action: TasksTestKeyedCompletableAction.self, key: "hello", on: dispatcher, fillOnError: 1)
+            .disposed(by: disposeBag)
+
+        expect(
+            self.testMiddleware
+                .action(of: TasksTestKeyedCompletableAction.self) {
+                    $0.payload == 1 && $0.key == "hello" && $0.task.status == .success
+                }
+        ).toEventually(beTrue())
+    }
+
     func test_tasks_keyed_completable_action_dispatch_error() {
         Single
             .error(Error.dummy)
@@ -272,6 +366,46 @@ final class PrimitiveSequenceTypeTests: XCTestCase {
         expect(action).to(equalAction(TasksTestCompletableAction(task: .success(), payload: 1)))
     }
 
+    func test_tasks_completable_action_action_fill_on_error() throws {
+        guard let action =
+            try Single
+            .error(Error.dummy)
+            .action(TasksTestCompletableAction.self, fillOnError: 1)
+            .toBlocking(timeout: 5.0).first() else { fatalError() }
+
+        expect(action).to(equalAction(TasksTestCompletableAction(task: .success(), payload: 1)))
+    }
+
+    func test_tasks_completable_action_action_error() throws {
+        guard let action =
+            try Single
+            .error(Error.dummy)
+            .action(TasksTestCompletableAction.self)
+            .toBlocking(timeout: 5.0).first() else { fatalError() }
+
+        expect(action).to(equalAction(TasksTestCompletableAction(task: .failure(Error.dummy), payload: nil)))
+    }
+
+    func test_tasks_empty_action_action() throws {
+        guard let action =
+            try Completable
+            .empty()
+            .action(TasksTestEmptyAction.self)
+            .toBlocking(timeout: 5.0).first() else { fatalError() }
+
+        expect(action).to(equalAction(TasksTestEmptyAction(task: .success())))
+    }
+
+    func test_tasks_empty_action_action_error() throws {
+        guard let action =
+            try Completable
+            .error(Error.dummy)
+            .action(TasksTestEmptyAction.self)
+            .toBlocking(timeout: 5.0).first() else { fatalError() }
+
+        expect(action).to(equalAction(TasksTestEmptyAction(task: .failure(Error.dummy))))
+    }
+
     func test_tasks_empty_action_dispatch() {
         Completable
             .empty()

Tests/MiniSwiftTests/TaskTests.swift

@@ -4,6 +4,18 @@ import XCTest
 class TaskTests: XCTestCase {
     let error = NSError(domain: #function, code: -1, userInfo: nil)
 
+    func test_check_states_for_idle_task() {
+        let task = AnyTask.idle()
+
+        XCTAssertEqual(task.status, .idle)
+        XCTAssertNil(task.error)
+
+        XCTAssertFalse(task.isRunning)
+        XCTAssertFalse(task.isFailure)
+        XCTAssertFalse(task.isCompleted)
+        XCTAssertFalse(task.isSuccessful)
+    }
+
     func test_check_states_for_running_task() {
         let task = AnyTask.running()
 
@@ -28,6 +40,19 @@ class TaskTests: XCTestCase {
         XCTAssertTrue(task.isSuccessful)
     }
 
+    func test_check_states_for_success_typed_task() {
+        let task: TypedTask<Int> = AnyTask.success(1)
+
+        XCTAssertEqual(task.status, .success)
+        XCTAssertNil(task.error)
+
+        XCTAssertFalse(task.isRunning)
+        XCTAssertFalse(task.isFailure)
+        XCTAssertTrue(task.isCompleted)
+        XCTAssertTrue(task.isSuccessful)
+        XCTAssertEqual(task.data, 1)
+    }
+
     func test_check_states_for_failure_task() {
         let task = AnyTask.failure(error)
 
@@ -39,4 +64,13 @@ class TaskTests: XCTestCase {
         XCTAssertTrue(task.isCompleted)
         XCTAssertFalse(task.isSuccessful)
     }
+
+    func test_task_properties() {
+        let task: AnyTask = .idle()
+        let date = Date()
+        task.date = date
+
+        XCTAssertEqual(task.date as Date?, date)
+        XCTAssertNil(task.not_a_property as Int?)
+    }
 }

Tests/MiniSwiftTests/XCTestManifests.swift

@@ -71,20 +71,32 @@
     //   `swift test --generate-linuxmain`
         // to regenerate.
         static let __allTests__PrimitiveSequenceTypeTests = [
+            ("test_promises_completable_action_action_error", test_promises_completable_action_action_error),
+            ("test_promises_completable_action_action_fill_on_error", test_promises_completable_action_action_fill_on_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_completable_action_dispatch_fill_on_error", test_promises_completable_action_dispatch_fill_on_error),
+            ("test_promises_empty_action_action_error", test_promises_empty_action_action_error),
+            ("test_promises_empty_action_action", test_promises_empty_action_action),
             ("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_promises_keyed_completable_action_dispatch_fill_on_error", test_promises_keyed_completable_action_dispatch_fill_on_error),
+            ("test_tasks_completable_action_action_error", test_tasks_completable_action_action_error),
+            ("test_tasks_completable_action_action_fill_on_error", test_tasks_completable_action_action_fill_on_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_completable_action_dispatch_fill_on_error", test_tasks_completable_action_dispatch_fill_on_error),
+            ("test_tasks_empty_action_action_error", test_tasks_empty_action_action_error),
+            ("test_tasks_empty_action_action", test_tasks_empty_action_action),
             ("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),
+            ("test_tasks_keyed_completable_action_dispatch_fill_on_error", test_tasks_keyed_completable_action_dispatch_fill_on_error),
         ]
     }
 
@@ -130,8 +142,11 @@
         // to regenerate.
         static let __allTests__TaskTests = [
             ("test_check_states_for_failure_task", test_check_states_for_failure_task),
+            ("test_check_states_for_idle_task", test_check_states_for_idle_task),
             ("test_check_states_for_running_task", test_check_states_for_running_task),
             ("test_check_states_for_success_task", test_check_states_for_success_task),
+            ("test_check_states_for_success_typed_task", test_check_states_for_success_typed_task),
+            ("test_task_properties", test_task_properties),
         ]
     }