Split the project into Lanework and Lanework Pro targets
Two app targets from one source tree — no build flags, no #if in shared code: an edition difference is a file one target compiles and the other does not. Base keeps everything it had (dev.rzen.indie.Kanban, minimal entitlements, AppIcon); KanbanPro compiles the same sources plus the reserved KanbanPro/ root (Git/, Remote/, Auth/ land with pro-m1 — libgit2 deliberately not added yet), adds network-client and its keychain group, and hand-writes its Info.plist with the UTI block verbatim — base exports the type, Pro imports it, one format either app opens. The unit-test sources compile twice, once per host, with Pro's module aliased so 56 test files keep @testable import Kanban unchanged; scheme Kanban stays the muscle-memory command and LaneworkPro joins it. InertGitTests pins the base posture with bytes and mtimes — a full editing session over boards carrying realistic .git trees at root and nested in a card leaves all twelve entries untouched, and moves and copies carry them verbatim. scripts/verify-editions.sh proves the rest: 26 checks over signatures, symbols, entitlements, identity, and the shared UTI, discounting Xcode's test-host exceptions by name rather than silently. Claude-Session: https://claude.ai/code/session_01SR4XGjmBE16ZUYWpfFHXwY
This commit is contained in:
@@ -0,0 +1,261 @@
|
||||
import Foundation
|
||||
import Testing
|
||||
@testable import Kanban
|
||||
|
||||
/// **Base's inert-`.git` posture, stated against real bytes on disk** (12-editions.md ▸ Base and
|
||||
/// `.git`): "any `.git` is inert — opening a board that has one works normally, but the app never
|
||||
/// reads history, never commits, never touches `.git` in any way."
|
||||
///
|
||||
/// Two halves of that posture are already pinned elsewhere and are referenced, not repeated:
|
||||
/// `FolderWatcherTests` ▸ ".git filtering" proves the watcher ignores churn under a `.git` at any
|
||||
/// depth, and `BoardLoaderStrayTests.strayFilesAndHiddenEntriesAreIgnoredWithoutWarning` proves a
|
||||
/// `.git` at the board root loads as an ordinary stray with no warning. Both are *input* claims:
|
||||
/// what the app does with events and entries it is handed.
|
||||
///
|
||||
/// This file states the **output** claim, which no existing test covers, and which is the one the
|
||||
/// edition split has to be able to demonstrate: a full session of ordinary base editing leaves
|
||||
/// every byte and every mtime under `.git` exactly as it found them. It is asserted the only way
|
||||
/// that is worth anything — by snapshotting the whole `.git` subtree from the filesystem before
|
||||
/// the edits and re-reading it afterwards, never through the app's own read path
|
||||
/// (`WriterTestSupport.swift`'s standing rule).
|
||||
///
|
||||
/// Note what "untouched" is worth as an mtime assertion specifically: bytes alone would pass even
|
||||
/// if the app rewrote a file with identical content, and re-writing git's index with identical
|
||||
/// bytes is exactly the kind of thing an accidental git dependency would do. The mtimes are the
|
||||
/// assertion that nothing *opened for writing* down there at all.
|
||||
|
||||
// MARK: - Subtree snapshots
|
||||
|
||||
/// One entry under `.git`: its path relative to the board root, its bytes (nil for directories),
|
||||
/// and its on-disk modification date. Directories carry an mtime too — a file created or removed
|
||||
/// inside a directory moves *that directory's* mtime, so including them catches a write the
|
||||
/// per-file comparison would miss because the file it added is not in the "before" set.
|
||||
private struct SubtreeEntry: Equatable, CustomStringConvertible {
|
||||
let relativePath: String
|
||||
let data: Data?
|
||||
let modified: Date
|
||||
|
||||
var description: String {
|
||||
"\(relativePath) (\(data.map { "\($0.count) bytes" } ?? "directory"), modified \(modified))"
|
||||
}
|
||||
}
|
||||
|
||||
/// Every entry beneath `root/subtree`, hidden entries included, sorted by path. `.git` is itself
|
||||
/// hidden and everything inside it is reached through it, so `.skipsHiddenFiles` is deliberately
|
||||
/// *not* passed — a snapshot that skipped hidden files would snapshot nothing at all.
|
||||
private func snapshotSubtree(_ root: URL, _ subtree: String) throws -> [SubtreeEntry] {
|
||||
let base = root.appendingPathComponent(subtree, isDirectory: true)
|
||||
let manager = FileManager.default
|
||||
guard let walker = manager.enumerator(atPath: base.path) else {
|
||||
Issue.record("could not enumerate \(subtree)")
|
||||
return []
|
||||
}
|
||||
|
||||
var entries: [SubtreeEntry] = []
|
||||
for case let relative as String in walker {
|
||||
let url = base.appendingPathComponent(relative)
|
||||
let attributes = try manager.attributesOfItem(atPath: url.path)
|
||||
guard let modified = attributes[.modificationDate] as? Date else {
|
||||
Issue.record("no modification date for \(subtree)/\(relative)")
|
||||
continue
|
||||
}
|
||||
let isDirectory = (attributes[.type] as? FileAttributeType) == .typeDirectory
|
||||
entries.append(SubtreeEntry(
|
||||
relativePath: "\(subtree)/\(relative)",
|
||||
data: isDirectory ? nil : try Data(contentsOf: url),
|
||||
modified: modified
|
||||
))
|
||||
}
|
||||
|
||||
// The directory the subtree hangs from, which the enumerator above does not yield.
|
||||
let rootAttributes = try manager.attributesOfItem(atPath: base.path)
|
||||
if let modified = rootAttributes[.modificationDate] as? Date {
|
||||
entries.append(SubtreeEntry(relativePath: subtree, data: nil, modified: modified))
|
||||
}
|
||||
|
||||
return entries.sorted { $0.relativePath < $1.relativePath }
|
||||
}
|
||||
|
||||
// MARK: - Fixture construction
|
||||
|
||||
/// A `.git` directory with the shape a real one has — a ref file, a binary index, a loose object
|
||||
/// two levels down, a packed-refs file, and an empty `objects/pack` — written under `parent`.
|
||||
/// The bytes are sentinels: recognizable, non-UTF-8 in the index's case, and nothing the app has
|
||||
/// any reader for.
|
||||
@discardableResult
|
||||
private func makeGitDirectory(in fixture: WriterFixture, under parent: String) throws -> String {
|
||||
let prefix = parent.isEmpty ? ".git" : "\(parent)/.git"
|
||||
|
||||
try fixture.file("\(prefix)/HEAD", Data("ref: refs/heads/main\n".utf8))
|
||||
try fixture.file("\(prefix)/config", Data("[core]\n\trepositoryformatversion = 0\n".utf8))
|
||||
// Deliberately not valid UTF-8 — a real `.git/index` is binary, and a byte comparison that
|
||||
// only ever sees text is not testing the thing that matters.
|
||||
try fixture.file("\(prefix)/index", Data([0x44, 0x49, 0x52, 0x43, 0x00, 0x00, 0x00, 0x02, 0xFF, 0xFE, 0x00, 0x01]))
|
||||
try fixture.file("\(prefix)/objects/ab/cdef0123456789", Data([0x78, 0x01, 0xCB, 0xC8, 0x4F, 0x00, 0x00]))
|
||||
try fixture.file("\(prefix)/refs/heads/main", Data("0123456789abcdef0123456789abcdef01234567\n".utf8))
|
||||
try fixture.file("\(prefix)/packed-refs", Data("# pack-refs with: peeled fully-peeled sorted\n".utf8))
|
||||
try FileManager.default.createDirectory(
|
||||
at: fixture.url("\(prefix)/objects/pack"),
|
||||
withIntermediateDirectories: true
|
||||
)
|
||||
|
||||
return prefix
|
||||
}
|
||||
|
||||
/// The board every test here edits: a root, two lanes, three cards, a `.git` at the board root
|
||||
/// **and** a second one nested inside a card folder (12: "any `.git` is inert", not just the
|
||||
/// root's own — a repo-nested board or a clone dropped inside a card is the same promise).
|
||||
private struct InertGitBoard {
|
||||
let fixture: WriterFixture
|
||||
let laneA: String
|
||||
let laneB: String
|
||||
let card1: String
|
||||
let card2: String
|
||||
/// The card carrying the nested repo — the one the move test drags across lanes.
|
||||
let cardWithRepo: String
|
||||
|
||||
init() throws {
|
||||
fixture = try WriterFixture()
|
||||
laneA = Ident.lane1
|
||||
laneB = Ident.lane2
|
||||
card1 = Ident.card1
|
||||
card2 = Ident.card2
|
||||
cardWithRepo = Ident.card3
|
||||
|
||||
try fixture.item("", Item.board)
|
||||
try fixture.item(laneA, Item.rich(order: "1024", title: "Doing"))
|
||||
try fixture.item(laneB, Item.rich(order: "2048", title: "Done"))
|
||||
try fixture.item("\(laneA)/\(card1)", Item.rich(order: "1024", title: "First"))
|
||||
try fixture.item("\(laneA)/\(card2)", Item.rich(order: "2048", title: "Second"))
|
||||
try fixture.item("\(laneA)/\(cardWithRepo)", Item.rich(order: "3072", title: "Has a clone"))
|
||||
|
||||
try makeGitDirectory(in: fixture, under: "")
|
||||
try makeGitDirectory(in: fixture, under: "\(laneA)/\(cardWithRepo)")
|
||||
}
|
||||
|
||||
var root: URL { fixture.root }
|
||||
func url(_ relativePath: String) -> URL { fixture.url(relativePath) }
|
||||
func tearDown() { fixture.tearDown() }
|
||||
}
|
||||
|
||||
// MARK: - The posture
|
||||
|
||||
struct BaseInertGitTests {
|
||||
@Test("A full session of ordinary edits leaves every byte and mtime under .git untouched")
|
||||
func anEditingSessionNeverTouchesGit() throws {
|
||||
let board = try InertGitBoard()
|
||||
defer { board.tearDown() }
|
||||
|
||||
let before = try snapshotSubtree(board.root, ".git")
|
||||
#expect(before.count == 12, "the fixture's own shape — files, directories and the root")
|
||||
|
||||
// A session's worth of every write the base app can make, in one go. `.git` is at the
|
||||
// board root, so anything that walks or renumbers the root's children walks past it.
|
||||
try BoardWriter.updateIndex(inItemFolder: board.url(""), operation: .rename(title: nil)) { document in
|
||||
document.set(FrontmatterKeys.title, to: .string("Renamed board"))
|
||||
}
|
||||
let newLane = try BoardWriter.createLane(inBoard: board.root, title: "Later")
|
||||
let newCard = try BoardWriter.createCard(inLane: board.url(newLane.rawValue), title: "Fresh")
|
||||
try BoardWriter.writeBody(inItemFolder: board.url("\(newLane.rawValue)/\(newCard.rawValue)"), body: "Body text.\n")
|
||||
try BoardWriter.updateIndex(
|
||||
inItemFolder: board.url("\(board.laneA)/\(board.card1)"),
|
||||
operation: .style(title: nil)
|
||||
) { document in
|
||||
document.set(FrontmatterKeys.title, to: .string("Retitled"))
|
||||
}
|
||||
_ = try BoardWriter.moveItem(
|
||||
at: board.url("\(board.laneA)/\(board.card2)"),
|
||||
toParent: board.url(board.laneB),
|
||||
sourceBoardRoot: board.root,
|
||||
destinationBoardRoot: board.root,
|
||||
order: nil
|
||||
)
|
||||
_ = try BoardWriter.copyItem(
|
||||
at: board.url("\(board.laneA)/\(board.card1)"),
|
||||
toParent: board.url(board.laneB),
|
||||
order: nil,
|
||||
stamps: .fork
|
||||
)
|
||||
try BoardWriter.deleteItem(at: board.url("\(board.laneA)/\(board.card1)"))
|
||||
try BoardWriter.restoreItem(at: board.url("\(board.laneA)/\(board.card1)"))
|
||||
// The renumbers are the pointed ones: both walk a parent's whole directory listing, which
|
||||
// is where a `.git` entry actually gets looked at.
|
||||
try BoardWriter.renumberVisibleChildren(of: board.root)
|
||||
try BoardWriter.renumberVisibleChildren(of: board.url(board.laneA))
|
||||
|
||||
#expect(try snapshotSubtree(board.root, ".git") == before)
|
||||
}
|
||||
|
||||
@Test("The board loads and renders normally with a .git at its root, without a warning")
|
||||
func aGitBearingBoardLoadsLikeAnyOther() throws {
|
||||
let board = try InertGitBoard()
|
||||
defer { board.tearDown() }
|
||||
|
||||
let before = try snapshotSubtree(board.root, ".git")
|
||||
|
||||
let result = try BoardLoader.load(boardRoot: board.root)
|
||||
|
||||
#expect(result.model.lanes.map(\.id.rawValue) == [board.laneA, board.laneB])
|
||||
#expect(result.model.lanes[0].cards.map(\.id.rawValue) == [board.card1, board.card2, board.cardWithRepo])
|
||||
#expect(result.warnings.isEmpty, "a `.git` is a stray like any other — strays are silent")
|
||||
// A load is a read, but a read that opened `.git` would still move its atimes and would
|
||||
// still be the app "touching" history; the mtime equality is what is checkable, and a
|
||||
// loader that decided to *repair* something down there would break it.
|
||||
#expect(try snapshotSubtree(board.root, ".git") == before)
|
||||
}
|
||||
|
||||
@Test("A nested .git rides along a card move byte- and mtime-verbatim")
|
||||
func aNestedRepositorySurvivesACardMove() throws {
|
||||
let board = try InertGitBoard()
|
||||
defer { board.tearDown() }
|
||||
|
||||
let nested = "\(board.laneA)/\(board.cardWithRepo)/.git"
|
||||
let before = try snapshotSubtree(board.root, nested)
|
||||
|
||||
let result = try BoardWriter.moveItem(
|
||||
at: board.url("\(board.laneA)/\(board.cardWithRepo)"),
|
||||
toParent: board.url(board.laneB),
|
||||
sourceBoardRoot: board.root,
|
||||
destinationBoardRoot: board.root,
|
||||
order: nil
|
||||
)
|
||||
|
||||
// Same identity, new parent — the folder moved whole, `.git` inside it.
|
||||
let moved = "\(board.laneB)/\(result.id.rawValue)/.git"
|
||||
let after = try snapshotSubtree(board.root, moved)
|
||||
|
||||
#expect(after.map(\.data) == before.map(\.data))
|
||||
#expect(after.map(\.modified) == before.map(\.modified))
|
||||
#expect(
|
||||
after.map { $0.relativePath.replacingOccurrences(of: moved, with: nested) } == before.map(\.relativePath)
|
||||
)
|
||||
}
|
||||
|
||||
@Test("A copy of a card carrying a .git reproduces it verbatim and leaves the original alone")
|
||||
func aCopyCarriesTheNestedRepositoryWithoutTouchingTheOriginal() throws {
|
||||
let board = try InertGitBoard()
|
||||
defer { board.tearDown() }
|
||||
|
||||
let nested = "\(board.laneA)/\(board.cardWithRepo)/.git"
|
||||
let before = try snapshotSubtree(board.root, nested)
|
||||
|
||||
let copyID = try BoardWriter.copyItem(
|
||||
at: board.url("\(board.laneA)/\(board.cardWithRepo)"),
|
||||
toParent: board.url(board.laneB),
|
||||
order: nil,
|
||||
stamps: .fork
|
||||
)
|
||||
|
||||
#expect(try snapshotSubtree(board.root, nested) == before, "the source is never touched")
|
||||
|
||||
// The copy's `.git` is the same tree with the same bytes (mtimes are a copy's to set —
|
||||
// `FileManager.copyItem` preserves them, but the promise being made here is about content
|
||||
// and shape, not about a copy having been a rename).
|
||||
let copied = try snapshotSubtree(board.root, "\(board.laneB)/\(copyID.rawValue)/.git")
|
||||
#expect(copied.map(\.data) == before.map(\.data))
|
||||
#expect(
|
||||
copied.map { $0.relativePath.replacingOccurrences(of: "\(board.laneB)/\(copyID.rawValue)/.git", with: nested) }
|
||||
== before.map(\.relativePath)
|
||||
)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user