diff --git a/Tests/DangerSwiftPeripheryTests/DangerSwiftPeripheryTests.swift b/Tests/DangerSwiftPeripheryTests/DangerSwiftPeripheryTests.swift index 7060cfd..5c17d05 100644 --- a/Tests/DangerSwiftPeripheryTests/DangerSwiftPeripheryTests.swift +++ b/Tests/DangerSwiftPeripheryTests/DangerSwiftPeripheryTests.swift @@ -3,55 +3,109 @@ import Danger @testable import DangerSwiftPeriphery final class DangerSwiftPeripheryTests: XCTestCase { - func testScanErrorOccuredWhileScanning() throws { - let scanExecutor = ErrorScanExecutor(errorMessage: "test error") + private var scanExecutor: PeripheryScanExecutableMock! + private var outputParser: CheckstyleOutputParsableMock! + private var diffProvider: PullRequestDiffProvidableMock! + + override func setUp() { + super.setUp() + + scanExecutor = PeripheryScanExecutableMock() + outputParser = CheckstyleOutputParsableMock(projectRootPath: DefaultCurrentPathProvider().currentPath) + diffProvider = PullRequestDiffProvidableMock() + } + + func testScanErrorOccurredWhileScanning() throws { + scanExecutor.executeHandler = { + throw TestError.scanError + } + outputParser.parseHandler = { _ in + [] + } + diffProvider.diffHandler = { _ in + .success(.modified(hunks: [])) + } let result = DangerPeriphery.scan(scanExecutor: scanExecutor, - outputParser: CheckstyleOutputParser(projectRootPath: DefaultCurrentPathProvider().currentPath), - diffProvider: DiffProviderMock(result: .failure(TestError.scanError(messege: "")))) + outputParser: outputParser, + diffProvider: diffProvider) switch result { case .success: XCTFail("Unexpected success") case .failure(let error as TestError): switch error { - case .scanError(let message): - XCTAssertEqual(message, "test error") + case .scanError: + // noop + break + default: + XCTFail("Unexpected error") } default: XCTFail("Unexpected result") } } - func testScanErrorOccuredWhileParsingResult() throws { - - } -} - -private extension DangerSwiftPeripheryTests { - enum TestError: Error { - case scanError(messege: String) - } - - final class ErrorScanExecutor: PeripheryScanExecutable { - let errorMessage: String - - init(errorMessage: String) { - self.errorMessage = errorMessage + func testScanErrorOccurredWhileParsingResult() throws { + scanExecutor.executeHandler = { + "test" } - - func execute() throws -> String { - throw TestError.scanError(messege: errorMessage) + outputParser.parseHandler = { _ in + throw TestError.parseError + } + diffProvider.diffHandler = { _ in + .success(.modified(hunks: [])) + } + let result = DangerPeriphery.scan(scanExecutor: scanExecutor, + outputParser: outputParser, + diffProvider: diffProvider) + switch result { + case .success: + XCTFail("Unexpected success") + case .failure(let error as TestError): + switch error { + case .parseError: + // noop + break + default: + XCTFail("Unexpected error") + } + default: + XCTFail("Unexpected result") } } - - final class DiffProviderMock: PullRequestDiffProvidable { - private let result: Result - - init(result: Result) { - self.result = result + + func testScanNoCommentViolationsWithoutCreatedOrModifiedDiff() { + scanExecutor.executeHandler = { "test" } + outputParser.parseHandler = { _ in + [ + .init(filePath: "path1", line: 1, message: "1"), + .init(filePath: "path2", line: 2, message: "2"), + ] } - - func diff(forFile: String) -> Result { - result + diffProvider.diffHandler = { filePath in + switch filePath { + case "path1": + return .success(.deleted(deletedLines: [])) + case "path2": + return .success(.renamed(oldPath: "", hunks: [])) + default: + return .success(.deleted(deletedLines: [])) + } } + let result = DangerPeriphery.scan(scanExecutor: scanExecutor, + outputParser: outputParser, + diffProvider: diffProvider) + switch result { + case let .success(violationsForComment): + XCTAssertEqual(violationsForComment.count, 0) + case .failure: + XCTFail("Unexpected error") + } + } +} + +private extension DangerSwiftPeripheryTests { + enum TestError: Error { + case scanError + case parseError } } diff --git a/Tests/DangerSwiftPeripheryTests/Mocks/CheckstyleOutputParsableMock.swift b/Tests/DangerSwiftPeripheryTests/Mocks/CheckstyleOutputParsableMock.swift new file mode 100644 index 0000000..ae5ce08 --- /dev/null +++ b/Tests/DangerSwiftPeripheryTests/Mocks/CheckstyleOutputParsableMock.swift @@ -0,0 +1,22 @@ +// +// Created by 多鹿豊 on 2022/07/24. +// + +import Foundation +@testable import DangerSwiftPeriphery + +final class CheckstyleOutputParsableMock: CheckstyleOutputParsable { + var parseHandler: ((String) throws -> [Violation])? + var projectRootPath: String + + init(projectRootPath: String) { + self.projectRootPath = projectRootPath + } + + func parse(xml: String) throws -> [Violation] { + guard let handler = parseHandler else { + fatalError("parseHandler is nil.") + } + return try handler(xml) + } +} diff --git a/Tests/DangerSwiftPeripheryTests/Mocks/PeripheryScanExecutableMock.swift b/Tests/DangerSwiftPeripheryTests/Mocks/PeripheryScanExecutableMock.swift new file mode 100644 index 0000000..8f52add --- /dev/null +++ b/Tests/DangerSwiftPeripheryTests/Mocks/PeripheryScanExecutableMock.swift @@ -0,0 +1,17 @@ +// +// Created by 多鹿豊 on 2022/07/24. +// + +import Foundation +@testable import DangerSwiftPeriphery + +final class PeripheryScanExecutableMock: PeripheryScanExecutable { + var executeHandler: (() throws -> String)? + + func execute() throws -> String { + guard let executeHandler = executeHandler else { + fatalError("executeHandler is nil.") + } + return try executeHandler() + } +} diff --git a/Tests/DangerSwiftPeripheryTests/Mocks/PullRequestDiffProvidableMock.swift b/Tests/DangerSwiftPeripheryTests/Mocks/PullRequestDiffProvidableMock.swift new file mode 100644 index 0000000..29f277e --- /dev/null +++ b/Tests/DangerSwiftPeripheryTests/Mocks/PullRequestDiffProvidableMock.swift @@ -0,0 +1,18 @@ +// +// Created by 多鹿豊 on 2022/07/24. +// + +import Foundation +import Danger +@testable import DangerSwiftPeriphery + +final class PullRequestDiffProvidableMock: PullRequestDiffProvidable { + var diffHandler: ((String) -> Result)? + + func diff(forFile: String) -> Result { + guard let handler = diffHandler else { + fatalError("diffHandler is nil.") + } + return handler(forFile) + } +} diff --git a/Tests/DangerSwiftPeripheryTests/Mocks/ShellExecutableMock.swift b/Tests/DangerSwiftPeripheryTests/Mocks/ShellExecutableMock.swift new file mode 100644 index 0000000..88b8315 --- /dev/null +++ b/Tests/DangerSwiftPeripheryTests/Mocks/ShellExecutableMock.swift @@ -0,0 +1,21 @@ +// +// Created by 多鹿豊 on 2022/07/24. +// + +import Foundation +@testable import DangerSwiftPeriphery + +final class ShellExecutableMock: ShellExecutable { + var executeHandler: ((String, [String]) -> Result)? + + func execute(_ command: String) -> Result { + execute(command, arguments: []) + } + + func execute(_ command: String, arguments: [String]) -> Result { + guard let handler = executeHandler else { + fatalError("executeHandler is nil.") + } + return handler(command, arguments) + } +} diff --git a/Tests/DangerSwiftPeripheryTests/PeripheryScanExecutorTests.swift b/Tests/DangerSwiftPeripheryTests/PeripheryScanExecutorTests.swift index c8a13f5..9a1bab0 100644 --- a/Tests/DangerSwiftPeripheryTests/PeripheryScanExecutorTests.swift +++ b/Tests/DangerSwiftPeripheryTests/PeripheryScanExecutorTests.swift @@ -21,8 +21,12 @@ final class PeripheryScanExecutorTests: XCTestCase { } func testExecuteThrowCommandError() throws { + let shellExecutor = ShellExecutableMock() + shellExecutor.executeHandler = { _, _ in + .failure(.init(status: 9999, description: "test error")) + } executor = PeripheryScanExecutor(commandBuilder: commandBuilder, - shellExecutor: ErrorShellExecutor(status: 9999, description: "test error")) + shellExecutor: shellExecutor) do { _ = try executor.execute() @@ -38,15 +42,18 @@ final class PeripheryScanExecutorTests: XCTestCase { } func testExecuteSucceed() throws { - let succeedShellExecutor = SucccedShellExecutor(output: """ - test - test2 - test3 - test4 - """) - + let shellExecutor = ShellExecutableMock() + shellExecutor.executeHandler = { _, _ in + .success(""" + test + test2 + test3 + test4 + """) + } + executor = PeripheryScanExecutor(commandBuilder: commandBuilder, - shellExecutor: succeedShellExecutor) + shellExecutor: shellExecutor) do { let output = try executor.execute() @@ -64,17 +71,19 @@ final class PeripheryScanExecutorTests: XCTestCase { } func testExecuteSucceedWithWarning() throws { - let succeedShellExecutor = SucccedShellExecutor(output: """ - test - warning: hoge - test2 - warning: fuga - test3 - test4 - """) - + let shellExecutor = ShellExecutableMock() + shellExecutor.executeHandler = { _, _ in + .success(""" + test + warning: hoge + test2 + warning: fuga + test3 + test4 + """) + } executor = PeripheryScanExecutor(commandBuilder: commandBuilder, - shellExecutor: succeedShellExecutor) + shellExecutor: shellExecutor) do { let output = try executor.execute() @@ -91,39 +100,3 @@ final class PeripheryScanExecutorTests: XCTestCase { } } } - -private extension PeripheryScanExecutorTests { - final class ErrorShellExecutor: ShellExecutable { - private let status: Int32 - private let description: String - - init(status: Int32, description: String) { - self.status = status - self.description = description - } - - func execute(_ command: String) -> Result { - execute(command, arguments: []) - } - - func execute(_ command: String, arguments: [String]) -> Result { - .failure(.init(status: status, description: description)) - } - } - - final class SucccedShellExecutor: ShellExecutable { - private let output: String - - init(output: String) { - self.output = output - } - - func execute(_ command: String) -> Result { - execute(command, arguments: []) - } - - func execute(_ command: String, arguments: [String]) -> Result { - .success(output) - } - } -}