new_test.go

package cmd

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

	"github.com/knqyf263/pet/config"
	"github.com/knqyf263/pet/snippet"
	"github.com/pelletier/go-toml"
)

// MockReadCloser is a mock implementation of io.ReadCloser
type MockReadCloser struct {
	*strings.Reader
}

// Close does nothing for this mock implementation
func (m *MockReadCloser) Close() error {
	return nil
}

func TestScan(t *testing.T) {
	message := "Enter something: "

	input := "test\n" // Simulated user input
	want := "test"    // Expected output
	expectedError := error(nil)

	// Create a buffer for output
	var outputBuffer bytes.Buffer
	// Create a mock ReadCloser for input
	inputReader := &MockReadCloser{strings.NewReader(input)}

	result, err := scan(message, &outputBuffer, inputReader, false)

	// Check if the input was printed
	got := result

	// Check if the result matches the expected result
	if want != got {
		t.Errorf("Expected result %q, but got %q", want, got)
	}

	// Check if the error matches the expected error
	if err != expectedError {
		t.Errorf("Expected error %v, but got %v", expectedError, err)
	}
}

func TestScan_EmptyStringWithAllowEmpty(t *testing.T) {
	message := "Enter something: "

	input := "\n"               // Simulated user input
	want := ""                  // Expected output
	expectedError := error(nil) // Should not error

	// Create a buffer for output
	var outputBuffer bytes.Buffer
	// Create a mock ReadCloser for input
	inputReader := &MockReadCloser{strings.NewReader(input)}

	result, err := scan(message, &outputBuffer, inputReader, true)

	// Check if the input was printed
	got := result

	// Check if the result is empty
	if want != got {
		t.Errorf("Expected result %q, but got %q", want, got)
	}

	// Check if the error matches the expected error
	if err != expectedError {
		t.Errorf("Expected error %v, but got %v", expectedError, err)
	}
}

func TestScan_EmptyStringWithoutAllowEmpty(t *testing.T) {
	message := "Enter something: "

	input := "\n" // Simulated user input
	want := ""    // Expected output
	expectedError := CanceledError()

	// Create a buffer for output
	var outputBuffer bytes.Buffer
	// Create a mock ReadCloser for input
	inputReader := &MockReadCloser{strings.NewReader(input)}

	result, err := scan(message, &outputBuffer, inputReader, false)

	// Check if the input was printed
	got := result
	// Check if the result matches the expected result
	if want != got {
		t.Errorf("Expected result %q, but got %q", want, got)
	}

	// Check if the error matches the expected error
	if err.Error() != expectedError.Error() {
		t.Errorf("Expected error %v, but got %v", expectedError, err)
	}
}

func TestScanMultiLine_ExitsOnTwoEmptyLines(t *testing.T) {
	prompt := "Enter something: "
	secondPrompt := "whatever"

	input := "test\nnewline here\nand another;\n\n\n" // Simulated user input
	want := "test\nnewline here\nand another;"        // Expected output
	expectedError := error(nil)

	// Create a buffer for output
	var outputBuffer bytes.Buffer
	// Create a mock ReadCloser for input
	inputReader := &MockReadCloser{strings.NewReader(input)}

	result, err := scanMultiLine(prompt, secondPrompt, &outputBuffer, inputReader)

	// Check if the input was printed
	got := result

	// Check if the result matches the expected result
	if want != got {
		t.Errorf("Expected result %q, but got %q", want, got)
	}

	// Check if the error matches the expected error
	if err != expectedError {
		t.Errorf("Expected error %v, but got %v", expectedError, err)
	}
}

func TestNew_SnippetCreationWithSnippetDirectory(t *testing.T) {
	// Setup temporary directory for config
	tempDir, _ := os.MkdirTemp("", "testdata")
	tempSnippetFile := filepath.Join(tempDir, "snippet.toml")
	tempSnippetDir1 := filepath.Join(tempDir, "snippets1")
	tempSnippetDir2 := filepath.Join(tempDir, "snippets2")

	// Clean up temp dirs, needed for windows
	// https://github.com/golang/go/issues/51442
	defer os.RemoveAll(tempDir)

	// Create snippet directories
	if err := os.Mkdir(tempSnippetDir1, 0755); err != nil {
		t.Fatalf("Failed to create temp snippet directory: %v", err)
	}
	if err := os.Mkdir(tempSnippetDir2, 0755); err != nil {
		t.Fatalf("Failed to create temp snippet directory: %v", err)
	}

	// Create dummy snippets in the main snippet file
	mainSnippets := snippet.Snippets{
		Snippets: []snippet.SnippetInfo{
			{Description: "main snippet 1", Command: "echo main1"},
			{Description: "main snippet 2", Command: "echo main2"},
		},
	}
	saveSnippetsToFile(t, tempSnippetFile, mainSnippets)

	// Create dummy snippets in the snippet directories
	dirSnippets1 := snippet.Snippets{
		Snippets: []snippet.SnippetInfo{
			{Description: "dir1 snippet 1", Command: "echo dir1-1"},
		},
	}
	dirSnippets2 := snippet.Snippets{
		Snippets: []snippet.SnippetInfo{
			{Description: "dir2 snippet 1", Command: "echo dir2-1"},
		},
	}
	saveSnippetsToFile(t, filepath.Join(tempSnippetDir1, "snippets1.toml"), dirSnippets1)
	saveSnippetsToFile(t, filepath.Join(tempSnippetDir2, "snippets2.toml"), dirSnippets2)

	// Mock configuration
	config.Conf.General.SnippetFile = tempSnippetFile
	config.Conf.General.SnippetDirs = []string{tempSnippetDir1, tempSnippetDir2}

	// Simulate creating a new snippet
	args := []string{"echo new command"}

	// Create a buffer for output
	var outputBuffer bytes.Buffer
	// Create a mock ReadCloser for input
	inputReader := &MockReadCloser{strings.NewReader("test\ntest")}

	err := _new(inputReader, &outputBuffer, args)
	if err != nil {
		t.Fatalf("Failed to create new snippet: %v", err)
	}

	// Load the main snippet file and check:
	// 1 - if the new snippet is added
	// 2 - if the number of snippets is correct (to avoid bugs like overwriting with dir snippets)
	var updatedMainSnippets snippet.Snippets
	loadSnippetsFromFile(t, tempSnippetFile, &updatedMainSnippets)

	if len(updatedMainSnippets.Snippets) != 3 {
		t.Fatalf("Expected 3 snippets in main snippet file, got %d", len(updatedMainSnippets.Snippets))
	}

	newSnippet := updatedMainSnippets.Snippets[2]
	if newSnippet.Command != "echo new command" {
		t.Errorf("Expected new command to be 'echo new command', got '%s'", newSnippet.Command)
	}

	// Ensure the snippet files in the directories remain unchanged
	var unchangedDirSnippets1, unchangedDirSnippets2 snippet.Snippets
	loadSnippetsFromFile(t, filepath.Join(tempSnippetDir1, "snippets1.toml"), &unchangedDirSnippets1)
	loadSnippetsFromFile(t, filepath.Join(tempSnippetDir2, "snippets2.toml"), &unchangedDirSnippets2)

	if !compareSnippets(dirSnippets1, unchangedDirSnippets1) {
		t.Errorf("Snippets in directory 1 have changed")
	}
	if !compareSnippets(dirSnippets2, unchangedDirSnippets2) {
		t.Errorf("Snippets in directory 2 have changed")
	}
}

func saveSnippetsToFile(t *testing.T, filename string, snippets snippet.Snippets) {
	f, err := os.Create(filename)
	if err != nil {
		t.Fatalf("Failed to create snippet file: %v", err)
	}
	defer f.Close()

	if err := toml.NewEncoder(f).Encode(snippets); err != nil {
		t.Fatalf("Failed to encode snippets to file: %v", err)
	}
}

func loadSnippetsFromFile(t *testing.T, filename string, snippets *snippet.Snippets) {
	f, err := os.ReadFile(filename)
	if err != nil {
		t.Fatalf("Failed to read snippet file: %v", err)
	}

	if err := toml.Unmarshal(f, snippets); err != nil {
		t.Fatalf("Failed to unmarshal snippets from file: %v", err)
	}
}

func compareSnippets(a, b snippet.Snippets) bool {
	if len(a.Snippets) != len(b.Snippets) {
		return false
	}
	for i := range a.Snippets {
		if a.Snippets[i].Description != b.Snippets[i].Description || a.Snippets[i].Command != b.Snippets[i].Command {
			return false
		}
	}
	return true
}

func TestNew_WithStaticFlag(t *testing.T) {
	// Setup temporary directory for config
	tempDir, _ := os.MkdirTemp("", "testdata")
	tempSnippetFile := filepath.Join(tempDir, "snippet.toml")

	// Clean up temp dirs
	defer os.RemoveAll(tempDir)

	// Create empty snippet file
	_, err := os.Create(tempSnippetFile)
	if err != nil {
		t.Fatalf("Failed to create temp snippet file: %v", err)
	}

	// Mock configuration
	config.Conf.General.SnippetFile = tempSnippetFile
	config.Conf.General.SnippetDirs = []string{}

	// Set the static flag to true
	originalStatic := config.Flag.Static
	config.Flag.Static = true
	defer func() { config.Flag.Static = originalStatic }()

	// Simulate creating a new snippet with static flag
	args := []string{"echo hello <name>"}

	// Create a buffer for output
	var outputBuffer bytes.Buffer
	// Create a mock ReadCloser for input (description)
	inputReader := &MockReadCloser{strings.NewReader("test description\n")}

	err = _new(inputReader, &outputBuffer, args)
	if err != nil {
		t.Fatalf("Failed to create new snippet: %v", err)
	}

	// Load the snippet file and check if static field is set
	var snippets snippet.Snippets
	loadSnippetsFromFile(t, tempSnippetFile, &snippets)

	if len(snippets.Snippets) != 1 {
		t.Fatalf("Expected 1 snippet, got %d", len(snippets.Snippets))
	}

	createdSnippet := snippets.Snippets[0]
	if createdSnippet.Command != "echo hello <name>" {
		t.Errorf("Expected command to be 'echo hello <name>', got '%s'", createdSnippet.Command)
	}

	if createdSnippet.Description != "test description" {
		t.Errorf("Expected description to be 'test description', got '%s'", createdSnippet.Description)
	}

	// Check that static field is set to true
	if createdSnippet.Static == nil {
		t.Error("Expected Static field to be set, got nil")
	} else if !*createdSnippet.Static {
		t.Error("Expected Static field to be true, got false")
	}
}

func TestNew_WithoutStaticFlag(t *testing.T) {
	// Setup temporary directory for config
	tempDir, _ := os.MkdirTemp("", "testdata")
	tempSnippetFile := filepath.Join(tempDir, "snippet.toml")

	// Clean up temp dirs
	defer os.RemoveAll(tempDir)

	// Create empty snippet file
	_, err := os.Create(tempSnippetFile)
	if err != nil {
		t.Fatalf("Failed to create temp snippet file: %v", err)
	}

	// Mock configuration
	config.Conf.General.SnippetFile = tempSnippetFile
	config.Conf.General.SnippetDirs = []string{}

	// Ensure the static flag is false
	originalStatic := config.Flag.Static
	config.Flag.Static = false
	defer func() { config.Flag.Static = originalStatic }()

	// Simulate creating a new snippet without static flag
	args := []string{"echo hello <name>"}

	// Create a buffer for output
	var outputBuffer bytes.Buffer
	// Create a mock ReadCloser for input (description)
	inputReader := &MockReadCloser{strings.NewReader("test description\n")}

	err = _new(inputReader, &outputBuffer, args)
	if err != nil {
		t.Fatalf("Failed to create new snippet: %v", err)
	}

	// Load the snippet file and check if static field is not set
	var snippets snippet.Snippets
	loadSnippetsFromFile(t, tempSnippetFile, &snippets)

	if len(snippets.Snippets) != 1 {
		t.Fatalf("Expected 1 snippet, got %d", len(snippets.Snippets))
	}

	createdSnippet := snippets.Snippets[0]
	if createdSnippet.Command != "echo hello <name>" {
		t.Errorf("Expected command to be 'echo hello <name>', got '%s'", createdSnippet.Command)
	}

	// Check that static field is nil (not set) when flag is false
	if createdSnippet.Static != nil {
		t.Errorf("Expected Static field to be nil when flag is false, got %v", *createdSnippet.Static)
	}
}

func TestNew_WithStaticFlagAndEditor(t *testing.T) {
	// Setup temporary directory for config
	tempDir, _ := os.MkdirTemp("", "testdata")
	tempSnippetFile := filepath.Join(tempDir, "snippet.toml")

	// Clean up temp dirs
	defer os.RemoveAll(tempDir)

	// Create empty snippet file
	_, err := os.Create(tempSnippetFile)
	if err != nil {
		t.Fatalf("Failed to create temp snippet file: %v", err)
	}

	// Mock configuration
	config.Conf.General.SnippetFile = tempSnippetFile
	config.Conf.General.SnippetDirs = []string{}
	config.Conf.General.Editor = "echo" // Use echo as a mock editor that won't actually open

	// Set flags
	originalStatic := config.Flag.Static
	originalUseEditor := config.Flag.UseEditor
	config.Flag.Static = true
	config.Flag.UseEditor = true
	defer func() {
		config.Flag.Static = originalStatic
		config.Flag.UseEditor = originalUseEditor
	}()

	// Simulate creating a new snippet with static flag and editor
	args := []string{} // No command args when using editor

	// Create a buffer for output
	var outputBuffer bytes.Buffer
	// Create a mock ReadCloser for input
	inputReader := &MockReadCloser{strings.NewReader("")}

	err = _new(inputReader, &outputBuffer, args)
	if err != nil {
		t.Fatalf("Failed to create new snippet: %v", err)
	}

	// Load the snippet file and check if static field is set
	var snippets snippet.Snippets
	loadSnippetsFromFile(t, tempSnippetFile, &snippets)

	if len(snippets.Snippets) != 1 {
		t.Fatalf("Expected 1 snippet, got %d", len(snippets.Snippets))
	}

	createdSnippet := snippets.Snippets[0]

	// Check that static field is set to true even when using editor
	if createdSnippet.Static == nil {
		t.Error("Expected Static field to be set, got nil")
	} else if !*createdSnippet.Static {
		t.Error("Expected Static field to be true, got false")
	}
}