From 0fc18a58af19407160d3294d9137e928d6e27377 Mon Sep 17 00:00:00 2001 From: alexrjones Date: Mon, 2 Nov 2026 17:20:36 +0800 Subject: [PATCH] v3: fix nested message references failing to generate --- pkg/asyncapi/v3/message.go | 4 +- test/v3/issues/341/asyncapi.gen.go | 718 +++++++++++++++++++++++++++++ test/v3/issues/341/asyncapi.yaml | 31 ++ test/v3/issues/341/suite_test.go | 36 ++ 4 files changed, 787 insertions(+), 2 deletions(-) create mode 100644 test/v3/issues/341/asyncapi.gen.go create mode 100644 test/v3/issues/341/asyncapi.yaml create mode 100644 test/v3/issues/341/suite_test.go diff --git a/pkg/asyncapi/v3/message.go b/pkg/asyncapi/v3/message.go index 91d1b1fe..9e2565cb 100644 --- a/pkg/asyncapi/v3/message.go +++ b/pkg/asyncapi/v3/message.go @@ -495,10 +495,10 @@ func (msg *Message) mergeWithMessageHeaders(msg2 Message, spec Specification) er return nil } -// Follow returns referenced message if specified or the actual message. +// Follow will follow the reference to the end. func (msg *Message) Follow() *Message { if msg.ReferenceTo != nil { - return msg.ReferenceTo + return msg.ReferenceTo.Follow() } return msg } diff --git a/test/v3/issues/341/asyncapi.gen.go b/test/v3/issues/341/asyncapi.gen.go new file mode 100644 index 00000000..3a49cc4a --- /dev/null +++ b/test/v3/issues/341/asyncapi.gen.go @@ -0,0 +1,718 @@ +// Package "issue341" provides primitives to interact with the AsyncAPI specification. +// +// Code generated by github.com/lerenn/asyncapi-codegen version (devel) DO NOT EDIT. +package issue341 + +import ( + "context" + "encoding/json" + "fmt" + + "github.com/lerenn/asyncapi-codegen/pkg/extensions" +) + +// controller is the controller that will be used to communicate with the broker +// It will be used internally by AppController and UserController +type controller struct { + // broker is the broker controller that will be used to communicate + broker extensions.BrokerController + // subscriptions is a map of all subscriptions + subscriptions map[string]extensions.BrokerChannelSubscription + // logger is the logger that will be used to log operations on controller + logger extensions.Logger + // middlewares are the middlewares that will be executed when sending or + // receiving messages + middlewares []extensions.Middleware + // handler to handle errors from consumers and middlewares + errorHandler extensions.ErrorHandler +} + +// ControllerOption is the type of the options that can be passed +// when creating a new Controller +type ControllerOption func(controller *controller) + +// WithLogger attaches a logger to the controller +func WithLogger(logger extensions.Logger) ControllerOption { + return func(controller *controller) { + controller.logger = logger + } +} + +// WithMiddlewares attaches middlewares that will be executed when sending or receiving messages +func WithMiddlewares(middlewares ...extensions.Middleware) ControllerOption { + return func(controller *controller) { + controller.middlewares = middlewares + } +} + +// WithErrorHandler attaches a errorhandler to handle errors from subscriber functions +func WithErrorHandler(handler extensions.ErrorHandler) ControllerOption { + return func(controller *controller) { + controller.errorHandler = handler + } +} + +// AppSubscriber contains all handlers that are listening messages for App +type AppSubscriber interface { + // ReceiveEventOperationReceived receive all Event messages from Events channel. + ReceiveEventOperationReceived(ctx context.Context, msg EventMessage) error +} + +// AppController is the structure that provides sending capabilities to the +// developer and and connect the broker with the App +type AppController struct { + controller +} + +// NewAppController links the App to the broker +func NewAppController(bc extensions.BrokerController, options ...ControllerOption) (*AppController, error) { + // Check if broker controller has been provided + if bc == nil { + return nil, extensions.ErrNilBrokerController + } + + // Create default controller + controller := controller{ + broker: bc, + subscriptions: make(map[string]extensions.BrokerChannelSubscription), + logger: extensions.DummyLogger{}, + middlewares: make([]extensions.Middleware, 0), + errorHandler: extensions.DefaultErrorHandler(), + } + + // Apply options + for _, option := range options { + option(&controller) + } + + return &AppController{controller: controller}, nil +} + +func (c AppController) wrapMiddlewares( + middlewares []extensions.Middleware, + callback extensions.NextMiddleware, +) func(ctx context.Context, msg *extensions.BrokerMessage) error { + var called bool + + // If there is no more middleware + if len(middlewares) == 0 { + return func(ctx context.Context, msg *extensions.BrokerMessage) error { + // Call the callback if it exists and it has not been called already + if callback != nil && !called { + called = true + return callback(ctx) + } + + // Nil can be returned, as the callback has already been called + return nil + } + } + + // Get the next function to call from next middlewares or callback + next := c.wrapMiddlewares(middlewares[1:], callback) + + // Wrap middleware into a check function that will call execute the middleware + // and call the next wrapped middleware if the returned function has not been + // called already + return func(ctx context.Context, msg *extensions.BrokerMessage) error { + // Call the middleware and the following if it has not been done already + if !called { + // Create the next call with the context and the message + nextWithArgs := func(ctx context.Context) error { + return next(ctx, msg) + } + + // Call the middleware and register it as already called + called = true + if err := middlewares[0](ctx, msg, nextWithArgs); err != nil { + return err + } + + // If next has already been called in middleware, it should not be executed again + return nextWithArgs(ctx) + } + + // Nil can be returned, as the next middleware has already been called + return nil + } +} + +func (c AppController) executeMiddlewares(ctx context.Context, msg *extensions.BrokerMessage, callback extensions.NextMiddleware) error { + // Wrap middleware to have 'next' function when calling them + wrapped := c.wrapMiddlewares(c.middlewares, callback) + + // Execute wrapped middlewares + return wrapped(ctx, msg) +} + +func addAppContextValues(ctx context.Context, addr string) context.Context { + ctx = context.WithValue(ctx, extensions.ContextKeyIsVersion, "1.0.0") + ctx = context.WithValue(ctx, extensions.ContextKeyIsProvider, "app") + return context.WithValue(ctx, extensions.ContextKeyIsChannel, addr) +} + +// Close will clean up any existing resources on the controller +func (c *AppController) Close(ctx context.Context) { + // Unsubscribing remaining channels + c.UnsubscribeFromAllChannels(ctx) + + c.logger.Info(ctx, "Closed app controller", extensions.LogInfosFromContext(ctx)...) +} + +// SubscribeToAllChannels will receive messages from channels where channel has +// no parameter on which the app is expecting messages. For channels with parameters, +// they should be subscribed independently. +func (c *AppController) SubscribeToAllChannels(ctx context.Context, as AppSubscriber) error { + if as == nil { + return extensions.ErrNilAppSubscriber + } + + if err := c.SubscribeToReceiveEventOperation(ctx, as.ReceiveEventOperationReceived); err != nil { + return err + } + + return nil +} + +// UnsubscribeFromAllChannels will stop the subscription of all remaining subscribed channels +func (c *AppController) UnsubscribeFromAllChannels(ctx context.Context) { + c.UnsubscribeFromReceiveEventOperation(ctx) +} + +// SubscribeToReceiveEventOperation will receive Event messages from Events channel. +// +// Callback function 'fn' will be called each time a new message is received. +// +// NOTE: for now, this only support the first message from AsyncAPI list. +// +// NOTE: for now, this only support the first message from AsyncAPI list. +// If you need support for other messages, please raise an issue. +func (c *AppController) SubscribeToReceiveEventOperation( + ctx context.Context, + fn func(ctx context.Context, msg EventMessage) error, +) error { + // Get channel address + addr := "v3.channelmessageref.events" + + // Set context + ctx = addAppContextValues(ctx, addr) + ctx = context.WithValue(ctx, extensions.ContextKeyIsDirection, "reception") + + // Check if the controller is already subscribed + _, exists := c.subscriptions[addr] + if exists { + err := fmt.Errorf("%w: controller is already subscribed on channel %q", extensions.ErrAlreadySubscribedChannel, addr) + c.logger.Error(ctx, err.Error(), extensions.LogInfosFromContext(ctx)...) + return err + } + + // Subscribe to broker channel + sub, err := c.broker.Subscribe(ctx, addr) + if err != nil { + c.logger.Error(ctx, err.Error(), extensions.LogInfosFromContext(ctx)...) + return err + } + c.logger.Info(ctx, "Subscribed to channel", extensions.LogInfosFromContext(ctx)...) + + // Asynchronously listen to new messages and pass them to app receiver + go func() { + for { + // Listen to next message + stop, err := c.listenToReceiveEventOperationNextMessage(addr, sub, fn) + if err != nil { + c.logger.Error(ctx, err.Error(), extensions.LogInfosFromContext(ctx)...) + } + + // Stop if required + if stop { + return + } + } + }() + + // Add the cancel channel to the inside map + c.subscriptions[addr] = sub + + return nil +} + +func (c *AppController) listenToReceiveEventOperationNextMessage( + addr string, + sub extensions.BrokerChannelSubscription, + fn func(ctx context.Context, msg EventMessage) error, +) (stop bool, err error) { + // Create a context for the received response + msgCtx, cancel := context.WithCancel(context.Background()) + msgCtx = addAppContextValues(msgCtx, addr) + msgCtx = context.WithValue(msgCtx, extensions.ContextKeyIsDirection, "reception") + defer cancel() + + // Wait for next message + acknowledgeableBrokerMessage, open := <-sub.MessagesChannel() + + // If subscription is closed and there is no more message + // (i.e. uninitialized message), then exit the function + if !open && acknowledgeableBrokerMessage.IsUninitialized() { + return true, nil + } + + // Set broker message to context + msgCtx = context.WithValue(msgCtx, extensions.ContextKeyIsBrokerMessage, acknowledgeableBrokerMessage.String()) + + // Execute middlewares before handling the message + if err := c.executeMiddlewares(msgCtx, &acknowledgeableBrokerMessage.BrokerMessage, func(middlewareCtx context.Context) error { + // Process message + msg, err := brokerMessageToEventMessage(acknowledgeableBrokerMessage.BrokerMessage) + if err != nil { + return err + } + + // Execute the subscription function + if err := fn(middlewareCtx, msg); err != nil { + return err + } + + acknowledgeableBrokerMessage.Ack() + + return nil + }); err != nil { + c.errorHandler(msgCtx, addr, &acknowledgeableBrokerMessage, err) + // On error execute the acknowledgeableBrokerMessage nack() function and + // let the BrokerAcknowledgment decide what is the right nack behavior for the broker + acknowledgeableBrokerMessage.Nak() + } + + return false, nil +} + +// UnsubscribeFromReceiveEventOperation will stop the reception of Event messages from Events channel. +// A timeout can be set in context to avoid blocking operation, if needed. +func (c *AppController) UnsubscribeFromReceiveEventOperation( + ctx context.Context, +) { + // Get channel address + addr := "v3.channelmessageref.events" + + // Check if there receivers for this channel + sub, exists := c.subscriptions[addr] + if !exists { + return + } + + // Set context + ctx = addAppContextValues(ctx, addr) + + // Stop the subscription + sub.Cancel(ctx) + + // Remove if from the receivers + delete(c.subscriptions, addr) + + c.logger.Info(ctx, "Unsubscribed from channel", extensions.LogInfosFromContext(ctx)...) +} + +// SendAsSendEventOperation will send a Event message on Events channel. +// +// NOTE: for now, this only support the first message from AsyncAPI list. +// If you need support for other messages, please raise an issue. +func (c *AppController) SendAsSendEventOperation( + ctx context.Context, + msg EventMessage, +) error { + // Set channel address + addr := "v3.channelmessageref.events" + + // Set context + ctx = addAppContextValues(ctx, addr) + ctx = context.WithValue(ctx, extensions.ContextKeyIsDirection, "publication") + + // Convert to BrokerMessage + brokerMsg, err := msg.toBrokerMessage() + if err != nil { + return err + } + + // Set broker message to context + ctx = context.WithValue(ctx, extensions.ContextKeyIsBrokerMessage, brokerMsg.String()) + + // Send the message on event-broker through middlewares + return c.executeMiddlewares(ctx, &brokerMsg, func(ctx context.Context) error { + return c.broker.Publish(ctx, addr, brokerMsg) + }) +} + +// UserSubscriber contains all handlers that are listening messages for User +type UserSubscriber interface { + // SendEventOperationReceived receive all Event messages from Events channel. + SendEventOperationReceived(ctx context.Context, msg EventMessage) error +} + +// UserController is the structure that provides sending capabilities to the +// developer and and connect the broker with the User +type UserController struct { + controller +} + +// NewUserController links the User to the broker +func NewUserController(bc extensions.BrokerController, options ...ControllerOption) (*UserController, error) { + // Check if broker controller has been provided + if bc == nil { + return nil, extensions.ErrNilBrokerController + } + + // Create default controller + controller := controller{ + broker: bc, + subscriptions: make(map[string]extensions.BrokerChannelSubscription), + logger: extensions.DummyLogger{}, + middlewares: make([]extensions.Middleware, 0), + errorHandler: extensions.DefaultErrorHandler(), + } + + // Apply options + for _, option := range options { + option(&controller) + } + + return &UserController{controller: controller}, nil +} + +func (c UserController) wrapMiddlewares( + middlewares []extensions.Middleware, + callback extensions.NextMiddleware, +) func(ctx context.Context, msg *extensions.BrokerMessage) error { + var called bool + + // If there is no more middleware + if len(middlewares) == 0 { + return func(ctx context.Context, msg *extensions.BrokerMessage) error { + // Call the callback if it exists and it has not been called already + if callback != nil && !called { + called = true + return callback(ctx) + } + + // Nil can be returned, as the callback has already been called + return nil + } + } + + // Get the next function to call from next middlewares or callback + next := c.wrapMiddlewares(middlewares[1:], callback) + + // Wrap middleware into a check function that will call execute the middleware + // and call the next wrapped middleware if the returned function has not been + // called already + return func(ctx context.Context, msg *extensions.BrokerMessage) error { + // Call the middleware and the following if it has not been done already + if !called { + // Create the next call with the context and the message + nextWithArgs := func(ctx context.Context) error { + return next(ctx, msg) + } + + // Call the middleware and register it as already called + called = true + if err := middlewares[0](ctx, msg, nextWithArgs); err != nil { + return err + } + + // If next has already been called in middleware, it should not be executed again + return nextWithArgs(ctx) + } + + // Nil can be returned, as the next middleware has already been called + return nil + } +} + +func (c UserController) executeMiddlewares(ctx context.Context, msg *extensions.BrokerMessage, callback extensions.NextMiddleware) error { + // Wrap middleware to have 'next' function when calling them + wrapped := c.wrapMiddlewares(c.middlewares, callback) + + // Execute wrapped middlewares + return wrapped(ctx, msg) +} + +func addUserContextValues(ctx context.Context, addr string) context.Context { + ctx = context.WithValue(ctx, extensions.ContextKeyIsVersion, "1.0.0") + ctx = context.WithValue(ctx, extensions.ContextKeyIsProvider, "user") + return context.WithValue(ctx, extensions.ContextKeyIsChannel, addr) +} + +// Close will clean up any existing resources on the controller +func (c *UserController) Close(ctx context.Context) { + // Unsubscribing remaining channels + c.UnsubscribeFromAllChannels(ctx) + + c.logger.Info(ctx, "Closed user controller", extensions.LogInfosFromContext(ctx)...) +} + +// SubscribeToAllChannels will receive messages from channels where channel has +// no parameter on which the app is expecting messages. For channels with parameters, +// they should be subscribed independently. +func (c *UserController) SubscribeToAllChannels(ctx context.Context, as UserSubscriber) error { + if as == nil { + return extensions.ErrNilUserSubscriber + } + + if err := c.SubscribeToSendEventOperation(ctx, as.SendEventOperationReceived); err != nil { + return err + } + + return nil +} + +// UnsubscribeFromAllChannels will stop the subscription of all remaining subscribed channels +func (c *UserController) UnsubscribeFromAllChannels(ctx context.Context) { + c.UnsubscribeFromSendEventOperation(ctx) +} + +// SubscribeToSendEventOperation will receive Event messages from Events channel. +// +// Callback function 'fn' will be called each time a new message is received. +// +// NOTE: for now, this only support the first message from AsyncAPI list. +// +// NOTE: for now, this only support the first message from AsyncAPI list. +// If you need support for other messages, please raise an issue. +func (c *UserController) SubscribeToSendEventOperation( + ctx context.Context, + fn func(ctx context.Context, msg EventMessage) error, +) error { + // Get channel address + addr := "v3.channelmessageref.events" + + // Set context + ctx = addUserContextValues(ctx, addr) + ctx = context.WithValue(ctx, extensions.ContextKeyIsDirection, "reception") + + // Check if the controller is already subscribed + _, exists := c.subscriptions[addr] + if exists { + err := fmt.Errorf("%w: controller is already subscribed on channel %q", extensions.ErrAlreadySubscribedChannel, addr) + c.logger.Error(ctx, err.Error(), extensions.LogInfosFromContext(ctx)...) + return err + } + + // Subscribe to broker channel + sub, err := c.broker.Subscribe(ctx, addr) + if err != nil { + c.logger.Error(ctx, err.Error(), extensions.LogInfosFromContext(ctx)...) + return err + } + c.logger.Info(ctx, "Subscribed to channel", extensions.LogInfosFromContext(ctx)...) + + // Asynchronously listen to new messages and pass them to app receiver + go func() { + for { + // Listen to next message + stop, err := c.listenToSendEventOperationNextMessage(addr, sub, fn) + if err != nil { + c.logger.Error(ctx, err.Error(), extensions.LogInfosFromContext(ctx)...) + } + + // Stop if required + if stop { + return + } + } + }() + + // Add the cancel channel to the inside map + c.subscriptions[addr] = sub + + return nil +} + +func (c *UserController) listenToSendEventOperationNextMessage( + addr string, + sub extensions.BrokerChannelSubscription, + fn func(ctx context.Context, msg EventMessage) error, +) (stop bool, err error) { + // Create a context for the received response + msgCtx, cancel := context.WithCancel(context.Background()) + msgCtx = addUserContextValues(msgCtx, addr) + msgCtx = context.WithValue(msgCtx, extensions.ContextKeyIsDirection, "reception") + defer cancel() + + // Wait for next message + acknowledgeableBrokerMessage, open := <-sub.MessagesChannel() + + // If subscription is closed and there is no more message + // (i.e. uninitialized message), then exit the function + if !open && acknowledgeableBrokerMessage.IsUninitialized() { + return true, nil + } + + // Set broker message to context + msgCtx = context.WithValue(msgCtx, extensions.ContextKeyIsBrokerMessage, acknowledgeableBrokerMessage.String()) + + // Execute middlewares before handling the message + if err := c.executeMiddlewares(msgCtx, &acknowledgeableBrokerMessage.BrokerMessage, func(middlewareCtx context.Context) error { + // Process message + msg, err := brokerMessageToEventMessage(acknowledgeableBrokerMessage.BrokerMessage) + if err != nil { + return err + } + + // Execute the subscription function + if err := fn(middlewareCtx, msg); err != nil { + return err + } + + acknowledgeableBrokerMessage.Ack() + + return nil + }); err != nil { + c.errorHandler(msgCtx, addr, &acknowledgeableBrokerMessage, err) + // On error execute the acknowledgeableBrokerMessage nack() function and + // let the BrokerAcknowledgment decide what is the right nack behavior for the broker + acknowledgeableBrokerMessage.Nak() + } + + return false, nil +} + +// UnsubscribeFromSendEventOperation will stop the reception of Event messages from Events channel. +// A timeout can be set in context to avoid blocking operation, if needed. +func (c *UserController) UnsubscribeFromSendEventOperation( + ctx context.Context, +) { + // Get channel address + addr := "v3.channelmessageref.events" + + // Check if there receivers for this channel + sub, exists := c.subscriptions[addr] + if !exists { + return + } + + // Set context + ctx = addUserContextValues(ctx, addr) + + // Stop the subscription + sub.Cancel(ctx) + + // Remove if from the receivers + delete(c.subscriptions, addr) + + c.logger.Info(ctx, "Unsubscribed from channel", extensions.LogInfosFromContext(ctx)...) +} + +// SendToReceiveEventOperation will send a Event message on Events channel. +// +// NOTE: for now, this only support the first message from AsyncAPI list. +// If you need support for other messages, please raise an issue. +func (c *UserController) SendToReceiveEventOperation( + ctx context.Context, + msg EventMessage, +) error { + // Set channel address + addr := "v3.channelmessageref.events" + + // Set context + ctx = addUserContextValues(ctx, addr) + ctx = context.WithValue(ctx, extensions.ContextKeyIsDirection, "publication") + + // Convert to BrokerMessage + brokerMsg, err := msg.toBrokerMessage() + if err != nil { + return err + } + + // Set broker message to context + ctx = context.WithValue(ctx, extensions.ContextKeyIsBrokerMessage, brokerMsg.String()) + + // Send the message on event-broker through middlewares + return c.executeMiddlewares(ctx, &brokerMsg, func(ctx context.Context) error { + return c.broker.Publish(ctx, addr, brokerMsg) + }) +} + +// AsyncAPIVersion is the version of the used AsyncAPI document +const AsyncAPIVersion = "1.0.0" + +// MessageWithCorrelationID is implemented by messages that carry a correlation ID. +type MessageWithCorrelationID interface { + CorrelationID() string + SetCorrelationID(id string) +} + +// Error is the error structure returned by the controller operations. +type Error struct { + Channel string + Err error +} + +// Error returns a string representation of the error. +func (e *Error) Error() string { + return fmt.Sprintf("channel %q: err %v", e.Channel, e.Err) +} + +// Message 'EventMessageFromEventsChannel' reference another one at '#/components/messages/event'. +// This should be fixed in a future version to allow message override. +// If you encounter this message, feel free to open an issue on this subject +// to let know that you need this functionnality. + +// EventMessagePayload is a schema from the AsyncAPI specification required in messages +type EventMessagePayload struct { + Id *string `json:"id,omitempty"` +} + +// EventMessage is the message expected for 'EventMessage' channel. +type EventMessage struct { + // Payload will be inserted in the message payload + Payload EventMessagePayload +} + +// NewEventMessage creates a new EventMessage with default values if any. +func NewEventMessage() EventMessage { + var msg EventMessage + + return msg +} + +// brokerMessageToEventMessage will fill a new EventMessage with data from generic broker message +func brokerMessageToEventMessage(bMsg extensions.BrokerMessage) (EventMessage, error) { + var msg EventMessage + + // Unmarshal payload to expected message payload format + err := json.Unmarshal(bMsg.Payload, &msg.Payload) + if err != nil { + return msg, err + } + + // TODO: run checks on msg type + + return msg, nil +} + +// toBrokerMessage will generate a generic broker message from EventMessage data +func (msg EventMessage) toBrokerMessage() (extensions.BrokerMessage, error) { + // TODO: implement checks on message + + // Marshal payload to JSON + payload, err := json.Marshal(msg.Payload) + if err != nil { + return extensions.BrokerMessage{}, err + } + + // There is no headers here + headers := make(map[string][]byte, 0) + + return extensions.BrokerMessage{ + Headers: headers, + Payload: payload, + }, nil +} + +const ( + // EventsChannelPath is the constant representing the 'EventsChannel' channel path. + EventsChannelPath = "v3.channelmessageref.events" +) + +// ChannelsPaths is an array of all channels paths +var ChannelsPaths = []string{ + EventsChannelPath, +} diff --git a/test/v3/issues/341/asyncapi.yaml b/test/v3/issues/341/asyncapi.yaml new file mode 100644 index 00000000..720741a2 --- /dev/null +++ b/test/v3/issues/341/asyncapi.yaml @@ -0,0 +1,31 @@ +asyncapi: 3.0.0 +info: + title: Operation message referencing a channel message + version: 1.0.0 +channels: + events: + address: v3.channelmessageref.events + messages: + event: + $ref: '#/components/messages/event' +operations: + sendEvent: + action: send + channel: + $ref: '#/channels/events' + messages: + - $ref: '#/channels/events/messages/event' + receiveEvent: + action: receive + channel: + $ref: '#/channels/events' + messages: + - $ref: '#/channels/events/messages/event' +components: + messages: + event: + payload: + type: object + properties: + id: + type: string diff --git a/test/v3/issues/341/suite_test.go b/test/v3/issues/341/suite_test.go new file mode 100644 index 00000000..c73e65aa --- /dev/null +++ b/test/v3/issues/341/suite_test.go @@ -0,0 +1,36 @@ +//go:generate go run ../../../../cmd/asyncapi-codegen -p issue341 -i asyncapi.yaml -o ./asyncapi.gen.go +package issue341 + +import ( + "context" + "testing" + + "github.com/stretchr/testify/suite" +) + +func TestSuite(t *testing.T) { + suite.Run(t, NewSuite()) +} + +type Suite struct { + suite.Suite +} + +func NewSuite() *Suite { + return &Suite{} +} + +// An operation message that references a channel message, which in turn references a component +// message, used to resolve to the channel message only. The generated controller code then used +// a type name that is never defined (in this example, EventMessageFromEventsChannel), so the +// package did not compile. +// The ability for this package to compile asserts that the issue is no longer present. +func (suite *Suite) TestOperationMessageResolvesToComponentMessage() { + var _ func(*AppController, context.Context, EventMessage) error = (*AppController).SendAsSendEventOperation + var _ func(AppSubscriber, context.Context, EventMessage) error = AppSubscriber.ReceiveEventOperationReceived + + msg := NewEventMessage() + id := "1" + msg.Payload.Id = &id + suite.Require().Equal("1", *msg.Payload.Id) +}