main_test.go

package main

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

// TestCLIBasicUsage tests basic CLI functionality with a real binary.
func TestCLIBasicUsage(t *testing.T) {
	// Build gostrings binary
	gostringsBin := filepath.Join(t.TempDir(), "gostrings")
	cmd := exec.Command("go", "build", "-o", gostringsBin, ".")
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build gostrings: %v", err)
	}

	// Build test binary
	tmpDir := t.TempDir()
	testSrc := filepath.Join(tmpDir, "test.go")
	testBin := filepath.Join(tmpDir, "test")

	testCode := `package main
import "fmt"

func main() {
	fmt.Println("CLI_TEST_STRING_12345")
}
`

	if err := os.WriteFile(testSrc, []byte(testCode), 0o644); err != nil {
		t.Fatalf("failed to write test source: %v", err)
	}

	cmd = exec.Command("go", "build", "-o", testBin, testSrc)
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build test binary: %v", err)
	}

	// Run gostrings on test binary
	cmd = exec.Command(gostringsBin, testBin)
	var out bytes.Buffer
	cmd.Stdout = &out
	cmd.Stderr = &out

	if err := cmd.Run(); err != nil {
		t.Fatalf("gostrings command failed: %v\nOutput: %s", err, out.String())
	}

	// Check output contains expected string
	output := out.String()
	if !strings.Contains(output, "CLI_TEST_STRING_12345") {
		t.Errorf("gostrings output missing expected string\nOutput: %s", output)
	}
}

// TestCLIMinLengthFlag tests the -n flag for minimum string length.
func TestCLIMinLengthFlag(t *testing.T) {
	gostringsBin := filepath.Join(t.TempDir(), "gostrings")
	cmd := exec.Command("go", "build", "-o", gostringsBin, ".")
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build gostrings: %v", err)
	}

	tmpDir := t.TempDir()
	testSrc := filepath.Join(tmpDir, "test.go")
	testBin := filepath.Join(tmpDir, "test")

	testCode := `package main
import "fmt"

func main() {
	fmt.Println("MINLEN_TEST_MARKER_12345")
}
`

	if err := os.WriteFile(testSrc, []byte(testCode), 0o644); err != nil {
		t.Fatalf("failed to write test source: %v", err)
	}

	cmd = exec.Command("go", "build", "-o", testBin, testSrc)
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build test binary: %v", err)
	}

	// Run with -n 20 (minimum length 20) - should find our marker
	cmd = exec.Command(gostringsBin, "-n", "20", testBin)
	var out bytes.Buffer
	cmd.Stdout = &out

	if err := cmd.Run(); err != nil {
		t.Fatalf("gostrings command failed: %v", err)
	}

	output := out.String()
	if !strings.Contains(output, "MINLEN_TEST_MARKER_12345") {
		t.Errorf("gostrings -n 20 did not find expected string")
	}

	// Run with -n 50 (minimum length 50) - should NOT find our marker
	cmd = exec.Command(gostringsBin, "-n", "50", testBin)
	out.Reset()
	cmd.Stdout = &out

	if err := cmd.Run(); err != nil {
		t.Fatalf("gostrings command failed: %v", err)
	}

	output = out.String()
	if strings.Contains(output, "MINLEN_TEST_MARKER_12345") {
		t.Errorf("gostrings -n 50 should not find 25-char string")
	}
}

// TestCLIUniqueFlag tests the -u flag for unique strings only.
func TestCLIUniqueFlag(t *testing.T) {
	gostringsBin := filepath.Join(t.TempDir(), "gostrings")
	cmd := exec.Command("go", "build", "-o", gostringsBin, ".")
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build gostrings: %v", err)
	}

	tmpDir := t.TempDir()
	testSrc := filepath.Join(tmpDir, "test.go")
	testBin := filepath.Join(tmpDir, "test")

	testCode := `package main
import "fmt"

func main() {
	fmt.Println("UNIQUE_TEST_MARKER_XYZ")
}
`

	if err := os.WriteFile(testSrc, []byte(testCode), 0o644); err != nil {
		t.Fatalf("failed to write test source: %v", err)
	}

	cmd = exec.Command("go", "build", "-o", testBin, testSrc)
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build test binary: %v", err)
	}

	// Run without -u flag (may have duplicates)
	cmd = exec.Command(gostringsBin, testBin)
	var outNonUnique bytes.Buffer
	cmd.Stdout = &outNonUnique

	if err := cmd.Run(); err != nil {
		t.Fatalf("gostrings command failed: %v", err)
	}

	// Run with -u flag
	cmd = exec.Command(gostringsBin, "-u", testBin)
	var outUnique bytes.Buffer
	cmd.Stdout = &outUnique

	if err := cmd.Run(); err != nil {
		t.Fatalf("gostrings command failed: %v", err)
	}

	// Unique output should be shorter or equal
	nonUniqueLines := len(strings.Split(strings.TrimSpace(outNonUnique.String()), "\n"))
	uniqueLines := len(strings.Split(strings.TrimSpace(outUnique.String()), "\n"))

	if uniqueLines > nonUniqueLines {
		t.Errorf("gostrings -u returned more strings (%d) than without -u (%d)", uniqueLines, nonUniqueLines)
	}

	// Verify our marker appears in both
	if !strings.Contains(outUnique.String(), "UNIQUE_TEST_MARKER_XYZ") {
		t.Error("gostrings -u did not find expected marker string")
	}
}

// TestCLINoArguments tests CLI behavior with no arguments.
func TestCLINoArguments(t *testing.T) {
	gostringsBin := filepath.Join(t.TempDir(), "gostrings")
	cmd := exec.Command("go", "build", "-o", gostringsBin, ".")
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build gostrings: %v", err)
	}

	// Run with no arguments
	cmd = exec.Command(gostringsBin)
	var stderr bytes.Buffer
	cmd.Stderr = &stderr

	err := cmd.Run()
	if err == nil {
		t.Error("gostrings with no arguments should fail, got success")
	}

	// Should print usage information
	stderrStr := stderr.String()
	if !strings.Contains(stderrStr, "Usage:") {
		t.Errorf("gostrings with no args should print usage, got: %s", stderrStr)
	}
}

// TestCLINonexistentFile tests CLI behavior with nonexistent file.
func TestCLINonexistentFile(t *testing.T) {
	gostringsBin := filepath.Join(t.TempDir(), "gostrings")
	cmd := exec.Command("go", "build", "-o", gostringsBin, ".")
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build gostrings: %v", err)
	}

	// Run with nonexistent file
	cmd = exec.Command(gostringsBin, "/nonexistent/file/path")
	var stderr bytes.Buffer
	cmd.Stderr = &stderr

	err := cmd.Run()
	if err == nil {
		t.Error("gostrings with nonexistent file should fail, got success")
	}

	// Should print error message
	stderrStr := stderr.String()
	if !strings.Contains(stderrStr, "Error:") {
		t.Errorf("gostrings with nonexistent file should print error, got: %s", stderrStr)
	}
}

// TestCLIVerboseFlag tests the -v flag for verbose output.
func TestCLIVerboseFlag(t *testing.T) {
	gostringsBin := filepath.Join(t.TempDir(), "gostrings")
	cmd := exec.Command("go", "build", "-o", gostringsBin, ".")
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build gostrings: %v", err)
	}

	tmpDir := t.TempDir()
	testSrc := filepath.Join(tmpDir, "test.go")
	testBin := filepath.Join(tmpDir, "test")

	testCode := `package main
import "fmt"

func main() {
	fmt.Println("verbose_test")
}
`

	if err := os.WriteFile(testSrc, []byte(testCode), 0o644); err != nil {
		t.Fatalf("failed to write test source: %v", err)
	}

	cmd = exec.Command("go", "build", "-o", testBin, testSrc)
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build test binary: %v", err)
	}

	// Run with -v flag
	cmd = exec.Command(gostringsBin, "-v", testBin)
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr

	if err := cmd.Run(); err != nil {
		t.Fatalf("gostrings command failed: %v", err)
	}

	// Verbose output should go to stderr and include format detection
	stderrStr := stderr.String()
	if !strings.Contains(stderrStr, "Detected") {
		t.Errorf("gostrings -v should print format detection to stderr, got: %s", stderrStr)
	}
}

// TestCLICombinedFlags tests multiple flags together.
func TestCLICombinedFlags(t *testing.T) {
	gostringsBin := filepath.Join(t.TempDir(), "gostrings")
	cmd := exec.Command("go", "build", "-o", gostringsBin, ".")
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build gostrings: %v", err)
	}

	tmpDir := t.TempDir()
	testSrc := filepath.Join(tmpDir, "test.go")
	testBin := filepath.Join(tmpDir, "test")

	testCode := `package main
import "fmt"

func main() {
	fmt.Println("combined_flags_test_string")
}
`

	if err := os.WriteFile(testSrc, []byte(testCode), 0o644); err != nil {
		t.Fatalf("failed to write test source: %v", err)
	}

	cmd = exec.Command("go", "build", "-o", testBin, testSrc)
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build test binary: %v", err)
	}

	// Run with -n, -u, and -v flags
	cmd = exec.Command(gostringsBin, "-n", "10", "-u", "-v", testBin)
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr

	if err := cmd.Run(); err != nil {
		t.Fatalf("gostrings command failed: %v", err)
	}

	// Check verbose output on stderr
	if !strings.Contains(stderr.String(), "Detected") {
		t.Errorf("expected verbose output on stderr")
	}

	// Check results respect minimum length
	lines := strings.Split(strings.TrimSpace(stdout.String()), "\n")
	for _, line := range lines {
		if line != "" && len(line) < 10 {
			t.Errorf("gostrings -n 10 returned string %q with length %d < 10", line, len(line))
		}
	}
}

// TestCLIFunctionNames tests that function names appear in the strings list.
func TestCLIFunctionNames(t *testing.T) {
	gostringsBin := filepath.Join(t.TempDir(), "gostrings")
	cmd := exec.Command("go", "build", "-o", gostringsBin, ".")
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build gostrings: %v", err)
	}

	tmpDir := t.TempDir()
	testSrc := filepath.Join(tmpDir, "test.go")
	testBin := filepath.Join(tmpDir, "test")

	testCode := `package main

func myUniqueTestFunction() {
	println("test")
}

func anotherSpecialFunction() {
	println("test2")
}

func main() {
	myUniqueTestFunction()
	anotherSpecialFunction()
}
`

	if err := os.WriteFile(testSrc, []byte(testCode), 0o644); err != nil {
		t.Fatalf("failed to write test source: %v", err)
	}

	cmd = exec.Command("go", "build", "-o", testBin, testSrc)
	if err := cmd.Run(); err != nil {
		t.Fatalf("failed to build test binary: %v", err)
	}

	// Run gostrings on test binary
	cmd = exec.Command(gostringsBin, testBin)
	var out bytes.Buffer
	cmd.Stdout = &out

	if err := cmd.Run(); err != nil {
		t.Fatalf("gostrings command failed: %v", err)
	}

	output := out.String()

	// Verify function names appear in output
	if !strings.Contains(output, "myUniqueTestFunction") {
		t.Errorf("gostrings output missing function name 'myUniqueTestFunction'\nOutput: %s", output)
	}
	if !strings.Contains(output, "anotherSpecialFunction") {
		t.Errorf("gostrings output missing function name 'anotherSpecialFunction'\nOutput: %s", output)
	}
}