softinio/Fishee
1
0
Fork 0
mirror of https://github.com/softinio/Fishee.git synced 2025-02-22 21:46:05 -08:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #1 from softinio/push-suonroksrrkt

Browse source 
Add GitHub actions workflows for running tests and for doing releases
This commit is contained in:
Salar Rahmanian 2025-02-09 11:02:29 -08:00 committed by GitHub
commit 1bab9a3dea
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
11 changed files with 513 additions and 423 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
.github/workflows/build-and-release.yml vendored Normal file
View file

@ -0,0 +1,51 @@
name: Build and Release Artifacts
on:
release:
types: [published]
jobs:
build-macos:
runs-on: macos-15
strategy:
matrix:
arch: [x86_64, arm64]
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Get swift version
run: swift --version
- name: Build for macOS
run: |
swift build -c release --arch ${{ matrix.arch }}
mkdir -p artifacts/macos-${{ matrix.arch }}
cp .build/apple/Products/Release/fishee artifacts/macos-${{ matrix.arch }}/
- name: Upload macOS artifacts
uses: actions/upload-artifact@v4
with:
name: fishee-macos-${{ matrix.arch }}-${{ github.ref_name }}
path: artifacts/macos-${{ matrix.arch }}
build-linux:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Get swift version
run: swift --version
- name: Build for Linux
run: |
swift build -c release
mkdir -p artifacts/linux
cp .build/release/fishee artifacts/linux/
- name: Upload Linux artifacts
uses: actions/upload-artifact@v4
with:
name: fishee-linux-${{ github.ref_name }}
path: artifacts/linux

28
.github/workflows/test.yml vendored Normal file
View file

@ -0,0 +1,28 @@
name: Run Tests
on:
push:
branches:
- main
pull_request:
branches:
- main
jobs:
test:
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [macos-15, ubuntu-latest]
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Get swift version
run: swift --version
- name: Build
run: swift build -v
- name: Run tests
run: swift test -v --parallel

53
Package.swift
View file

@ -4,30 +4,31 @@
import PackageDescription import PackageDescription
let package = Package( let package = Package(
name: "Fishee", name: "Fishee",
dependencies: [ products: [
.package(url: "https://github.com/apple/swift-argument-parser.git", .upToNextMajor(from: "1.5.0")), .executable(name: "fishee", targets: ["Fishee"])
.package(url: "https://github.com/duckdb/duckdb-swift", .upToNextMinor(from: .init(1, 1, 0))), ],
], dependencies: [
targets: [ .package(
// Targets are the basic building blocks of a package, defining a module or a test suite. url: "https://github.com/apple/swift-argument-parser.git", .upToNextMajor(from: "1.5.0"))
// Targets can depend on other targets in this package and products from dependencies. ],
.executableTarget( targets: [
name: "Fishee", .executableTarget(
dependencies: [ name: "Fishee",
.product(name: "ArgumentParser", package: "swift-argument-parser"), dependencies: [
.product(name: "DuckDB", package: "duckdb-swift"), .product(name: "ArgumentParser", package: "swift-argument-parser")
], ],
path: "Sources" path: "Sources"
), ),
.testTarget( .testTarget(
name: "FisheeTests", name: "FisheeTests",
dependencies: ["Fishee"], dependencies: ["Fishee"],
path: "Tests", path: "Tests",
resources: [ resources: [
.copy("Resources/fish_history_test.txt"), .copy("Resources/fish_history_test.txt"),
.copy("Resources/fish_history_test_2.txt"), .copy("Resources/fish_history_test_2.txt"),
] .process("TestPlan.xctestplan"),
) ]
] ),
]
) )

40
Sources/Algebra.swift
View file

@ -18,27 +18,27 @@ import Foundation
/// Data Structure/Schema representing an entry in a fish history file. /// Data Structure/Schema representing an entry in a fish history file.
struct FishHistoryEntry: Equatable { struct FishHistoryEntry: Equatable {
let cmd: String let cmd: String
let when: Int let when: Int
let paths: [String] let paths: [String]
/// Converts time to Date object /// Converts time to Date object
func getDate() -> Date { func getDate() -> Date {
Date(timeIntervalSince1970: TimeInterval(when)) Date(timeIntervalSince1970: TimeInterval(when))
}
/// Converts structure back to list of strings as expected in a fish history file.
func writeEntry() -> [String] {
var output: [String] = []
output.append("- cmd: \(cmd)")
output.append(" when: \(when)")
if !paths.isEmpty {
output.append(" paths:")
paths.forEach { output.append(" - \(String($0))") }
} }
/// Converts structure back to list of strings as expected in a fish history file. return output
func writeEntry() -> [String] { }
var output: [String] = []
output.append("- cmd: \(cmd)")
output.append(" when: \(when)")
if !paths.isEmpty {
output.append(" paths:")
paths.forEach { output.append(" - \(String($0))") }
}
return output
}
} }

26
Sources/FileHelpers.swift
View file

@ -14,10 +14,8 @@
// limitations under the License. // limitations under the License.
// //
import Foundation import Foundation
/// Gets the full file path to a given file. /// Gets the full file path to a given file.
/// ///
/// - Parameters /// - Parameters
@ -25,20 +23,20 @@ import Foundation
/// ///
/// - Returns: A Valid file URL or None if invalid. /// - Returns: A Valid file URL or None if invalid.
func getPath(_ pathStr: String) -> URL? { func getPath(_ pathStr: String) -> URL? {
let userHomeDirectory = FileManager.default.homeDirectoryForCurrentUser.path let userHomeDirectory = FileManager.default.homeDirectoryForCurrentUser.path
var filePath: String = pathStr var filePath: String = pathStr
if pathStr.hasPrefix("~") { if pathStr.hasPrefix("~") {
filePath = (pathStr as NSString).expandingTildeInPath filePath = (pathStr as NSString).expandingTildeInPath
} }
if pathStr.hasPrefix("$HOME") { if pathStr.hasPrefix("$HOME") {
filePath = filePath.replacingOccurrences(of: "$HOME", with: userHomeDirectory) filePath = filePath.replacingOccurrences(of: "$HOME", with: userHomeDirectory)
} }
if !FileManager.default.fileExists(atPath: filePath) { if !FileManager.default.fileExists(atPath: filePath) {
return nil return nil
} }
return URL(fileURLWithPath: filePath) return URL(fileURLWithPath: filePath)
} }

141
Sources/Fishee.swift
View file

@ -14,7 +14,6 @@
// limitations under the License. // limitations under the License.
// //
import ArgumentParser import ArgumentParser
import Foundation import Foundation
@ -22,81 +21,83 @@ let DEFAULT_FISH_HISTORY_LOCATION: String = "~/.local/share/fish/fish_history"
@main @main
struct Fishee: ParsableCommand { struct Fishee: ParsableCommand {
@Option(name: [.short, .customLong("history-file")], help: "Location of your fish history file. Will default to ~/.local/share/fish/fish_history") @Option(
var fishHistoryLocationStr: String? name: [.short, .customLong("history-file")],
help: "Location of your fish history file. Will default to ~/.local/share/fish/fish_history")
var fishHistoryLocationStr: String?
@Option(name: .shortAndLong, help: "File path to file to merge with history file.") @Option(name: .shortAndLong, help: "File path to file to merge with history file.")
var mergeFile: String? var mergeFile: String?
@Option( @Option(
name: [.short, .customLong("output-file")], name: [.short, .customLong("output-file")],
help: "File to write to. Default: same as current history file." help: "File to write to. Default: same as current history file."
) )
var writeFileStr: String? var writeFileStr: String?
@Flag( @Flag(
name: .shortAndLong, name: .shortAndLong,
help: "Dry run. Will only print to the console without actually modifying the history file." help: "Dry run. Will only print to the console without actually modifying the history file."
) )
var dryRun: Bool = false var dryRun: Bool = false
@Flag( @Flag(
name: .shortAndLong, name: .shortAndLong,
help: "Remove duplicates from combined history. Default: false" help: "Remove duplicates from combined history. Default: false"
) )
var removeDuplicates: Bool = false var removeDuplicates: Bool = false
@Flag( @Flag(
name: .shortAndLong, name: .shortAndLong,
inversion: .prefixedNo, inversion: .prefixedNo,
help: "Backup fish history file given before writing." help: "Backup fish history file given before writing."
) )
var backup: Bool = true var backup: Bool = true
var fishHistoryLocation: URL? { var fishHistoryLocation: URL? {
let pathStr = fishHistoryLocationStr ?? DEFAULT_FISH_HISTORY_LOCATION let pathStr = fishHistoryLocationStr ?? DEFAULT_FISH_HISTORY_LOCATION
return getPath(pathStr) return getPath(pathStr)
}
var writeFileLocation: URL? {
let pathStr = writeFileStr ?? DEFAULT_FISH_HISTORY_LOCATION
return getPath(pathStr)
}
public func run() throws {
let mergeFileLocation = mergeFile.flatMap { getPath($0) }
let finalHistory: [FishHistoryEntry] =
switch (fishHistoryLocation, mergeFileLocation) {
case let (fishHistoryLocation?, mergeFileLocation?):
{
let currentHistory = parseFishHistory(from: fishHistoryLocation.path) ?? []
let toMergeHistory = parseFishHistory(from: mergeFileLocation.path) ?? []
return mergeFishHistory(
currentHistory, toMergeHistory, removeDuplicates: removeDuplicates)
}()
case let (fishHistoryLocation?, nil):
parseFishHistory(from: fishHistoryLocation.path) ?? []
default:
[]
}
if dryRun {
finalHistory.forEach { print("\($0.writeEntry().joined(separator: "\n"))") }
} else {
if let writePath = writeFileLocation?.path {
let result = writeFishHistory(
to: writePath,
history: finalHistory,
backup: backup
)
if result {
print("Succussfully updated \(writePath)")
} else {
print("Failed to update \(writePath)")
}
}
} }
var writeFileLocation: URL? { return
let pathStr = writeFileStr ?? DEFAULT_FISH_HISTORY_LOCATION }
return getPath(pathStr)
}
public func run() throws {
let mergeFileLocation = mergeFile.flatMap { getPath($0) }
let finalHistory: [FishHistoryEntry] = switch (fishHistoryLocation, mergeFileLocation) {
case let (fishHistoryLocation?, mergeFileLocation?):
{
let currentHistory = parseFishHistory(from: fishHistoryLocation.path) ?? []
let toMergeHistory = parseFishHistory(from: mergeFileLocation.path) ?? []
return mergeFishHistory(currentHistory, toMergeHistory, removeDuplicates: removeDuplicates)
}()
case let (fishHistoryLocation?, nil):
parseFishHistory(from: fishHistoryLocation.path) ?? []
default:
[]
}
if dryRun {
finalHistory.forEach { print("\($0.writeEntry().joined(separator: "\n"))") }
}
else {
if let writePath = writeFileLocation?.path {
let result = writeFishHistory(
to: writePath,
history: finalHistory,
backup: backup
)
if result {
print("Succussfully updated \(writePath)")
}
else {
print("Failed to update \(writePath)")
}
}
}
return
}
} }

177
Sources/Parser.swift
View file

@ -14,10 +14,8 @@
// limitations under the License. // limitations under the License.
// //
import Foundation import Foundation
/// Make a backup of the fish history. /// Make a backup of the fish history.
/// ///
/// ``` /// ```
@ -31,33 +29,33 @@ import Foundation
/// ///
/// - Returns: true if backup copy successful, false if not. /// - Returns: true if backup copy successful, false if not.
func backupHistory(_ path: String) -> Bool { func backupHistory(_ path: String) -> Bool {
let fileManager = FileManager.default let fileManager = FileManager.default
guard fileManager.fileExists(atPath: path) else { guard fileManager.fileExists(atPath: path) else {
print("File does not exist at path: \(path)") print("File does not exist at path: \(path)")
return false return false
} }
let fileURL = URL(fileURLWithPath: path) let fileURL = URL(fileURLWithPath: path)
let fileExtension = fileURL.pathExtension let fileExtension = fileURL.pathExtension
let fileNameWithoutExtension = fileURL.deletingPathExtension().lastPathComponent let fileNameWithoutExtension = fileURL.deletingPathExtension().lastPathComponent
let directory = fileURL.deletingLastPathComponent() let directory = fileURL.deletingLastPathComponent()
let newFileName = "\(fileNameWithoutExtension)_copy" let newFileName = "\(fileNameWithoutExtension)_copy"
let newFileURL = directory.appendingPathComponent(newFileName).appendingPathExtension(fileExtension) let newFileURL = directory.appendingPathComponent(newFileName).appendingPathExtension(
fileExtension)
do { do {
try? fileManager.removeItem(at: newFileURL) try? fileManager.removeItem(at: newFileURL)
try fileManager.copyItem(at: fileURL, to: newFileURL) try fileManager.copyItem(at: fileURL, to: newFileURL)
print("File duplicated successfully to: \(newFileURL.path)") print("File duplicated successfully to: \(newFileURL.path)")
return true return true
} catch { } catch {
print("error making a backup of \(path), got error: \(error)") print("error making a backup of \(path), got error: \(error)")
return false return false
} }
} }
/// Write fish history to file. /// Write fish history to file.
/// ///
/// - Parameters /// - Parameters
@ -67,32 +65,31 @@ func backupHistory(_ path: String) -> Bool {
/// ///
/// - Returns: true if writing to file copy successful, false if not. /// - Returns: true if writing to file copy successful, false if not.
func writeFishHistory(to path: String, history: [FishHistoryEntry], backup: Bool = true) -> Bool { func writeFishHistory(to path: String, history: [FishHistoryEntry], backup: Bool = true) -> Bool {
var output = "" var output = ""
if backup { if backup {
let result = backupHistory(path) let result = backupHistory(path)
if !result { if !result {
print("Failed to backup \(path) so aborting!") print("Failed to backup \(path) so aborting!")
return false return false
}
} }
}
history.forEach { output += $0.writeEntry().joined(separator: "\n") + "\n" } history.forEach { output += $0.writeEntry().joined(separator: "\n") + "\n" }
if !output.isEmpty { if !output.isEmpty {
do { do {
try output.write(toFile: path, atomically: true, encoding: .utf8) try output.write(toFile: path, atomically: true, encoding: .utf8)
print("Successfully wrote merged history to \(path)") print("Successfully wrote merged history to \(path)")
return true return true
} catch { } catch {
print("Error writing merged history: \(error)") print("Error writing merged history: \(error)")
return false return false
}
}
else {
print("Nothing to write to \(path)")
return false
} }
} else {
print("Nothing to write to \(path)")
return false
}
} }
/// Parse the fish history file. /// Parse the fish history file.
@ -102,41 +99,45 @@ func writeFishHistory(to path: String, history: [FishHistoryEntry], backup: Bool
/// ///
/// - Returns: List of ``FishHistoryEntry`` entries from history file. /// - Returns: List of ``FishHistoryEntry`` entries from history file.
func parseFishHistory(from filePath: String) -> [FishHistoryEntry]? { func parseFishHistory(from filePath: String) -> [FishHistoryEntry]? {
guard let fileContents = try? String(contentsOfFile: filePath) else { guard let fileContents = try? String(contentsOfFile: filePath, encoding: .utf8) else {
print("Failed to open file.") print("Failed to open file.")
return nil return nil
}
let lines = fileContents.split(separator: "\n").map {
String($0).trimmingCharacters(in: .whitespaces)
}
let initialState:
(entries: [FishHistoryEntry], currentCmd: String?, currentWhen: Int?, currentPaths: [String]) =
([], nil, nil, [])
let result = lines.reduce(into: initialState) { state, line in
if line.starts(with: "- cmd:") {
if let cmd = state.currentCmd, let when = state.currentWhen {
let entry = FishHistoryEntry(cmd: cmd, when: when, paths: state.currentPaths)
state.entries.append(entry)
state.currentPaths = []
}
state.currentCmd = String(line.dropFirst("- cmd:".count).trimmingCharacters(in: .whitespaces))
} else if line.starts(with: "when:") {
if let whenValue = Int(line.dropFirst("when:".count).trimmingCharacters(in: .whitespaces)) {
state.currentWhen = whenValue
}
} else if line.starts(with: "paths:") {
return
} else if line.starts(with: "- ") {
let path = String(line.dropFirst("- ".count).trimmingCharacters(in: .whitespaces))
state.currentPaths.append(path)
} }
}
let lines = fileContents.split(separator: "\n").map { String($0).trimmingCharacters(in: .whitespaces) } if let cmd = result.currentCmd, let when = result.currentWhen {
let entry = FishHistoryEntry(cmd: cmd, when: when, paths: result.currentPaths)
return result.entries + [entry]
}
let initialState: (entries: [FishHistoryEntry], currentCmd: String?, currentWhen: Int?, currentPaths: [String]) = ([], nil, nil, []) return result.entries
let result = lines.reduce(into: initialState) { state, line in
if line.starts(with: "- cmd:") {
if let cmd = state.currentCmd, let when = state.currentWhen {
let entry = FishHistoryEntry(cmd: cmd, when: when, paths: state.currentPaths)
state.entries.append(entry)
state.currentPaths = []
}
state.currentCmd = String(line.dropFirst("- cmd:".count).trimmingCharacters(in: .whitespaces))
} else if line.starts(with: "when:") {
if let whenValue = Int(line.dropFirst("when:".count).trimmingCharacters(in: .whitespaces)) {
state.currentWhen = whenValue
}
} else if line.starts(with: "paths:") {
return
} else if line.starts(with: "- ") {
let path = String(line.dropFirst("- ".count).trimmingCharacters(in: .whitespaces))
state.currentPaths.append(path)
}
}
if let cmd = result.currentCmd, let when = result.currentWhen {
let entry = FishHistoryEntry(cmd: cmd, when: when, paths: result.currentPaths)
return result.entries + [entry]
}
return result.entries
} }
/// Merge two given ``FishHistoryEntry`` lists into one list. /// Merge two given ``FishHistoryEntry`` lists into one list.
@ -147,18 +148,20 @@ func parseFishHistory(from filePath: String) -> [FishHistoryEntry]? {
/// - removeDuplicates: if true, remove any duplicates found after merging the two lists. /// - removeDuplicates: if true, remove any duplicates found after merging the two lists.
/// ///
/// - Returns: Single list of ``FishHistoryEntry`` entries. /// - Returns: Single list of ``FishHistoryEntry`` entries.
func mergeFishHistory(_ left: [FishHistoryEntry], _ right: [FishHistoryEntry], removeDuplicates: Bool = false) -> [FishHistoryEntry] { func mergeFishHistory(
_ left: [FishHistoryEntry], _ right: [FishHistoryEntry], removeDuplicates: Bool = false
) -> [FishHistoryEntry] {
let merged = left + right let merged = left + right
if removeDuplicates { if removeDuplicates {
let finalList = merged.reduce(into: [String:FishHistoryEntry]()) { result, entry in let finalList = merged.reduce(into: [String: FishHistoryEntry]()) { result, entry in
if result[entry.cmd] == nil { if result[entry.cmd] == nil {
result[entry.cmd] = entry result[entry.cmd] = entry
} }
}
return Array(finalList.values)
} else {
return merged
} }
return Array(finalList.values)
} else {
return merged
}
} }

34
Tests/AlgebraTest.swift
View file

@ -16,27 +16,29 @@
import Foundation import Foundation
import Testing import Testing
@testable import Fishee @testable import Fishee
@Suite @Suite
final class AlgebraTests { final class AlgebraTests {
let historyItem = FishHistoryEntry(cmd: "cd Projects/Fishee/", when: 1727545693, paths: ["Projects/Fishee/"]) let historyItem = FishHistoryEntry(
cmd: "cd Projects/Fishee/", when: 1_727_545_693, paths: ["Projects/Fishee/"])
@Test func dateFromHistoryTest() { @Test func dateFromHistoryTest() {
let gotDate = historyItem.getDate() let gotDate = historyItem.getDate()
#expect(gotDate == Date(timeIntervalSince1970: 1727545693)) #expect(gotDate == Date(timeIntervalSince1970: 1_727_545_693))
} }
@Test func writeEntryTest() { @Test func writeEntryTest() {
let entry = historyItem.writeEntry() let entry = historyItem.writeEntry()
#expect(entry.count > 0) #expect(entry.count > 0)
let expectedEntry = """ let expectedEntry = """
- cmd: cd Projects/Fishee/ - cmd: cd Projects/Fishee/
when: 1727545693 when: 1727545693
paths: paths:
- Projects/Fishee/ - Projects/Fishee/
""" """
#expect(entry.joined(separator: "\n") == expectedEntry) #expect(entry.joined(separator: "\n") == expectedEntry)
} }
} }

46
Tests/FileHelpersTests.swift
View file

@ -16,33 +16,35 @@
import Foundation import Foundation
import Testing import Testing
@testable import Fishee
@testable import Fishee
@Suite(.serialized) @Suite(.serialized)
final class FileHelpersTests { final class FileHelpersTests {
let filePath = FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent("myfile.txt") let filePath = FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent(
"myfile.txt")
init() { init() {
try? "this is a test".write( try? "this is a test".write(
to: filePath, to: filePath,
atomically: true, atomically: true,
encoding: .utf8 encoding: .utf8
) )
} }
deinit { deinit {
try? FileManager.default.removeItem(at: filePath) try? FileManager.default.removeItem(at: filePath)
} }
@Test(arguments: [ @Test(arguments: [
"$HOME/myfile.txt", "$HOME/myfile.txt",
"~/myfile.txt", "~/myfile.txt",
"\(FileManager.default.homeDirectoryForCurrentUser.path)/myfile.txt" "\(FileManager.default.homeDirectoryForCurrentUser.path)/myfile.txt",
]) ])
func getPathTest(testPath: String) { func getPathTest(testPath: String) {
let path = getPath(testPath) let path = getPath(testPath)
let expected = URL(fileURLWithPath: "\(FileManager.default.homeDirectoryForCurrentUser.path)/myfile.txt") let expected = URL(
#expect(path == expected) fileURLWithPath: "\(FileManager.default.homeDirectoryForCurrentUser.path)/myfile.txt")
} #expect(path == expected)
}
} }

86
Tests/FisheeTests.swift
View file

@ -14,64 +14,64 @@
// limitations under the License. // limitations under the License.
// //
import Foundation import Foundation
import Testing import Testing
@testable import Fishee @testable import Fishee
@Suite @Suite
final class FisheeTests { final class FisheeTests {
@Test func DryRunTest() { @Test func DryRunTest() {
do { do {
let help = try #require(Fishee.parse(["--dry-run"]) as Fishee) let help = try #require(Fishee.parse(["--dry-run"]) as Fishee)
#expect(help.dryRun) #expect(help.dryRun)
} catch { } catch {
Issue.record("Test failed! \(error)") Issue.record("Test failed! \(error)")
}
} }
}
@Test func HistoryFileTest() { @Test func HistoryFileTest() {
do { do {
let help = try #require(Fishee.parse(["--history-file", "/tmp/fishtest.txt"]) as Fishee) let help = try #require(Fishee.parse(["--history-file", "/tmp/fishtest.txt"]) as Fishee)
#expect(help.fishHistoryLocationStr == "/tmp/fishtest.txt") #expect(help.fishHistoryLocationStr == "/tmp/fishtest.txt")
} catch { } catch {
Issue.record("Test failed! \(error)") Issue.record("Test failed! \(error)")
}
} }
}
@Test func OutputFileTest() { @Test func OutputFileTest() {
do { do {
let help = try #require(Fishee.parse(["--output-file", "/tmp/fishtest.txt"]) as Fishee) let help = try #require(Fishee.parse(["--output-file", "/tmp/fishtest.txt"]) as Fishee)
#expect(help.writeFileStr == "/tmp/fishtest.txt") #expect(help.writeFileStr == "/tmp/fishtest.txt")
} catch { } catch {
Issue.record("Test failed! \(error)") Issue.record("Test failed! \(error)")
}
} }
}
@Test func RemoveDuplicatesTest() { @Test func RemoveDuplicatesTest() {
do { do {
let help = try #require(Fishee.parse(["--remove-duplicates"]) as Fishee) let help = try #require(Fishee.parse(["--remove-duplicates"]) as Fishee)
#expect(help.removeDuplicates) #expect(help.removeDuplicates)
} catch { } catch {
Issue.record("Test failed! \(error)") Issue.record("Test failed! \(error)")
}
} }
}
@Test func BackupTest() { @Test func BackupTest() {
do { do {
let help = try #require(Fishee.parse(["--backup"]) as Fishee) let help = try #require(Fishee.parse(["--backup"]) as Fishee)
#expect(help.backup) #expect(help.backup)
} catch { } catch {
Issue.record("Test failed! \(error)") Issue.record("Test failed! \(error)")
}
} }
}
@Test func NoBackupTest() { @Test func NoBackupTest() {
do { do {
let help = try #require(Fishee.parse(["--no-backup"]) as Fishee) let help = try #require(Fishee.parse(["--no-backup"]) as Fishee)
#expect(!help.backup) #expect(!help.backup)
} catch { } catch {
Issue.record("Test failed! \(error)") Issue.record("Test failed! \(error)")
}
} }
}
} }

144
Tests/ParserTests.swift
View file

@ -16,83 +16,87 @@
import Foundation import Foundation
import Testing import Testing
@testable import Fishee @testable import Fishee
@Suite(.serialized) @Suite(.serialized)
final class ParserTests { final class ParserTests {
let fishHistoryFile = Bundle.module.path(forResource: "fish_history_test", ofType: "txt") let fishHistoryFile = Bundle.module.path(forResource: "fish_history_test", ofType: "txt")
let historyItem = FishHistoryEntry(cmd: "cd Projects/Fishee/", when: 1727545693, paths: ["Projects/Fishee/"]) let historyItem = FishHistoryEntry(
let historyItem2 = FishHistoryEntry(cmd: "swift package tools-version", when: 1727545709, paths: []) cmd: "cd Projects/Fishee/", when: 1_727_545_693, paths: ["Projects/Fishee/"])
let filePathforWriteTest = FileManager.default.urls(for: .downloadsDirectory, in: .userDomainMask)[0].appendingPathComponent( let historyItem2 = FishHistoryEntry(
"myfile.txt" cmd: "swift package tools-version", when: 1_727_545_709, paths: [])
let filePathforWriteTest = FileManager.default.temporaryDirectory.appendingPathComponent(
"myfile.txt")
let filePathforFileBackupTest = FileManager.default.temporaryDirectory
.appendingPathComponent("myfile_copy.txt")
deinit {
if FileManager.default.fileExists(atPath: filePathforWriteTest.path) {
_ = try? FileManager.default.removeItem(at: filePathforWriteTest)
}
if FileManager.default.fileExists(atPath: filePathforFileBackupTest.path) {
_ = try? FileManager.default.removeItem(at: filePathforFileBackupTest)
}
}
@Test func parseFishHistoryTest() {
#expect(fishHistoryFile != nil)
let fishHistory = parseFishHistory(from: fishHistoryFile!)
#expect(fishHistory!.count > 0)
let expectedHistory = [historyItem, historyItem2]
#expect(fishHistory == expectedHistory)
}
@Test func writeFishHistoryTest() {
let written = writeFishHistory(
to: filePathforWriteTest.path,
history: [historyItem],
backup: false
) )
let filePathforFileBackupTest = FileManager.default.urls(for: .downloadsDirectory, in: .userDomainMask)[0].appendingPathComponent( #expect(written)
"myfile_copy.txt"
let fileContent = try? String(contentsOf: filePathforWriteTest, encoding: .utf8)
let expectedEntry = """
- cmd: cd Projects/Fishee/
when: 1727545693
paths:
- Projects/Fishee/
"""
#expect(fileContent == expectedEntry)
// confirm backup functionality is working
#expect(FileManager.default.fileExists(atPath: filePathforWriteTest.path))
let write_again = writeFishHistory(
to: filePathforWriteTest.path,
history: [historyItem],
backup: true
) )
#expect(write_again)
#expect(FileManager.default.fileExists(atPath: filePathforFileBackupTest.path))
}
deinit { @Test func mergeFishHistoryTest() {
if FileManager.default.fileExists(atPath: filePathforWriteTest.path) { let merged = mergeFishHistory([historyItem], [historyItem2])
_ = try? FileManager.default.removeItem(at: filePathforWriteTest) #expect(merged.count == 2)
} #expect(merged.contains(historyItem))
if FileManager.default.fileExists(atPath: filePathforFileBackupTest.path) { #expect(merged.contains(historyItem2))
_ = try? FileManager.default.removeItem(at: filePathforFileBackupTest) }
}
}
@Test func parseFishHistoryTest() { @Test func mergeFishHistoryWithDuplicateTest() {
#expect(fishHistoryFile != nil) let merged = mergeFishHistory([historyItem], [historyItem, historyItem2])
let fishHistory = parseFishHistory(from: fishHistoryFile!) #expect(merged.count == 3)
#expect(fishHistory!.count > 0) #expect(merged.contains(historyItem))
let expectedHistory = [historyItem, historyItem2] #expect(merged.contains(historyItem2))
#expect(fishHistory == expectedHistory) }
}
@Test func writeFishHistoryTest() { @Test func mergeFishHistoryRemoveDuplicateTest() {
let written = writeFishHistory( let merged = mergeFishHistory(
to: filePathforWriteTest.path, [historyItem], [historyItem, historyItem2], removeDuplicates: true)
history: [historyItem], #expect(merged.count == 2)
backup: false #expect(merged.contains(historyItem))
) #expect(merged.contains(historyItem2))
#expect(written) }
let fileContent = try? String(contentsOf: filePathforWriteTest, encoding: .utf8)
let expectedEntry = """
- cmd: cd Projects/Fishee/
when: 1727545693
paths:
- Projects/Fishee/
"""
#expect(fileContent == expectedEntry)
// confirm backup functionality is working
let write_again = writeFishHistory(
to: filePathforWriteTest.path,
history: [historyItem],
backup: true
)
#expect(write_again)
#expect(FileManager.default.fileExists(atPath: filePathforFileBackupTest.path))
}
@Test func mergeFishHistoryTest() {
let merged = mergeFishHistory([historyItem], [historyItem2])
#expect(merged.count == 2)
#expect(merged.contains(historyItem))
#expect(merged.contains(historyItem2))
}
@Test func mergeFishHistoryWithDuplicateTest() {
let merged = mergeFishHistory([historyItem], [historyItem, historyItem2])
#expect(merged.count == 3)
#expect(merged.contains(historyItem))
#expect(merged.contains(historyItem2))
}
@Test func mergeFishHistoryRemoveDuplicateTest() {
let merged = mergeFishHistory([historyItem], [historyItem, historyItem2], removeDuplicates: true)
#expect(merged.count == 2)
#expect(merged.contains(historyItem))
#expect(merged.contains(historyItem2))
}
} }