mirror of
https://github.com/cheat/cheat.git
synced 2026-03-07 11:13:33 +01:00
chore: housekeeping and refactoring (bump to 4.7.1)
- Remove unused parameters, dead files, and inaccurate doc.go files - Extract shared helpers, eliminate duplication - Rename cheatpath.Cheatpath to cheatpath.Path - Optimize filesystem walks (WalkDir, skip .git) - Move sheet name validation to sheet.Validate - Move integration tests to test/integration/ - Consolidate internal/mock into mocks/ - Move fuzz.sh to test/ - Inline loadSheets helper into command callers - Extract config.New into its own file - Fix stale references in HACKING.md and CLAUDE.md - Restore plan9 build target - Remove redundant and low-value tests - Clean up project documentation Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Christopher Allen Lane
305
test/integration/first_run_integration_test.go
Normal file
305
test/integration/first_run_integration_test.go
Normal file
@@ -0,0 +1,305 @@
|
||||
package integration
|
||||
|
||||
import (
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestFirstRunIntegration exercises the end-to-end first-run experience:
|
||||
// no config exists, the binary creates one, and subsequent runs succeed.
|
||||
// This is the regression test for issues #721, #771, and #730.
|
||||
func TestFirstRunIntegration(t *testing.T) {
|
||||
// Build the cheat binary
|
||||
binName := "cheat_test"
|
||||
if runtime.GOOS == "windows" {
|
||||
binName += ".exe"
|
||||
}
|
||||
binPath := filepath.Join(t.TempDir(), binName)
|
||||
build := exec.Command("go", "build", "-o", binPath, "./cmd/cheat")
|
||||
build.Dir = repoRoot(t)
|
||||
if output, err := build.CombinedOutput(); err != nil {
|
||||
t.Fatalf("failed to build cheat: %v\nOutput: %s", err, output)
|
||||
}
|
||||
|
||||
t.Run("init comments out community", func(t *testing.T) {
|
||||
testHome := t.TempDir()
|
||||
env := firstRunEnv(testHome)
|
||||
|
||||
cmd := exec.Command(binPath, "--init")
|
||||
cmd.Env = env
|
||||
output, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("--init failed: %v\nOutput: %s", err, output)
|
||||
}
|
||||
outStr := string(output)
|
||||
|
||||
// No placeholder strings should survive (regression for #721)
|
||||
assertNoPlaceholders(t, outStr)
|
||||
|
||||
// Community cheatpath should be commented out
|
||||
assertCommunityCommentedOut(t, outStr)
|
||||
|
||||
// Personal and work cheatpaths should be active (uncommented)
|
||||
assertCheatpathActive(t, outStr, "personal")
|
||||
assertCheatpathActive(t, outStr, "work")
|
||||
|
||||
// Should include clone instructions
|
||||
if !strings.Contains(outStr, "git clone") {
|
||||
t.Error("expected git clone instructions in --init output")
|
||||
}
|
||||
|
||||
// Save the config and verify it loads without errors.
|
||||
// --init only outputs config, it doesn't create directories,
|
||||
// so we need to create the cheatpath dirs the config references.
|
||||
confpath := filepath.Join(testHome, "conf.yml")
|
||||
if err := os.WriteFile(confpath, output, 0644); err != nil {
|
||||
t.Fatalf("failed to write config: %v", err)
|
||||
}
|
||||
|
||||
// Determine the confdir that --init used (same logic as cmd_init.go)
|
||||
initConfpaths := firstRunConfpaths(testHome)
|
||||
initConfdir := filepath.Dir(initConfpaths[0])
|
||||
for _, name := range []string{"personal", "work"} {
|
||||
dir := filepath.Join(initConfdir, "cheatsheets", name)
|
||||
if err := os.MkdirAll(dir, 0755); err != nil {
|
||||
t.Fatalf("failed to create %s dir: %v", name, err)
|
||||
}
|
||||
}
|
||||
|
||||
cmd2 := exec.Command(binPath, "--directories")
|
||||
cmd2.Env = append(append([]string{}, env...), "CHEAT_CONFIG_PATH="+confpath)
|
||||
output2, err := cmd2.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("config from --init failed to load: %v\nOutput: %s", err, output2)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("decline config creation", func(t *testing.T) {
|
||||
testHome := t.TempDir()
|
||||
env := firstRunEnv(testHome)
|
||||
|
||||
cmd := exec.Command(binPath)
|
||||
cmd.Env = env
|
||||
cmd.Stdin = strings.NewReader("n\n")
|
||||
output, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("cheat exited with error: %v\nOutput: %s", err, output)
|
||||
}
|
||||
|
||||
// Verify no config was created
|
||||
if firstRunConfigExists(testHome) {
|
||||
t.Error("config file was created despite user declining")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("accept config decline community", func(t *testing.T) {
|
||||
testHome := t.TempDir()
|
||||
env := firstRunEnv(testHome)
|
||||
|
||||
// First run: yes to create config, no to community cheatsheets
|
||||
cmd := exec.Command(binPath)
|
||||
cmd.Env = env
|
||||
cmd.Stdin = strings.NewReader("y\nn\n")
|
||||
output, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("first run failed: %v\nOutput: %s", err, output)
|
||||
}
|
||||
outStr := string(output)
|
||||
|
||||
// Parse the config path from output
|
||||
confpath := parseCreatedConfPath(t, outStr)
|
||||
if confpath == "" {
|
||||
t.Fatalf("could not find config path in output:\n%s", outStr)
|
||||
}
|
||||
|
||||
// Verify config file exists
|
||||
if _, err := os.Stat(confpath); os.IsNotExist(err) {
|
||||
t.Fatalf("config file not found at %s", confpath)
|
||||
}
|
||||
|
||||
// Verify config file contents
|
||||
content, err := os.ReadFile(confpath)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to read config: %v", err)
|
||||
}
|
||||
contentStr := string(content)
|
||||
|
||||
// No placeholder strings should survive (regression for #721)
|
||||
assertNoPlaceholders(t, contentStr)
|
||||
|
||||
// Community cheatpath should be commented out
|
||||
assertCommunityCommentedOut(t, contentStr)
|
||||
|
||||
// Personal and work cheatpaths should be active (uncommented)
|
||||
assertCheatpathActive(t, contentStr, "personal")
|
||||
assertCheatpathActive(t, contentStr, "work")
|
||||
|
||||
// Verify personal and work directories were created
|
||||
confdir := filepath.Dir(confpath)
|
||||
for _, name := range []string{"personal", "work"} {
|
||||
dir := filepath.Join(confdir, "cheatsheets", name)
|
||||
if _, err := os.Stat(dir); os.IsNotExist(err) {
|
||||
t.Errorf("expected %s directory at %s", name, dir)
|
||||
}
|
||||
}
|
||||
|
||||
// Community directory should NOT exist
|
||||
communityDir := filepath.Join(confdir, "cheatsheets", "community")
|
||||
if _, err := os.Stat(communityDir); err == nil {
|
||||
t.Error("community directory should not exist when declined")
|
||||
}
|
||||
|
||||
// --- Second run: verify the config loads successfully ---
|
||||
// This is the core regression test for #721/#771/#730:
|
||||
// previously, the second run would fail because config.New()
|
||||
// hard-errored on the missing community cheatpath directory.
|
||||
// Use --directories (not --list, which exits 2 when no sheets exist).
|
||||
cmd2 := exec.Command(binPath, "--directories")
|
||||
cmd2.Env = append(append([]string{}, env...), "CHEAT_CONFIG_PATH="+confpath)
|
||||
output2, err := cmd2.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf(
|
||||
"second run failed (regression for #721/#771/#730): %v\nOutput: %s",
|
||||
err, output2,
|
||||
)
|
||||
}
|
||||
|
||||
// Verify the output lists the expected cheatpaths
|
||||
outStr2 := string(output2)
|
||||
if !strings.Contains(outStr2, "personal") {
|
||||
t.Errorf("expected 'personal' cheatpath in --directories output:\n%s", outStr2)
|
||||
}
|
||||
if !strings.Contains(outStr2, "work") {
|
||||
t.Errorf("expected 'work' cheatpath in --directories output:\n%s", outStr2)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// firstRunEnv returns a minimal environment for a clean first-run test.
|
||||
func firstRunEnv(home string) []string {
|
||||
env := []string{
|
||||
"PATH=" + os.Getenv("PATH"),
|
||||
}
|
||||
|
||||
switch runtime.GOOS {
|
||||
case "windows":
|
||||
env = append(env,
|
||||
"APPDATA="+filepath.Join(home, "AppData", "Roaming"),
|
||||
"USERPROFILE="+home,
|
||||
"SystemRoot="+os.Getenv("SystemRoot"),
|
||||
)
|
||||
default:
|
||||
env = append(env,
|
||||
"HOME="+home,
|
||||
"EDITOR=vi",
|
||||
)
|
||||
}
|
||||
|
||||
return env
|
||||
}
|
||||
|
||||
// parseCreatedConfPath extracts the config file path from the installer's
|
||||
// "Created config file: <path>" output. The message may appear mid-line
|
||||
// (after prompt text), so we search for the substring anywhere in the output.
|
||||
func parseCreatedConfPath(t *testing.T, output string) string {
|
||||
t.Helper()
|
||||
const marker = "Created config file: "
|
||||
idx := strings.Index(output, marker)
|
||||
if idx < 0 {
|
||||
return ""
|
||||
}
|
||||
rest := output[idx+len(marker):]
|
||||
// the path ends at the next newline
|
||||
if nl := strings.IndexByte(rest, '\n'); nl >= 0 {
|
||||
rest = rest[:nl]
|
||||
}
|
||||
return strings.TrimSpace(rest)
|
||||
}
|
||||
|
||||
// firstRunConfpaths returns the config file paths that cheat would check
|
||||
// for the given home directory, matching the logic in config.Paths().
|
||||
func firstRunConfpaths(home string) []string {
|
||||
switch runtime.GOOS {
|
||||
case "windows":
|
||||
return []string{
|
||||
filepath.Join(home, "AppData", "Roaming", "cheat", "conf.yml"),
|
||||
}
|
||||
default:
|
||||
return []string{
|
||||
filepath.Join(home, ".config", "cheat", "conf.yml"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// assertNoPlaceholders verifies that no template placeholder strings survived
|
||||
// in the config output. This is the regression check for #721 (literal
|
||||
// PAGER_PATH appearing in the config).
|
||||
func assertNoPlaceholders(t *testing.T, content string) {
|
||||
t.Helper()
|
||||
placeholders := []string{
|
||||
"PAGER_PATH",
|
||||
"COMMUNITY_PATH",
|
||||
"PERSONAL_PATH",
|
||||
"WORK_PATH",
|
||||
}
|
||||
for _, p := range placeholders {
|
||||
if strings.Contains(content, p) {
|
||||
t.Errorf("placeholder %q was not replaced in config", p)
|
||||
}
|
||||
}
|
||||
// EDITOR_PATH is special: it survives if no editor is found.
|
||||
// In our test env EDITOR=vi is set, so it should be replaced.
|
||||
if strings.Contains(content, "editor: EDITOR_PATH") {
|
||||
t.Error("placeholder EDITOR_PATH was not replaced in config")
|
||||
}
|
||||
}
|
||||
|
||||
// assertCommunityCommentedOut verifies that the community cheatpath entry
|
||||
// is commented out (not active) in the config.
|
||||
func assertCommunityCommentedOut(t *testing.T, content string) {
|
||||
t.Helper()
|
||||
for _, line := range strings.Split(content, "\n") {
|
||||
trimmed := strings.TrimSpace(line)
|
||||
if trimmed == "- name: community" {
|
||||
t.Error("community cheatpath should be commented out")
|
||||
return
|
||||
}
|
||||
}
|
||||
if !strings.Contains(content, "#- name: community") {
|
||||
t.Error("expected commented-out community cheatpath")
|
||||
}
|
||||
}
|
||||
|
||||
// assertCheatpathActive verifies that a named cheatpath is present and
|
||||
// uncommented in the config.
|
||||
func assertCheatpathActive(t *testing.T, content string, name string) {
|
||||
t.Helper()
|
||||
marker := "- name: " + name
|
||||
for _, line := range strings.Split(content, "\n") {
|
||||
trimmed := strings.TrimSpace(line)
|
||||
if trimmed == marker {
|
||||
return
|
||||
}
|
||||
}
|
||||
t.Errorf("expected active (uncommented) cheatpath %q", name)
|
||||
}
|
||||
|
||||
// firstRunConfigExists checks whether a cheat config file exists under the
|
||||
// given home directory at any of the standard locations.
|
||||
func firstRunConfigExists(home string) bool {
|
||||
candidates := []string{
|
||||
filepath.Join(home, ".config", "cheat", "conf.yml"),
|
||||
filepath.Join(home, ".cheat", "conf.yml"),
|
||||
filepath.Join(home, "AppData", "Roaming", "cheat", "conf.yml"),
|
||||
}
|
||||
for _, p := range candidates {
|
||||
if _, err := os.Stat(p); err == nil {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
Reference in New Issue
Block a user