From f703a8df5d83b46392cbf130bb8db978c3e8bf91 Mon Sep 17 00:00:00 2001 From: Spencer Brower Date: Sun, 21 Jun 2026 16:53:13 -0400 Subject: [PATCH] refactor(db.odin): Renamed fields for consistency. --- db.odin | 128 +++++++++++++++++++++++------------------------ db_test.odin | 138 +++++++++++++++++++++++++-------------------------- 2 files changed, 133 insertions(+), 133 deletions(-) diff --git a/db.odin b/db.odin index da77e25..6b428f5 100644 --- a/db.odin +++ b/db.odin @@ -56,28 +56,28 @@ delete_envfile :: proc(f: ^EnvFile) { delete(f.contents) } -db_open :: proc(cfg_path: string) -> (database: Db, ok: bool) { - database = db_init() or_return - database.cfg = load_config(cfg_path, db_allocator(&database)) or_return +db_open :: proc(cfg_path: string) -> (db: Db, ok: bool) { + db = db_init() or_return + db.cfg = load_config(cfg_path, db_allocator(&db)) or_return // TODO: Use different allocators? - data_path := data_path(database.cfg.config_path, context.temp_allocator) + data_path := data_path(db.cfg.config_path, context.temp_allocator) if os.exists(data_path) { - if ok = db_restore_from_encrypted(&database, data_path); !ok { - sqlite.close(database.conn) - return database, false + if ok = db_restore_from_encrypted(&db, data_path); !ok { + sqlite.close(db.conn) + return db, false } } else { // DB was created - database.changed = true + db.changed = true } - return database, true + return db, true } // Creates a database an allocator and fresh, empty table, with zero encryption. // In production, you most likely want to use `db_open`. -db_init :: proc() -> (database: Db, ok: bool) { +db_init :: proc() -> (db: Db, ok: bool) { conn: sqlite.Db rc := sqlite.open(":memory:", &conn) if rc != sqlite.OK { @@ -92,11 +92,11 @@ db_init :: proc() -> (database: Db, ok: bool) { sqlite.close(conn) return } - database.conn = conn + db.conn = conn - mem.dynamic_arena_init(&database.arena) + mem.dynamic_arena_init(&db.arena) - return database, true + return db, true } db_allocator :: proc(db: ^Db) -> mem.Allocator { @@ -138,26 +138,26 @@ db_restore_from_encrypted :: proc(db: ^Db, data_path: string) -> bool { return true } -db_close :: proc(d: ^Db) { - allocator := db_allocator(d) +db_close :: proc(db: ^Db) { + allocator := db_allocator(db) defer { - sqlite.close(d.conn) + sqlite.close(db.conn) - delete_config(&d.cfg, allocator) + delete_config(&db.cfg, allocator) - mem.dynamic_arena_destroy(&d.arena) + mem.dynamic_arena_destroy(&db.arena) } - if d.changed { - rc := sqlite.db_exec(d.conn, "VACUUM", nil, nil, nil) + if db.changed { + rc := sqlite.db_exec(db.conn, "VACUUM", nil, nil, nil) if rc != sqlite.OK { - fmt.printf("Error vacuuming database: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error vacuuming database: %s\n", sqlite.db_errmsg(db.conn)) return } sz: i64 - data := sqlite.serialize(d.conn, "main", &sz, 0) + data := sqlite.serialize(db.conn, "main", &sz, 0) if data == nil { fmt.println("Error: failed to serialize database") return @@ -166,14 +166,14 @@ db_close :: proc(d: ^Db) { sqlite_data := data[:sz] // TODO: PAss allocator chain - encrypted, enc_ok := encrypt(sqlite_data, d.cfg.Keys[:]) + encrypted, enc_ok := encrypt(sqlite_data, db.cfg.Keys[:]) if !enc_ok { fmt.println("Error: encryption failed") return } - data_path := data_path(d.cfg.config_path, allocator) - envr_d := envr_dir(d.cfg.config_path) + data_path := data_path(db.cfg.config_path, allocator) + envr_d := envr_dir(db.cfg.config_path) os.mkdir_all(envr_d) write_err := os.write_entire_file(data_path, encrypted) @@ -183,27 +183,27 @@ db_close :: proc(d: ^Db) { return } - d.changed = false + db.changed = false } } // Results will be freed when `db_close` is called. -db_list :: proc(d: ^Db) -> ([]EnvFile, bool) { +db_list :: proc(db: ^Db) -> ([]EnvFile, bool) { stmt: sqlite.Stmt rc := sqlite.prepare_v2( - d.conn, + db.conn, "SELECT path, remotes, sha256, contents FROM envr_env_files", -1, &stmt, nil, ) if rc != sqlite.OK { - fmt.printf("Error preparing query: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error preparing query: %s\n", sqlite.db_errmsg(db.conn)) return []EnvFile{}, false } defer sqlite.finalize(stmt) - allocator := db_allocator(d) + allocator := db_allocator(db) results := make([dynamic]EnvFile, 0, 10, allocator) for { @@ -212,7 +212,7 @@ db_list :: proc(d: ^Db) -> ([]EnvFile, bool) { break } if rc != sqlite.ROW { - fmt.printf("Error stepping query: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error stepping query: %s\n", sqlite.db_errmsg(db.conn)) #no_bounds_check return results[:], false } @@ -239,7 +239,7 @@ db_list :: proc(d: ^Db) -> ([]EnvFile, bool) { } // TODO: Should we use context.temp_allocator for proc scoped lifetimes? -db_insert :: proc(d: ^Db, file: EnvFile) -> bool { +db_insert :: proc(db: ^Db, file: EnvFile) -> bool { remotes_json, marshal_err := json.marshal(file.Remotes, allocator = context.temp_allocator) if marshal_err != nil { fmt.printf("Error marshaling remotes: %v\n", marshal_err) @@ -250,9 +250,9 @@ db_insert :: proc(d: ^Db, file: EnvFile) -> bool { "INSERT OR REPLACE INTO " + "envr_env_files (path, remotes, sha256, contents) VALUES (?, ?, ?, ?)" stmt: sqlite.Stmt - rc := sqlite.prepare_v2(d.conn, sql, -1, &stmt, nil) + rc := sqlite.prepare_v2(db.conn, sql, -1, &stmt, nil) if rc != sqlite.OK { - fmt.printf("Error preparing insert: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error preparing insert: %s\n", sqlite.db_errmsg(db.conn)) return false } defer sqlite.finalize(stmt) @@ -262,7 +262,7 @@ db_insert :: proc(d: ^Db, file: EnvFile) -> bool { defer delete(cpath) rc = sqlite.bind_text(stmt, 1, cpath, -1, nil) if rc != sqlite.OK { - fmt.printf("Error binding path: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error binding path: %s\n", sqlite.db_errmsg(db.conn)) return false } @@ -270,7 +270,7 @@ db_insert :: proc(d: ^Db, file: EnvFile) -> bool { defer delete(cremotes) rc = sqlite.bind_text(stmt, 2, cremotes, -1, nil) if rc != sqlite.OK { - fmt.printf("Error binding remotes: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error binding remotes: %s\n", sqlite.db_errmsg(db.conn)) return false } @@ -278,7 +278,7 @@ db_insert :: proc(d: ^Db, file: EnvFile) -> bool { defer delete(csha) rc = sqlite.bind_text(stmt, 3, csha, -1, nil) if rc != sqlite.OK { - fmt.printf("Error binding sha256: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error binding sha256: %s\n", sqlite.db_errmsg(db.conn)) return false } @@ -286,38 +286,38 @@ db_insert :: proc(d: ^Db, file: EnvFile) -> bool { defer delete(ccontents) rc = sqlite.bind_text(stmt, 4, ccontents, -1, nil) if rc != sqlite.OK { - fmt.printf("Error binding contents: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error binding contents: %s\n", sqlite.db_errmsg(db.conn)) return false } rc = sqlite.step(stmt) if rc != sqlite.DONE { - fmt.printf("Error inserting: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error inserting: %s\n", sqlite.db_errmsg(db.conn)) return false } - d.changed = true + db.changed = true return true } // Result will be freed when `db_close` is called. -db_fetch :: proc(d: ^Db, path: string) -> (EnvFile, bool) { +db_fetch :: proc(db: ^Db, path: string) -> (EnvFile, bool) { sql: cstring = "SELECT path, remotes, sha256, contents FROM envr_env_files WHERE path = ?" stmt: sqlite.Stmt - rc := sqlite.prepare_v2(d.conn, sql, -1, &stmt, nil) + rc := sqlite.prepare_v2(db.conn, sql, -1, &stmt, nil) if rc != sqlite.OK { - fmt.printf("Error preparing fetch: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error preparing fetch: %s\n", sqlite.db_errmsg(db.conn)) return EnvFile{}, false } defer sqlite.finalize(stmt) - allocator := db_allocator(d) + allocator := db_allocator(db) cpath := to_cstring(path, allocator) defer delete(cpath, allocator) rc = sqlite.bind_text(stmt, 1, cpath, -1, nil) if rc != sqlite.OK { - fmt.printf("Error binding path: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error binding path: %s\n", sqlite.db_errmsg(db.conn)) return EnvFile{}, false } rc = sqlite.step(stmt) @@ -326,7 +326,7 @@ db_fetch :: proc(d: ^Db, path: string) -> (EnvFile, bool) { return EnvFile{}, false } if rc != sqlite.ROW { - fmt.printf("Error fetching: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error fetching: %s\n", sqlite.db_errmsg(db.conn)) return EnvFile{}, false } @@ -348,12 +348,12 @@ db_fetch :: proc(d: ^Db, path: string) -> (EnvFile, bool) { true } -db_delete :: proc(d: ^Db, path: string) -> bool { +db_delete :: proc(db: ^Db, path: string) -> bool { sql: cstring = "DELETE FROM envr_env_files WHERE path = ?" stmt: sqlite.Stmt - rc := sqlite.prepare_v2(d.conn, sql, -1, &stmt, nil) + rc := sqlite.prepare_v2(db.conn, sql, -1, &stmt, nil) if rc != sqlite.OK { - fmt.printf("Error preparing delete: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error preparing delete: %s\n", sqlite.db_errmsg(db.conn)) return false } defer sqlite.finalize(stmt) @@ -362,21 +362,21 @@ db_delete :: proc(d: ^Db, path: string) -> bool { defer delete(cpath) rc = sqlite.bind_text(stmt, 1, cpath, -1, nil) if rc != sqlite.OK { - fmt.printf("Error binding path: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error binding path: %s\n", sqlite.db_errmsg(db.conn)) return false } rc = sqlite.step(stmt) if rc != sqlite.DONE { - fmt.printf("Error deleting: %s\n", sqlite.db_errmsg(d.conn)) + fmt.printf("Error deleting: %s\n", sqlite.db_errmsg(db.conn)) return false } - if sqlite.changes(d.conn) == 0 { + if sqlite.changes(db.conn) == 0 { fmt.printf("No file found with path: %s\n", path) return false } - d.changed = true + db.changed = true return true } @@ -414,13 +414,13 @@ new_env_file :: proc(path: string) -> (EnvFile, bool) { } // Reconciles `f` with the filesystem and persists changes to the database. -db_sync :: proc(d: ^Db, f: ^EnvFile) -> (SyncFlag, SyncError) { - allocator := db_allocator(d) +db_sync :: proc(db: ^Db, f: ^EnvFile) -> (SyncFlag, SyncError) { + allocator := db_allocator(db) result: SyncFlag = {} old_path := f.Path if !os.exists(f.Dir) { - moved, err := try_move_dir(d, f, allocator) + moved, err := try_move_dir(db, f, allocator) if !moved { return {}, err } @@ -434,7 +434,7 @@ db_sync :: proc(d: ^Db, f: ^EnvFile) -> (SyncFlag, SyncError) { return result, .WriteFailed } - if !db_persist(d, f, old_path) { + if !db_persist(db, f, old_path) { return result, .DbFailed } return result + {.Restored}, .None @@ -455,7 +455,7 @@ db_sync :: proc(d: ^Db, f: ^EnvFile) -> (SyncFlag, SyncError) { current_sha := string(hex_bytes) if current_sha == f.Sha256 { - if !db_persist(d, f, old_path) { + if !db_persist(db, f, old_path) { return result, .DbFailed } return result, .None @@ -463,23 +463,23 @@ db_sync :: proc(d: ^Db, f: ^EnvFile) -> (SyncFlag, SyncError) { f.contents = string(data) f.Sha256 = current_sha - if !db_persist(d, f, old_path) { + if !db_persist(db, f, old_path) { return result, .DbFailed } return result + {.BackedUp}, .None } -db_persist :: proc(d: ^Db, f: ^EnvFile, old_path: string) -> bool { +db_persist :: proc(db: ^Db, f: ^EnvFile, old_path: string) -> bool { if f.Path != old_path { - if !db_delete(d, old_path) { + if !db_delete(db, old_path) { return false } } - return db_insert(d, f^) + return db_insert(db, f^) } -try_move_dir :: proc(d: ^Db, f: ^EnvFile, allocator: mem.Allocator) -> (bool, SyncError) { - roots, ok := find_git_roots(d.cfg) +try_move_dir :: proc(db: ^Db, f: ^EnvFile, allocator: mem.Allocator) -> (bool, SyncError) { + roots, ok := find_git_roots(db.cfg) if !ok { return false, .GitRootFailed } diff --git a/db_test.odin b/db_test.odin index 6f38a79..c60428f 100644 --- a/db_test.odin +++ b/db_test.odin @@ -27,10 +27,10 @@ make_test_env_file :: proc(path, sha, contents: string, remotes: []string = {}) @(test) test_db_insert_and_fetch :: proc(t: ^testing.T) { - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") if !ok do return - defer db_close(&d) + defer db_close(&db) path := "/project/.env" sha := "abc123" @@ -39,9 +39,9 @@ test_db_insert_and_fetch :: proc(t: ^testing.T) { f := make_test_env_file(path, sha, contents, []string{"git@github.com:user/repo.git"}) defer delete(f.Remotes) - testing.expect(t, db_insert(&d, f), "insert should succeed") + testing.expect(t, db_insert(&db, f), "insert should succeed") - fetched, fetch_ok := db_fetch(&d, "/project/.env") + fetched, fetch_ok := db_fetch(&db, "/project/.env") // defer delete_envfile(&fetched) testing.expect(t, fetch_ok, "fetch should succeed") if !fetch_ok do return @@ -55,35 +55,35 @@ test_db_insert_and_fetch :: proc(t: ^testing.T) { @(test) test_db_fetch_missing :: proc(t: ^testing.T) { - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") if !ok do return - defer db_close(&d) + defer db_close(&db) - _, fetch_ok := db_fetch(&d, "/nonexistent/.env") + _, fetch_ok := db_fetch(&db, "/nonexistent/.env") testing.expect(t, !fetch_ok, "fetch missing should return false") } @(test) test_db_insert_or_replace :: proc(t: ^testing.T) { - d, ok := db_init() - defer db_close(&d) + db, ok := db_init() + defer db_close(&db) testing.expect(t, ok, "failed to create test db") f1 := make_test_env_file("/project/.env", "sha1", "KEY=old") defer delete(f1.Remotes) - testing.expect(t, db_insert(&d, f1), "first insert should succeed") + testing.expect(t, db_insert(&db, f1), "first insert should succeed") f2 := make_test_env_file("/project/.env", "sha2", "KEY=new") defer delete(f2.Remotes) - testing.expect(t, db_insert(&d, f2), "second insert should succeed") + testing.expect(t, db_insert(&db, f2), "second insert should succeed") - results, list_ok := db_list(&d) + results, list_ok := db_list(&db) testing.expect(t, list_ok, "list should succeed") testing.expect(t, len(results) == 1, "should have 1 row, not 2") - fetched, fetch_ok := db_fetch(&d, "/project/.env") + fetched, fetch_ok := db_fetch(&db, "/project/.env") testing.expect(t, fetch_ok, "fetch should succeed") if !fetch_ok do return // defer delete_envfile(&fetched) @@ -94,36 +94,36 @@ test_db_insert_or_replace :: proc(t: ^testing.T) { @(test) test_db_delete_existing :: proc(t: ^testing.T) { - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") if !ok do return - defer db_close(&d) + defer db_close(&db) f := make_test_env_file("/project/.env", "sha", "KEY=val") defer delete(f.Remotes) - db_insert(&d, f) + db_insert(&db, f) - testing.expect(t, db_delete(&d, "/project/.env"), "delete should return true") + testing.expect(t, db_delete(&db, "/project/.env"), "delete should return true") - _, fetch_ok := db_fetch(&d, "/project/.env") + _, fetch_ok := db_fetch(&db, "/project/.env") testing.expect(t, !fetch_ok, "row should be gone after delete") } @(test) test_db_delete_missing :: proc(t: ^testing.T) { - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") if !ok do return - defer db_close(&d) + defer db_close(&db) - testing.expect(t, !db_delete(&d, "/nonexistent/.env"), "delete missing should return false") + testing.expect(t, !db_delete(&db, "/nonexistent/.env"), "delete missing should return false") } @(test) test_db_list_multiple :: proc(t: ^testing.T) { - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") - defer db_close(&d) + defer db_close(&db) f1 := make_test_env_file("/proj1/.env", "sha1", "A=1", []string{"git@github.com:a/repo.git"}) defer delete(f1.Remotes) @@ -131,11 +131,11 @@ test_db_list_multiple :: proc(t: ^testing.T) { defer delete(f2.Remotes) f3 := make_test_env_file("/proj3/.env", "sha3", "C=3") - db_insert(&d, f1) - db_insert(&d, f2) - db_insert(&d, f3) + db_insert(&db, f1) + db_insert(&db, f2) + db_insert(&db, f3) - results, list_ok := db_list(&d) + results, list_ok := db_list(&db) testing.expect(t, list_ok, "list should succeed") testing.expect_value(t, len(results), 3) @@ -143,60 +143,60 @@ test_db_list_multiple :: proc(t: ^testing.T) { @(test) test_db_list_empty :: proc(t: ^testing.T) { - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") - defer db_close(&d) + defer db_close(&db) - results, list_ok := db_list(&d) + results, list_ok := db_list(&db) testing.expect(t, list_ok, "list should succeed on empty db") testing.expect(t, len(results) == 0, "should have 0 rows") } @(test) test_db_insert_sets_changed :: proc(t: ^testing.T) { - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") if !ok do return - defer db_close(&d) + defer db_close(&db) - testing.expect(t, !d.changed, "changed should start false") + testing.expect(t, !db.changed, "changed should start false") f := make_test_env_file("/project/.env", "sha", "KEY=val") defer delete(f.Remotes) - db_insert(&d, f) + db_insert(&db, f) - testing.expect(t, d.changed, "changed should be true after insert") + testing.expect(t, db.changed, "changed should be true after insert") } @(test) test_db_delete_sets_changed :: proc(t: ^testing.T) { - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") if !ok do return - defer db_close(&d) + defer db_close(&db) f := make_test_env_file("/project/.env", "sha", "KEY=val") defer delete(f.Remotes) - db_insert(&d, f) - d.changed = false + db_insert(&db, f) + db.changed = false - db_delete(&d, "/project/.env") - testing.expect(t, d.changed, "changed should be true after delete") + db_delete(&db, "/project/.env") + testing.expect(t, db.changed, "changed should be true after delete") } @(test) test_db_serialize :: proc(t: ^testing.T) { - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") if !ok do return - defer db_close(&d) + defer db_close(&db) f := make_test_env_file("/project/.env", "sha", "KEY=val") defer delete(f.Remotes) - db_insert(&d, f) + db_insert(&db, f) sz: i64 - data := sqlite.serialize(d.conn, "main", &sz, 0) + data := sqlite.serialize(db.conn, "main", &sz, 0) testing.expect(t, data != nil, "serialize should return non-nil") if data == nil do return defer sqlite.free(data) @@ -439,15 +439,15 @@ test_db_sync_noop :: proc(t: ^testing.T) { hex_bytes, _ := hex.encode(digest, context.temp_allocator) sha := string(hex_bytes) - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") - defer db_close(&d) + defer db_close(&db) f := make_test_env_file(env_path, sha, content) f.Dir = base - db_insert(&d, f) + db_insert(&db, f) - result, sync_err := db_sync(&d, &f) + result, sync_err := db_sync(&db, &f) testing.expect(t, sync_err == .None, "sync should not error") testing.expect(t, result == {}, "should be noop") } @@ -463,15 +463,15 @@ test_db_sync_backed_up :: proc(t: ^testing.T) { write_err := os.write_entire_file(env_path, transmute([]u8)changed_content) testing.expect(t, write_err == nil, "should write .env file") - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") - defer db_close(&d) + defer db_close(&db) f := make_test_env_file(env_path, "old_sha", "KEY=original") f.Dir = base - db_insert(&d, f) + db_insert(&db, f) - result, sync_err := db_sync(&d, &f) + result, sync_err := db_sync(&db, &f) testing.expect(t, sync_err == .None, "sync should not error") testing.expect(t, .BackedUp in result, "should be backed up") } @@ -484,16 +484,16 @@ test_db_sync_restored :: proc(t: ^testing.T) { env_path := fmt.tprintf("%s/.env", base) - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") - defer db_close(&d) + defer db_close(&db) f := make_test_env_file(env_path, "some_sha", "SECRET=value") f.Dir = base defer delete(f.Remotes) - db_insert(&d, f) + db_insert(&db, f) - result, err := db_sync(&d, &f) + result, err := db_sync(&db, &f) testing.expect(t, err == .None, "sync should not error") testing.expect(t, .Restored in result, "should be restored") @@ -506,14 +506,14 @@ test_db_sync_restored :: proc(t: ^testing.T) { @(test) test_db_sync_dir_missing :: proc(t: ^testing.T) { - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") - defer db_close(&d) + defer db_close(&db) f := make_test_env_file("/nonexistent/path/.env", "sha", "KEY=val") - db_insert(&d, f) + db_insert(&db, f) - result, err := db_sync(&d, &f) + result, err := db_sync(&db, &f) testing.expect_value(t, err, SyncError.DirMissing) testing.expect_value(t, result, nil) } @@ -533,12 +533,12 @@ test_db_sync_moved :: proc(t: ^testing.T) { write_err := os.write_entire_file(config_path, transmute([]u8)config_content) testing.expect(t, write_err == nil, "should write .git/config") - d, ok := db_init() + db, ok := db_init() testing.expect(t, ok, "failed to create test db") - defer db_close(&d) + defer db_close(&db) - d.cfg.ScanConfig.Include = make([dynamic]string, 0, 1, context.temp_allocator) - append(&d.cfg.ScanConfig.Include, search_root) + db.cfg.ScanConfig.Include = make([dynamic]string, 0, 1, context.temp_allocator) + append(&db.cfg.ScanConfig.Include, search_root) f := make_test_env_file( "/old/nonexistent/path/.env", @@ -546,9 +546,9 @@ test_db_sync_moved :: proc(t: ^testing.T) { "SECRET=value", []string{"git@github.com:user/repo.git"}, ) - testing.expect(t, db_insert(&d, f), "insert should succeed") + testing.expect(t, db_insert(&db, f), "insert should succeed") - result, err := db_sync(&d, &f) + result, err := db_sync(&db, &f) testing.expect(t, err == .None, "sync should not error") if err != .None do return testing.expect(t, .DirUpdated in result, "should have DirUpdated flag") @@ -558,10 +558,10 @@ test_db_sync_moved :: proc(t: ^testing.T) { testing.expect_value(t, f.Path, expected_path) testing.expect_value(t, f.Dir, repo_dir) - _, old_exists := db_fetch(&d, "/old/nonexistent/path/.env") + _, old_exists := db_fetch(&db, "/old/nonexistent/path/.env") testing.expect(t, !old_exists, "old path should be deleted from db") - new_fetched, new_ok := db_fetch(&d, expected_path) + new_fetched, new_ok := db_fetch(&db, expected_path) testing.expect(t, new_ok, "new path should exist in db") if new_ok { testing.expect_value(t, new_fetched.contents, "SECRET=value")