utils_test.go

package main

import (
	"bytes"
	"encoding/json"
	"os"
	"testing"
	"time"
)

func TestPrintTableUtil(t *testing.T) {
	headers := []string{"ID", "Name", "Status"}
	rows := [][]string{
		{"1", "Item One", "Active"},
		{"2", "Item Two", "Inactive"},
	}

	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	PrintTableUtil(headers, rows)

	w.Close()
	os.Stdout = oldStdout

	var buf bytes.Buffer
	buf.ReadFrom(r)
	output := buf.String()

	if output == "" {
		t.Error("expected table output, got empty string")
	}

	if !containsStr(output, "ID") {
		t.Error("expected header 'ID' in output")
	}

	if !containsStr(output, "Item One") {
		t.Error("expected 'Item One' in output")
	}
}

func TestPrintJSONUtil(t *testing.T) {
	data := map[string]interface{}{
		"name":  "Test",
		"value": 123,
	}

	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	PrintJSONUtil(data)

	w.Close()
	os.Stdout = oldStdout

	var buf bytes.Buffer
	buf.ReadFrom(r)
	output := buf.String()

	var result map[string]interface{}
	err := json.Unmarshal([]byte(output), &result)
	if err != nil {
		t.Errorf("output is not valid JSON: %v", err)
	}

	if result["name"] != "Test" {
		t.Errorf("expected name 'Test', got %v", result["name"])
	}
}

func TestStringSliceToTabSeparated(t *testing.T) {
	tests := []struct {
		name     string
		input    []string
		expected string
	}{
		{
			name:     "empty slice",
			input:    []string{},
			expected: "",
		},
		{
			name:     "single element",
			input:    []string{"one"},
			expected: "one",
		},
		{
			name:     "multiple elements",
			input:    []string{"one", "two", "three"},
			expected: "one\ttwo\tthree",
		},
	}

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

func TestPromptForInput(t *testing.T) {
	oldStdin := os.Stdin
	r, w, _ := os.Pipe()
	os.Stdin = r

	input := "test input\n"
	w.Write([]byte(input))
	w.Close()

	result := promptForInput("Prompt", "default")

	os.Stdin = oldStdin

	if result != "test input" {
		t.Errorf("expected 'test input', got %q", result)
	}
}

func TestPromptForInput_EmptyWithDefault(t *testing.T) {
	oldStdin := os.Stdin
	r, w, _ := os.Pipe()
	os.Stdin = r

	input := "\n"
	w.Write([]byte(input))
	w.Close()

	result := promptForInput("Prompt", "default value")

	os.Stdin = oldStdin

	if result != "default value" {
		t.Errorf("expected 'default value', got %q", result)
	}
}

func TestPromptConfirm(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected bool
	}{
		{"empty default", "\n", true},
		{"yes uppercase", "Y\n", true},
		{"yes lowercase", "y\n", true},
		{"no", "n\n", false},
		{"no uppercase", "N\n", false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			oldStdin := os.Stdin
			r, w, _ := os.Pipe()
			os.Stdin = r

			w.Write([]byte(tt.input))
			w.Close()

			result := promptConfirm("Confirm?")

			os.Stdin = oldStdin

			if result != tt.expected {
				t.Errorf("input %q: expected %v, got %v", tt.input, tt.expected, result)
			}
		})
	}
}

func TestMaskString(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected string
	}{
		{"empty", "", "(not set)"},
		{"short", "abc", "****"},
		{"exactly 4", "abcd", "****"},
		{"long", "abcdefghij", "****ghij"},
	}

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

func TestValidatePort(t *testing.T) {
	tests := []struct {
		name        string
		port        string
		expectError bool
	}{
		{"valid", "3456", false},
		{"minimum", "3000", false},
		{"maximum", "9000", false},
		{"too low", "2999", true},
		{"too high", "9001", true},
		{"not a number", "abc", true},
		{"empty", "", true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := validatePort(tt.port)
			if tt.expectError && err == nil {
				t.Error("expected error, got nil")
			}
			if !tt.expectError && err != nil {
				t.Errorf("expected no error, got %v", err)
			}
		})
	}
}

func TestPrintStep(t *testing.T) {
	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	printStep("1", "5", "Test Step")

	w.Close()
	os.Stdout = oldStdout

	var buf bytes.Buffer
	buf.ReadFrom(r)
	output := buf.String()

	if !containsStr(output, "Step 1/5") {
		t.Error("expected step indicator in output")
	}

	if !containsStr(output, "Test Step") {
		t.Error("expected step title in output")
	}
}

func TestPrintConfigSummary(t *testing.T) {
	config := &Config{
		ClientID:     "test-client",
		RedirectURI:  "http://localhost:3456/callback",
		Scopes:       "openid accounting.transactions",
		Port:         "3456",
		ClientSecret: "secret123",
	}

	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	printConfigSummary(config)

	w.Close()
	os.Stdout = oldStdout

	var buf bytes.Buffer
	buf.ReadFrom(r)
	output := buf.String()

	if !containsStr(output, "Configuration Summary") {
		t.Error("expected summary header")
	}

	if !containsStr(output, "test-client") {
		t.Error("expected client ID in output")
	}
}

func containsStr(s, substr string) bool {
	return len(s) >= len(substr) && (s == substr || containsAtLocal(s, substr))
}

func containsAtLocal(s, substr string) bool {
	for i := 0; i <= len(s)-len(substr); i++ {
		if s[i:i+len(substr)] == substr {
			return true
		}
	}
	return false
}

func TestSaveToJSON(t *testing.T) {
	tmpFile := "test_token_save.json"
	defer os.Remove(tmpFile)

	token := &TokenStore{
		AccessToken:  "test-token",
		RefreshToken: "test-refresh",
		Expiry:       time.Now().Add(30 * time.Minute),
		TenantID:     "tenant-123",
		TenantName:   "Test Org",
	}

	err := SaveToJSON(tmpFile, token)
	if err != nil {
		t.Fatalf("SaveToJSON failed: %v", err)
	}

	var loaded TokenStore
	err = LoadFromJSON(tmpFile, &loaded)
	if err != nil {
		t.Fatalf("LoadFromJSON failed: %v", err)
	}

	if loaded.AccessToken != token.AccessToken {
		t.Errorf("access token mismatch")
	}
}

func TestLoadFromJSON_NotExist(t *testing.T) {
	var target interface{}
	err := LoadFromJSON("non_existent_file.json", &target)
	if err == nil {
		t.Error("expected error for non-existent file, got nil")
	}
	if !os.IsNotExist(err) {
		t.Errorf("expected IsNotExist error, got %v", err)
	}
}