validator_test.go

package main

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

func TestValidate_TargetExistenceAndType(t *testing.T) {
	tempDir := t.TempDir()

	fileTarget := filepath.Join(tempDir, "testfile.txt")
	err := os.WriteFile(fileTarget, []byte("test"), 0644)
	if err != nil {
		t.Fatalf("failed to create test file: %v", err)
	}

	dirTarget := filepath.Join(tempDir, "testdir")
	err = os.Mkdir(dirTarget, 0755)
	if err != nil {
		t.Fatalf("failed to create test dir: %v", err)
	}

	missingTarget := filepath.Join(tempDir, "missing.txt")

	tests := []struct {
		name    string
		cmd     *ParsedCommand
		wantErr bool
		errText string
	}{
		{
			name: "Valid file",
			cmd: &ParsedCommand{
				Target: fileTarget,
			},
			wantErr: false,
		},
		{
			name: "Valid directory",
			cmd: &ParsedCommand{
				Target: dirTarget,
			},
			wantErr: false,
		},
		{
			name: "Missing target",
			cmd: &ParsedCommand{
				Target: missingTarget,
			},
			wantErr: true,
			errText: "does not exist",
		},
		{
			name: "Valid recursive on directory",
			cmd: &ParsedCommand{
				Target:      dirTarget,
				Recursively: true,
			},
			wantErr: false,
		},
		{
			name: "Invalid recursive on file",
			cmd: &ParsedCommand{
				Target:      fileTarget,
				Recursively: true,
			},
			wantErr: true,
			errText: "is not a directory",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := Validate(tt.cmd)
			if (err != nil) != tt.wantErr {
				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if tt.wantErr && err != nil {
				if !strings.Contains(err.Error(), tt.errText) {
					t.Errorf("Validate() error = %v, expected error to contain %q", err, tt.errText)
				}
			}
			if !tt.wantErr && tt.cmd.FileInfo == nil {
				t.Errorf("Validate() expected FileInfo to be populated, got nil")
			}
		})
	}
}

func TestValidate_ActorExistence(t *testing.T) {
	cleanup := setMocks()
	defer cleanup()

	tempDir := t.TempDir()
	fileTarget := filepath.Join(tempDir, "testfile.txt")
	os.WriteFile(fileTarget, []byte("test"), 0644)

	tests := []struct {
		name    string
		cmd     *ParsedCommand
		wantErr bool
		errText string
	}{
		{
			name: "Valid user implicit",
			cmd: &ParsedCommand{
				Target: fileTarget,
				Actor:  "alice",
			},
			wantErr: false,
		},
		{
			name: "Valid user explicit",
			cmd: &ParsedCommand{
				Target:    fileTarget,
				ActorType: "user",
				Actor:     "bob",
			},
			wantErr: false,
		},
		{
			name: "Valid group implicit",
			cmd: &ParsedCommand{
				Target: fileTarget,
				Actor:  "dev",
			},
			wantErr: false,
		},
		{
			name: "Valid group explicit",
			cmd: &ParsedCommand{
				Target:    fileTarget,
				ActorType: "group",
				Actor:     "admins",
			},
			wantErr: false,
		},
		{
			name: "Invalid user explicit",
			cmd: &ParsedCommand{
				Target:    fileTarget,
				ActorType: "user",
				Actor:     "dev", // dev is a group, not a user
			},
			wantErr: true,
			errText: "user 'dev' not found on system",
		},
		{
			name: "Invalid group explicit",
			cmd: &ParsedCommand{
				Target:    fileTarget,
				ActorType: "group",
				Actor:     "alice", // alice is a user, not a group
			},
			wantErr: true,
			errText: "group 'alice' not found on system",
		},
		{
			name: "Invalid actor implicit",
			cmd: &ParsedCommand{
				Target: fileTarget,
				Actor:  "nobody",
			},
			wantErr: true,
			errText: "actor 'nobody' not found as a user or group on system",
		},
		{
			name: "Reserved keyword implicit (everyone)",
			cmd: &ParsedCommand{
				Target: fileTarget,
				Actor:  "everyone",
			},
			wantErr: false,
		},
		{
			name: "Reserved keyword explicit user (everyone)",
			cmd: &ParsedCommand{
				Target:    fileTarget,
				ActorType: "user",
				Actor:     "everyone", // System likely doesn't have local user 'everyone', should fail
			},
			wantErr: true,
			errText: "user 'everyone' not found on system",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := Validate(tt.cmd)
			if (err != nil) != tt.wantErr {
				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if tt.wantErr && err != nil {
				if !strings.Contains(err.Error(), tt.errText) {
					t.Errorf("Validate() error = %v, expected error to contain %q", err, tt.errText)
				}
			}
			if !tt.wantErr {
				if tt.cmd.Actor == "everyone" && tt.cmd.ActorType != "user" && tt.cmd.ActorType != "group" {
					if tt.cmd.ActorType != "other" {
						t.Errorf("Validate() expected ActorType 'other', got %q", tt.cmd.ActorType)
					}
				} else if tt.cmd.ActorType == "" {
					t.Errorf("Validate() expected ActorType to be resolved, got empty string")
				}
			}
		})
	}
}