Merge pull request #16 from fabricekabongo/codex/increase-code-coverage-for-edge-cases

Author: fabricekabongo

clustering/cluster_test.go

@@ -0,0 +1,67 @@
+package clustering
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/fabricekabongo/loggerhead/config"
+	"github.com/hashicorp/memberlist"
+)
+
+func TestStateToString(t *testing.T) {
+	cases := map[memberlist.NodeStateType]string{
+		memberlist.StateAlive:         "Alive",
+		memberlist.StateSuspect:       "Suspect",
+		memberlist.StateLeft:          "Left",
+		memberlist.StateDead:          "Dead",
+		memberlist.NodeStateType(255): "Unknown",
+	}
+
+	for state, expected := range cases {
+		if got := StateToString(state); got != expected {
+			t.Fatalf("expected %s for state %v but got %s", expected, state, got)
+		}
+	}
+}
+
+func TestGetClusterIPsWithSeedNode(t *testing.T) {
+	cfg := config.Config{SeedNode: "10.0.0.1"}
+
+	ips, err := getClusterIPs(cfg)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(ips) != 1 || ips[0] != cfg.SeedNode {
+		t.Fatalf("expected seed node slice with %s, got %#v", cfg.SeedNode, ips)
+	}
+}
+
+func TestGetClusterIPsWithDNS(t *testing.T) {
+	cfg := config.Config{ClusterDNS: "localhost"}
+
+	ips, err := getClusterIPs(cfg)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(ips) == 0 {
+		t.Fatal("expected at least one IP from localhost resolution")
+	}
+}
+
+func TestGetClusterIPsDNSFailure(t *testing.T) {
+	cfg := config.Config{ClusterDNS: "nonexistent.invalid."}
+
+	_, err := getClusterIPs(cfg)
+	if !errors.Is(err, ErrFailedToExtractIPsFromDNS) {
+		t.Fatalf("expected ErrFailedToExtractIPsFromDNS, got %v", err)
+	}
+}
+
+func TestGetIPsFromDomainNameInvalid(t *testing.T) {
+	_, err := getIPsFromDomainName("nonexistent.invalid.")
+	if err == nil {
+		t.Fatal("expected lookup error for invalid domain")
+	}
+}

clustering/engine_test.go

@@ -0,0 +1,90 @@
+package clustering
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/fabricekabongo/loggerhead/query"
+	"github.com/fabricekabongo/loggerhead/world"
+	"github.com/hashicorp/memberlist"
+)
+
+func TestEngineDecoratorQueuesBroadcasts(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	cluster := &Cluster{broadcasts: &memberlist.TransmitLimitedQueue{NumNodes: func() int { return 1 }, RetransmitMult: 1}}
+	engine := query.NewWriteQueryEngine(world.NewWorld())
+
+	decorator := NewEngineDecorator(ctx, cluster, engine)
+	ed := decorator.(*EngineDecorator)
+
+	result := ed.ExecuteQuery("SAVE ns loc 1 1")
+	if result != "1.0,saved\n" {
+		t.Fatalf("expected save confirmation, got %q", result)
+	}
+
+	var broadcasts [][]byte
+	deadline := time.Now().Add(200 * time.Millisecond)
+	for time.Now().Before(deadline) {
+		broadcasts = cluster.broadcasts.GetBroadcasts(0, 1024)
+		if len(broadcasts) > 0 {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	if len(broadcasts) != 1 {
+		t.Fatalf("expected 1 broadcast, got %d", len(broadcasts))
+	}
+
+	if string(broadcasts[0]) != "SAVE ns loc 1 1" {
+		t.Fatalf("unexpected broadcast message %q", string(broadcasts[0]))
+	}
+}
+
+func TestEngineDecoratorStopsWithCanceledContext(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cluster := &Cluster{broadcasts: &memberlist.TransmitLimitedQueue{NumNodes: func() int { return 1 }, RetransmitMult: 1}}
+	engine := query.NewWriteQueryEngine(world.NewWorld())
+
+	NewEngineDecorator(ctx, cluster, engine)
+	cancel()
+
+	time.Sleep(10 * time.Millisecond)
+
+	select {
+	case <-ctx.Done():
+	default:
+		t.Fatal("context should be cancelled")
+	}
+}
+
+func TestLocationBroadcastBehaviors(t *testing.T) {
+	first := NewLocationBroadcast("SAVE ns loc 1 1")
+	second := NewLocationBroadcast("SAVE ns loc 1 1")
+	different := NewLocationBroadcast("SAVE ns loc 2 2")
+
+	if !first.Invalidates(second) {
+		t.Fatal("expected identical commands to invalidate each other")
+	}
+
+	if different.Invalidates(first) {
+		t.Fatal("expected different commands to not invalidate")
+	}
+
+	notify := make(chan struct{})
+	withNotify := &LocationBroadcast{command: "SAVE ns loc 1 1", msg: []byte("payload"), notify: notify}
+	withNotify.Finished()
+
+	select {
+	case <-notify:
+	case <-time.After(time.Second):
+		t.Fatal("expected notify channel to be closed")
+	}
+
+	if string(first.Message()) != "SAVE ns loc 1 1" {
+		t.Fatalf("unexpected message payload %q", string(first.Message()))
+	}
+}