snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/tests/messagebus/main_test.go

@@ -0,0 +1,146 @@
+package messagebus
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/cortezaproject/corteza/server/app"
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+	"github.com/cortezaproject/corteza/server/pkg/cli"
+	"github.com/cortezaproject/corteza/server/pkg/eventbus"
+	"github.com/cortezaproject/corteza/server/pkg/id"
+	"github.com/cortezaproject/corteza/server/pkg/logger"
+	"github.com/cortezaproject/corteza/server/pkg/messagebus"
+	"github.com/cortezaproject/corteza/server/pkg/options"
+	"github.com/cortezaproject/corteza/server/pkg/rand"
+	"github.com/cortezaproject/corteza/server/store/adapters/rdbms/drivers/sqlite"
+	"github.com/cortezaproject/corteza/server/system/service"
+	sysTypes "github.com/cortezaproject/corteza/server/system/types"
+	"github.com/cortezaproject/corteza/server/tests/helpers"
+	"github.com/go-chi/chi/v5"
+	_ "github.com/joho/godotenv/autoload"
+	"github.com/stretchr/testify/require"
+)
+
+type (
+	helper struct {
+		t *testing.T
+		a *require.Assertions
+
+		cUser  *sysTypes.User
+		roleID uint64
+	}
+)
+
+var (
+	testApp *app.CortezaApp
+	r       chi.Router
+
+	eventBus = eventbus.New()
+)
+
+func init() {
+	helpers.RecursiveDotEnvLoad()
+}
+
+// random string, 10 chars long by default
+func rs(a ...int) string {
+	var l = 10
+	if len(a) > 0 {
+		l = a[0]
+	}
+
+	return string(rand.Bytes(l))
+}
+
+func InitTestApp() {
+	if testApp == nil {
+		ctx := cli.Context()
+
+		testApp = helpers.NewIntegrationTestApp(ctx, func(app *app.CortezaApp) (err error) {
+			service.DefaultStore, err = sqlite.ConnectInMemory(ctx)
+
+			if err != nil {
+				return err
+			}
+
+			eventbus.Set(eventBus)
+
+			messageBus := messagebus.New(&options.MessagebusOpt{Enabled: true, LogEnabled: false}, logger.Default())
+			messagebus.Set(messageBus)
+
+			return nil
+		})
+	}
+}
+
+func TestMain(m *testing.M) {
+	InitTestApp()
+	os.Exit(m.Run())
+}
+
+func newHelper(t *testing.T) helper {
+	h := helper{
+		t:      t,
+		a:      require.New(t),
+		roleID: id.Next(),
+		cUser: &sysTypes.User{
+			ID: id.Next(),
+		},
+	}
+
+	h.cUser.SetRoles(h.roleID)
+	helpers.UpdateRBAC(h.roleID)
+
+	return h
+}
+
+// Returns context w/ security details
+func (h helper) secCtx() context.Context {
+	return auth.SetIdentityToContext(context.Background(), h.cUser)
+}
+
+// Unwraps error before it passes it to the tester
+func (h helper) noError(err error) {
+	for errors.Unwrap(err) != nil {
+		err = errors.Unwrap(err)
+	}
+
+	h.a.NoError(err)
+}
+
+func (h helper) prepareQueues(ctx context.Context, qs ...*sysTypes.Queue) {
+	h.noError(testApp.Store.TruncateQueues(ctx))
+	h.noError(testApp.Store.CreateQueue(ctx, qs...))
+}
+
+func (h helper) prepareMessages(ctx context.Context, qs ...*sysTypes.Queue) {
+	h.noError(testApp.Store.TruncateQueueMessages(ctx))
+}
+
+func (h helper) checkPersistedMessages(ctx context.Context, f sysTypes.QueueMessageFilter) sysTypes.QueueMessageSet {
+	s, f, err := service.DefaultStore.SearchQueueMessages(ctx, f)
+	h.noError(err)
+
+	return s
+}
+
+func (h helper) initMessagebus(ctx context.Context) {
+	// re-init
+	messagebus.Service().Init(ctx, service.DefaultQueue)
+
+	// set messagebus watchers again
+	messagebus.Service().Listen(ctx)
+}
+
+func makeDelay(d time.Duration) *time.Duration {
+	return &d
+}
+
+func now() *time.Time {
+	c := time.Now().Round(time.Second)
+	return &c
+}

server/tests/messagebus/message_consume_test.go

@@ -0,0 +1,158 @@
+package messagebus
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/cortezaproject/corteza/server/pkg/eventbus"
+	"github.com/cortezaproject/corteza/server/pkg/messagebus"
+	mtypes "github.com/cortezaproject/corteza/server/pkg/messagebus/types"
+	"github.com/cortezaproject/corteza/server/system/service/event"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	dispatcher interface {
+		Register(h eventbus.HandlerFn, ops ...eventbus.HandlerRegOp) uintptr
+		Dispatch(ctx context.Context, ev eventbus.Event)
+	}
+)
+
+var (
+	testQueueDispatched = &types.Queue{
+		ID:       1,
+		Queue:    "test",
+		Consumer: string(mtypes.ConsumerStore),
+		Meta: types.QueueMeta{
+			PollDelay:      makeDelay(time.Second),
+			DispatchEvents: true,
+		},
+	}
+
+	testQueueEb = &types.Queue{
+		ID:       1,
+		Queue:    "test_eb",
+		Consumer: string(mtypes.ConsumerEventbus),
+		Meta: types.QueueMeta{
+			PollDelay:      makeDelay(time.Second),
+			DispatchEvents: true,
+		},
+	}
+
+	testQueueMessage = types.QueueMessage{
+		ID:      1,
+		Queue:   "test",
+		Payload: []byte(`{"foo": "bar"}`),
+		Created: now(),
+	}
+)
+
+func TestMessageWrite(t *testing.T) {
+	t.Skipf("this still causes timeout issues")
+
+	var (
+		h   = newHelper(t)
+		ctx = context.Background()
+	)
+
+	h.prepareQueues(ctx, testQueueDispatched)
+
+	// reinit the messagebus
+	h.initMessagebus(ctx)
+
+	timeout := time.After(time.Second * 5)
+
+	w := sync.WaitGroup{}
+	w.Add(1)
+
+	go func() {
+		messagebus.Service().Push("test", []byte("this is a test"))
+		messagebus.Service().Push("test", []byte("foo bar"))
+
+		for {
+			select {
+			case <-timeout:
+				// this test fail now and then. not sure why
+				// for now, let's just skip it.
+				t.Skipf("timed-out")
+				w.Done()
+				return
+
+			default:
+				set := h.checkPersistedMessages(ctx, types.QueueMessageFilter{})
+
+				// success, will eventually get persisted
+				if len(set) >= 2 {
+					h.a.NotEmpty(set)
+					h.a.Equal([]byte(`this is a test`), set[0].Payload)
+					h.a.Equal([]byte(`foo bar`), set[1].Payload)
+					w.Done()
+					return
+				}
+			}
+		}
+	}()
+
+	w.Wait()
+}
+
+func TestMessageWriteEventbus(t *testing.T) {
+	var (
+		h   = newHelper(t)
+		ctx = context.Background()
+
+		messageProcessed   = make(chan bool)
+		messageProcessedFn = func(c chan bool) eventbus.HandlerFn {
+			return func(ctx context.Context, ev eventbus.Event) error {
+				c <- true
+				return nil
+			}
+		}
+	)
+
+	h.prepareQueues(ctx, testQueueEb)
+
+	// reinit the messagebus
+	h.initMessagebus(ctx)
+
+	// safety net, the test should be instantaneous
+	timeout := time.After(time.Second * 3)
+
+	w := sync.WaitGroup{}
+	w.Add(1)
+
+	// eventbus is the consumer, update temporary channel
+	// so we get the value back lower
+	registerTestEvent(messageProcessedFn(messageProcessed))
+
+	go func() {
+		messagebus.Service().Push(testQueueEb.Queue, []byte("this is a test"))
+
+		for {
+			select {
+			case <-timeout:
+				w.Done()
+				t.Fail()
+				return
+
+			case <-messageProcessed:
+				w.Done()
+				return
+			}
+		}
+	}()
+
+	w.Wait()
+}
+
+func registerTestEvent(fn eventbus.HandlerFn) {
+	e := event.QueueOnMessage(&types.QueueMessage{})
+
+	eventbus.
+		Service().
+		Register(fn,
+			eventbus.On(e.EventType()),
+			eventbus.For(e.ResourceType()))
+}