Add tests

Package.swift

@@ -88,7 +88,7 @@ let package = Package(
         ),
         .target(
             name: "TuistSupport",
-            dependencies: ["SPMUtility", "RxSwift"]
+            dependencies: ["SPMUtility", "RxSwift", "RxRelay"]
         ),
         .target(
             name: "TuistSupportTesting",

Sources/TuistSupport/System/SystemEvent.swift

@@ -19,18 +19,18 @@ public enum SystemEvent<T> {
     }
 }
 
-// extension SystemEvent: Equatable where T is Equatable {
-//    public static func == (lhs: SystemEvent<T>, rhs: SystemEvent<T>) -> Bool {
-//        switch (lhs, rhs) {
-//        case (.standardOutput(let lhsValue), .standardOutput(let rhsValue)):
-//            return lhsValue == rhsValue
-//        case (.standardError(let lhsValue), .standardError(let rhsValue)):
-//            return lhsValue == rhsValue
-//        default:
-//            return false
-//        }
-//    }
-// }
+extension SystemEvent: Equatable where T: Equatable {
+    public static func == (lhs: SystemEvent<T>, rhs: SystemEvent<T>) -> Bool {
+        switch (lhs, rhs) {
+        case let (.standardOutput(lhsValue), .standardOutput(rhsValue)):
+            return lhsValue == rhsValue
+        case let (.standardError(lhsValue), .standardError(rhsValue)):
+            return lhsValue == rhsValue
+        default:
+            return false
+        }
+    }
+}
 
 extension SystemEvent where T == Data {
     /// Maps the standard output and error from data to string using the utf8 encoding

Tests/TuistSupportTests/System/Observable+SystemTests.swift

@@ -0,0 +1,162 @@
+import Foundation
+import RxBlocking
+import RxRelay
+import RxSwift
+import XCTest
+@testable import TuistSupport
+@testable import TuistSupportTesting
+
+final class ObservableSystemTests: TuistUnitTestCase {
+    func test_mapToString() {
+        // Given
+        let subject = PublishSubject<SystemEvent<Data>>()
+        var got: [SystemEvent<String>] = []
+
+        // When
+        _ = subject.asObservable().mapToString().subscribe(onNext: {
+            got.append($0)
+        })
+        subject.on(.next(.standardOutput("a".data(using: .utf8)!)))
+        subject.on(.next(.standardOutput("b".data(using: .utf8)!)))
+
+        // Then
+        XCTAssertEqual(got.count, 2)
+        XCTAssertEqual(got.first, .standardOutput("a"))
+        XCTAssertEqual(got.last, .standardOutput("b"))
+    }
+
+    func test_collectAndMergeOutput() {
+        // Given
+        let subject = PublishSubject<SystemEvent<Data>>()
+        var got: String = ""
+
+        // When
+        _ = subject.asObservable()
+            .mapToString()
+            .collectAndMergeOutput()
+            .subscribe(onNext: {
+                got.append($0)
+            })
+        subject.on(.next(.standardOutput("a\n".data(using: .utf8)!)))
+        subject.on(.next(.standardOutput("b\n".data(using: .utf8)!)))
+        subject.on(.completed)
+
+        // Then
+        XCTAssertEqual(got, "a\nb\n")
+    }
+
+    func test_collectOutput() {
+        // Given
+        let subject = PublishSubject<SystemEvent<Data>>()
+        var got: SystemCollectedOutput?
+
+        // When
+        _ = subject.asObservable()
+            .mapToString()
+            .collectOutput()
+            .subscribe(onNext: {
+                got = $0
+            })
+        subject.on(.next(.standardOutput("a\n".data(using: .utf8)!)))
+        subject.on(.next(.standardOutput("b\n".data(using: .utf8)!)))
+        subject.on(.next(.standardError("c\n".data(using: .utf8)!)))
+        subject.on(.next(.standardError("d\n".data(using: .utf8)!)))
+        subject.on(.completed)
+
+        // Then
+        XCTAssertEqual(got?.standardOutput, "a\nb\n")
+        XCTAssertEqual(got?.standardError, "c\nd\n")
+    }
+
+    func test_filterStandardOutput() {
+        // Given
+        let subject = PublishSubject<SystemEvent<Data>>()
+        var got: [SystemEvent<String>] = []
+
+        // When
+        _ = subject.asObservable()
+            .mapToString()
+            .filterStandardOutput { $0.contains("a") }
+            .subscribe(onNext: {
+                got.append($0)
+            })
+        subject.on(.next(.standardOutput("a\n".data(using: .utf8)!)))
+        subject.on(.next(.standardOutput("b\n".data(using: .utf8)!)))
+        subject.on(.next(.standardError("d\n".data(using: .utf8)!)))
+        subject.on(.completed)
+
+        // Then
+        XCTAssertEqual(got.count, 2)
+        XCTAssertEqual(got.first, .standardOutput("a\n"))
+        XCTAssertEqual(got.last, .standardError("d\n"))
+    }
+
+    func test_rejectStandardOutput() {
+        // Given
+        let subject = PublishSubject<SystemEvent<Data>>()
+        var got: [SystemEvent<String>] = []
+
+        // When
+        _ = subject.asObservable()
+            .mapToString()
+            .rejectStandardOutput { $0.contains("a") }
+            .subscribe(onNext: {
+                got.append($0)
+            })
+        subject.on(.next(.standardOutput("a\n".data(using: .utf8)!)))
+        subject.on(.next(.standardOutput("b\n".data(using: .utf8)!)))
+        subject.on(.next(.standardError("d\n".data(using: .utf8)!)))
+        subject.on(.completed)
+
+        // Then
+        XCTAssertEqual(got.count, 2)
+        XCTAssertEqual(got.first, .standardOutput("b\n"))
+        XCTAssertEqual(got.last, .standardError("d\n"))
+    }
+
+    func test_filterStandardError() {
+        // Given
+        let subject = PublishSubject<SystemEvent<Data>>()
+        var got: [SystemEvent<String>] = []
+
+        // When
+        _ = subject.asObservable()
+            .mapToString()
+            .filterStandardError { $0.contains("c") }
+            .subscribe(onNext: {
+                got.append($0)
+            })
+        subject.on(.next(.standardOutput("a\n".data(using: .utf8)!)))
+        subject.on(.next(.standardError("c\n".data(using: .utf8)!)))
+        subject.on(.next(.standardError("d\n".data(using: .utf8)!)))
+        subject.on(.completed)
+
+        // Then
+        XCTAssertEqual(got.count, 2)
+        XCTAssertEqual(got.first, .standardOutput("a\n"))
+        XCTAssertEqual(got.last, .standardError("c\n"))
+    }
+
+    func test_rejectStandardError() {
+        // Given
+        let subject = PublishSubject<SystemEvent<Data>>()
+        var got: [SystemEvent<String>] = []
+
+        // When
+        _ = subject.asObservable()
+            .mapToString()
+            .rejectStandardError { $0.contains("c") }
+            .subscribe(onNext: {
+                got.append($0)
+            })
+        subject.on(.next(.standardOutput("a\n".data(using: .utf8)!)))
+        subject.on(.next(.standardError("c\n".data(using: .utf8)!)))
+        subject.on(.next(.standardError("d\n".data(using: .utf8)!)))
+        subject.on(.completed)
+
+        // Then
+        XCTAssertEqual(got.count, 2)
+        XCTAssertEqual(got.first, .standardOutput("a\n"))
+        XCTAssertEqual(got.last, .standardError("d\n"))
+    }
+}

Tests/TuistSupportTests/System/SystemEventTests.swift

@@ -4,6 +4,24 @@ import XCTest
 @testable import TuistSupportTesting
 
 final class SystemEventTests: TuistUnitTestCase {
+    func test_value_when_standardOutput() {
+        // Given
+        let value = "test"
+        let subject = SystemEvent<String>.standardOutput(value)
+
+        // Then
+        XCTAssertEqual(subject.value, value)
+    }
+
+    func test_value_when_standardError() {
+        // Given
+        let value = "test"
+        let subject = SystemEvent<String>.standardError(value)
+
+        // Then
+        XCTAssertEqual(subject.value, value)
+    }
+
     func test_mapToString_when_standardOutput() {
         // Given
         let value = "test"
@@ -14,5 +32,19 @@ final class SystemEventTests: TuistUnitTestCase {
         let got = subject.mapToString()
 
         // Then
+        XCTAssertEqual(got, .standardOutput(value))
+    }
+
+    func test_mapToString_when_standardError() {
+        // Given
+        let value = "test"
+        let data = value.data(using: .utf8)!
+        let subject = SystemEvent<Data>.standardError(data)
+
+        // When
+        let got = subject.mapToString()
+
+        // Then
+        XCTAssertEqual(got, .standardError(value))
     }
 }