From aeafb36f02a2bd352bc3c8257486c48fb1932b89 Mon Sep 17 00:00:00 2001 From: "Takuto NAKAMURA (Kyome)" Date: Tue, 28 Jan 2025 09:57:51 +0900 Subject: [PATCH 1/3] Migrate PackageParserTests to swift-testing --- .../LicenseType+Extension.swift | 37 +++ .../PackageParserTests.swift | 239 ++++-------------- 2 files changed, 92 insertions(+), 184 deletions(-) create mode 100644 Tests/LicenseCheckerModuleTests/LicenseType+Extension.swift diff --git a/Tests/LicenseCheckerModuleTests/LicenseType+Extension.swift b/Tests/LicenseCheckerModuleTests/LicenseType+Extension.swift new file mode 100644 index 0000000..6f7bcc5 --- /dev/null +++ b/Tests/LicenseCheckerModuleTests/LicenseType+Extension.swift @@ -0,0 +1,37 @@ +import LicenseCheckerModule + +extension LicenseType: @unchecked Sendable { + var containerDirectoryName: String { + switch self { + case .apache: + "SourcePackagesApache" + case .mit: + "SourcePackagesMIT" + case .bsd: + "SourcePackagesBSD" + case .zlib: + "SourcePackagesZlib" + case .boringSSL: + "SourcePackagesBoringSSL" + case .unknown: + "" + } + } + + var packageDirectoryName: String { + switch self { + case .apache: + "apache-package" + case .mit: + "mit-package" + case .bsd: + "bsd-package" + case .zlib: + "zlib-package" + case .boringSSL: + "boringssl-package" + case .unknown: + "" + } + } +} diff --git a/Tests/LicenseCheckerModuleTests/PackageParserTests.swift b/Tests/LicenseCheckerModuleTests/PackageParserTests.swift index 090eb75..06d462c 100644 --- a/Tests/LicenseCheckerModuleTests/PackageParserTests.swift +++ b/Tests/LicenseCheckerModuleTests/PackageParserTests.swift @@ -1,208 +1,79 @@ -import XCTest +import Testing import TestResources @testable import LicenseCheckerModule -final class PackageParserTests: XCTestCase { +struct PackageParserTests { let testResources = TestResources() - let whiteListDummy = WhiteList(licenses: nil, libraries: nil) - func test_init_PackageParser_success() throws { + @Test("If workspace-state is normal, PackageParser initialization succeeds.") + func init_PackageParser_success() async throws { let jsonPath = "SourcePackagesUnknown/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - - let sut = PackageParser(url: jsonURL) - XCTAssertNotNil(sut) + let jsonURL = try #require(testResources.getJsonUrl(jsonPath)) + + let actual = PackageParser(url: jsonURL) + #expect(actual != nil) } - - func test_init_PackageParser_failure() throws { + + @Test("If workspace-state is broken, PackageParser initialization fails.") + func init_PackageParser_failure() async throws { let jsonPath = "SourcePackagesWorkspaceStateBroken/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - - let sut = PackageParser(url: jsonURL) - XCTAssertNil(sut) - } - - // MARK: Apache - func test_extractLicense_apache() throws { - let jsonPath = "SourcePackagesUnknown/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - let packageParser = try XCTUnwrap(PackageParser(url: jsonURL)) - let resourceURL = try XCTUnwrap(testResources.resourceURL) - let directoryURL = resourceURL.appendingPathComponent("SourcePackagesApache") - .appendingPathComponent("checkouts") - .appendingPathComponent("apache-package") - let sut = packageParser.extractLicense(directoryURL: directoryURL) - XCTAssertEqual(sut, LicenseType.apache) + let jsonURL = try #require(testResources.getJsonUrl(jsonPath)) + + let actual = PackageParser(url: jsonURL) + #expect(actual == nil) } - func test_extractLicence_apache() throws { + @Test( + "The license file is successfully extracted.", + arguments: [LicenseType.apache, .mit, .bsd, .zlib, .boringSSL] + ) + func extractLicense(_ licenseType: LicenseType) async throws { let jsonPath = "SourcePackagesUnknown/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - let packageParser = try XCTUnwrap(PackageParser(url: jsonURL)) - let resourceURL = try XCTUnwrap(testResources.resourceURL) - let directoryURL = resourceURL.appendingPathComponent("SourcePackagesLICENCE") + let jsonURL = try #require(testResources.getJsonUrl(jsonPath)) + let packageParser = try #require(PackageParser(url: jsonURL)) + let resourceURL = try #require(testResources.resourceURL) + let directoryURL = resourceURL.appendingPathComponent(licenseType.containerDirectoryName) .appendingPathComponent("checkouts") - .appendingPathComponent("apache-package") - let sut = packageParser.extractLicense(directoryURL: directoryURL) - XCTAssertEqual(sut, LicenseType.apache) - } - - func test_parse_apache() throws { - let jsonPath = "SourcePackagesApache/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - let packageParser = try XCTUnwrap(PackageParser(url: jsonURL)) - - let resourcePath = try XCTUnwrap(testResources.resourcePath) - let checkoutsPath = "\(resourcePath)/SourcePackagesApache/checkouts" - let sut = packageParser.parse(with: checkoutsPath, whiteList: whiteListDummy) - - let expect = Acknowledgement( - libraryName: "apache-package", - licenseType: .apache, - isForbidden: true - ) - XCTAssertEqual(sut, [expect]) - } - - // MARK: MIT - func test_extractLicense_mit() throws { - let jsonPath = "SourcePackagesUnknown/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - let packageParser = try XCTUnwrap(PackageParser(url: jsonURL)) - - let resourceURL = try XCTUnwrap(testResources.resourceURL) - let directoryURL = resourceURL.appendingPathComponent("SourcePackagesMIT") - .appendingPathComponent("checkouts") - .appendingPathComponent("mit-package") - - let sut = packageParser.extractLicense(directoryURL: directoryURL) - XCTAssertEqual(sut, LicenseType.mit) + .appendingPathComponent(licenseType.packageDirectoryName) + let actual = packageParser.extractLicense(directoryURL: directoryURL) + #expect(actual == licenseType) } - func test_extractLicence_mit() throws { + @Test( + "The licence file is successfully extracted.", + arguments: [LicenseType.apache, .mit] + ) + func extractLicence(_ licenseType: LicenseType) async throws { let jsonPath = "SourcePackagesUnknown/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - let packageParser = try XCTUnwrap(PackageParser(url: jsonURL)) - - let resourceURL = try XCTUnwrap(testResources.resourceURL) + let jsonURL = try #require(testResources.getJsonUrl(jsonPath)) + let packageParser = try #require(PackageParser(url: jsonURL)) + let resourceURL = try #require(testResources.resourceURL) let directoryURL = resourceURL.appendingPathComponent("SourcePackagesLICENCE") .appendingPathComponent("checkouts") - .appendingPathComponent("mit-package") - - let sut = packageParser.extractLicense(directoryURL: directoryURL) - XCTAssertEqual(sut, LicenseType.mit) - } - - func test_parse_mit() throws { - let jsonPath = "SourcePackagesMIT/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - let packageParser = try XCTUnwrap(PackageParser(url: jsonURL)) - - let resourcePath = try XCTUnwrap(testResources.resourcePath) - let checkoutsPath = "\(resourcePath)/SourcePackagesMIT/checkouts" - let sut = packageParser.parse(with: checkoutsPath, whiteList: whiteListDummy) - - let expect = Acknowledgement( - libraryName: "mit-package", - licenseType: .mit, - isForbidden: true - ) - XCTAssertEqual(sut, [expect]) - } - - // MARK: BSD - func test_extractLicense_bsd() throws { - let jsonPath = "SourcePackagesUnknown/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - let packageParser = try XCTUnwrap(PackageParser(url: jsonURL)) - - let resourceURL = try XCTUnwrap(testResources.resourceURL) - let directoryURL = resourceURL.appendingPathComponent("SourcePackagesBSD") - .appendingPathComponent("checkouts") - .appendingPathComponent("bsd-package") - - let sut = packageParser.extractLicense(directoryURL: directoryURL) - XCTAssertEqual(sut, LicenseType.bsd) - } - - func test_parse_bsd() throws { - let jsonPath = "SourcePackagesBSD/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - let packageParser = try XCTUnwrap(PackageParser(url: jsonURL)) - - let resourcePath = try XCTUnwrap(testResources.resourcePath) - let checkoutsPath = "\(resourcePath)/SourcePackagesBSD/checkouts" - let sut = packageParser.parse(with: checkoutsPath, whiteList: whiteListDummy) - - let expect = Acknowledgement( - libraryName: "bsd-package", - licenseType: .bsd, - isForbidden: true - ) - XCTAssertEqual(sut, [expect]) - } - - // MARK: zlib - func test_extractLicense_zlib() throws { - let jsonPath = "SourcePackagesUnknown/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - let packageParser = try XCTUnwrap(PackageParser(url: jsonURL)) - - let resourceURL = try XCTUnwrap(testResources.resourceURL) - let directoryURL = resourceURL.appendingPathComponent("SourcePackagesZlib") - .appendingPathComponent("checkouts") - .appendingPathComponent("zlib-package") - - let sut = packageParser.extractLicense(directoryURL: directoryURL) - XCTAssertEqual(sut, LicenseType.zlib) + .appendingPathComponent(licenseType.packageDirectoryName) + let actual = packageParser.extractLicense(directoryURL: directoryURL) + #expect(actual == licenseType) } - - func test_parse_zlib() throws { - let jsonPath = "SourcePackagesZlib/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - let packageParser = try XCTUnwrap(PackageParser(url: jsonURL)) - - let resourcePath = try XCTUnwrap(testResources.resourcePath) - let checkoutsPath = "\(resourcePath)/SourcePackagesZlib/checkouts" - let sut = packageParser.parse(with: checkoutsPath, whiteList: whiteListDummy) - - let expect = Acknowledgement( - libraryName: "zlib-package", - licenseType: .zlib, - isForbidden: true - ) - XCTAssertEqual(sut, [expect]) - } - - // MARK: BoringSSL - func test_extractLicense_boringssl() throws { - let jsonPath = "SourcePackagesUnknown/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - let packageParser = try XCTUnwrap(PackageParser(url: jsonURL)) - - let resourceURL = try XCTUnwrap(testResources.resourceURL) - let directoryURL = resourceURL.appendingPathComponent("SourcePackagesBoringSSL") - .appendingPathComponent("checkouts") - .appendingPathComponent("boringssl-package") - - let sut = packageParser.extractLicense(directoryURL: directoryURL) - XCTAssertEqual(sut, LicenseType.boringSSL) - } - - func test_parse_boringssl() throws { - let jsonPath = "SourcePackagesBoringSSL/workspace-state" - let jsonURL = try XCTUnwrap(testResources.getJsonUrl(jsonPath)) - let packageParser = try XCTUnwrap(PackageParser(url: jsonURL)) - - let resourcePath = try XCTUnwrap(testResources.resourcePath) - let checkoutsPath = "\(resourcePath)/SourcePackagesBoringSSL/checkouts" - let sut = packageParser.parse(with: checkoutsPath, whiteList: whiteListDummy) + + @Test( + "The license file is successfully parsed.", + arguments: [LicenseType.apache, .mit, .bsd, .zlib, .boringSSL] + ) + func parseLicense(_ licenseType: LicenseType) async throws { + let jsonPath = "\(licenseType.containerDirectoryName)/workspace-state" + let jsonURL = try #require(testResources.getJsonUrl(jsonPath)) + let packageParser = try #require(PackageParser(url: jsonURL)) + + let resourcePath = try #require(testResources.resourcePath) + let checkoutsPath = "\(resourcePath)/\(licenseType.containerDirectoryName)/checkouts" + let whiteListDummy = WhiteList(licenses: nil, libraries: nil) + let actual = packageParser.parse(with: checkoutsPath, whiteList: whiteListDummy) let expect = Acknowledgement( - libraryName: "boringssl-package", - licenseType: .boringSSL, + libraryName: licenseType.packageDirectoryName, + licenseType: licenseType, isForbidden: true ) - XCTAssertEqual(sut, [expect]) + #expect(actual == [expect]) } } From 8cbf15f44e92bd4239a892211205804034902f1e Mon Sep 17 00:00:00 2001 From: "Takuto NAKAMURA (Kyome)" Date: Tue, 28 Jan 2025 10:18:48 +0900 Subject: [PATCH 2/3] Migrate WhiteListTests to swift-testing --- .../WhiteListTests.swift | 79 ++++++++----------- 1 file changed, 34 insertions(+), 45 deletions(-) diff --git a/Tests/LicenseCheckerModuleTests/WhiteListTests.swift b/Tests/LicenseCheckerModuleTests/WhiteListTests.swift index e155fe5..2f7f821 100644 --- a/Tests/LicenseCheckerModuleTests/WhiteListTests.swift +++ b/Tests/LicenseCheckerModuleTests/WhiteListTests.swift @@ -1,53 +1,42 @@ -import XCTest -import TestResources +import Foundation +import Testing @testable import LicenseCheckerModule -final class WhiteListTests: XCTestCase { - - func getJsonUrl(_ jsonName: String) -> URL? { - return Bundle.module.url(forResource: jsonName, withExtension: "json") +struct WhiteListTests { + private func getJsonUrl(_ jsonName: String) -> URL? { + Bundle.module.url(forResource: jsonName, withExtension: "json") } - - func test_load_broken_white_list() throws { - let jsonURL = try XCTUnwrap(getJsonUrl("white-list-broken")) - - let sut = WhiteList.load(url: jsonURL) - XCTAssertNil(sut) + + @Test("If the whitelist is broken, loading fails.") + func load_broken_white_list_failure() throws { + let jsonURL = try #require(getJsonUrl("white-list-broken")) + let actual = WhiteList.load(url: jsonURL) + #expect(actual == nil) } - - - func test_load_empty_white_list() throws { - let jsonURL = try XCTUnwrap(getJsonUrl("white-list-empty")) - - let sut = WhiteList.load(url: jsonURL) - XCTAssertNotNil(sut) - - let actual = try XCTUnwrap(sut) - XCTAssertNotNil(actual.licenses) - XCTAssertEqual(actual.licenses?.isEmpty, true) - XCTAssertNotNil(actual.libraries) - XCTAssertEqual(actual.libraries?.isEmpty, true) + + @Test("If the whitelist is empty, loading succeeds.") + func load_empty_white_list_success() throws { + let jsonURL = try #require(getJsonUrl("white-list-empty")) + let actual = try #require(WhiteList.load(url: jsonURL)) + #expect(actual.licenses != nil) + #expect(actual.licenses?.isEmpty == true) + #expect(actual.libraries != nil) + #expect(actual.libraries?.isEmpty == true) } - - func test_load_licenses() throws { - let jsonURL = try XCTUnwrap(getJsonUrl("white-list-one-license")) - - let sut = WhiteList.load(url: jsonURL) - XCTAssertNotNil(sut) - - let actual = try XCTUnwrap(sut) - XCTAssertEqual(actual.licenses, ["Apache"]) - XCTAssertNil(actual.libraries) + + @Test("If the whitelist is normal and contains a license, loading it succeeds.") + func load_normal_white_list_with_license_success() throws { + let jsonURL = try #require(getJsonUrl("white-list-one-license")) + let actual = try #require(WhiteList.load(url: jsonURL)) + #expect(actual.licenses == ["Apache"]) + #expect(actual.libraries == nil) } - - func test_load_libraries() throws { - let jsonURL = try XCTUnwrap(getJsonUrl("white-list-one-library")) - - let sut = WhiteList.load(url: jsonURL) - XCTAssertNotNil(sut) - - let actual = try XCTUnwrap(sut) - XCTAssertNil(actual.licenses) - XCTAssertEqual(actual.libraries, ["some-package"]) + + @Test("If the whitelist is normal and contains a library, loading it succeeds.") + func load_normal_white_list_with_library_success() throws { + let jsonURL = try #require(getJsonUrl("white-list-one-library")) + let actual = try #require(WhiteList.load(url: jsonURL)) + #expect(actual.licenses == nil) + #expect(actual.libraries == ["some-package"]) } } From 1f3f36beaf75a2a78959d3a34541d045af9208ea Mon Sep 17 00:00:00 2001 From: "Takuto NAKAMURA (Kyome)" Date: Tue, 28 Jan 2025 10:56:39 +0900 Subject: [PATCH 3/3] Migrate LicenseCheckerTests to swift-testing --- .../PackageParserTests.swift | 8 +- .../LicenseCheckerTests.swift | 180 ++++++------------ 2 files changed, 64 insertions(+), 124 deletions(-) diff --git a/Tests/LicenseCheckerModuleTests/PackageParserTests.swift b/Tests/LicenseCheckerModuleTests/PackageParserTests.swift index 06d462c..eb28cf2 100644 --- a/Tests/LicenseCheckerModuleTests/PackageParserTests.swift +++ b/Tests/LicenseCheckerModuleTests/PackageParserTests.swift @@ -3,7 +3,7 @@ import TestResources @testable import LicenseCheckerModule struct PackageParserTests { - let testResources = TestResources() + private let testResources = TestResources() @Test("If workspace-state is normal, PackageParser initialization succeeds.") func init_PackageParser_success() async throws { @@ -27,7 +27,7 @@ struct PackageParserTests { "The license file is successfully extracted.", arguments: [LicenseType.apache, .mit, .bsd, .zlib, .boringSSL] ) - func extractLicense(_ licenseType: LicenseType) async throws { + func extract_license(_ licenseType: LicenseType) async throws { let jsonPath = "SourcePackagesUnknown/workspace-state" let jsonURL = try #require(testResources.getJsonUrl(jsonPath)) let packageParser = try #require(PackageParser(url: jsonURL)) @@ -43,7 +43,7 @@ struct PackageParserTests { "The licence file is successfully extracted.", arguments: [LicenseType.apache, .mit] ) - func extractLicence(_ licenseType: LicenseType) async throws { + func extract_licence(_ licenseType: LicenseType) async throws { let jsonPath = "SourcePackagesUnknown/workspace-state" let jsonURL = try #require(testResources.getJsonUrl(jsonPath)) let packageParser = try #require(PackageParser(url: jsonURL)) @@ -59,7 +59,7 @@ struct PackageParserTests { "The license file is successfully parsed.", arguments: [LicenseType.apache, .mit, .bsd, .zlib, .boringSSL] ) - func parseLicense(_ licenseType: LicenseType) async throws { + func parse_license(_ licenseType: LicenseType) async throws { let jsonPath = "\(licenseType.containerDirectoryName)/workspace-state" let jsonURL = try #require(testResources.getJsonUrl(jsonPath)) let packageParser = try #require(PackageParser(url: jsonURL)) diff --git a/Tests/LicenseCheckerTests/LicenseCheckerTests.swift b/Tests/LicenseCheckerTests/LicenseCheckerTests.swift index 8250daf..1b5b052 100644 --- a/Tests/LicenseCheckerTests/LicenseCheckerTests.swift +++ b/Tests/LicenseCheckerTests/LicenseCheckerTests.swift @@ -1,22 +1,24 @@ -import XCTest +import Foundation +import Testing import TestResources -final class LicenseCheckerTests: XCTestCase { - let testResources = TestResources() - +struct LicenseCheckerTests { + private let testResources = TestResources() + /// Returns path to the built products directory. - var productsDirectory: URL { - #if os(macOS) + private var productsDirectory: URL { + #if os(macOS) for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") { return bundle.bundleURL.deletingLastPathComponent() } fatalError("couldn't find the products directory") - #else + #else return Bundle.main.bundleURL - #endif + #endif } - - func test_invalid_args() throws { + + @Test("If executed with invalid arguments, the command exits with instructions on how to use it.") + func pass_invalid_arguments() throws { let licenseCheckerBinary = productsDirectory.appendingPathComponent("license-checker") let process = Process() process.executableURL = licenseCheckerBinary @@ -26,7 +28,7 @@ final class LicenseCheckerTests: XCTestCase { process.waitUntilExit() let data = pipe.fileHandleForReading.readDataToEndOfFile() let output = String(data: data, encoding: .utf8) - + let expect = """ Error: Missing expected argument '--source-packages-path ' @@ -42,179 +44,117 @@ final class LicenseCheckerTests: XCTestCase { --version Show the version. -h, --help Show help information.\n\n """ - XCTAssertEqual(output, expect) - XCTAssertEqual(process.terminationStatus, 64) - } - - func test_Apache() throws { - let licenseCheckerBinary = productsDirectory.appendingPathComponent("license-checker") - let process = Process() - process.executableURL = licenseCheckerBinary - let pipe = Pipe() - process.standardOutput = pipe - let resourceURL = try XCTUnwrap(testResources.resourceURL) - let sourcePackagesURL = resourceURL.appendingPathComponent("SourcePackagesApache") - let whiteListURL = sourcePackagesURL.appendingPathComponent("white-list.json") - process.arguments = ["-s", sourcePackagesURL.absolutePath, "-w", whiteListURL.absolutePath] - try process.run() - process.waitUntilExit() - let data = pipe.fileHandleForReading.readDataToEndOfFile() - let output = try XCTUnwrap(String(data: data, encoding: .utf8)) - - XCTAssertTrue(output.hasSuffix("✅ No problems with library licensing.\n")) - XCTAssertEqual(process.terminationStatus, 0) - } - - func test_MIT() throws { - let licenseCheckerBinary = productsDirectory.appendingPathComponent("license-checker") - let process = Process() - process.executableURL = licenseCheckerBinary - let pipe = Pipe() - process.standardOutput = pipe - let resourceURL = try XCTUnwrap(testResources.resourceURL) - let sourcePackagesURL = resourceURL.appendingPathComponent("SourcePackagesMIT") - let whiteListURL = sourcePackagesURL.appendingPathComponent("white-list.json") - process.arguments = ["-s", sourcePackagesURL.absolutePath, "-w", whiteListURL.absolutePath] - try process.run() - process.waitUntilExit() - let data = pipe.fileHandleForReading.readDataToEndOfFile() - let output = try XCTUnwrap(String(data: data, encoding: .utf8)) - - XCTAssertTrue(output.hasSuffix("✅ No problems with library licensing.\n")) - XCTAssertEqual(process.terminationStatus, 0) - } - - func test_BSD() throws { - let licenseCheckerBinary = productsDirectory.appendingPathComponent("license-checker") - let process = Process() - process.executableURL = licenseCheckerBinary - let pipe = Pipe() - process.standardOutput = pipe - let resourceURL = try XCTUnwrap(testResources.resourceURL) - let sourcePackagesURL = resourceURL.appendingPathComponent("SourcePackagesBSD") - let whiteListURL = sourcePackagesURL.appendingPathComponent("white-list.json") - process.arguments = ["-s", sourcePackagesURL.absolutePath, "-w", whiteListURL.absolutePath] - try process.run() - process.waitUntilExit() - let data = pipe.fileHandleForReading.readDataToEndOfFile() - let output = try XCTUnwrap(String(data: data, encoding: .utf8)) - - XCTAssertTrue(output.hasSuffix("✅ No problems with library licensing.\n")) - XCTAssertEqual(process.terminationStatus, 0) - } - - func test_zlib() throws { - let licenseCheckerBinary = productsDirectory.appendingPathComponent("license-checker") - let process = Process() - process.executableURL = licenseCheckerBinary - let pipe = Pipe() - process.standardOutput = pipe - let resourceURL = try XCTUnwrap(testResources.resourceURL) - let sourcePackagesURL = resourceURL.appendingPathComponent("SourcePackagesZlib") - let whiteListURL = sourcePackagesURL.appendingPathComponent("white-list.json") - process.arguments = ["-s", sourcePackagesURL.absolutePath, "-w", whiteListURL.absolutePath] - try process.run() - process.waitUntilExit() - let data = pipe.fileHandleForReading.readDataToEndOfFile() - let output = try XCTUnwrap(String(data: data, encoding: .utf8)) - - XCTAssertTrue(output.hasSuffix("✅ No problems with library licensing.\n")) - XCTAssertEqual(process.terminationStatus, 0) + #expect(output == expect) + #expect(process.terminationStatus == 64) } - - func test_BoringSSL() throws { + + @Test( + "If the license type is contained in the whitelist, the command exits normally.", + arguments: [ + "SourcePackagesApache", + "SourcePackagesMIT", + "SourcePackagesBSD", + "SourcePackagesZlib", + "SourcePackagesBoringSSL", + ] + ) + func check_license(_ directoryName: String) throws { let licenseCheckerBinary = productsDirectory.appendingPathComponent("license-checker") let process = Process() process.executableURL = licenseCheckerBinary let pipe = Pipe() process.standardOutput = pipe - let resourceURL = try XCTUnwrap(testResources.resourceURL) - let sourcePackagesURL = resourceURL.appendingPathComponent("SourcePackagesBoringSSL") + let resourceURL = try #require(testResources.resourceURL) + let sourcePackagesURL = resourceURL.appendingPathComponent(directoryName) let whiteListURL = sourcePackagesURL.appendingPathComponent("white-list.json") process.arguments = ["-s", sourcePackagesURL.absolutePath, "-w", whiteListURL.absolutePath] try process.run() process.waitUntilExit() let data = pipe.fileHandleForReading.readDataToEndOfFile() - let output = try XCTUnwrap(String(data: data, encoding: .utf8)) + let output = try #require(String(data: data, encoding: .utf8)) - XCTAssertTrue(output.hasSuffix("✅ No problems with library licensing.\n")) - XCTAssertEqual(process.terminationStatus, 0) + #expect(output.hasSuffix("✅ No problems with library licensing.\n")) + #expect(process.terminationStatus == 0) } - - func test_SomePackage() throws { + + @Test("If the library name is contained in the whitelist, the command exits normally.") + func check_library() throws { let licenseCheckerBinary = productsDirectory.appendingPathComponent("license-checker") let process = Process() process.executableURL = licenseCheckerBinary let pipe = Pipe() process.standardOutput = pipe - let resourceURL = try XCTUnwrap(testResources.resourceURL) + let resourceURL = try #require(testResources.resourceURL) let sourcePackagesURL = resourceURL.appendingPathComponent("SourcePackagesSomePackage") let whiteListURL = sourcePackagesURL.appendingPathComponent("white-list.json") process.arguments = ["-s", sourcePackagesURL.absolutePath, "-w", whiteListURL.absolutePath] try process.run() process.waitUntilExit() let data = pipe.fileHandleForReading.readDataToEndOfFile() - let output = try XCTUnwrap(String(data: data, encoding: .utf8)) + let output = try #require(String(data: data, encoding: .utf8)) - XCTAssertTrue(output.hasSuffix("✅ No problems with library licensing.\n")) - XCTAssertEqual(process.terminationStatus, 0) + #expect(output.hasSuffix("✅ No problems with library licensing.\n")) + #expect(process.terminationStatus == 0) } - - func test_workspace_state_broken() throws { + + @Test("If the workspace-state.json is broken, the command exits with error message.") + func pass_broken_workspace_state() throws { let licenseCheckerBinary = productsDirectory.appendingPathComponent("license-checker") let process = Process() process.executableURL = licenseCheckerBinary let pipe = Pipe() process.standardOutput = pipe - let resourceURL = try XCTUnwrap(testResources.resourceURL) + let resourceURL = try #require(testResources.resourceURL) let sourcePackagesURL = resourceURL.appendingPathComponent("SourcePackagesWorkspaceStateBroken") let whiteListURL = sourcePackagesURL.appendingPathComponent("white-list.json") process.arguments = ["-s", sourcePackagesURL.absolutePath, "-w", whiteListURL.absolutePath] try process.run() process.waitUntilExit() let data = pipe.fileHandleForReading.readDataToEndOfFile() - let output = try XCTUnwrap(String(data: data, encoding: .utf8)) + let output = try #require(String(data: data, encoding: .utf8)) - XCTAssertTrue(output.hasSuffix("error: Couldn't load workspace-state.json\n")) - XCTAssertEqual(process.terminationStatus, 1) + #expect(output.hasSuffix("error: Couldn't load workspace-state.json\n")) + #expect(process.terminationStatus == 1) } - - func test_white_list_broken() throws { + + @Test("If the white-list.json is broken, the command exits with error message.") + func pass_broken_white_list() throws { let licenseCheckerBinary = productsDirectory.appendingPathComponent("license-checker") let process = Process() process.executableURL = licenseCheckerBinary let pipe = Pipe() process.standardOutput = pipe - let resourceURL = try XCTUnwrap(testResources.resourceURL) + let resourceURL = try #require(testResources.resourceURL) let sourcePackagesURL = resourceURL.appendingPathComponent("SourcePackagesWhiteListBroken") let whiteListURL = sourcePackagesURL.appendingPathComponent("white-list.json") process.arguments = ["-s", sourcePackagesURL.absolutePath, "-w", whiteListURL.absolutePath] try process.run() process.waitUntilExit() let data = pipe.fileHandleForReading.readDataToEndOfFile() - let output = try XCTUnwrap(String(data: data, encoding: .utf8)) + let output = try #require(String(data: data, encoding: .utf8)) - XCTAssertTrue(output.hasSuffix("error: Couldn't load white-list.json\n")) - XCTAssertEqual(process.terminationStatus, 2) + #expect(output.hasSuffix("error: Couldn't load white-list.json\n")) + #expect(process.terminationStatus == 2) } - - func test_unknown_license() throws { + + @Test("If an unknown type of license is found, the command exits with error message.") + func check_unknown_license() throws { let licenseCheckerBinary = productsDirectory.appendingPathComponent("license-checker") let process = Process() process.executableURL = licenseCheckerBinary let pipe = Pipe() process.standardOutput = pipe - let resourceURL = try XCTUnwrap(testResources.resourceURL) + let resourceURL = try #require(testResources.resourceURL) let sourcePackagesURL = resourceURL.appendingPathComponent("SourcePackagesUnknown") let whiteListURL = sourcePackagesURL.appendingPathComponent("white-list.json") process.arguments = ["-s", sourcePackagesURL.absolutePath, "-w", whiteListURL.absolutePath] try process.run() process.waitUntilExit() let data = pipe.fileHandleForReading.readDataToEndOfFile() - let output = try XCTUnwrap(String(data: data, encoding: .utf8)) + let output = try #require(String(data: data, encoding: .utf8)) - XCTAssertTrue(output.hasSuffix("error: Library with forbidden license is found.\n")) - XCTAssertEqual(process.terminationStatus, 3) + #expect(output.hasSuffix("error: Library with forbidden license is found.\n")) + #expect(process.terminationStatus == 3) } }