remove que from ignore

Author: njenia

.gitignore

@@ -4,7 +4,6 @@
 *.dll
 *.so
 *.dylib
-que
 que.exe
 
 # Test binary, built with `go test -c`

cmd/que/e2e_test.go

@@ -0,0 +1,247 @@
+package main
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/jenian/que/internal/config"
+	"github.com/jenian/que/internal/enricher"
+	"github.com/jenian/que/internal/ingestor"
+	"github.com/jenian/que/internal/sanitizer"
+)
+
+// TestE2E_NoProblem tests the full pipeline when no problem is detected
+func TestE2E_NoProblem(t *testing.T) {
+	// Setup: Create a simple log with no errors
+	logInput := "2024-01-15 10:00:00 INFO Application started successfully\n2024-01-15 10:00:01 INFO Server listening on port 8080"
+	
+	// Test the pipeline components
+	reader := strings.NewReader(logInput)
+	rawLog, err := ingestor.IngestFromReader(reader)
+	if err != nil {
+		t.Fatalf("Failed to ingest: %v", err)
+	}
+	
+	ctx := enricher.Enrich()
+	redactor := sanitizer.NewRedactor()
+	sanitizedLog, _ := redactor.Redact(rawLog)
+	
+	// Verify sanitization worked
+	if sanitizedLog != rawLog {
+		t.Logf("Log was sanitized (expected for this test)")
+	}
+	
+	// Verify we got the log
+	if !strings.Contains(rawLog, "Application started") {
+		t.Error("Expected log content not found")
+	}
+	
+	// Verify context was gathered
+	if ctx.OS == "" {
+		t.Error("Expected OS to be set in context")
+	}
+}
+
+// TestE2E_WithSecrets tests the full pipeline with secrets that should be redacted
+func TestE2E_WithSecrets(t *testing.T) {
+	// Setup: Create a log with a GitHub token (gitleaks will detect this)
+	logInput := "GITHUB_TOKEN=ghp_123456789012345678901234567890123456\nError: Authentication failed"
+	
+	redactor := sanitizer.NewRedactor()
+	sanitizedLog, count := redactor.Redact(logInput)
+	
+	// Verify secrets were detected and redacted
+	if count == 0 {
+		t.Log("No secrets detected (may depend on gitleaks patterns)")
+	} else {
+		// If secrets were found, they should be redacted
+		if strings.Contains(sanitizedLog, "ghp_123456789012345678901234567890123456") {
+			t.Error("Secret should be redacted but found in output")
+		}
+		if !strings.Contains(sanitizedLog, "REDACTED") {
+			t.Log("Redaction placeholder not found (may use different format)")
+		}
+	}
+}
+
+// TestE2E_LLMResponseFormats tests different LLM response formats
+func TestE2E_LLMResponseFormats(t *testing.T) {
+	testCases := []struct {
+		name     string
+		response string
+		validate func(t *testing.T, result string)
+	}{
+		{
+			name: "no_problem_status",
+			response: func() string {
+				resp := config.LLMResponse{
+					Status:    "no_problem",
+					RootCause:  "",
+					Evidence:   "",
+					Fix:        "",
+				}
+				jsonData, _ := json.Marshal(resp)
+				return string(jsonData)
+			}(),
+			validate: func(t *testing.T, result string) {
+				if !strings.Contains(result, "no problems detected") {
+					t.Error("Should contain 'no problems detected' message")
+				}
+			},
+		},
+		{
+			name: "insufficient_data_status",
+			response: func() string {
+				resp := config.LLMResponse{
+					Status:    "insufficient_data",
+					RootCause:  "Some error",
+					Evidence:   config.EvidenceString("Error log line 1\nError log line 2"),
+					Fix:        "",
+				}
+				jsonData, _ := json.Marshal(resp)
+				return string(jsonData)
+			}(),
+			validate: func(t *testing.T, result string) {
+				if !strings.Contains(result, "Evidence") {
+					t.Error("Should contain Evidence section")
+				}
+				if !strings.Contains(result, "insufficient data") {
+					t.Error("Should contain insufficient data warning")
+				}
+				if strings.Contains(result, "Fix") {
+					t.Error("Should NOT contain Fix section")
+				}
+			},
+		},
+		{
+			name: "problem_detected_full",
+			response: func() string {
+				resp := config.LLMResponse{
+					Status:    "problem_detected",
+					RootCause:  "Invalid API key",
+					Evidence:   config.EvidenceString("401 Unauthorized"),
+					Fix:        "export API_KEY='valid_key'",
+				}
+				jsonData, _ := json.Marshal(resp)
+				return string(jsonData)
+			}(),
+			validate: func(t *testing.T, result string) {
+				if !strings.Contains(result, "Root Cause") {
+					t.Error("Should contain Root Cause section")
+				}
+				if !strings.Contains(result, "Evidence") {
+					t.Error("Should contain Evidence section")
+				}
+				if !strings.Contains(result, "Fix") {
+					t.Error("Should contain Fix section")
+				}
+			},
+		},
+		{
+			name: "evidence_as_array",
+			response: func() string {
+				// Test evidence as array
+				resp := map[string]interface{}{
+					"status":     "problem_detected",
+					"root_cause": "Test error",
+					"evidence":   []string{"Line 1", "Line 2", "Line 3"},
+					"fix":        "Test fix",
+				}
+				jsonData, _ := json.Marshal(resp)
+				return string(jsonData)
+			}(),
+			validate: func(t *testing.T, result string) {
+				if !strings.Contains(result, "Line 1") {
+					t.Error("Should contain first evidence line")
+				}
+				if !strings.Contains(result, "Line 2") {
+					t.Error("Should contain second evidence line")
+				}
+			},
+		},
+	}
+	
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Import the parseAndFormatResponse function from advisor package
+			// Since it's not exported, we'll test through the advisor.Advise function
+			// But for unit testing, we can test the JSON parsing directly
+			var llmResp config.LLMResponse
+			err := json.Unmarshal([]byte(tc.response), &llmResp)
+			if err != nil {
+				t.Fatalf("Failed to parse JSON: %v", err)
+			}
+			
+			// Verify the response was parsed correctly
+			if tc.name == "no_problem_status" && llmResp.Status != "no_problem" {
+				t.Error("Status should be 'no_problem'")
+			}
+			if tc.name == "insufficient_data_status" && llmResp.Status != "insufficient_data" {
+				t.Error("Status should be 'insufficient_data'")
+			}
+			if tc.name == "problem_detected_full" && llmResp.Status != "problem_detected" {
+				t.Error("Status should be 'problem_detected'")
+			}
+		})
+	}
+}
+
+// TestE2E_PipelineFlow tests the complete pipeline flow
+func TestE2E_PipelineFlow(t *testing.T) {
+	// Create test log
+	testLog := `2024-01-15 14:32:11 ERROR Database connection failed
+Unable to connect to PostgreSQL database
+Connection string: postgresql://user:password@localhost:5432/mydb`
+
+	// Step 1: Ingest
+	reader := strings.NewReader(testLog)
+	rawLog, err := ingestor.IngestFromReader(reader)
+	if err != nil {
+		t.Fatalf("Ingestion failed: %v", err)
+	}
+	if rawLog == "" {
+		t.Error("Expected non-empty log")
+	}
+
+	// Step 2: Enrich
+	ctx := enricher.Enrich()
+	if ctx.OS == "" {
+		t.Error("Expected OS to be set")
+	}
+	if ctx.Timestamp.IsZero() {
+		t.Error("Expected timestamp to be set")
+	}
+
+	// Step 3: Sanitize
+	redactor := sanitizer.NewRedactor()
+	sanitizedLog, count := redactor.Redact(rawLog)
+	
+	// Verify sanitization
+	if count > 0 {
+		// If secrets were found, verify they're redacted
+		if strings.Contains(sanitizedLog, "password") && !strings.Contains(sanitizedLog, "REDACTED") {
+			t.Log("Password found but may not be detected by gitleaks patterns")
+		}
+	}
+
+	// Step 4: Create payload
+	payload := config.QueryPayload{
+		RawLog:       rawLog,
+		SanitizedLog: sanitizedLog,
+		SystemContext: ctx,
+	}
+
+	// Verify payload
+	if payload.RawLog == "" {
+		t.Error("Payload should have raw log")
+	}
+	if payload.SanitizedLog == "" {
+		t.Error("Payload should have sanitized log")
+	}
+	if payload.SystemContext.OS == "" {
+		t.Error("Payload should have system context")
+	}
+}
+
+