orca/internal/cli/namespace_test.go

package cli

import (
	"bytes"
	"encoding/json"
	"os"
	"path/filepath"
	"testing"

	"git.cloudinit.dev/coreci/orca/internal/certpaths"
)

func resetRootFlags(t *testing.T) {
	t.Helper()
	rootCmd.SetArgs(nil)
	var buf bytes.Buffer
	rootCmd.SetOut(&buf)
	rootCmd.SetErr(&buf)
	_ = rootCmd.PersistentFlags().Set("system", "false")
	_ = rootCmd.PersistentFlags().Set("json", "false")
}

func TestNamespaceDefaultsToUserHome(t *testing.T) {
	t.Setenv("ORCA_HOME", "")
	home, err := os.UserHomeDir()
	if err != nil {
		t.Fatalf("UserHomeDir: %v", err)
	}
	want := filepath.Join(home, ".orca")
	if got := certpaths.Dir(); got != want {
		t.Errorf("certpaths.Dir() = %q, want %q", got, want)
	}
}

func TestNamespaceHonorsORCAHOME(t *testing.T) {
	tmp := t.TempDir()
	t.Setenv("ORCA_HOME", tmp)
	if got := certpaths.Dir(); got != tmp {
		t.Errorf("certpaths.Dir() = %q, want %q", got, tmp)
	}
	if got := certpaths.DBPath(); got != filepath.Join(tmp, "orca.db") {
		t.Errorf("certpaths.DBPath() = %q, want %q", got, filepath.Join(tmp, "orca.db"))
	}
}

func TestInitHonorsORCAHOME(t *testing.T) {
	tmp := t.TempDir()
	t.Setenv("ORCA_HOME", tmp)
	resetRootFlags(t)

	rootCmd.SetArgs([]string{"init"})
	if err := rootCmd.Execute(); err != nil {
		t.Fatalf("init: %v", err)
	}

	info, err := os.Stat(tmp)
	if err != nil {
		t.Fatalf("stat %s: %v", tmp, err)
	}
	if !info.IsDir() {
		t.Errorf("%s is not a directory", tmp)
	}
}

func TestSystemFlagSetsORCAHOME(t *testing.T) {
	t.Setenv("ORCA_HOME", "")
	resetRootFlags(t)

	rootCmd.SetArgs([]string{"--system", "init"})
	if err := rootCmd.Execute(); err != nil {
		t.Fatalf("--system init: %v", err)
	}
	if got := os.Getenv("ORCA_HOME"); got != systemNamespaceRoot {
		t.Errorf("ORCA_HOME = %q, want %q", got, systemNamespaceRoot)
	}
}

func TestSystemFlagConflictsWithORCAHOME(t *testing.T) {
	t.Setenv("ORCA_HOME", "/custom/path")
	resetRootFlags(t)

	rootCmd.SetArgs([]string{"--system", "init"})
	err := rootCmd.Execute()
	if err == nil {
		t.Fatal("expected error for --system + ORCA_HOME conflict, got nil")
	}
}

func TestInitJSONOutput(t *testing.T) {
	tmp := t.TempDir()
	t.Setenv("ORCA_HOME", tmp)
	resetRootFlags(t)

	var buf bytes.Buffer
	rootCmd.SetOut(&buf)
	rootCmd.SetArgs([]string{"init", "--json"})
	if err := rootCmd.Execute(); err != nil {
		t.Fatalf("init --json: %v", err)
	}

	// v0.6: init --json now outputs a full bootstrap summary object.
	var result map[string]any
	if err := json.Unmarshal(bytes.TrimSpace(buf.Bytes()), &result); err != nil {
		t.Fatalf("unmarshal init output: %v\noutput: %s", err, buf.String())
	}
	if result["namespace"] != tmp {
		t.Errorf("init --json namespace = %q, want %q", result["namespace"], tmp)
	}
	if result["os"] == nil || result["os"] == "" {
		t.Errorf("init --json os is missing/empty")
	}
	if result["node_id"] == nil || result["node_id"] == "" {
		t.Errorf("init --json node_id is missing/empty")
	}
	steps, ok := result["steps"].([]any)
	if !ok || len(steps) < 6 {
		t.Errorf("init --json steps: expected 6+ entries, got %v", result["steps"])
	}
}

func TestSystemFlagIsPersistent(t *testing.T) {
	for _, name := range []string{"system", "json"} {
		f := rootCmd.PersistentFlags().Lookup(name)
		if f == nil {
			t.Errorf("persistent flag %q not found", name)
		}
	}
}