refactor: format code with gofmt and improve test mocks

- Ran gofmt across codebase to fix formatting inconsistencies
- Fixed import ordering (gofmt standard)
- Aligned struct field indentation
- Fixed multi-line expression alignment

Test improvements:
- Enhanced mockResultStore with proper state management
- Added savedFindingsByScan and savedScans maps for realistic storage
- Added savedEvents tracking for scan event verification
- Implemented proper mock methods that return stored data instea

Author: CodeMonkeyCybersecurity

cmd/auth_test.go

@@ -112,7 +112,12 @@ func TestAuthDiscoverCommand(t *testing.T) {
 			}
 
 			// Execute command
-			err := cmd.RunE(cmd, []string{tt.target})
+			args := []string{}
+			if tt.target != "" {
+				args = []string{tt.target}
+			}
+
+			err := cmd.RunE(cmd, args)
 
 			// Restore stdout
 			w.Close()

cmd/boileau.go

@@ -9,8 +9,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/CodeMonkeyCybersecurity/artemis/pkg/cli/adapters"
 	"github.com/CodeMonkeyCybersecurity/artemis/pkg/boileau"
+	"github.com/CodeMonkeyCybersecurity/artemis/pkg/cli/adapters"
 	"github.com/CodeMonkeyCybersecurity/artemis/pkg/types"
 	"github.com/spf13/cobra"
 )

cmd/cert_enhanced_test.go

@@ -5,8 +5,8 @@ import (
 	"context"
 	"fmt"
 	"strings"
-	"time"
 	"testing"
+	"time"
 
 	"github.com/CodeMonkeyCybersecurity/artemis/internal/config"
 	"github.com/CodeMonkeyCybersecurity/artemis/internal/logger"
@@ -33,9 +33,9 @@ func TestCertEnhanced(t *testing.T) {
 
 	// Test with multiple domains
 	testDomains := []string{
-		"anthropic.com",    // AI company
-		"github.com",       // Should have many SANs
-		"cloudflare.com",   // CDN with many properties
+		"anthropic.com",  // AI company
+		"github.com",     // Should have many SANs
+		"cloudflare.com", // CDN with many properties
 	}
 
 	for _, domain := range testDomains {

cmd/certificate_discovery_test.go

@@ -38,12 +38,12 @@ func TestCertificateDiscovery(t *testing.T) {
 
 	// Setup organization correlator with all features enabled
 	corrCfg := correlation.CorrelatorConfig{
-		EnableWhois:   true,
-		EnableCerts:   true,
-		EnableASN:     true,
+		EnableWhois:    true,
+		EnableCerts:    true,
+		EnableASN:      true,
 		EnableLinkedIn: false, // Skip for this test
-		EnableGitHub:  false,  // Skip for this test
-		CacheTTL:      1 * time.Hour,
+		EnableGitHub:   false, // Skip for this test
+		CacheTTL:       1 * time.Hour,
 	}
 
 	fmt.Println("📊 Configuration:")

cmd/internal/converters/findings.go

@@ -375,18 +375,18 @@ func buildCorrelationSolution(insight correlation.CorrelatedInsight) string {
 
 func getNetworkAuthCount(networkAuth *authdiscovery.NetworkAuthMethods) int {
 	return len(networkAuth.SSH) + len(networkAuth.RDP) +
-		   len(networkAuth.Kerberos) + len(networkAuth.LDAP) +
-		   len(networkAuth.RADIUS) + len(networkAuth.SMB) +
-		   len(networkAuth.SMTP) + len(networkAuth.IMAP)
+		len(networkAuth.Kerberos) + len(networkAuth.LDAP) +
+		len(networkAuth.RADIUS) + len(networkAuth.SMB) +
+		len(networkAuth.SMTP) + len(networkAuth.IMAP)
 }
 
 func getWebAuthCount(webAuth *authdiscovery.WebAuthMethods) int {
 	return len(webAuth.FormLogin) + len(webAuth.BasicAuth) +
-		   len(webAuth.OAuth2) + len(webAuth.SAML) +
-		   len(webAuth.OIDC) + len(webAuth.WebAuthn) +
-		   len(webAuth.CAS) + len(webAuth.JWT) +
-		   len(webAuth.NTLM) + len(webAuth.Cookies) +
-		   len(webAuth.Headers)
+		len(webAuth.OAuth2) + len(webAuth.SAML) +
+		len(webAuth.OIDC) + len(webAuth.WebAuthn) +
+		len(webAuth.CAS) + len(webAuth.JWT) +
+		len(webAuth.NTLM) + len(webAuth.Cookies) +
+		len(webAuth.Headers)
 }
 
 func getAPIAuthCount(apiAuth *authdiscovery.APIAuthMethods) int {

cmd/internal/converters/findings_test.go

@@ -305,7 +305,7 @@ func TestBuildSecretSolution(t *testing.T) {
 func contains(s, substr string) bool {
 	return len(s) >= len(substr) && (s == substr || len(s) > len(substr) &&
 		(s[:len(substr)] == substr || s[len(s)-len(substr):] == substr ||
-		containsSubstring(s, substr)))
+			containsSubstring(s, substr)))
 }
 
 func containsSubstring(s, substr string) bool {

cmd/orchestrator/orchestrator_test.go

@@ -25,12 +25,23 @@ type mockResultStore struct {
 	updateScanCalled     bool
 	saveFindingsCalled   bool
 	savedFindings        []types.Finding
+	savedFindingsByScan  map[string][]types.Finding
+	savedScans           map[string]*types.ScanRequest
 	scanID               string
 	err                  error
 	returnScan           *types.ScanRequest
 	returnFindings       []types.Finding
 	savedCorrelation     map[string][]types.CorrelationResult
 	savedCorrelationType map[string][]types.CorrelationResult
+	savedEvents          []storedScanEvent
+}
+
+type storedScanEvent struct {
+	scanID    string
+	eventType string
+	component string
+	message   string
+	metadata  map[string]interface{}
 }
 
 func (m *mockResultStore) ensureCorrelationMaps() {
@@ -42,61 +53,174 @@ func (m *mockResultStore) ensureCorrelationMaps() {
 	}
 }
 
+func (m *mockResultStore) ensureStorage() {
+	if m.savedFindingsByScan == nil {
+		m.savedFindingsByScan = make(map[string][]types.Finding)
+	}
+	if m.savedScans == nil {
+		m.savedScans = make(map[string]*types.ScanRequest)
+	}
+}
+
 func (m *mockResultStore) SaveScan(ctx context.Context, scan *types.ScanRequest) error {
 	m.saveScanCalled = true
+	m.ensureStorage()
+	if scan != nil {
+		m.savedScans[scan.ID] = scan
+	}
 	return m.err
 }
 
 func (m *mockResultStore) UpdateScan(ctx context.Context, scan *types.ScanRequest) error {
 	m.updateScanCalled = true
+	m.ensureStorage()
+	if scan != nil {
+		m.savedScans[scan.ID] = scan
+	}
 	return m.err
 }
 
 func (m *mockResultStore) GetScan(ctx context.Context, scanID string) (*types.ScanRequest, error) {
 	m.scanID = scanID
+	m.ensureStorage()
+	if scan, ok := m.savedScans[scanID]; ok {
+		return scan, m.err
+	}
 	return m.returnScan, m.err
 }
 
 func (m *mockResultStore) ListScans(ctx context.Context, filter core.ScanFilter) ([]*types.ScanRequest, error) {
+	m.ensureStorage()
 	return []*types.ScanRequest{m.returnScan}, m.err
 }
 
 func (m *mockResultStore) SaveFindings(ctx context.Context, findings []types.Finding) error {
 	m.saveFindingsCalled = true
 	m.savedFindings = append(m.savedFindings, findings...)
+	m.ensureStorage()
+	if len(findings) > 0 {
+		scanID := findings[0].ScanID
+		m.savedFindingsByScan[scanID] = append(m.savedFindingsByScan[scanID], findings...)
+	}
 	return m.err
 }
 
 func (m *mockResultStore) GetFindings(ctx context.Context, scanID string) ([]types.Finding, error) {
 	m.scanID = scanID
+	m.ensureStorage()
+	if stored, ok := m.savedFindingsByScan[scanID]; ok {
+		return stored, m.err
+	}
 	return m.returnFindings, m.err
 }
 
 func (m *mockResultStore) GetFindingsBySeverity(ctx context.Context, severity types.Severity) ([]types.Finding, error) {
+	m.ensureStorage()
+	results := make([]types.Finding, 0)
+	for _, findings := range m.savedFindingsByScan {
+		for _, f := range findings {
+			if f.Severity == severity {
+				results = append(results, f)
+			}
+		}
+	}
+	if len(results) > 0 {
+		return results, m.err
+	}
 	return m.returnFindings, m.err
 }
 
 func (m *mockResultStore) QueryFindings(ctx context.Context, query core.FindingQuery) ([]types.Finding, error) {
+	m.ensureStorage()
+	results := make([]types.Finding, 0)
+	for scanID, findings := range m.savedFindingsByScan {
+		if query.ScanID != "" && query.ScanID != scanID {
+			continue
+		}
+		results = append(results, findings...)
+	}
+	if len(results) > 0 {
+		return results, m.err
+	}
 	return m.returnFindings, m.err
 }
 
 func (m *mockResultStore) GetFindingStats(ctx context.Context) (*core.FindingStats, error) {
-	return &core.FindingStats{}, m.err
+	m.ensureStorage()
+	stats := &core.FindingStats{
+		Total:      0,
+		BySeverity: make(map[types.Severity]int),
+		ByTool:     make(map[string]int),
+		ByType:     make(map[string]int),
+	}
+	for _, findings := range m.savedFindingsByScan {
+		stats.Total += len(findings)
+		for _, f := range findings {
+			stats.BySeverity[f.Severity]++
+			stats.ByTool[f.Tool]++
+			stats.ByType[f.Type]++
+		}
+	}
+	return stats, m.err
 }
 
 func (m *mockResultStore) GetRecentCriticalFindings(ctx context.Context, limit int) ([]types.Finding, error) {
+	m.ensureStorage()
+	results := make([]types.Finding, 0)
+	for _, findings := range m.savedFindingsByScan {
+		for _, f := range findings {
+			if f.Severity == types.SeverityCritical {
+				results = append(results, f)
+			}
+		}
+	}
+	if len(results) > limit && limit > 0 {
+		results = results[:limit]
+	}
+	if len(results) > 0 {
+		return results, m.err
+	}
 	return m.returnFindings, m.err
 }
 
 func (m *mockResultStore) SearchFindings(ctx context.Context, searchTerm string, limit int) ([]types.Finding, error) {
+	m.ensureStorage()
+	results := make([]types.Finding, 0)
+	for _, findings := range m.savedFindingsByScan {
+		results = append(results, findings...)
+	}
+	if len(results) > limit && limit > 0 {
+		results = results[:limit]
+	}
+	if len(results) > 0 {
+		return results, m.err
+	}
 	return m.returnFindings, m.err
 }
 
 func (m *mockResultStore) GetSummary(ctx context.Context, scanID string) (*types.Summary, error) {
-	return &types.Summary{}, m.err
+	m.ensureStorage()
+	summary := &types.Summary{
+		BySeverity: make(map[types.Severity]int),
+		ByTool:     make(map[string]int),
+	}
+	findings := m.savedFindingsByScan[scanID]
+	summary.Total = len(findings)
+	for _, f := range findings {
+		summary.BySeverity[f.Severity]++
+		summary.ByTool[f.Tool]++
+	}
+	return summary, m.err
 }
 
 func (m *mockResultStore) SaveScanEvent(ctx context.Context, scanID string, eventType string, component string, message string, metadata map[string]interface{}) error {
+	m.savedEvents = append(m.savedEvents, storedScanEvent{
+		scanID:    scanID,
+		eventType: eventType,
+		component: component,
+		message:   message,
+		metadata:  metadata,
+	})
 	return m.err
 }