Template support for input parameters (#4)

This PR contains the work done to support input parameters for the `create` command of the executable target, and to render content dynamically for the newly-generated project.

Reviewed-on: #4
Co-authored-by: Javier Cicchelli <javier@rock-n-code.com>
Co-committed-by: Javier Cicchelli <javier@rock-n-code.com>

Test/Sources/Cases/Public/Services/FileServiceTests.swift

@@ -35,7 +35,7 @@ struct FileServiceTests {
         // WHEN
         try await service.copyFile(from: source, to: destination)
 
-        // THENn
+        // THEN
         #expect(spy.actions.count == 1)
         
         let action = try #require(spy.actions.last)
@@ -57,6 +57,37 @@ struct FileServiceTests {
         #expect(spy.actions.isEmpty == true)
     }
     
+    @Test(arguments: zip([URL.someNewFile],
+                         [Data("some data goes here...".utf8)]))
+    func createFile(with location: URL, and data: Data) async throws {
+        // GIVEN
+        let service = service(action: .createFile(location, data))
+        
+        // WHEN
+        try await service.createFile(at: location, with: data)
+        
+        // THEN
+        #expect(spy.actions.count == 1)
+        
+        let action = try #require(spy.actions.last)
+        
+        #expect(action == .fileCreated(location, data))
+    }
+    
+    @Test(arguments: [FileServiceError.itemAlreadyExists, .fileDataIsEmpty, .fileNotCreated])
+    func createFile(throws error: FileServiceError) async throws {
+        // GIVEN
+        let service = service(action: .error(error))
+        
+        // WHEN
+        // THEN
+        await #expect(throws: error) {
+            try await service.createFile(at: .someNewFile, with: .init())
+        }
+        
+        #expect(spy.actions.isEmpty == true)
+    }
+    
     @Test(arguments: [URL.someNewFolder, .someNewFile])
     func createFolder(with location: URL) async throws {
         // GIVEN

Test/Sources/Cases/Public/Services/TemplateServiceTests.swift

@@ -0,0 +1,48 @@
+import ColibriLibrary
+import Foundation
+import Testing
+
+struct TemplateServiceTests {
+    
+    // MARK: Properties
+    
+    private let spy = TemplateServiceSpy()
+    
+    // MARK: Functions tests
+
+    @Test(arguments: [String.content])
+    func render(_ content: String) async throws {
+        // GIVEN
+        let service = TemplateServiceMock(action: .render(content), spy: spy)
+        
+        // WHEN
+        let result = try await service.render([:], on: .template)
+        
+        // THEN
+        #expect(result == content)
+
+        #expect(spy.actions.isEmpty == false)
+    }
+    
+    @Test(arguments: [TemplateServiceError.serviceNotInitialized, .resourcePathNotFound, .templateNotFound, .contentNotRendered])
+    func render(throws error: TemplateServiceError) async throws {
+        // GIVEN
+        let service = TemplateServiceMock(action: .error(error), spy: spy)
+        
+        // WHEN
+        // THEN
+        await #expect(throws: error) {
+            try await service.render([:], on: .template)
+        }
+        
+        #expect(spy.actions.isEmpty == true)
+    }
+
+}
+
+// MARK: - String+Constants
+
+private extension String {
+    static let content = ""
+    static let template = ""
+}

Test/Sources/Cases/Public/Services/TerminalServiceTests.swift

@@ -0,0 +1,51 @@
+import ColibriLibrary
+import Foundation
+import Testing
+
+struct TerminalServiceTests {
+    
+    // MARK: Properties
+    
+    private let spy = TerminalServiceSpy()
+    
+    // MARK: Functions
+
+    @Test(arguments: [URL.someNewFile], [[], ["--example"], ["--example", "--more", "--etc"]])
+    func run(with executableURL: URL, and arguments: [String]) async throws {
+        // GIVEN
+        let service = TerminalServiceMock(action: .run(executableURL, arguments), spy: spy)
+
+        // WHEN
+        let result = try await service.run(executableURL, arguments: arguments)
+        
+        // THEN
+        #expect(result == .content)
+
+        #expect(spy.actions.isEmpty == false)
+
+        let action = try #require(spy.actions.last)
+        
+        #expect(action == .ran(executableURL, arguments))
+    }
+    
+    @Test(arguments: [TerminalServiceError.unexpected, .captured("Some captured error"), .output("Some output error")])
+    func run(throws error: TerminalServiceError) async throws {
+        // GIVEN
+        let service = TerminalServiceMock(action: .error(error), spy: spy)
+        
+        // WHEN
+        // THEN
+        await #expect(throws: error) {
+            try await service.run(URL.someNewFile, arguments: [])
+        }
+        
+        #expect(spy.actions.isEmpty == true)
+    }
+
+}
+
+// MARK: - String+Constants
+
+private extension String {
+    static let content = ""
+}

Test/Sources/Cases/Public/Tasks/InitGitInFolderTaskTests.swift

@@ -0,0 +1,30 @@
+import Foundation
+import Testing
+
+@testable import ColibriLibrary
+
+struct InitGitInFolderTaskTests {
+
+    // MARK: Functions tests
+
+    @Test(arguments: [URL.someCurrentFolder, .someNewFolder, .someDotFolder, .someTildeFolder])
+    func task(at rootFolder: URL) async throws {
+        // GIVEN
+        let terminalService = TerminalServiceSpy()
+        
+        let initGitInFolder = InitGitInFolderTask(terminalService: terminalService)
+        
+        // WHEN
+        try await initGitInFolder(at: rootFolder)
+        
+        // THEN
+        let executableURL = URL(at: "/usr/bin/git")
+        let pathFolder = rootFolder.pathString
+
+        #expect(terminalService.actions.count == 3)
+        #expect(terminalService.actions[0] == .ran(executableURL, ["init", pathFolder]))
+        #expect(terminalService.actions[1] == .ran(executableURL, ["-C", pathFolder, "add", "."]))
+        #expect(terminalService.actions[2] == .ran(executableURL, ["-C", pathFolder, "commit", "-m", "Initial commit"]))
+    }
+
+}

Test/Sources/Cases/Public/Tasks/RenderFilesTaskTests.swift

@@ -0,0 +1,41 @@
+import Foundation
+import Testing
+
+@testable import ColibriLibrary
+
+struct RenderFilesTaskTests {
+
+    @Test(arguments: [URL.someCurrentFolder], [Project(name: "Some name goes here...")])
+    func task(at rootFolder: URL, with project: Project) async throws {
+        // GIVEN
+        let fileService = FileServiceSpy()
+        let templateService = TemplateServiceSpy()
+        
+        let renderFiles = RenderFilesTask(fileService: fileService,
+                                          templateService: templateService)
+
+        // WHEN
+        try await renderFiles(at: rootFolder, with: project)
+        
+        // THEN
+        let fileData = Data()
+        let templates = Template.allCases
+
+        #expect(fileService.actions.count == 3)
+        #expect(templateService.actions.count == 3)
+        
+        fileService.actions.enumerated().forEach { index, action in
+            #expect(action == .fileCreated(rootFolder.appendingPath(templates[index].filePath), fileData))
+        }
+
+        templateService.actions.enumerated().forEach { index, action in
+            if case let .rendered(object, template) = action {
+                #expect(object as? Project == project)
+                #expect(template == templates[index].rawValue)
+            } else {
+                Issue.record("Action should have been a case of the `TemplateServiceSpy.Action` enumeration.")
+            }
+        }
+    }
+
+}