Fix short flags, AllowTCP wiring, invalid root server error, add config tests

- Register -v/-q short flag aliases sharing the same bool variable as
  --verbose/--quiet so both forms work identically
- Register -d and -dd flags; use ParseDebugLevel() helper so -d sets
  Debug=1 and -dd sets Debug=2; remove the broken strings.Count approach
- Add AllowTCP field to dns.QueryConfig; guard TCP truncation fallback in
  QueryWithExchange and IterativeQueryWithExchange behind cfg.AllowTCP;
  wire cfg.AllowTCP from CLI config into QueryConfig in main.go
- ParseRootServer() now returns ErrInvalidRootServer instead of (nil,nil)
  when the string is non-empty but net.ParseIP fails
- Add internal/config/config_test.go covering ParseQueryType, ParseUDPSize,
  Validate, GetDomain, ParseRootServer, ParseDebugLevel, and the
  --always-tcp/--allow-tcp cross-check
- Add TestQueryNoTCPFallbackWhenDisabled to dns/query_test.go
- Update existing truncation tests to set AllowTCP:true
- Add TODO comments on display flags not yet wired to output layer

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: multica-agent <github@multica.ai>

internal/config/config.go

@@ -11,12 +11,13 @@ import (
 )
 
 var (
-	ErrInvalidQueryType    = errors.New("invalid query type")
-	ErrInvalidUDPSize      = errors.New("UDP size must be between 512 and 4096")
-	ErrInvalidMaxDepth     = errors.New("max depth must be between 1 and 100")
-	ErrInvalidRetries      = errors.New("retries must be between 0 and 10")
-	ErrMissingDomain       = errors.New("domain is required")
+	ErrInvalidQueryType     = errors.New("invalid query type")
+	ErrInvalidUDPSize       = errors.New("UDP size must be between 512 and 4096")
+	ErrInvalidMaxDepth      = errors.New("max depth must be between 1 and 100")
+	ErrInvalidRetries       = errors.New("retries must be between 0 and 10")
+	ErrMissingDomain        = errors.New("domain is required")
 	ErrAlwaysTCPRequiresTCP = errors.New("--always-tcp requires --allow-tcp")
+	ErrInvalidRootServer    = errors.New("invalid root server IP address")
 )
 
 type Config struct {
@@ -138,7 +139,23 @@ func (c *Config) ParseRootServer() (net.IP, error) {
 	if c.RootServer == "" {
 		return nil, nil
 	}
-	return net.ParseIP(c.RootServer), nil
+	ip := net.ParseIP(c.RootServer)
+	if ip == nil {
+		return nil, fmt.Errorf("%w: %s", ErrInvalidRootServer, c.RootServer)
+	}
+	return ip, nil
+}
+
+// ParseDebugLevel returns the debug verbosity level from the -d and -dd flag values.
+// dd=true → 2 (library debug), d=true → 1 (application debug), neither → 0.
+func ParseDebugLevel(d, dd bool) int {
+	if dd {
+		return 2
+	}
+	if d {
+		return 1
+	}
+	return 0
 }
 
 func PrintUsage() {

internal/config/config_test.go

@@ -0,0 +1,216 @@
+package config
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestParseQueryTypeValid(t *testing.T) {
+	cases := []struct {
+		input    string
+		wantType uint16
+	}{
+		{"A", 1},
+		{"aaaa", 28},
+		{"NS", 2},
+		{"CNAME", 5},
+		{"MX", 15},
+		{"TXT", 16},
+		{"SOA", 6},
+		{"PTR", 12},
+		{"ANY", 255},
+	}
+	for _, tc := range cases {
+		got, err := ParseQueryType(tc.input)
+		if err != nil {
+			t.Errorf("ParseQueryType(%q) unexpected error: %v", tc.input, err)
+		}
+		if got != tc.wantType {
+			t.Errorf("ParseQueryType(%q) = %d, want %d", tc.input, got, tc.wantType)
+		}
+	}
+}
+
+func TestParseQueryTypeInvalid(t *testing.T) {
+	_, err := ParseQueryType("BOGUS")
+	if err == nil {
+		t.Fatal("expected error for invalid query type")
+	}
+	if !errors.Is(err, ErrInvalidQueryType) {
+		t.Errorf("expected ErrInvalidQueryType, got %v", err)
+	}
+}
+
+func TestParseUDPSizeValid(t *testing.T) {
+	cases := []string{"512", "2048", "4096"}
+	for _, s := range cases {
+		if _, err := ParseUDPSize(s); err != nil {
+			t.Errorf("ParseUDPSize(%q) unexpected error: %v", s, err)
+		}
+	}
+}
+
+func TestParseUDPSizeInvalid(t *testing.T) {
+	cases := []string{"0", "511", "4097", "notanumber"}
+	for _, s := range cases {
+		_, err := ParseUDPSize(s)
+		if err == nil {
+			t.Errorf("ParseUDPSize(%q): expected error", s)
+		}
+		if !errors.Is(err, ErrInvalidUDPSize) {
+			t.Errorf("ParseUDPSize(%q): expected ErrInvalidUDPSize, got %v", s, err)
+		}
+	}
+}
+
+func TestValidateOK(t *testing.T) {
+	cfg := DefaultConfig()
+	if err := cfg.Validate(); err != nil {
+		t.Fatalf("DefaultConfig should be valid, got: %v", err)
+	}
+}
+
+func TestValidateAlwaysTCPRequiresAllowTCP(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.AlwaysTCP = true
+	cfg.AllowTCP = false
+	err := cfg.Validate()
+	if err == nil {
+		t.Fatal("expected error when AlwaysTCP=true and AllowTCP=false")
+	}
+	if !errors.Is(err, ErrAlwaysTCPRequiresTCP) {
+		t.Errorf("expected ErrAlwaysTCPRequiresTCP, got %v", err)
+	}
+}
+
+func TestValidateAlwaysTCPWithAllowTCP(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.AlwaysTCP = true
+	cfg.AllowTCP = true
+	if err := cfg.Validate(); err != nil {
+		t.Errorf("AlwaysTCP=true, AllowTCP=true should be valid, got: %v", err)
+	}
+}
+
+func TestValidateBadUDPSize(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.UDPSize = 100
+	if err := cfg.Validate(); !errors.Is(err, ErrInvalidUDPSize) {
+		t.Errorf("expected ErrInvalidUDPSize, got %v", err)
+	}
+}
+
+func TestValidateBadMaxDepth(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.MaxDepth = 0
+	if err := cfg.Validate(); !errors.Is(err, ErrInvalidMaxDepth) {
+		t.Errorf("expected ErrInvalidMaxDepth, got %v", err)
+	}
+}
+
+func TestValidateBadRetries(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.Retries = 11
+	if err := cfg.Validate(); !errors.Is(err, ErrInvalidRetries) {
+		t.Errorf("expected ErrInvalidRetries, got %v", err)
+	}
+}
+
+func TestGetDomainOK(t *testing.T) {
+	cfg := DefaultConfig()
+	d, err := cfg.GetDomain([]string{"example.com"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if d != "example.com" {
+		t.Errorf("got %q, want %q", d, "example.com")
+	}
+}
+
+func TestGetDomainMissing(t *testing.T) {
+	cfg := DefaultConfig()
+	_, err := cfg.GetDomain([]string{})
+	if err == nil {
+		t.Fatal("expected error for missing domain")
+	}
+	if !errors.Is(err, ErrMissingDomain) {
+		t.Errorf("expected ErrMissingDomain, got %v", err)
+	}
+}
+
+func TestParseRootServerEmpty(t *testing.T) {
+	cfg := DefaultConfig()
+	ip, err := cfg.ParseRootServer()
+	if err != nil {
+		t.Fatalf("unexpected error for empty root server: %v", err)
+	}
+	if ip != nil {
+		t.Errorf("expected nil IP for empty root server, got %v", ip)
+	}
+}
+
+func TestParseRootServerValidIPv4(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.RootServer = "198.41.0.4"
+	ip, err := cfg.ParseRootServer()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if ip == nil || ip.String() != "198.41.0.4" {
+		t.Errorf("expected 198.41.0.4, got %v", ip)
+	}
+}
+
+func TestParseRootServerValidIPv6(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.RootServer = "2001:503:ba3e::2:30"
+	ip, err := cfg.ParseRootServer()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if ip == nil {
+		t.Error("expected non-nil IP for valid IPv6 address")
+	}
+}
+
+func TestParseRootServerInvalid(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.RootServer = "not-an-ip"
+	_, err := cfg.ParseRootServer()
+	if err == nil {
+		t.Fatal("expected error for invalid root server IP")
+	}
+	if !errors.Is(err, ErrInvalidRootServer) {
+		t.Errorf("expected ErrInvalidRootServer, got %v", err)
+	}
+}
+
+func TestParseRootServerHostname(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.RootServer = "a.root-servers.net"
+	_, err := cfg.ParseRootServer()
+	if err == nil {
+		t.Fatal("expected error for hostname (not IP) root server")
+	}
+	if !errors.Is(err, ErrInvalidRootServer) {
+		t.Errorf("expected ErrInvalidRootServer, got %v", err)
+	}
+}
+
+func TestParseDebugLevel(t *testing.T) {
+	cases := []struct {
+		d, dd bool
+		want  int
+	}{
+		{false, false, 0},
+		{true, false, 1},
+		{false, true, 2},
+		{true, true, 2}, // dd takes precedence
+	}
+	for _, tc := range cases {
+		got := ParseDebugLevel(tc.d, tc.dd)
+		if got != tc.want {
+			t.Errorf("ParseDebugLevel(d=%v, dd=%v) = %d, want %d", tc.d, tc.dd, got, tc.want)
+		}
+	}
+}

internal/dns/query.go

@@ -10,18 +10,20 @@ import (
 )
 
 type QueryConfig struct {
-	UDPSize int
-	Timeout time.Duration
-	Retries int
-	UseTCP  bool
+	UDPSize  int
+	Timeout  time.Duration
+	Retries  int
+	UseTCP   bool
+	AllowTCP bool
 }
 
 func DefaultQueryConfig() *QueryConfig {
 	return &QueryConfig{
-		UDPSize: DefaultEDNS0UDPSize(),
-		Timeout: 5 * time.Second,
-		Retries: 3,
-		UseTCP:  false,
+		UDPSize:  DefaultEDNS0UDPSize(),
+		Timeout:  5 * time.Second,
+		Retries:  3,
+		UseTCP:   false,
+		AllowTCP: true,
 	}
 }
 
@@ -110,7 +112,7 @@ func QueryWithExchange(ctx context.Context, server net.IP, name string, qtype ui
 			continue
 		}
 
-		if resp.Truncated {
+		if resp.Truncated && cfg.AllowTCP {
 			resp, err = exchangeFn(ctx, serverStr, msg, true)
 			if err != nil {
 				lastErr = err
@@ -178,7 +180,7 @@ func IterativeQueryWithExchange(ctx context.Context, server net.IP, name string,
 			continue
 		}
 
-		if resp.Truncated {
+		if resp.Truncated && cfg.AllowTCP {
 			resp, err = exchangeFn(ctx, serverStr, msg, true)
 			if err != nil {
 				lastErr = err

internal/dns/query_test.go

@@ -110,10 +110,11 @@ func TestQueryTCPFallbackOnTruncation(t *testing.T) {
 	}
 
 	cfg := &QueryConfig{
-		UDPSize: 2048,
-		Timeout: 5,
-		Retries: 1,
-		UseTCP:  false,
+		UDPSize:  2048,
+		Timeout:  5,
+		Retries:  1,
+		UseTCP:   false,
+		AllowTCP: true,
 	}
 
 	server := net.ParseIP("8.8.8.8")
@@ -272,10 +273,11 @@ func TestQueryTCPFallbackFailsThenRetries(t *testing.T) {
 	}
 
 	cfg := &QueryConfig{
-		UDPSize: 2048,
-		Timeout: 5,
-		Retries: 2,
-		UseTCP:  false,
+		UDPSize:  2048,
+		Timeout:  5,
+		Retries:  2,
+		UseTCP:   false,
+		AllowTCP: true,
 	}
 
 	server := net.ParseIP("8.8.8.8")
@@ -287,3 +289,43 @@ func TestQueryTCPFallbackFailsThenRetries(t *testing.T) {
 		t.Errorf("expected 4 calls (2 retries x UDP+TCP), got %d", callCount)
 	}
 }
+
+func TestQueryNoTCPFallbackWhenDisabled(t *testing.T) {
+	truncatedResp := new(dns.Msg)
+	truncatedResp.Truncated = true
+	truncatedResp.SetReply(new(dns.Msg))
+
+	var mu sync.Mutex
+	calls := []bool{}
+	exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
+		mu.Lock()
+		defer mu.Unlock()
+		calls = append(calls, useTCP)
+		return truncatedResp.Copy(), nil
+	}
+
+	cfg := &QueryConfig{
+		UDPSize:  2048,
+		Timeout:  5,
+		Retries:  1,
+		UseTCP:   false,
+		AllowTCP: false, // TCP fallback must be suppressed
+	}
+
+	server := net.ParseIP("8.8.8.8")
+	resp, err := QueryWithExchange(context.Background(), server, "example.com", TypeA, cfg, exchangeFn)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	// Only one UDP call; no TCP fallback.
+	if len(calls) != 1 {
+		t.Fatalf("expected 1 exchange call (no TCP fallback), got %d", len(calls))
+	}
+	if calls[0] != false {
+		t.Error("expected UDP-only call")
+	}
+	if !resp.Truncated {
+		t.Error("expected truncated response to be returned as-is")
+	}
+}
+