Add comprehensive tests for EventBus and LetsEncrypt modules

- Implemented multi-engine routing tests to verify correct engine selection based on routing rules.
- Added tests to ensure publishing before starting the EventBus returns an error.
- Created additional tests for Redis EventBus to validate behavior when starting, publishing, and subscribing before initialization.
- Developed statistics tests to confirm correct accumulation of event delivery counts per engine.
- Introduced a noopLogger for testing purposes to avoid logging during tests.
- Added topic prefix filter tests to ensure filtering works as expected.
- Enhanced LetsEncrypt module with tests for configuration validation, certificate handling, and error paths.
- Implemented tests for DNS provider configurations to cover various error scenarios.
- Added tests for certificate renewal and revocation processes, ensuring proper error handling and state management.
- Created storage helper tests to validate certificate storage and expiration checks.

Author: intel352

.gitignore

@@ -26,6 +26,9 @@
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
+# coverage files
+*.cov
+
 # Dependency directories (remove the comment below to include it)
 # vendor/
 

modules/eventbus/additional_eventbus_tests_test.go

@@ -0,0 +1,131 @@
+package eventbus
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// Test basic publish/subscribe lifecycle using memory engine ensuring message receipt and stats increments.
+func TestEventBusPublishSubscribeBasic(t *testing.T) {
+	m := NewModule().(*EventBusModule)
+	app := newMockApp()
+	// Register default config section as RegisterConfig would
+	if err := m.RegisterConfig(app); err != nil {
+		t.Fatalf("register config: %v", err)
+	}
+	if err := m.Init(app); err != nil {
+		t.Fatalf("init: %v", err)
+	}
+	if err := m.Start(context.Background()); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+	defer m.Stop(context.Background())
+
+	received := make(chan struct{}, 1)
+	_, err := m.Subscribe(context.Background(), "test.topic", func(ctx context.Context, e Event) error {
+		if e.Topic != "test.topic" {
+			t.Errorf("unexpected topic %s", e.Topic)
+		}
+		received <- struct{}{}
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("subscribe: %v", err)
+	}
+
+	if err := m.Publish(context.Background(), "test.topic", "payload"); err != nil {
+		t.Fatalf("publish: %v", err)
+	}
+
+	select {
+	case <-received:
+	case <-time.After(2 * time.Second):
+		t.Fatal("timeout waiting for event delivery")
+	}
+
+	del, _ := m.Stats()
+	if del == 0 {
+		t.Fatalf("expected delivered stats > 0")
+	}
+}
+
+// Test unsubscribe removes subscription and no further deliveries occur.
+func TestEventBusUnsubscribe(t *testing.T) {
+	m := NewModule().(*EventBusModule)
+	app := newMockApp()
+	if err := m.RegisterConfig(app); err != nil {
+		t.Fatalf("register config: %v", err)
+	}
+	if err := m.Init(app); err != nil {
+		t.Fatalf("init: %v", err)
+	}
+	if err := m.Start(context.Background()); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+	defer m.Stop(context.Background())
+
+	count := 0
+	sub, err := m.Subscribe(context.Background(), "once.topic", func(ctx context.Context, e Event) error { count++; return nil })
+	if err != nil {
+		t.Fatalf("subscribe: %v", err)
+	}
+
+	if err := m.Publish(context.Background(), "once.topic", 1); err != nil {
+		t.Fatalf("publish1: %v", err)
+	}
+	time.Sleep(50 * time.Millisecond)
+	if count != 1 {
+		t.Fatalf("expected 1 delivery got %d", count)
+	}
+
+	if err := m.Unsubscribe(context.Background(), sub); err != nil {
+		t.Fatalf("unsubscribe: %v", err)
+	}
+	if err := m.Publish(context.Background(), "once.topic", 2); err != nil {
+		t.Fatalf("publish2: %v", err)
+	}
+	time.Sleep(50 * time.Millisecond)
+	if count != 1 {
+		t.Fatalf("expected no additional deliveries after unsubscribe")
+	}
+}
+
+// Test async subscription processes events without blocking publisher.
+func TestEventBusAsyncSubscription(t *testing.T) {
+	m := NewModule().(*EventBusModule)
+	app := newMockApp()
+	if err := m.RegisterConfig(app); err != nil {
+		t.Fatalf("register config: %v", err)
+	}
+	if err := m.Init(app); err != nil {
+		t.Fatalf("init: %v", err)
+	}
+	if err := m.Start(context.Background()); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+	defer m.Stop(context.Background())
+
+	received := make(chan struct{}, 1)
+	_, err := m.SubscribeAsync(context.Background(), "async.topic", func(ctx context.Context, e Event) error { received <- struct{}{}; return nil })
+	if err != nil {
+		t.Fatalf("subscribe async: %v", err)
+	}
+
+	start := time.Now()
+	if err := m.Publish(context.Background(), "async.topic", 123); err != nil {
+		t.Fatalf("publish: %v", err)
+	}
+	// We expect Publish to return quickly (well under 100ms) even if handler not yet executed.
+	if time.Since(start) > 200*time.Millisecond {
+		t.Fatalf("publish blocked unexpectedly long")
+	}
+
+	select {
+	case <-received:
+	case <-time.After(2 * time.Second):
+		t.Fatal("timeout waiting for async delivery")
+	}
+}
+
+// Removed local mockApp (reuse the one defined in module_test.go)

modules/eventbus/cancel_idempotency_test.go

@@ -0,0 +1,53 @@
+package eventbus
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// TestCancelIdempotency ensures calling Cancel multiple times on subscriptions is safe.
+func TestCancelIdempotency(t *testing.T) {
+	// Memory event bus setup
+	memCfg := &EventBusConfig{MaxEventQueueSize: 10, DefaultEventBufferSize: 1, WorkerCount: 1, RetentionDays: 1}
+	mem := NewMemoryEventBus(memCfg)
+	if err := mem.Start(context.Background()); err != nil {
+		t.Fatalf("start memory: %v", err)
+	}
+	sub, err := mem.Subscribe(context.Background(), "idempotent.topic", func(ctx context.Context, e Event) error { return nil })
+	if err != nil {
+		t.Fatalf("subscribe mem: %v", err)
+	}
+	if err := sub.Cancel(); err != nil {
+		t.Fatalf("first cancel mem: %v", err)
+	}
+	// Second cancel should be no-op
+	if err := sub.Cancel(); err != nil {
+		t.Fatalf("second cancel mem: %v", err)
+	}
+
+	// Custom memory event bus setup
+	busRaw, err := NewCustomMemoryEventBus(map[string]interface{}{"enableMetrics": false, "defaultEventBufferSize": 1})
+	if err != nil {
+		t.Fatalf("create custom: %v", err)
+	}
+	cust := busRaw.(*CustomMemoryEventBus)
+	if err := cust.Start(context.Background()); err != nil {
+		t.Fatalf("start custom: %v", err)
+	}
+	csub, err := cust.Subscribe(context.Background(), "idempotent.custom", func(ctx context.Context, e Event) error { return nil })
+	if err != nil {
+		t.Fatalf("subscribe custom: %v", err)
+	}
+	if err := csub.Cancel(); err != nil {
+		t.Fatalf("first cancel custom: %v", err)
+	}
+	if err := csub.Cancel(); err != nil {
+		t.Fatalf("second cancel custom: %v", err)
+	}
+
+	// Publish after cancellation should not trigger handler (cannot easily assert directly without races; rely on no panic).
+	_ = mem.Publish(context.Background(), Event{Topic: "idempotent.topic"})
+	_ = cust.Publish(context.Background(), Event{Topic: "idempotent.custom"})
+	time.Sleep(10 * time.Millisecond)
+}

modules/eventbus/custom_memory_errors_test.go

@@ -0,0 +1,58 @@
+package eventbus
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+)
+
+// TestCustomMemoryErrorPaths covers Publish/Subscribe before Start and nil handler validation.
+func TestCustomMemoryErrorPaths(t *testing.T) {
+	ctx := context.Background()
+	ebRaw, err := NewCustomMemoryEventBus(map[string]interface{}{"enableMetrics": false})
+	if err != nil {
+		t.Fatalf("new bus: %v", err)
+	}
+	eb := ebRaw.(*CustomMemoryEventBus)
+
+	// Publish before Start
+	if err := eb.Publish(ctx, Event{Topic: "x"}); !errors.Is(err, ErrEventBusNotStarted) {
+		t.Fatalf("expected ErrEventBusNotStarted publish, got %v", err)
+	}
+	// Subscribe before Start
+	if _, err := eb.Subscribe(ctx, "x", func(context.Context, Event) error { return nil }); !errors.Is(err, ErrEventBusNotStarted) {
+		t.Fatalf("expected ErrEventBusNotStarted subscribe, got %v", err)
+	}
+	if _, err := eb.SubscribeAsync(ctx, "x", func(context.Context, Event) error { return nil }); !errors.Is(err, ErrEventBusNotStarted) {
+		t.Fatalf("expected ErrEventBusNotStarted subscribe async, got %v", err)
+	}
+
+	// Start now
+	if err := eb.Start(ctx); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	// Nil handler
+	if _, err := eb.Subscribe(ctx, "y", nil); !errors.Is(err, ErrEventHandlerNil) {
+		t.Fatalf("expected ErrEventHandlerNil got %v", err)
+	}
+
+	// Basic successful subscription after start
+	sub, err := eb.Subscribe(ctx, "y", func(context.Context, Event) error { return nil })
+	if err != nil {
+		t.Fatalf("subscribe after start: %v", err)
+	}
+	if sub.Topic() != "y" {
+		t.Fatalf("unexpected topic %s", sub.Topic())
+	}
+
+	// Publish should succeed now
+	if err := eb.Publish(ctx, Event{Topic: "y"}); err != nil {
+		t.Fatalf("publish after start: %v", err)
+	}
+
+	// Allow processing
+	time.Sleep(20 * time.Millisecond)
+	_ = eb.Stop(ctx)
+}

modules/eventbus/custom_memory_filter_reject_test.go

@@ -0,0 +1,62 @@
+package eventbus
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// TestCustomMemoryFilterReject ensures events not matching TopicPrefixFilter are skipped without metrics increment.
+func TestCustomMemoryFilterReject(t *testing.T) {
+	busRaw, err := NewCustomMemoryEventBus(map[string]interface{}{
+		"enableMetrics":          true,
+		"defaultEventBufferSize": 1,
+	})
+	if err != nil {
+		t.Fatalf("create bus: %v", err)
+	}
+	bus := busRaw.(*CustomMemoryEventBus)
+
+	// Inject a filter allowing only topics starting with "allow.".
+	bus.eventFilters = []EventFilter{&TopicPrefixFilter{AllowedPrefixes: []string{"allow."}, name: "topicPrefix"}}
+	if err := bus.Start(context.Background()); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	// Subscribe to both allowed and denied topics; only allowed should receive events.
+	allowedCount := int64(0)
+	deniedCount := int64(0)
+	_, err = bus.Subscribe(context.Background(), "allow.test", func(ctx context.Context, e Event) error { allowedCount++; return nil })
+	if err != nil {
+		t.Fatalf("subscribe allow: %v", err)
+	}
+	_, err = bus.Subscribe(context.Background(), "deny.test", func(ctx context.Context, e Event) error { deniedCount++; return nil })
+	if err != nil {
+		t.Fatalf("subscribe deny: %v", err)
+	}
+
+	// Publish one denied event and one allowed; denied should be filtered out early.
+	_ = bus.Publish(context.Background(), Event{Topic: "deny.test"})
+	_ = bus.Publish(context.Background(), Event{Topic: "allow.test"})
+
+	// Wait briefly for allowed delivery.
+	time.Sleep(20 * time.Millisecond)
+
+	if allowedCount != 1 {
+		t.Fatalf("expected allowedCount=1 got %d", allowedCount)
+	}
+	if deniedCount != 0 {
+		t.Fatalf("expected deniedCount=0 got %d", deniedCount)
+	}
+
+	metrics := bus.GetMetrics()
+	if metrics.TotalEvents != 1 {
+		t.Fatalf("expected metrics.TotalEvents=1 got %d", metrics.TotalEvents)
+	}
+	if metrics.EventsPerTopic["deny.test"] != 0 {
+		t.Fatalf("deny.test should not be counted")
+	}
+	if metrics.EventsPerTopic["allow.test"] != 1 {
+		t.Fatalf("allow.test metrics missing")
+	}
+}

modules/eventbus/custom_memory_invalid_unsubscribe_test.go

@@ -0,0 +1,39 @@
+package eventbus
+
+import (
+	"context"
+	"testing"
+)
+
+// foreignSub implements Subscription but is not the concrete type expected by CustomMemoryEventBus.
+type foreignSub struct{}
+
+func (f foreignSub) Topic() string { return "valid.topic" }
+func (f foreignSub) ID() string    { return "foreign" }
+func (f foreignSub) IsAsync() bool { return false }
+func (f foreignSub) Cancel() error { return nil }
+
+// TestCustomMemoryInvalidUnsubscribe exercises the ErrInvalidSubscriptionType branch.
+func TestCustomMemoryInvalidUnsubscribe(t *testing.T) {
+	busRaw, err := NewCustomMemoryEventBus(map[string]interface{}{"enableMetrics": false})
+	if err != nil {
+		t.Fatalf("create bus: %v", err)
+	}
+	bus := busRaw.(*CustomMemoryEventBus)
+	if err := bus.Start(context.Background()); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	// Create a valid subscription to ensure bus started logic executed (not strictly required for invalid path).
+	sub, err := bus.Subscribe(context.Background(), "valid.topic", func(ctx context.Context, e Event) error { return nil })
+	if err != nil {
+		t.Fatalf("subscribe: %v", err)
+	}
+	if sub == nil {
+		t.Fatalf("expected non-nil subscription")
+	}
+
+	if err := bus.Unsubscribe(context.Background(), foreignSub{}); err == nil || err != ErrInvalidSubscriptionType {
+		t.Fatalf("expected ErrInvalidSubscriptionType, got %v", err)
+	}
+}