github__gh-stack/cmd/alias_test.go

package cmd

import (
	"os"
	"path/filepath"
	"runtime"
	"testing"

	"github.com/github/gh-stack/internal/config"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestAliasCmd_ValidatesName(t *testing.T) {
	tests := []struct {
		name    string
		input   string
		wantErr bool
	}{
		{"default", "gs", false},
		{"alphanumeric", "gst2", false},
		{"with-hyphen", "my-stack", false},
		{"with-underscore", "my_stack", false},
		{"starts-with-digit", "2gs", true},
		{"has-spaces", "my stack", true},
		{"has-slash", "my/stack", true},
		{"empty", "", true},
		{"special-chars", "gs!", true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert.Equal(t, !tt.wantErr, validAliasName.MatchString(tt.input))
		})
	}
}

// skipWindows skips the current test on Windows since the alias command
// creates Unix shell scripts.
func skipWindows(t *testing.T) {
	t.Helper()
	if runtime.GOOS == "windows" {
		t.Skip("alias command uses shell scripts; not supported on Windows")
	}
}

// withTmpBinDir skips on Windows, overrides localBinDirFunc to use a temp
// directory, and restores it when the test completes.
func withTmpBinDir(t *testing.T) string {
	t.Helper()
	skipWindows(t)
	tmpDir := t.TempDir()
	orig := localBinDirFunc
	localBinDirFunc = func() (string, error) { return tmpDir, nil }
	t.Cleanup(func() { localBinDirFunc = orig })
	return tmpDir
}

// testAliasName is a name unlikely to collide with real commands on PATH.
const testAliasName = "ghstacktest"

func TestRunAlias_CreatesWrapperScript(t *testing.T) {
	tmpDir := withTmpBinDir(t)
	cfg, _, _ := config.NewTestConfig()

	err := runAlias(cfg, testAliasName, tmpDir)
	require.NoError(t, err)

	scriptPath := filepath.Join(tmpDir, testAliasName)
	data, err := os.ReadFile(scriptPath)
	require.NoError(t, err)
	assert.Equal(t, markedWrapperContent, string(data))

	info, err := os.Stat(scriptPath)
	require.NoError(t, err)
	assert.True(t, info.Mode()&0o111 != 0, "script should be executable")
}

func TestRunAlias_Idempotent(t *testing.T) {
	tmpDir := withTmpBinDir(t)
	cfg, _, _ := config.NewTestConfig()

	// First install
	require.NoError(t, runAlias(cfg, testAliasName, tmpDir))
	// Second install should succeed (idempotent)
	require.NoError(t, runAlias(cfg, testAliasName, tmpDir))
}

func TestRunAlias_RejectsExistingCommand(t *testing.T) {
	tmpDir := withTmpBinDir(t)
	cfg, _, _ := config.NewTestConfig()

	// "ls" exists on every Unix system
	err := runAlias(cfg, "ls", tmpDir)
	assert.ErrorIs(t, err, ErrInvalidArgs)
}

func TestRunAliasRemove_RemovesWrapper(t *testing.T) {
	tmpDir := withTmpBinDir(t)
	cfg, _, _ := config.NewTestConfig()

	require.NoError(t, runAlias(cfg, testAliasName, tmpDir))

	scriptPath := filepath.Join(tmpDir, testAliasName)
	require.FileExists(t, scriptPath)

	require.NoError(t, runAliasRemove(cfg, testAliasName, tmpDir))
	assert.NoFileExists(t, scriptPath)
}

func TestRunAliasRemove_RefusesNonOurScript(t *testing.T) {
	tmpDir := withTmpBinDir(t)
	cfg, _, _ := config.NewTestConfig()

	// Create a file that isn't our wrapper
	scriptPath := filepath.Join(tmpDir, testAliasName)
	require.NoError(t, os.WriteFile(scriptPath, []byte("#!/bin/sh\necho hello\n"), 0o755))

	err := runAliasRemove(cfg, testAliasName, tmpDir)
	assert.Error(t, err)
	assert.FileExists(t, scriptPath)
}

func TestRunAliasRemove_ErrorsWhenNotFound(t *testing.T) {
	tmpDir := withTmpBinDir(t)
	cfg, _, _ := config.NewTestConfig()

	err := runAliasRemove(cfg, testAliasName, tmpDir)
	assert.Error(t, err)
}

func TestIsOurWrapper(t *testing.T) {
	tmpDir := t.TempDir()

	ourPath := filepath.Join(tmpDir, "ours")
	require.NoError(t, os.WriteFile(ourPath, []byte(markedWrapperContent), 0o755))
	assert.True(t, isOurWrapper(ourPath))

	otherPath := filepath.Join(tmpDir, "other")
	require.NoError(t, os.WriteFile(otherPath, []byte("#!/bin/sh\necho hi\n"), 0o755))
	assert.False(t, isOurWrapper(otherPath))

	assert.False(t, isOurWrapper(filepath.Join(tmpDir, "nope")))
}

func TestDirInPath(t *testing.T) {
	// Use a directory we know is in PATH on any platform.
	found := false
	for _, dir := range filepath.SplitList(os.Getenv("PATH")) {
		if dirInPath(dir) {
			found = true
			break
		}
	}
	assert.True(t, found, "expected at least one PATH entry to be found by dirInPath")
	assert.False(t, dirInPath("/nonexistent/path/that/should/not/exist"))
}

func TestAliasCmd_RemoveFlagWiring(t *testing.T) {
	tmpDir := withTmpBinDir(t)
	cfg, _, _ := config.NewTestConfig()

	// Install the alias first via runAlias so there's something to remove.
	require.NoError(t, runAlias(cfg, testAliasName, tmpDir))
	require.FileExists(t, filepath.Join(tmpDir, testAliasName))

	// Now exercise the cobra command with --remove to verify flag plumbing.
	cmd := AliasCmd(cfg)
	cmd.SetArgs([]string{"--remove", testAliasName})
	require.NoError(t, cmd.Execute())

	assert.NoFileExists(t, filepath.Join(tmpDir, testAliasName))
}

func TestAliasCmd_WindowsReturnsError(t *testing.T) {
	if runtime.GOOS != "windows" {
		t.Skip("Windows-only test")
	}

	cfg, _, _ := config.NewTestConfig()

	cmd := AliasCmd(cfg)
	cmd.SetArgs([]string{testAliasName})
	assert.Error(t, cmd.Execute())
}

func TestValidateAliasName(t *testing.T) {
	cfg, _, _ := config.NewTestConfig()

	assert.NoError(t, validateAliasName(cfg, "gs"))
	assert.NoError(t, validateAliasName(cfg, "my-stack"))
	assert.ErrorIs(t, validateAliasName(cfg, ""), ErrInvalidArgs)
	assert.ErrorIs(t, validateAliasName(cfg, "2bad"), ErrInvalidArgs)
	assert.ErrorIs(t, validateAliasName(cfg, "has space"), ErrInvalidArgs)
}