feat: initial commit

pkg/bus/testing/publish_subscribe.go

@@ -0,0 +1,96 @@
+package testing
+
+import (
+	"context"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"forge.cadoles.com/arcad/edge/pkg/bus"
+	"github.com/pkg/errors"
+)
+
+const (
+	testNamespace bus.MessageNamespace = "testNamespace"
+)
+
+type testMessage struct{}
+
+func (e *testMessage) MessageNamespace() bus.MessageNamespace {
+	return testNamespace
+}
+
+func TestPublishSubscribe(t *testing.T, b bus.Bus) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	t.Log("subscribe")
+
+	messages, err := b.Subscribe(ctx, testNamespace)
+	if err != nil {
+		t.Fatal(errors.WithStack(err))
+	}
+
+	var wg sync.WaitGroup
+
+	wg.Add(5)
+
+	go func() {
+		// 5 events should be received
+		t.Log("publish 0")
+
+		if err := b.Publish(ctx, &testMessage{}); err != nil {
+			t.Error(errors.WithStack(err))
+		}
+
+		t.Log("publish 1")
+
+		if err := b.Publish(ctx, &testMessage{}); err != nil {
+			t.Error(errors.WithStack(err))
+		}
+
+		t.Log("publish 2")
+
+		if err := b.Publish(ctx, &testMessage{}); err != nil {
+			t.Error(errors.WithStack(err))
+		}
+
+		t.Log("publish 3")
+
+		if err := b.Publish(ctx, &testMessage{}); err != nil {
+			t.Error(errors.WithStack(err))
+		}
+
+		t.Log("publish 4")
+
+		if err := b.Publish(ctx, &testMessage{}); err != nil {
+			t.Error(errors.WithStack(err))
+		}
+	}()
+
+	var count int32 = 0
+
+	go func() {
+		t.Log("range for events")
+
+		for msg := range messages {
+			t.Logf("received msg %d", atomic.LoadInt32(&count))
+			atomic.AddInt32(&count, 1)
+
+			if e, g := testNamespace, msg.MessageNamespace(); e != g {
+				t.Errorf("evt.MessageNamespace(): expected '%v', got '%v'", e, g)
+			}
+
+			wg.Done()
+		}
+	}()
+
+	wg.Wait()
+
+	b.Unsubscribe(ctx, testNamespace, messages)
+
+	if e, g := int32(5), count; e != g {
+		t.Errorf("message received count: expected '%v', got '%v'", e, g)
+	}
+}

pkg/bus/testing/request_reply.go

@@ -0,0 +1,110 @@
+package testing
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	"forge.cadoles.com/arcad/edge/pkg/bus"
+	"github.com/pkg/errors"
+)
+
+const (
+	testTypeReqRes bus.MessageNamespace = "testNamspaceReqRes"
+)
+
+type testReqResMessage struct {
+	i int
+}
+
+func (m *testReqResMessage) MessageNamespace() bus.MessageNamespace {
+	return testNamespace
+}
+
+func TestRequestReply(t *testing.T, b bus.Bus) {
+	expectedRoundTrips := 256
+	timeout := time.Now().Add(time.Duration(expectedRoundTrips) * time.Second)
+
+	var (
+		initWaitGroup sync.WaitGroup
+		resWaitGroup  sync.WaitGroup
+	)
+
+	initWaitGroup.Add(1)
+
+	go func() {
+		repondCtx, cancelRespond := context.WithDeadline(context.Background(), timeout)
+		defer cancelRespond()
+
+		initWaitGroup.Done()
+
+		err := b.Reply(repondCtx, testNamespace, func(msg bus.Message) (bus.Message, error) {
+			defer resWaitGroup.Done()
+
+			req, ok := msg.(*testReqResMessage)
+			if !ok {
+				return nil, errors.WithStack(bus.ErrUnexpectedMessage)
+			}
+
+			result := &testReqResMessage{req.i}
+
+			// Simulate random work
+			time.Sleep(time.Millisecond * 100)
+
+			t.Logf("[RES] sending res #%d", req.i)
+
+			return result, nil
+		})
+		if err != nil {
+			t.Error(err)
+		}
+	}()
+
+	initWaitGroup.Wait()
+
+	var reqWaitGroup sync.WaitGroup
+
+	for i := 0; i < expectedRoundTrips; i++ {
+		resWaitGroup.Add(1)
+		reqWaitGroup.Add(1)
+
+		go func(i int) {
+			defer reqWaitGroup.Done()
+
+			requestCtx, cancelRequest := context.WithDeadline(context.Background(), timeout)
+			defer cancelRequest()
+
+			req := &testReqResMessage{i}
+
+			t.Logf("[REQ] sending req #%d", i)
+
+			result, err := b.Request(requestCtx, req)
+			if err != nil {
+				t.Error(err)
+			}
+
+			t.Logf("[REQ] received req #%d reply", i)
+
+			if result == nil {
+				t.Error("result should not be nil")
+
+				return
+			}
+
+			res, ok := result.(*testReqResMessage)
+			if !ok {
+				t.Error(errors.WithStack(bus.ErrUnexpectedMessage))
+
+				return
+			}
+
+			if e, g := req.i, res.i; e != g {
+				t.Errorf("res.i: expected '%v', got '%v'", e, g)
+			}
+		}(i)
+	}
+
+	reqWaitGroup.Wait()
+	resWaitGroup.Wait()
+}