main_test.go

package main

import (
	"os/exec"
	"regexp"
	"strconv"
	"strings"
	"testing"
)

func TestHasChanges(t *testing.T) {
	// Skip if not in a git repo
	if !isInGitRepo() {
		t.Skip("Not in a git repository")
	}

	tests := []struct {
		name        string
		filename    string
		description string
	}{
		{
			name:        "nonexistent file",
			filename:    "this_file_does_not_exist.txt",
			description: "should return false for nonexistent files",
		},
		{
			name:        "current file",
			filename:    "main.go", 
			description: "test with actual project file",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Just test that the function doesn't panic and returns a boolean
			result := hasChanges(tt.filename)
			t.Logf("%s: hasChanges(%q) = %v", tt.description, tt.filename, result)
			// We can't predict the exact result since it depends on git state
			// but we can verify the function runs without error
		})
	}
}

func TestGetChangedLines_DiffParsing(t *testing.T) {
	tests := []struct {
		name          string
		diffOutput    string
		expectedLines []int
		shouldError   bool
	}{
		{
			name: "simple additions",
			diffOutput: `diff --git a/test.txt b/test.txt
index 1234567..abcdefg 100644
--- a/test.txt
+++ b/test.txt
@@ -1,3 +1,4 @@
 line 1
+new line 2
 line 3
+another new line`,
			expectedLines: []int{2, 4},
			shouldError:   false,
		},
		{
			name: "multiple hunks",
			diffOutput: `diff --git a/test.txt b/test.txt
index 1234567..abcdefg 100644
--- a/test.txt
+++ b/test.txt
@@ -1,2 +1,3 @@
 line 1
+added line 2
 line 3
@@ -10,2 +11,3 @@
 line 10
+added line 11
 line 12`,
			expectedLines: []int{2, 12},
			shouldError:   false,
		},
		{
			name: "only context lines",
			diffOutput: `diff --git a/test.txt b/test.txt
index 1234567..abcdefg 100644
--- a/test.txt
+++ b/test.txt
@@ -1,3 +1,3 @@
 line 1
 line 2
 line 3`,
			expectedLines: []int{},
			shouldError:   false,
		},
		{
			name: "mixed additions and deletions",
			diffOutput: `diff --git a/test.txt b/test.txt
index 1234567..abcdefg 100644
--- a/test.txt
+++ b/test.txt
@@ -1,5 +1,5 @@
 line 1
-old line 2
+new line 2
 line 3
-old line 4
+new line 4
 line 5`,
			expectedLines: []int{2, 4},
			shouldError:   false,
		},
		{
			name:          "no changes",
			diffOutput:    "",
			expectedLines: []int{},
			shouldError:   false,
		},
		{
			name: "complex hunk with line number gaps",
			diffOutput: `diff --git a/test.txt b/test.txt
index 1234567..abcdefg 100644
--- a/test.txt
+++ b/test.txt
@@ -15,8 +15,10 @@
 context line 15
 context line 16
+new line 17
 context line 17
+new line 18
 context line 18
 context line 19
+final new line
 context line 20`,
			expectedLines: []int{17, 19, 22},
			shouldError:   false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			lines := parseChangedLinesFromDiff(tt.diffOutput)

			if len(lines) != len(tt.expectedLines) {
				t.Errorf("parseChangedLinesFromDiff() returned %d lines, want %d\nGot: %v\nWant: %v", 
					len(lines), len(tt.expectedLines), lines, tt.expectedLines)
				return
			}

			for i, line := range lines {
				if line != tt.expectedLines[i] {
					t.Errorf("parseChangedLinesFromDiff() line %d = %d, want %d", i, line, tt.expectedLines[i])
				}
			}
		})
	}
}

func TestFormatLines(t *testing.T) {
	tests := []struct {
		name     string
		lines    []int
		expected string
	}{
		{
			name:     "single line",
			lines:    []int{42},
			expected: "42",
		},
		{
			name:     "multiple lines",
			lines:    []int{10, 20, 30},
			expected: "10, 20, 30",
		},
		{
			name:     "empty slice",
			lines:    []int{},
			expected: "",
		},
		{
			name:     "unordered lines",
			lines:    []int{30, 10, 20},
			expected: "30, 10, 20",
		},
		{
			name:     "single line zero",
			lines:    []int{0},
			expected: "0",
		},
		{
			name:     "large numbers",
			lines:    []int{1000, 2000, 3000},
			expected: "1000, 2000, 3000",
		},
	}

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



func TestCommitInfoGrouping(t *testing.T) {
	tests := []struct {
		name            string
		lines           []int
		blameOutputs    map[int]string // line number -> blame output
		expectedCommits []CommitInfo
		shouldError     bool
	}{
		{
			name:  "single commit multiple lines",
			lines: []int{10, 20, 30},
			blameOutputs: map[int]string{
				10: "abc123 author 2023-01-01 line content",
				20: "abc123 author 2023-01-01 line content",
				30: "abc123 author 2023-01-01 line content",
			},
			expectedCommits: []CommitInfo{
				{
					Hash:  "abc123",
					Lines: []int{10, 20, 30},
				},
			},
		},
		{
			name:  "multiple commits preserving order",
			lines: []int{10, 20, 30, 40},
			blameOutputs: map[int]string{
				10: "abc123 author 2023-01-01 line content",
				20: "def456 author 2023-01-02 line content",
				30: "abc123 author 2023-01-01 line content",
				40: "def456 author 2023-01-02 line content",
			},
			expectedCommits: []CommitInfo{
				{
					Hash:  "abc123",
					Lines: []int{10, 30},
				},
				{
					Hash:  "def456",
					Lines: []int{20, 40},
				},
			},
		},
		{
			name:  "commits with different hash lengths",
			lines: []int{5, 15},
			blameOutputs: map[int]string{
				5:  "a1b2c3d4e5f6 author 2023-01-01 line content",
				15: "123abc author 2023-01-02 line content",
			},
			expectedCommits: []CommitInfo{
				{
					Hash:  "a1b2c3d4e5f6",
					Lines: []int{5},
				},
				{
					Hash:  "123abc",
					Lines: []int{15},
				},
			},
		},
		{
			name:  "single line single commit",
			lines: []int{1},
			blameOutputs: map[int]string{
				1: "abcdef123456 user 2023-05-15 some line content here",
			},
			expectedCommits: []CommitInfo{
				{
					Hash:  "abcdef123456",
					Lines: []int{1},
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			commits := simulateCommitGrouping(tt.lines, tt.blameOutputs)

			if len(commits) != len(tt.expectedCommits) {
				t.Errorf("got %d commits, want %d", len(commits), len(tt.expectedCommits))
				return
			}

			for i, commit := range commits {
				expected := tt.expectedCommits[i]
				if commit.Hash != expected.Hash {
					t.Errorf("commit %d hash = %q, want %q", i, commit.Hash, expected.Hash)
				}
				if len(commit.Lines) != len(expected.Lines) {
					t.Errorf("commit %d has %d lines, want %d", i, len(commit.Lines), len(expected.Lines))
					continue
				}
				for j, line := range commit.Lines {
					if line != expected.Lines[j] {
						t.Errorf("commit %d line %d = %d, want %d", i, j, line, expected.Lines[j])
					}
				}
			}
		})
	}
}

func TestAnalyzeConflictRisk_Logic(t *testing.T) {
	// Test the conflict risk analysis logic without requiring actual Git repositories
	tests := []struct {
		name           string
		commitAge      int  // commits between target and HEAD
		hasMerges      bool
		expectConflict bool
		expectedReason string
	}{
		{
			name:           "recent commit no merges",
			commitAge:      5,
			hasMerges:      false,
			expectConflict: false,
			expectedReason: "",
		},
		{
			name:           "distant commit",
			commitAge:      25,
			hasMerges:      false,
			expectConflict: true,
			expectedReason: "distant",
		},
		{
			name:           "recent commit with merges",
			commitAge:      5,
			hasMerges:      true,
			expectConflict: true,
			expectedReason: "merge",
		},
		{
			name:           "distant commit with merges",
			commitAge:      30,
			hasMerges:      true,
			expectConflict: true,
			expectedReason: "distant", // Should catch distance first
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			hasConflict, reason := simulateConflictAnalysis(tt.commitAge, tt.hasMerges)
			
			if hasConflict != tt.expectConflict {
				t.Errorf("Expected conflict risk %v, got %v", tt.expectConflict, hasConflict)
			}
			
			if tt.expectConflict && !strings.Contains(strings.ToLower(reason), tt.expectedReason) {
				t.Errorf("Expected reason to contain %q, got %q", tt.expectedReason, reason)
			}
		})
	}
}

// Helper functions for testing

func isInGitRepo() bool {
	command := exec.Command("git", "rev-parse", "--git-dir")
	return command.Run() == nil
}

func parseChangedLinesFromDiff(diffOutput string) []int {
	// This extracts the core parsing logic from getChangedLines for testing
	var changedLines []int
	lines := strings.Split(diffOutput, "\n")

	hunkRegex := regexp.MustCompile(`^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@`)
	var currentLine int

	for _, line := range lines {
		if matches := hunkRegex.FindStringSubmatch(line); matches != nil {
			currentLine, _ = strconv.Atoi(matches[1])
		} else if strings.HasPrefix(line, "+") && !strings.HasPrefix(line, "+++") {
			changedLines = append(changedLines, currentLine)
			currentLine++
		} else if strings.HasPrefix(line, " ") {
			currentLine++
		}
	}

	return changedLines
}



func simulateCommitGrouping(lines []int, blameOutputs map[int]string) []CommitInfo {
	// This simulates the commit grouping logic for testing
	lineToCommit := make(map[int]string)

	for lineNum, blameOutput := range blameOutputs {
		parts := strings.Fields(blameOutput)
		if len(parts) > 0 {
			commitHash := parts[0]
			lineToCommit[lineNum] = commitHash
		}
	}

	// Group lines by commit, preserving order of first appearance
	var seenCommits []string
	commitToLines := make(map[string][]int)

	for _, lineNum := range lines {
		if commitHash, exists := lineToCommit[lineNum]; exists {
			if _, seen := commitToLines[commitHash]; !seen {
				seenCommits = append(seenCommits, commitHash)
				commitToLines[commitHash] = []int{}
			}
			commitToLines[commitHash] = append(commitToLines[commitHash], lineNum)
		}
	}

	// Create result slice
	var commits []CommitInfo
	for _, commitHash := range seenCommits {
		commits = append(commits, CommitInfo{
			Hash:  commitHash,
			Lines: commitToLines[commitHash],
		})
	}

	return commits
}

func simulateConflictAnalysis(commitAge int, hasMerges bool) (bool, string) {
	// Simulate the conflict analysis logic for testing
	if commitAge > 20 {
		return true, "commit is distant, context may have changed"
	}
	
	if hasMerges {
		return true, "merge commits present, potential context conflicts"
	}
	
	return false, ""
}