ConfigKit/examples/consumers/diff_test.go

package consumers_test

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"testing"

	configkit "gitea.maximumdirect.net/eric/ConfigKit"
	"gitea.maximumdirect.net/eric/ConfigKit/examples/consumers"
)

func ExampleCompareFiles() {
	directory, err := os.MkdirTemp("", "configkit-diff-files-")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(directory)
	leftPath := filepath.Join(directory, "before.yml")
	rightPath := filepath.Join(directory, "after.yml")
	if err := os.WriteFile(leftPath, []byte("name: before\nentries: {}\n"), 0o600); err != nil {
		fmt.Println(err)
		return
	}
	if err := os.WriteFile(rightPath, []byte("name: after\nentries:\n  added: null\n"), 0o600); err != nil {
		fmt.Println(err)
		return
	}
	output, err := consumers.CompareFiles(leftPath, rightPath)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Print(output)
	// Output:
	// /entries/added: left=<absent> right="null\n"
	// /name: left="before\n" right="after\n"
}

func ExampleCompareRolloutOverlay() {
	const baseToken = "CONFIGKIT_DIFF_EXAMPLE_BASE_TOKEN"
	const overlayToken = "CONFIGKIT_DIFF_EXAMPLE_OVERLAY_TOKEN"
	defer preserveEnvironment(baseToken)()
	defer preserveEnvironment(overlayToken)()
	_ = os.Setenv(baseToken, "disposable-example-base-credential")
	_ = os.Setenv(overlayToken, "disposable-example-overlay-credential")

	directory, err := os.MkdirTemp("", "configkit-diff-overlay-")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(directory)
	basePath := filepath.Join(directory, "config.yml")
	overlayPath := filepath.Join(directory, "overlays", "canary.yml")
	if err := os.MkdirAll(filepath.Dir(overlayPath), 0o700); err != nil {
		fmt.Println(err)
		return
	}
	base := "service:\n  endpoint:\n    host: base.example\n    port: 8443\n  credential:\n    token: " + baseToken + "\n"
	overlay := "service:\n  endpoint:\n    host: canary.example\n  credential:\n    token: " + overlayToken + "\n"
	if err := os.WriteFile(basePath, []byte(base), 0o600); err != nil {
		fmt.Println(err)
		return
	}
	if err := os.WriteFile(overlayPath, []byte(overlay), 0o600); err != nil {
		fmt.Println(err)
		return
	}
	output, err := consumers.CompareRolloutOverlay(basePath, "canary")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Print(output)
	// Output:
	// /service/credential/token: left="'[REDACTED]'\n" right="'[REDACTED]'\n" hidden-change
	// /service/endpoint/host: left="base.example\n" right="canary.example\n"
	// /service/endpoint/url: left="https://base.example:8443\n" right="https://canary.example:8443\n"
}

func TestCompareFilesUsesCallerSelectedSourcesAndSafePresence(t *testing.T) {
	directory := t.TempDir()
	leftPath := filepath.Join(directory, "before.yml")
	rightPath := filepath.Join(directory, "after.yml")
	writeConfiguration(t, leftPath, "name: before\nentries: {}\n")
	writeConfiguration(t, rightPath, "name: after\nentries:\n  added: null\n")

	output, err := consumers.CompareFiles(leftPath, rightPath)
	if err != nil {
		t.Fatal(err)
	}
	want := "/entries/added: left=<absent> right=\"null\\n\"\n" +
		"/name: left=\"before\\n\" right=\"after\\n\"\n"
	if output != want {
		t.Fatalf("comparison output = %q, want %q", output, want)
	}
	if again, err := consumers.CompareFiles(leftPath, rightPath); err != nil || again != output {
		t.Fatalf("repeat output = %q, %v", again, err)
	}
}

func TestCompareFilesReturnsEachLoadError(t *testing.T) {
	directory := t.TempDir()
	leftPath := filepath.Join(directory, "before.yml")
	rightPath := filepath.Join(directory, "after.yml")
	writeConfiguration(t, leftPath, "name: before\n")
	writeConfiguration(t, rightPath, "unknown: invalid\n")

	output, err := consumers.CompareFiles(leftPath, rightPath)
	if err == nil || output != "" || !strings.Contains(err.Error(), "load right configuration") {
		t.Fatalf("right load failure = %q, %v", output, err)
	}
	if _, err := consumers.CompareFiles(filepath.Join(directory, "missing.yml"), rightPath); err == nil || !strings.Contains(err.Error(), "load left configuration") {
		t.Fatalf("left load failure = %v", err)
	}
}

func TestCompareRolloutOverlayShowsResolvedSafeChangesAndRetainsSiblings(t *testing.T) {
	t.Setenv("CONFIGKIT_DIFF_BASE_TOKEN", "disposable-base-credential")
	t.Setenv("CONFIGKIT_DIFF_OVERLAY_TOKEN", "disposable-overlay-credential")
	directory := t.TempDir()
	basePath := filepath.Join(directory, "config.yml")
	overlayPath := filepath.Join(directory, "overlays", "canary.yml")
	if err := os.MkdirAll(filepath.Dir(overlayPath), 0o700); err != nil {
		t.Fatal(err)
	}
	writeConfiguration(t, basePath, "service:\n  endpoint:\n    host: base.example\n    port: 8443\n  credential:\n    token: CONFIGKIT_DIFF_BASE_TOKEN\n")
	writeConfiguration(t, overlayPath, "service:\n  endpoint:\n    host: canary.example\n  credential:\n    token: CONFIGKIT_DIFF_OVERLAY_TOKEN\n")

	base, err := consumers.LoadRollout(basePath, "")
	if err != nil {
		t.Fatal(err)
	}
	withOverlay, err := consumers.LoadRollout(basePath, "canary")
	if err != nil {
		t.Fatal(err)
	}
	if base.Config.Service.Endpoint.Port != 8443 || withOverlay.Config.Service.Endpoint.Port != 8443 {
		t.Fatalf("lower-priority port was not retained: base=%#v overlay=%#v", base.Config.Service.Endpoint, withOverlay.Config.Service.Endpoint)
	}
	urlInfo, found := withOverlay.Metadata().Lookup(configkit.Keys("service", "endpoint", "url"))
	if !found || urlInfo.Origin.Layer != configkit.LayerResolution || withOverlay.Config.Service.Endpoint.URL != "https://canary.example:8443" {
		t.Fatalf("resolved endpoint = %#v, metadata=%#v, %v", withOverlay.Config.Service.Endpoint, urlInfo, found)
	}

	differences, err := configkit.Diff(base, withOverlay)
	if err != nil {
		t.Fatal(err)
	}
	if len(differences) != 3 {
		t.Fatalf("differences = %#v", differences)
	}
	wantPaths := []string{"/service/credential/token", "/service/endpoint/host", "/service/endpoint/url"}
	for index, difference := range differences {
		if got := difference.Path.String(); got != wantPaths[index] {
			t.Errorf("path[%d] = %q, want %q", index, got, wantPaths[index])
		}
	}
	secret := differences[0]
	if !secret.Left.Redacted || !secret.Right.Redacted || !secret.HiddenChanged || secret.Left.YAML != "'[REDACTED]'\n" || secret.Right.YAML != "'[REDACTED]'\n" {
		t.Fatalf("classified credential difference = %#v", secret)
	}
	if strings.Contains(consumers.FormatDifferences(differences), "disposable-") {
		t.Fatal("formatted differences exposed credential contents")
	}

	output, err := consumers.CompareRolloutOverlay(basePath, "canary")
	if err != nil || output != consumers.FormatDifferences(differences) {
		t.Fatalf("formatted base/overlay comparison = %q, %v", output, err)
	}
}

func TestFormatDifferencesUsesRecordMembershipForNoChange(t *testing.T) {
	if got := consumers.FormatDifferences(nil); got != "No effective changes.\n" {
		t.Fatalf("no-change output = %q", got)
	}
}

func writeConfiguration(t *testing.T, filename, contents string) {
	t.Helper()
	if err := os.WriteFile(filename, []byte(contents), 0o600); err != nil {
		t.Fatal(err)
	}
}