store_test.go

package gitstore

import (
	"context"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"github.com/codeGROOVE-dev/gitMDM/internal/gitmdm"
)

func TestSanitizeID(t *testing.T) {
	tests := []struct {
		input    string
		expected string
	}{
		{"normal-id", "normal-id"},
		{"../../../etc/passwd", "etc-passwd"},
		{"id/with/slashes", "id-with-slashes"},
		{"id\\with\\backslashes", "id-with-backslashes"},
		{"id:with:colons", "id-with-colons"},
		{"id with spaces", "id-with-spaces"},
		{"id<with>special*chars?", "id-with-special-chars"},
		{"", "id-e3b0c44298fc1c14"},                          // hash of empty string
		{"..", "id-5ec1f7e700f37c3d"},                        // hash of ".."
		{"./", "id-c14cecec97312ad1"},                        // hash of "./"
		{strings.Repeat("a", 300), strings.Repeat("a", 100)}, // max length is now 100
	}

	for _, tt := range tests {
		t.Run(tt.input, func(t *testing.T) {
			result := sanitizeID(tt.input)
			if result != tt.expected {
				t.Errorf("sanitizeID(%q) = %q, want %q", tt.input, result, tt.expected)
			}
		})
	}
}

func TestNewStore(t *testing.T) {
	ctx := context.Background()
	tempDir := t.TempDir()
	localPath := filepath.Join(tempDir, "test-repo")

	// Initialize git repo first
	if err := os.MkdirAll(localPath, 0o755); err != nil {
		t.Fatalf("Failed to create directory: %v", err)
	}
	cmd := exec.Command("git", "init")
	cmd.Dir = localPath
	if err := cmd.Run(); err != nil {
		t.Fatalf("Failed to init git repo: %v", err)
	}

	// Test local repository creation
	store, err := NewLocal(ctx, localPath)
	if err != nil {
		t.Fatalf("Failed to create local store: %v", err)
	}
	if store == nil {
		t.Fatal("Store is nil")
	}

	// Verify repository was initialized
	gitDir := filepath.Join(localPath, ".git")
	if _, err := os.Stat(gitDir); os.IsNotExist(err) {
		t.Error("Git repository was not initialized")
	}

	// Verify devices directory was created
	devicesDir := filepath.Join(localPath, "devices")
	if _, err := os.Stat(devicesDir); os.IsNotExist(err) {
		t.Error("Devices directory was not created")
	}
}

func TestSaveAndLoadDevice(t *testing.T) {
	ctx := context.Background()
	tempDir := t.TempDir()
	localPath := filepath.Join(tempDir, "test-repo")

	// Initialize git repo first
	if err := os.MkdirAll(localPath, 0o755); err != nil {
		t.Fatalf("Failed to create directory: %v", err)
	}
	cmd := exec.Command("git", "init")
	cmd.Dir = localPath
	if err := cmd.Run(); err != nil {
		t.Fatalf("Failed to init git repo: %v", err)
	}

	store, err := NewLocal(ctx, localPath)
	if err != nil {
		t.Fatalf("Failed to create store: %v", err)
	}

	// Create test device
	device := &gitmdm.Device{
		HardwareID: "test-device-123",
		Hostname:   "test-host",
		User:       "test-user",
		LastSeen:   time.Now(),
		Checks: map[string]gitmdm.Check{
			"hostname": {
				Outputs: []gitmdm.CommandOutput{
					{
						Command:  "hostname",
						Stdout:   "test-host.local",
						Stderr:   "",
						ExitCode: 0,
					},
				},
				Status: "n/a",
				Reason: "Informational",
			},
			"uname": {
				Outputs: []gitmdm.CommandOutput{
					{
						Command:  "uname -a",
						Stdout:   "Linux test-host 5.10.0",
						Stderr:   "",
						ExitCode: 0,
					},
				},
				Status: "n/a",
				Reason: "Informational",
			},
		},
	}

	// Save device
	if err := store.SaveDevice(ctx, device); err != nil {
		t.Fatalf("Failed to save device: %v", err)
	}

	// Load devices
	devices, err := store.LoadDevices(ctx)
	if err != nil {
		t.Fatalf("Failed to list devices: %v", err)
	}

	if len(devices) != 1 {
		t.Fatalf("Expected 1 device, got %d", len(devices))
	}

	// Verify loaded device
	loaded := devices[0]
	if loaded.HardwareID != device.HardwareID {
		t.Errorf("HardwareID mismatch: got %s, want %s", loaded.HardwareID, device.HardwareID)
	}
	if loaded.Hostname != device.Hostname {
		t.Errorf("Hostname mismatch: got %s, want %s", loaded.Hostname, device.Hostname)
	}
	if loaded.User != device.User {
		t.Errorf("User mismatch: got %s, want %s", loaded.User, device.User)
	}
	if len(loaded.Checks) != len(device.Checks) {
		t.Errorf("Checks count mismatch: got %d, want %d", len(loaded.Checks), len(device.Checks))
	}

	// Verify checks content
	for name, check := range device.Checks {
		loadedCheck, exists := loaded.Checks[name]
		if !exists {
			t.Errorf("Check %s not found in loaded device", name)
			continue
		}
		if len(loadedCheck.Outputs) != len(check.Outputs) {
			t.Errorf("Check %s outputs count mismatch: got %d, want %d", name, len(loadedCheck.Outputs), len(check.Outputs))
			continue
		}
		for i, output := range check.Outputs {
			if i >= len(loadedCheck.Outputs) {
				break
			}
			loadedOutput := loadedCheck.Outputs[i]
			if loadedOutput.Command != output.Command {
				t.Errorf("Check %s output %d command mismatch: got %s, want %s", name, i, loadedOutput.Command, output.Command)
			}
			if loadedOutput.Stdout != output.Stdout {
				t.Errorf("Check %s output %d stdout mismatch: got %s, want %s", name, i, loadedOutput.Stdout, output.Stdout)
			}
			if loadedOutput.ExitCode != output.ExitCode {
				t.Errorf("Check %s output %d exit code mismatch: got %d, want %d", name, i, loadedOutput.ExitCode, output.ExitCode)
			}
		}
	}
}

func TestPathTraversalPrevention(t *testing.T) {
	ctx := context.Background()
	tempDir := t.TempDir()
	localPath := filepath.Join(tempDir, "test-repo")

	// Initialize git repo first
	if err := os.MkdirAll(localPath, 0o755); err != nil {
		t.Fatalf("Failed to create directory: %v", err)
	}
	cmd := exec.Command("git", "init")
	cmd.Dir = localPath
	if err := cmd.Run(); err != nil {
		t.Fatalf("Failed to init git repo: %v", err)
	}

	store, err := NewLocal(ctx, localPath)
	if err != nil {
		t.Fatalf("Failed to create store: %v", err)
	}

	// Try to save device with path traversal attempt
	device := &gitmdm.Device{
		HardwareID: "../../../etc/passwd",
		Hostname:   "evil-host",
		User:       "evil-user",
		LastSeen:   time.Now(),
		Checks: map[string]gitmdm.Check{
			"../../../evil": {
				Outputs: []gitmdm.CommandOutput{
					{
						Command:  "evil command",
						Stdout:   "evil output",
						Stderr:   "",
						ExitCode: 0,
					},
				},
				Status: "fail",
				Reason: "Evil detected",
			},
		},
	}

	// This should succeed but sanitize the paths
	if err := store.SaveDevice(ctx, device); err != nil {
		t.Fatalf("Failed to save device: %v", err)
	}

	// Verify the file was saved in the correct location (sanitized)
	expectedDir := filepath.Join(localPath, "devices", "etc-passwd")
	if _, err := os.Stat(expectedDir); os.IsNotExist(err) {
		t.Error("Device directory was not created in expected location")
	}

	// Verify no files were created outside the repo
	etcPasswd := "/etc/passwd.md"
	if _, err := os.Stat(etcPasswd); err == nil {
		t.Fatal("Path traversal was not prevented!")
	}
}

func TestConcurrentSaves(t *testing.T) {
	ctx := context.Background()
	tempDir := t.TempDir()
	localPath := filepath.Join(tempDir, "test-repo")

	// Initialize git repo first
	if err := os.MkdirAll(localPath, 0o755); err != nil {
		t.Fatalf("Failed to create directory: %v", err)
	}
	cmd := exec.Command("git", "init")
	cmd.Dir = localPath
	if err := cmd.Run(); err != nil {
		t.Fatalf("Failed to init git repo: %v", err)
	}

	store, err := NewLocal(ctx, localPath)
	if err != nil {
		t.Fatalf("Failed to create store: %v", err)
	}

	// Run concurrent saves
	done := make(chan bool, 10)
	for i := range 10 {
		go func(id int) {
			device := &gitmdm.Device{
				HardwareID: fmt.Sprintf("device-%d", id),
				Hostname:   fmt.Sprintf("host-%d", id),
				User:       "test-user",
				LastSeen:   time.Now(),
				Checks:     map[string]gitmdm.Check{},
			}
			if err := store.SaveDevice(ctx, device); err != nil {
				t.Errorf("Failed to save device %d: %v", id, err)
			}
			done <- true
		}(i)
	}

	// Wait for all saves to complete
	for range 10 {
		<-done
	}

	// Verify all devices were saved
	devices, err := store.LoadDevices(ctx)
	if err != nil {
		t.Fatalf("Failed to list devices: %v", err)
	}

	if len(devices) != 10 {
		t.Errorf("Expected 10 devices, got %d", len(devices))
	}
}