project: implement unit tests

Author: Thibault Wittemberg

Package.swift

@@ -18,16 +18,12 @@ let package = Package(
         // Targets can depend on other targets in this package, and on products in packages which this package depends on.
         .target(
             name: "XcodeCoverageConverter",
-            dependencies: [.product(name: "ArgumentParser", package: "swift-argument-parser"), "Core"],
+            dependencies: ["Core"],
             path: "Sources/XcodeCoverageConverter"),
         .target(
             name: "Core",
-            dependencies: [],
+            dependencies: [.product(name: "ArgumentParser", package: "swift-argument-parser")],
             path: "Sources/Core"),
-        .testTarget(
-            name: "XcodeCoverageConverterTests",
-            dependencies: ["XcodeCoverageConverter"],
-            path: "Tests/XcodeCoverageConverterTests"),
         .testTarget(
             name: "CoreTests",
             dependencies: ["Core"],

Sources/Core/Commands/GenerateCommand.swift

@@ -15,18 +15,23 @@ public extension Xccov.Commands.Generate {
 
     enum Output: String, ExpressibleByArgument {
         case coberturaXml = "cobertura-xml"
+        case failable = "failable"
 
         var converter: Xccov.Converters.Converter {
             switch self {
             case .coberturaXml:
                 return Xccov.Converters.CoberturaXml.convert(coverageReport:)
+            case .failable:
+                return Xccov.Converters.FailableConverter.convert(coverageReport:)
             }
         }
 
         var filename: String {
             switch self {
             case .coberturaXml:
                 return "cobertura.xml"
+            case .failable:
+                return "failable.xml"
             }
         }
     }

Sources/Core/Commons/Models/Export.swift

@@ -5,7 +5,7 @@
 //  Created by Thibault Wittemberg on 2020-06-03.
 //
 
-public struct Export {
+public struct Export: Equatable {
     public let content: String
     public let filename: String
 

Sources/Core/Converters/CoberturaXmlConverter.swift

@@ -12,9 +12,16 @@ public extension Xccov.Converters {
 }
 
 public extension Xccov.Converters.CoberturaXml {
+
     static func convert(coverageReport: CoverageReport) -> Result<String, Xccov.Error> {
-        let currentDirectoryPath = FileManager.default.currentDirectoryPath
+        Self.convert(coverageReport: coverageReport,
+                     timeStamp: Date().timeIntervalSince1970,
+                     currentDirectoryPath: FileManager.default.currentDirectoryPath)
+    }
 
+    static func convert(coverageReport: CoverageReport,
+                        timeStamp: TimeInterval = Date().timeIntervalSince1970,
+                        currentDirectoryPath: String = FileManager.default.currentDirectoryPath) -> Result<String, Xccov.Error> {
         let dtd = try! XMLDTD(contentsOf: URL(string: "http://cobertura.sourceforge.net/xml/coverage-04.dtd")!)
         dtd.name = "coverage"
         dtd.systemID = "http://cobertura.sourceforge.net/xml/coverage-04.dtd"
@@ -24,7 +31,7 @@ public extension Xccov.Converters.CoberturaXml {
         rootElement.addAttribute(XMLNode.attribute(withName: "branch-rate", stringValue: "1.0") as! XMLNode)
         rootElement.addAttribute(XMLNode.attribute(withName: "lines-covered", stringValue: "\(coverageReport.coveredLines)") as! XMLNode)
         rootElement.addAttribute(XMLNode.attribute(withName: "lines-valid", stringValue: "\(coverageReport.executableLines)") as! XMLNode)
-        rootElement.addAttribute(XMLNode.attribute(withName: "timestamp", stringValue: "\(Date().timeIntervalSince1970)") as! XMLNode)
+        rootElement.addAttribute(XMLNode.attribute(withName: "timestamp", stringValue: "\(timeStamp)") as! XMLNode)
         rootElement.addAttribute(XMLNode.attribute(withName: "version", stringValue: "diff_coverage 0.1") as! XMLNode)
         rootElement.addAttribute(XMLNode.attribute(withName: "complexity", stringValue: "0.0") as! XMLNode)
         rootElement.addAttribute(XMLNode.attribute(withName: "branches-valid", stringValue: "1.0") as! XMLNode)

Sources/Core/Converters/FailableConverter.swift

@@ -0,0 +1,16 @@
+//
+//  FailableConverter.swift
+//  
+//
+//  Created by Thibault Wittemberg on 2020-07-05.
+//
+
+public extension Xccov.Converters {
+    enum FailableConverter {}
+}
+
+public extension Xccov.Converters.FailableConverter {
+    static func convert(coverageReport: CoverageReport) -> Result<String, Xccov.Error> {
+        .failure(Xccov.Error.conversionFailed(""))
+    }
+}

Sources/Core/Converters/Xccov+Converter.swift

@@ -14,4 +14,3 @@ public extension Xccov {
 public extension Xccov.Converters {
     typealias Converter = (CoverageReport) -> Result<String, Xccov.Error>
 }
-

Sources/Core/Decoder/JsonDecoder.swift renamed to Sources/Core/Decoders/JsonDecoder.swift

@@ -0,0 +1,77 @@
+//
+//  GenerateCommandTests.swift
+//  
+//
+//  Created by Thibault Wittemberg on 2020-07-05.
+//
+
+@testable import Core
+import XCTest
+
+final class GenerateCommandTests: XCTestCase {
+    func testFilename_return_expected_value_for_cobertura() {
+        // Given: a Cobertura command output
+        let sut = Xccov.Commands.Generate.Output.coberturaXml
+
+        // When: requesting the filename
+        // Then: it is the expected one
+        XCTAssertEqual(sut.filename, "cobertura.xml")
+    }
+
+    func testConvert_to_coberturalXml_return_success_when_coverageReport_is_valid() {
+        // Given: a valid json report
+        let data = converterFixtureCoverageJson.data(using: .utf8)
+        let coverageReport = try! JSONDecoder().decode(CoverageReport.self, from: data!)
+
+        // When: converting it to Cobertura xml
+        let receivedResult = Xccov.Commands.Generate.convert(report: coverageReport, to: .coberturaXml)
+
+        // Then: it is a success
+        XCTAssertNoThrow(try receivedResult.get())
+    }
+
+    func testConvert_to_failable_return_failure() {
+        // Given: a json report
+        let data = converterFixtureCoverageJson.data(using: .utf8)
+        let coverageReport = try! JSONDecoder().decode(CoverageReport.self, from: data!)
+
+        // When: converting it to Failable output
+        let receivedResult = Xccov.Commands.Generate.convert(report: coverageReport, to: .failable)
+
+        // Then: it is a failure
+        XCTAssertEqual(receivedResult, Result.failure(Xccov.Error.conversionFailed("")))
+    }
+
+    func testConvert_to_several_outputs_return_success_when_coverageReport_is_valid() {
+        // Given: a valid json report
+        let data = converterFixtureCoverageJson.data(using: .utf8)
+        let coverageReport = try! JSONDecoder().decode(CoverageReport.self, from: data!)
+
+        // When: converting it to several output formats
+        let receivedResult = Xccov.Commands.Generate.convert(report: coverageReport, to: [.coberturaXml])
+
+        // Then: it is a success with the count of output formats
+        XCTAssertNoThrow(try receivedResult.get())
+        XCTAssertEqual((try receivedResult.get()).count, 1)
+    }
+
+    func testConvert_to_several_outputs_return_failure_when_a_conversion_fails() {
+        // Given: a json report
+        let data = converterFixtureCoverageJson.data(using: .utf8)
+        let coverageReport = try! JSONDecoder().decode(CoverageReport.self, from: data!)
+
+        // When: converting it to several output formats
+        let receivedResult = Xccov.Commands.Generate.convert(report: coverageReport, to: [.coberturaXml, .failable, .failable])
+
+        // Then: it is a failure
+        XCTAssertEqual(receivedResult, Result.failure(Xccov.Error.conversionFailed("")))
+    }
+
+    static var allTests = [
+        ("testFilename_return_expected_value_for_cobertura", testFilename_return_expected_value_for_cobertura),
+        ("testConvert_to_coberturalXml_return_success_when_coverageReport_is_valid", testConvert_to_coberturalXml_return_success_when_coverageReport_is_valid),
+        ("testConvert_to_failable_return_failure", testConvert_to_failable_return_failure),
+        ("testConvert_to_several_outputs_return_success_when_coverageReport_is_valid", testConvert_to_several_outputs_return_success_when_coverageReport_is_valid),
+        ("testConvert_to_several_outputs_return_failure_when_a_conversion_fails", testConvert_to_several_outputs_return_failure_when_a_conversion_fails),
+    ]
+}

Sources/Core/Decoder/Xccov+Decoder.swift renamed to Sources/Core/Decoders/Xccov+Decoder.swift

@@ -0,0 +1,80 @@
+//
+//  Result+MapEachTests.swift
+//  
+//
+//  Created by Thibault Wittemberg on 2020-07-04.
+//
+
+@testable import Core
+import XCTest
+
+private enum MockError: Error, Equatable {
+    case someError
+}
+
+final class Result_MapEachTests: XCTestCase {
+    func testMapEach_give_error_to_onFailure_function_and_return_result_from_onFailure() {
+        let expectedError = MockError.someError
+        var receivedError: MockError?
+        let expectedResult = Result<[Int],MockError>.failure(.someError)
+        var receivedResult: Result<[Int],MockError>?
+        let spyFailureFunction: (MockError) -> Result<[Int], MockError> = { error in
+            receivedError = error
+            return .failure(error)
+        }
+
+        // Given: a result being a failure
+        let sut = Result<[Int],MockError>.failure(.someError)
+
+        // When: calling mapEach on it
+        receivedResult = sut.mapEach(onFailure: spyFailureFunction, onSuccess: { return .success($0) })
+
+        // Then: the error received in the onFailure function is the one from the failure
+        XCTAssertEqual(receivedError, expectedError)
+
+        // Then: the result of mapEach is the one returned by the onFailure function
+        XCTAssertEqual(receivedResult, expectedResult)
+    }
+
+    func testMapEach_give_values_to_onSuccess_function_and_return_result_from_onSuccess() {
+        let expectedValues = [1, 2, 3, 4, 5]
+        var receivedValues = [Int]()
+        let expectedResult = Result<[String],MockError>.success(["1", "2", "3", "4", "5"])
+        var receivedResult: Result<[String],MockError>?
+
+        // Given: a result being a success
+        let spySuccessFunction: (Int) -> Result<String, MockError> = { value in
+            receivedValues.append(value)
+            return .success("\(value)")
+        }
+        let sut = Result<[Int],MockError>.success([1, 2, 3, 4, 5])
+        receivedResult = sut.mapEach(onSuccess: spySuccessFunction)
+
+        XCTAssertEqual(receivedValues, expectedValues)
+        XCTAssertEqual(receivedResult, expectedResult)
+    }
+
+    func testMapEach_return_failure_if_onSuccess_return_failure() {
+        let expectedResult = Result<[String],MockError>.failure(.someError)
+        var receivedResult: Result<[String],MockError>?
+
+        // Given: a result being a success
+        let spySuccessFunction: (Int) -> Result<String, MockError> = { value in
+            if value == 3 {
+                return .failure(MockError.someError)
+            }
+            return .success("\(value)")
+        }
+
+        let sut = Result<[Int],MockError>.success([1, 2, 3, 4, 5])
+        receivedResult = sut.mapEach(onSuccess: spySuccessFunction)
+
+        XCTAssertEqual(receivedResult, expectedResult)
+    }
+
+    static var allTests = [
+        ("testMapEach_give_error_to_onFailure_function_and_return_result_from_onFailure", testMapEach_give_error_to_onFailure_function_and_return_result_from_onFailure),
+        ("testMapEach_give_values_to_onSuccess_function_and_return_result_from_onSuccess", testMapEach_give_values_to_onSuccess_function_and_return_result_from_onSuccess),
+        ("testMapEach_return_failure_if_onSuccess_return_failure", testMapEach_return_failure_if_onSuccess_return_failure),
+    ]
+}