god-eye/internal/config/config_test.go

package config

import (
	"encoding/json"
	"testing"
)

func TestDefaultResolversNonEmpty(t *testing.T) {
	if len(DefaultResolvers) == 0 {
		t.Fatal("DefaultResolvers is empty")
	}
	for _, r := range DefaultResolvers {
		if r == "" {
			t.Errorf("empty resolver in DefaultResolvers")
		}
	}
}

func TestDefaultWordlistNonEmpty(t *testing.T) {
	if len(DefaultWordlist) < 50 {
		t.Errorf("DefaultWordlist too small: %d entries", len(DefaultWordlist))
	}
	seen := make(map[string]bool)
	for _, w := range DefaultWordlist {
		if w == "" {
			t.Error("empty entry in DefaultWordlist")
		}
		// Note: v1 wordlist contains "smtp" and "staging" twice — that's a bug
		// but not something we fix in baseline tests. Just verify no ALL duplicates.
		seen[w] = true
	}
	if len(seen) < 50 {
		t.Errorf("too many duplicates: %d unique out of %d", len(seen), len(DefaultWordlist))
	}
}

func TestSubdomainResult_JSONRoundtrip(t *testing.T) {
	orig := &SubdomainResult{
		Subdomain:     "api.example.com",
		IPs:           []string{"1.2.3.4"},
		CNAME:         "cname.example.com",
		StatusCode:    200,
		Title:         "API",
		Tech:          []string{"nginx", "Go"},
		CloudProvider: "AWS",
		TLSFingerprint: &TLSFingerprint{
			Vendor:        "Fortinet",
			Product:       "FortiGate",
			ApplianceType: "firewall",
		},
	}

	data, err := json.Marshal(orig)
	if err != nil {
		t.Fatalf("marshal failed: %v", err)
	}

	var decoded SubdomainResult
	if err := json.Unmarshal(data, &decoded); err != nil {
		t.Fatalf("unmarshal failed: %v", err)
	}

	if decoded.Subdomain != orig.Subdomain {
		t.Errorf("Subdomain mismatch: got %q want %q", decoded.Subdomain, orig.Subdomain)
	}
	if len(decoded.IPs) != 1 || decoded.IPs[0] != "1.2.3.4" {
		t.Errorf("IPs mismatch: got %v", decoded.IPs)
	}
	if decoded.TLSFingerprint == nil {
		t.Fatal("TLSFingerprint is nil after roundtrip")
	}
	if decoded.TLSFingerprint.Vendor != "Fortinet" {
		t.Errorf("TLSFingerprint.Vendor = %q, want Fortinet", decoded.TLSFingerprint.Vendor)
	}
}

func TestSubdomainResult_OmitemptyMinimal(t *testing.T) {
	// Ensure zero-value struct produces a minimal JSON (only subdomain field would be present if set).
	empty := &SubdomainResult{}
	data, err := json.Marshal(empty)
	if err != nil {
		t.Fatal(err)
	}
	// Only the required "subdomain" field (empty string) should appear — every other is omitempty.
	expected := `{"subdomain":""}`
	if string(data) != expected {
		t.Errorf("empty struct JSON = %s, want %s", string(data), expected)
	}
}

func TestConfigZeroValue(t *testing.T) {
	var c Config
	if c.Domain != "" {
		t.Errorf("default Domain should be empty, got %q", c.Domain)
	}
	if c.EnableAI {
		t.Error("EnableAI should default to false")
	}
	if c.Concurrency != 0 {
		t.Error("Concurrency should default to 0 (overridden by CLI default)")
	}
}