test: Added tests.

cli_test.odin

@@ -1,3 +1,5 @@
+#+feature dynamic-literals
+package main
 
 import "core:fmt"
 import "core:strings"
@@ -140,3 +142,50 @@ test_command_help_version :: proc(t: ^testing.T) {
 }
 
 @(test)
+test_has_flag_bool_set :: proc(t: ^testing.T) {
+	cmd := Command {
+		name = "test",
+		bool_set = map[string]bool{"force" = true},
+	}
+	defer delete(cmd.bool_set)
+
+	testing.expect(t, has_flag(&cmd, "force"), "should find flag in bool_set")
+	testing.expect(t, !has_flag(&cmd, "verbose"), "should not find missing flag")
+}
+
+@(test)
+test_has_flag_value_map :: proc(t: ^testing.T) {
+	cmd := Command {
+		name = "test",
+		flags = map[string]string{"output" = "/tmp/out"},
+	}
+	defer delete(cmd.flags)
+
+	testing.expect(t, has_flag(&cmd, "output"), "should find flag in flags map")
+	testing.expect(t, !has_flag(&cmd, "force"), "should not find missing flag")
+}
+
+@(test)
+test_has_flag_both_maps :: proc(t: ^testing.T) {
+	cmd := Command {
+		name = "test",
+		flags = map[string]string{"output" = "/tmp/out"},
+		bool_set = map[string]bool{"force" = true},
+	}
+	defer delete(cmd.flags)
+	defer delete(cmd.bool_set)
+
+	testing.expect(t, has_flag(&cmd, "output"), "should find in flags")
+	testing.expect(t, has_flag(&cmd, "force"), "should find in bool_set")
+	testing.expect(t, !has_flag(&cmd, "verbose"), "should not find missing flag")
+}
+
+@(test)
+test_has_flag_empty_command :: proc(t: ^testing.T) {
+	cmd := Command {
+		name = "test",
+	}
+	testing.expect(t, !has_flag(&cmd, "anything"), "empty command should have no flags")
+}
+
+

config.odin

@@ -13,17 +13,17 @@ SshKeyPair :: struct {
 
 ScanConfig :: struct {
 	Matcher: string `json:"matcher"`,
-	Exclude: []string `json:"exclude"`,
+	Exclude: [dynamic]string `json:"exclude"`,
-	Include: []string `json:"include"`,
+	Include: [dynamic]string `json:"include"`,
 }
 
 Config :: struct {
-	Keys:       []SshKeyPair `json:"keys"`,
+	Keys:       [dynamic]SshKeyPair `json:"keys"`,
 	ScanConfig: ScanConfig `json:"scan"`,
 }
 
 load_config :: proc() -> (Config, bool) {
-	home, home_err := os.user_home_dir(context.allocator)
+	home, home_err := os.user_home_dir(context.temp_allocator)
 	if home_err != nil {
 		fmt.printf("Error getting home dir: %v\n", home_err)
 		return Config{}, false
@@ -49,6 +49,12 @@ load_config :: proc() -> (Config, bool) {
 	return cfg, true
 }
 
+delete_config :: proc(cfg: Config) {
+	delete(cfg.Keys)
+	delete(cfg.ScanConfig.Exclude)
+	delete(cfg.ScanConfig.Include)
+}
+
 envr_dir :: proc() -> string {
 	home, _ := os.user_home_dir(context.allocator)
 	dir, _ := filepath.join([]string{home, ".envr"})
@@ -107,7 +113,8 @@ find_ssh_private_keys :: proc() -> (keys: [dynamic]string, ok: bool) {
 new_config :: proc(private_key_paths: []string) -> Config {
 	keys := make([dynamic]SshKeyPair, 0, len(private_key_paths))
 	for priv in private_key_paths {
-		pub, _ := strings.concatenate([]string{priv, ".pub"})
+		// TODO: Is this bad?
+		pub, _ := strings.concatenate([]string{priv, ".pub"}, context.temp_allocator)
 		append(&keys, SshKeyPair{Private = priv, Public = pub})
 	}
 
@@ -122,11 +129,11 @@ new_config :: proc(private_key_paths: []string) -> Config {
 
 	scan_cfg := ScanConfig {
 		Matcher = "\\.env",
-		Exclude = exclude[:],
+		Exclude = exclude,
-		Include = include[:],
+		Include = include,
 	}
 
-	return Config{Keys = keys[:], ScanConfig = scan_cfg}
+	return Config{Keys = keys, ScanConfig = scan_cfg}
 }
 
 save_config :: proc(cfg: Config, force: bool = false) -> bool {

config_test.odin

@@ -0,0 +1,63 @@
+package main
+
+import "core:testing"
+
+@(test)
+test_new_config_single_key :: proc(t: ^testing.T) {
+	paths := []string{"/home/user/.ssh/id_ed25519"}
+	cfg := new_config(paths)
+	defer delete_config(cfg)
+
+	testing.expect(t, len(cfg.Keys) == 1, "should have 1 key")
+	testing.expect(t, cfg.Keys[0].Private == "/home/user/.ssh/id_ed25519", "Private path mismatch")
+	testing.expect(
+		t,
+		cfg.Keys[0].Public == "/home/user/.ssh/id_ed25519.pub",
+		"Public path mismatch",
+	)
+}
+
+@(test)
+test_new_config_multiple_keys :: proc(t: ^testing.T) {
+	paths := []string{"/home/user/.ssh/id_ed25519", "/home/user/.ssh/id_rsa"}
+	cfg := new_config(paths)
+	defer delete_config(cfg)
+
+	testing.expect(t, len(cfg.Keys) == 2, "should have 2 keys")
+	testing.expect(t, cfg.Keys[0].Private == "/home/user/.ssh/id_ed25519")
+	testing.expect(t, cfg.Keys[1].Private == "/home/user/.ssh/id_rsa")
+}
+
+@(test)
+test_new_config_empty_keys :: proc(t: ^testing.T) {
+	paths: []string
+	cfg := new_config(paths)
+	defer delete_config(cfg)
+
+	testing.expect(t, len(cfg.Keys) == 0, "should have 0 keys")
+}
+
+@(test)
+test_new_config_scan_defaults :: proc(t: ^testing.T) {
+	paths := []string{"/home/user/.ssh/id_ed25519"}
+	cfg := new_config(paths)
+	defer delete_config(cfg)
+
+	testing.expect(t, cfg.ScanConfig.Matcher == "\\.env", "matcher should be \\.env")
+	testing.expect(t, len(cfg.ScanConfig.Exclude) == 4, "should have 4 exclude patterns")
+	testing.expect(t, len(cfg.ScanConfig.Include) == 1, "should have 1 include path")
+	testing.expect(t, cfg.ScanConfig.Include[0] == "~", "include should be ~")
+}
+
+@(test)
+test_new_config_exclude_patterns :: proc(t: ^testing.T) {
+	paths := []string{"/home/user/.ssh/id_ed25519"}
+	cfg := new_config(paths)
+	defer delete_config(cfg)
+
+	expected := []string{"*\\.envrc", "\\.local/", "node_modules", "vendor"}
+	for i in 0 ..< len(expected) {
+		testing.expect(t, cfg.ScanConfig.Exclude[i] == expected[i])
+	}
+}
+

db_test.odin

@@ -0,0 +1,90 @@
+package main
+
+import "core:testing"
+
+@(test)
+test_db_update_required_noop :: proc(t: ^testing.T) {
+	testing.expect(t, !db_update_required(.Noop), "Noop should not require update")
+}
+
+@(test)
+test_db_update_required_backed_up :: proc(t: ^testing.T) {
+	testing.expect(t, db_update_required(.BackedUp), "BackedUp should require update")
+}
+
+@(test)
+test_db_update_required_dir_updated :: proc(t: ^testing.T) {
+	testing.expect(t, db_update_required(.DirUpdated), "DirUpdated should require update")
+}
+
+@(test)
+test_db_update_required_restored :: proc(t: ^testing.T) {
+	testing.expect(t, !db_update_required(.Restored), "Restored alone should not require update")
+}
+
+@(test)
+test_db_update_required_error :: proc(t: ^testing.T) {
+	testing.expect(t, !db_update_required(.Error), "Error alone should not require update")
+}
+
+@(test)
+test_db_update_required_combined :: proc(t: ^testing.T) {
+	s := i32(SyncResult.DirUpdated) | i32(SyncResult.Restored)
+	combined := SyncResult(s)
+	testing.expect(t, db_update_required(combined), "DirUpdated|Restored should require update")
+}
+
+@(test)
+test_shares_remote_overlap :: proc(t: ^testing.T) {
+	f := EnvFile {
+		Remotes = make([dynamic]string, 2, context.temp_allocator),
+	}
+	append(&f.Remotes, "git@github.com:user/repo.git")
+	append(&f.Remotes, "git@gitlab.com:user/repo.git")
+
+	remotes := []string{"git@github.com:user/repo.git"}
+	testing.expect(t, shares_remote(&f, remotes), "should share remote")
+}
+
+@(test)
+test_shares_remote_no_overlap :: proc(t: ^testing.T) {
+	f := EnvFile {
+		Remotes = make([dynamic]string, 1, context.temp_allocator),
+	}
+	append(&f.Remotes, "git@github.com:user/repo.git")
+
+	remotes := []string{"git@github.com:other/repo.git"}
+	testing.expect(t, !shares_remote(&f, remotes), "should not share remote")
+}
+
+@(test)
+test_shares_remote_empty_file_remotes :: proc(t: ^testing.T) {
+	f := EnvFile {
+		Remotes = make([dynamic]string, 0, context.temp_allocator),
+	}
+
+	remotes := []string{"git@github.com:user/repo.git"}
+	testing.expect(t, !shares_remote(&f, remotes), "empty file remotes should not share")
+}
+
+@(test)
+test_shares_remote_empty_check_remotes :: proc(t: ^testing.T) {
+	f := EnvFile {
+		Remotes = make([dynamic]string, 1, context.temp_allocator),
+	}
+	append(&f.Remotes, "git@github.com:user/repo.git")
+
+	remotes: []string
+	testing.expect(t, !shares_remote(&f, remotes), "empty check remotes should not share")
+}
+
+@(test)
+test_shares_remote_both_empty :: proc(t: ^testing.T) {
+	f := EnvFile {
+		Remotes = make([dynamic]string, 0),
+	}
+
+	remotes: []string
+	testing.expect(t, !shares_remote(&f, remotes), "both empty should not share")
+}
+

scan_test.odin

@@ -37,7 +37,7 @@ test_scan_path_finds_gitignored_env_files :: proc(t: ^testing.T) {
 	_ = os.write_entire_file(fmt.tprintf("%s/config.yaml", base), "key: value")
 
 	cfg := Config {
-		ScanConfig = ScanConfig{Matcher = "\\.env", Exclude = []string{}, Include = []string{}},
+		ScanConfig = ScanConfig{Matcher = "\\.env"},
 	}
 
 	results, ok := scan_path(base, cfg)
@@ -76,7 +76,7 @@ test_scan_path_empty_dir :: proc(t: ^testing.T) {
 	defer os.remove_all(base)
 
 	cfg := Config {
-		ScanConfig = ScanConfig{Matcher = "\\.env", Exclude = []string{}, Include = []string{}},
+		ScanConfig = ScanConfig{Matcher = "\\.env"},
 	}
 
 	results, ok := scan_path(base, cfg)