conflict_test.go

package main

import (
  "fmt"
  "os"
  "path/filepath"
  "strings"
  "testing"
  "time"
)

// TestConflictDetectionBasic tests basic conflict detection scenarios
func TestConflictDetectionBasic(t *testing.T) {
  scenario := createTestScenario(t, "conflict_basic")
  defer scenario.cleanup()
  
  restoreDir := scenario.changeToScenarioDir()
  defer restoreDir()
  
  // Create initial commit
  initialContent := "line 1\nline 2\nline 3\n"
  oldCommitHash := scenario.commitFile(scenario.filename, initialContent, "Initial commit")
  
  // Modify the same line in a new commit
  modifiedContent := "line 1\nmodified line 2\nline 3\n"
  scenario.commitFile(scenario.filename, modifiedContent, "Modify line 2")
  
  // Now modify line 2 again (unstaged)
  finalContent := "line 1\nfurther modified line 2\nline 3\n"
  scenario.modifyFile(scenario.filename, finalContent)
  
  // Test conflict detection for line that was modified since original commit
  hasConflict, reason := analyzeConflictRisk(scenario.filename, oldCommitHash, []int{2})
  
  if !hasConflict {
    t.Error("Expected conflict risk for line modified since original commit")
  }
  
  if !strings.Contains(reason, "modified since original commit") {
    t.Errorf("Expected reason about line modification, got: %s", reason)
  }
}

// TestConflictDetectionDistance tests conflict detection for distant commits
func TestConflictDetectionDistance(t *testing.T) {
  scenario := createTestScenario(t, "conflict_distance")
  defer scenario.cleanup()
  
  restoreDir := scenario.changeToScenarioDir()
  defer restoreDir()
  
  // Create initial commit
  initialContent := "function main() {\n  return 0;\n}\n"
  oldCommitHash := scenario.commitFile(scenario.filename, initialContent, "Add main function")
  
  // Create many commits to make the original distant
  content := initialContent
  for i := 0; i < 25; i++ {
    content = fmt.Sprintf("function main() {\n  return 0;\n}\n\n// Comment %d\n", i)
    scenario.commitFile(scenario.filename, content, fmt.Sprintf("Add comment %d", i))
  }
  
  // Modify the original line
  finalContent := "function main() {\n  return 1; // changed return value\n}\n\n// Comment 24\n"
  scenario.modifyFile(scenario.filename, finalContent)
  
  // Test conflict detection for distant commit
  hasConflict, reason := analyzeConflictRisk(scenario.filename, oldCommitHash, []int{2})
  
  if !hasConflict {
    t.Error("Expected conflict risk for distant commit")
  }
  
  if !strings.Contains(reason, "distant") && !strings.Contains(reason, "context may have changed") {
    t.Errorf("Expected distance-related reason, got: %s", reason)
  }
}

// TestConflictDetectionMergeCommits tests conflict detection with merge commits
func TestConflictDetectionMergeCommits(t *testing.T) {
  scenario := createTestScenario(t, "conflict_merge")
  defer scenario.cleanup()
  
  restoreDir := scenario.changeToScenarioDir()
  defer restoreDir()
  
  // Create initial commit
  initialContent := "class MyClass {\n  constructor() {}\n}\n"
  oldCommitHash := scenario.commitFile(scenario.filename, initialContent, "Add MyClass")
  
  // Create a feature branch
  scenario.runGitCommand("checkout", "-b", "feature")
  featureContent := "class MyClass {\n  constructor() {}\n  \n  method() {\n    return true;\n  }\n}\n"
  scenario.commitFile(scenario.filename, featureContent, "Add method to MyClass")
  
  // Go back to main and make a different change (non-conflicting)
  scenario.runGitCommand("checkout", "main")
  mainContent := "// Added comment on main branch\nclass MyClass {\n  constructor() {}\n}\n"
  scenario.commitFile(scenario.filename, mainContent, "Add comment to MyClass")
  
  // Merge feature branch (this creates a merge commit)
  scenario.runGitCommand("merge", "feature", "--no-ff", "-m", "Merge feature branch")
  
  // Now modify original constructor line
  finalContent := strings.Replace(scenario.getFileContent(), "constructor() {}", "constructor(name) { this.name = name; }", 1)
  scenario.modifyFile(scenario.filename, finalContent)
  
  // Test conflict detection with merge commits present
  hasConflict, reason := analyzeConflictRisk(scenario.filename, oldCommitHash, []int{2})
  
  if !hasConflict {
    t.Error("Expected conflict risk due to merge commits")
  }
  
  if !strings.Contains(reason, "merge") {
    t.Errorf("Expected merge-related reason, got: %s", reason)
  }
}

// TestConflictDetectionNoConflict tests scenarios that should not trigger conflicts
func TestConflictDetectionNoConflict(t *testing.T) {
  scenario := createTestScenario(t, "conflict_none")
  defer scenario.cleanup()
  
  restoreDir := scenario.changeToScenarioDir()
  defer restoreDir()
  
  // Create initial commit
  initialContent := "line 1\nline 2\nline 3\nline 4\n"
  oldCommitHash := scenario.commitFile(scenario.filename, initialContent, "Initial commit")
  
  // Make a few more commits but don't touch the same lines
  scenario.commitFile(scenario.filename, initialContent+"line 5\n", "Add line 5")
  scenario.commitFile(scenario.filename, initialContent+"line 5\nline 6\n", "Add line 6")
  
  // Modify a line from the original commit
  finalContent := "modified line 1\nline 2\nline 3\nline 4\nline 5\nline 6\n"
  scenario.modifyFile(scenario.filename, finalContent)
  
  // Test conflict detection - should be low risk
  hasConflict, reason := analyzeConflictRisk(scenario.filename, oldCommitHash, []int{1})
  
  if hasConflict {
    t.Errorf("Expected no conflict risk for recent commit without modifications, got: %s", reason)
  }
}

// TestConflictDetectionMultipleLines tests conflict detection for multiple lines
func TestConflictDetectionMultipleLines(t *testing.T) {
  scenario := createTestScenario(t, "conflict_multiline")
  defer scenario.cleanup()
  
  restoreDir := scenario.changeToScenarioDir()
  defer restoreDir()
  
  // Create initial commit
  initialContent := "line 1\nline 2\nline 3\nline 4\nline 5\n"
  oldCommitHash := scenario.commitFile(scenario.filename, initialContent, "Initial commit")
  
  // Modify some lines in a new commit
  intermediateContent := "line 1\nmodified line 2\nline 3\nmodified line 4\nline 5\n"
  scenario.commitFile(scenario.filename, intermediateContent, "Modify lines 2 and 4")
  
  // Now modify all original lines
  finalContent := "new line 1\nnew line 2\nnew line 3\nnew line 4\nnew line 5\n"
  scenario.modifyFile(scenario.filename, finalContent)
  
  // Test conflict detection for multiple lines
  hasConflict, reason := analyzeConflictRisk(scenario.filename, oldCommitHash, []int{1, 2, 3, 4, 5})
  
  if !hasConflict {
    t.Error("Expected conflict risk for lines modified since original commit")
  }
  
  if !strings.Contains(reason, "modified since original commit") {
    t.Errorf("Expected modification-related reason, got: %s", reason)
  }
}

// TestConflictDetectionEdgeCases tests edge cases in conflict detection
func TestConflictDetectionEdgeCases(t *testing.T) {
  t.Run("invalid commit hash", func(t *testing.T) {
    scenario := createTestScenario(t, "conflict_invalid_hash")
    defer scenario.cleanup()
    
    restoreDir := scenario.changeToScenarioDir()
    defer restoreDir()
    
    scenario.commitFile(scenario.filename, "content\n", "Initial commit")
    
    // Test with invalid commit hash - should not crash
    hasConflict, _ := analyzeConflictRisk(scenario.filename, "invalidhash123", []int{1})
    
    // Should handle error gracefully and return false
    if hasConflict {
      t.Error("Expected no conflict risk for invalid commit hash")
    }
  })
  
  t.Run("nonexistent file", func(t *testing.T) {
    scenario := createTestScenario(t, "conflict_nonexistent")
    defer scenario.cleanup()
    
    restoreDir := scenario.changeToScenarioDir()
    defer restoreDir()
    
    commitHash := scenario.commitFile(scenario.filename, "content\n", "Initial commit")
    
    // Test with nonexistent file - should handle gracefully
    hasConflict, _ := analyzeConflictRisk("nonexistent.txt", commitHash, []int{1})
    
    // Should handle error gracefully
    if hasConflict {
      t.Error("Expected no conflict risk for nonexistent file")
    }
  })
  
  t.Run("empty lines list", func(t *testing.T) {
    scenario := createTestScenario(t, "conflict_empty_lines")
    defer scenario.cleanup()
    
    restoreDir := scenario.changeToScenarioDir()
    defer restoreDir()
    
    commitHash := scenario.commitFile(scenario.filename, "content\n", "Initial commit")
    
    // Test with empty lines list
    hasConflict, _ := analyzeConflictRisk(scenario.filename, commitHash, []int{})
    
    // Should not detect conflict for no lines
    if hasConflict {
      t.Error("Expected no conflict risk for empty lines list")
    }
  })
  
  t.Run("line beyond file bounds", func(t *testing.T) {
    scenario := createTestScenario(t, "conflict_bounds")
    defer scenario.cleanup()
    
    restoreDir := scenario.changeToScenarioDir()
    defer restoreDir()
    
    // Create a short file
    commitHash := scenario.commitFile(scenario.filename, "line 1\nline 2\n", "Initial commit")
    
    // Test with line number beyond file bounds
    hasConflict, _ := analyzeConflictRisk(scenario.filename, commitHash, []int{100})
    
    // Should handle gracefully
    if hasConflict {
      t.Error("Expected no conflict risk for line beyond file bounds")
    }
  })
}

// TestConflictDetectionRealWorldScenarios tests realistic conflict scenarios
func TestConflictDetectionRealWorldScenarios(t *testing.T) {
  t.Run("refactoring scenario", func(t *testing.T) {
    scenario := createTestScenario(t, "conflict_refactor")
    defer scenario.cleanup()
    
    restoreDir := scenario.changeToScenarioDir()
    defer restoreDir()
    
    // Create initial code
    initialCode := `package main

import "fmt"

func main() {
    fmt.Println("Hello World")
    processData()
}

func processData() {
    data := "test"
    fmt.Println(data)
}`
    oldCommitHash := scenario.commitFile(scenario.filename, initialCode, "Initial implementation")
    
    // Refactor: Extract variable, rename function
    refactoredCode := `package main

import "fmt"

func main() {
    message := "Hello World"
    fmt.Println(message)
    handleData()
}

func handleData() {
    data := "test"
    fmt.Println(data)
}`
    scenario.commitFile(scenario.filename, refactoredCode, "Refactor code")
    
    // Now fix a bug in original function
    fixedCode := strings.Replace(refactoredCode, `fmt.Println("Hello World")`, `fmt.Println("Hello, World!")`, 1)
    scenario.modifyFile(scenario.filename, fixedCode)
    
    // Should detect potential conflict due to refactoring
    hasConflict, reason := analyzeConflictRisk(scenario.filename, oldCommitHash, []int{6})
    
    if !hasConflict {
      t.Error("Expected conflict risk for refactored code")
    }
    
    if !strings.Contains(reason, "modified since original commit") {
      t.Errorf("Expected modification-related reason, got: %s", reason)
    }
  })
  
  t.Run("hotfix on old release", func(t *testing.T) {
    scenario := createTestScenario(t, "conflict_hotfix")
    defer scenario.cleanup()
    
    restoreDir := scenario.changeToScenarioDir()
    defer restoreDir()
    
    // Simulate old release commit
    releaseCode := `const VERSION = "1.0.0"
const DEBUG = false

function main() {
    if (DEBUG) console.log("Debug mode")
    console.log("App version: " + VERSION)
}`
    oldReleaseHash := scenario.commitFile(scenario.filename, releaseCode, "Release 1.0.0")
    
    // Many commits simulating ongoing development
    currentCode := releaseCode
    for i := 1; i <= 30; i++ {
      currentCode = fmt.Sprintf(`const VERSION = "1.0.%d"
const DEBUG = false

function main() {
    if (DEBUG) console.log("Debug mode")
    console.log("App version: " + VERSION)
    // Feature %d
}`, i, i)
      scenario.commitFile(scenario.filename, currentCode, fmt.Sprintf("Development iteration %d", i))
    }
    
    // Now need to hotfix the old release (change DEBUG to true)
    hotfixCode := strings.Replace(currentCode, "const DEBUG = false", "const DEBUG = true", 1)
    scenario.modifyFile(scenario.filename, hotfixCode)
    
    // Should detect high conflict risk due to distance
    hasConflict, reason := analyzeConflictRisk(scenario.filename, oldReleaseHash, []int{2})
    
    if !hasConflict {
      t.Error("Expected conflict risk for hotfix on old release")
    }
    
    if !strings.Contains(reason, "distant") {
      t.Errorf("Expected distance-related reason, got: %s", reason)
    }
  })
}

// TestConflictDetectionPerformance tests performance of conflict detection
func TestConflictDetectionPerformance(t *testing.T) {
  if testing.Short() {
    t.Skip("Skipping performance test in short mode")
  }
  
  scenario := createTestScenario(t, "conflict_perf")
  defer scenario.cleanup()
  
  restoreDir := scenario.changeToScenarioDir()
  defer restoreDir()
  
  // Create a large file
  var largeContent strings.Builder
  for i := 1; i <= 1000; i++ {
    largeContent.WriteString(fmt.Sprintf("line %d content here\n", i))
  }
  
  oldCommitHash := scenario.commitFile(scenario.filename, largeContent.String(), "Large initial file")
  
  // Add some commits
  for i := 0; i < 10; i++ {
    largeContent.WriteString(fmt.Sprintf("additional line %d\n", i))
    scenario.commitFile(scenario.filename, largeContent.String(), fmt.Sprintf("Add line %d", i))
  }
  
  // Modify many lines
  modifiedContent := strings.ReplaceAll(largeContent.String(), "line ", "modified line ")
  scenario.modifyFile(scenario.filename, modifiedContent)
  
  // Create a large list of line numbers
  var lines []int
  for i := 1; i <= 500; i++ {
    lines = append(lines, i)
  }
  
  // Measure performance
  start := time.Now()
  hasConflict, reason := analyzeConflictRisk(scenario.filename, oldCommitHash, lines)
  duration := time.Since(start)
  
  t.Logf("Conflict analysis for %d lines took %v", len(lines), duration)
  t.Logf("Conflict detected: %v, Reason: %s", hasConflict, reason)
  
  // Should complete within reasonable time
  if duration > 10*time.Second {
    t.Errorf("Conflict detection took too long: %v", duration)
  }
}

// Helper method for TestScenario to get file content
func (s *TestScenario) getFileContent() string {
  s.t.Helper()
  
  content, err := os.ReadFile(filepath.Join(s.dir, s.filename))
  if err != nil {
    s.t.Fatal("Failed to read file content:", err)
  }
  return string(content)
}

// BenchmarkConflictDetection benchmarks the conflict detection function
func BenchmarkConflictDetection(b *testing.B) {
  scenario := createTestScenario(&testing.T{}, "bench_conflict")
  defer scenario.cleanup()
  
  restoreDir := scenario.changeToScenarioDir()
  defer restoreDir()
  
  // Setup test scenario
  initialContent := strings.Repeat("line content\n", 100)
  oldCommitHash := scenario.commitFile(scenario.filename, initialContent, "Initial commit")
  
  // Add a few commits
  for i := 0; i < 5; i++ {
    content := initialContent + fmt.Sprintf("extra line %d\n", i)
    scenario.commitFile(scenario.filename, content, fmt.Sprintf("Commit %d", i))
  }
  
  // Modify file
  modifiedContent := strings.ReplaceAll(initialContent+"extra line 4\n", "line content", "modified content")
  scenario.modifyFile(scenario.filename, modifiedContent)
  
  lines := []int{1, 10, 20, 30, 40, 50}
  
  b.ResetTimer()
  
  for i := 0; i < b.N; i++ {
    analyzeConflictRisk(scenario.filename, oldCommitHash, lines)
  }
}