nats

type Connection ¶

type Connection interface {
	QueueSubscribe(
		subject,
		qgroup string,
		cb stan.MsgHandler,
		opts ...stan.SubscriptionOption) (stan.Subscription, error)
	Publish(subj string, data []byte) error
}

Connection defines the behaviour required for the Nats connection

type ConnectionMock ¶

type ConnectionMock struct {
	// PublishFunc mocks the Publish method.
	PublishFunc func(subj string, data []byte) error

	// QueueSubscribeFunc mocks the QueueSubscribe method.
	QueueSubscribeFunc func(subject string, qgroup string, cb stan.MsgHandler, opts ...stan.SubscriptionOption) (stan.Subscription, error)
	// contains filtered or unexported fields
}

ConnectionMock is a mock implementation of Connection.

    func TestSomethingThatUsesConnection(t *testing.T) {

        // make and configure a mocked Connection
        mockedConnection := &ConnectionMock{
            PublishFunc: func(subj string, data []byte) error {
	               panic("TODO: mock out the Publish method")
            },
            QueueSubscribeFunc: func(subject string, qgroup string, cb stan.MsgHandler, opts ...stan.SubscriptionOption) (stan.Subscription, error) {
	               panic("TODO: mock out the QueueSubscribe method")
            },
        }

        // TODO: use mockedConnection in code that requires Connection
        //       and then make assertions.

    }

func (mock *ConnectionMock) Publish(subj string, data []byte) error

func (mock *ConnectionMock) PublishCalls() []struct {
	Subj string
	Data []byte
}

len(mockedConnection.PublishCalls())

func (mock *ConnectionMock) QueueSubscribe(subject string, qgroup string, cb stan.MsgHandler, opts ...stan.SubscriptionOption) (stan.Subscription, error)

func (mock *ConnectionMock) QueueSubscribeCalls() []struct {
	Subject string
	Qgroup  string
	Cb      stan.MsgHandler
	Opts    []stan.SubscriptionOption
}

len(mockedConnection.QueueSubscribeCalls())

type ConnectionPool ¶

type ConnectionPool interface {
	GetConnection(server, clusterID string) (Connection, error)
}

type ConnectionPoolMock ¶

type ConnectionPoolMock struct {
	// GetConnectionFunc mocks the GetConnection method.
	GetConnectionFunc func(server string, clusterID string) (Connection, error)
	// contains filtered or unexported fields
}

ConnectionPoolMock is a mock implementation of ConnectionPool.

    func TestSomethingThatUsesConnectionPool(t *testing.T) {

        // make and configure a mocked ConnectionPool
        mockedConnectionPool := &ConnectionPoolMock{
            GetConnectionFunc: func(server string, clusterID string) (Connection, error) {
	               panic("TODO: mock out the GetConnection method")
            },
        }

        // TODO: use mockedConnectionPool in code that requires ConnectionPool
        //       and then make assertions.

    }

func (mock *ConnectionPoolMock) GetConnection(server string, clusterID string) (Connection, error)

func (mock *ConnectionPoolMock) GetConnectionCalls() []struct {
	Server    string
	ClusterID string
}

len(mockedConnectionPool.GetConnectionCalls())

type StreamingConnectionPool ¶

type StreamingConnectionPool struct {
	// contains filtered or unexported fields
}

StreamingConnectionPool implements a connection pool for Nats Streaming

func NewStreamingConnectionPool() *StreamingConnectionPool

func (scp *StreamingConnectionPool) GetConnection(server, clusterID string) (Connection, error)

type StreamingProvider ¶

type StreamingProvider struct {
	Server    string               `hcl:"server"`
	ClusterID string               `hcl:"cluster_id"`
	Queue     string               `hcl:"queue"`
	AuthBasic *providers.AuthBasic `hcl:"auth_basic,block"`
	AuthMTLS  *providers.AuthMTLS  `hcl:"auth_mtls,block"`
	// contains filtered or unexported fields
}

func NewStreamingProvider(
	name, direction string,
	cp ConnectionPool,
	l logger.Logger) *StreamingProvider

func (sp *StreamingProvider) Direction() string

func (sp *StreamingProvider) Listen() (<-chan *providers.Message, error)

func (sp *StreamingProvider) Name() string

func (sp *StreamingProvider) Publish(msg providers.Message) (providers.Message, error)

func (sp *StreamingProvider) Setup() error

func (sp *StreamingProvider) Stop() error

func (sp *StreamingProvider) Type() string

type Subscription ¶

type Subscription interface {
	stan.Subscription
}

type SubscriptionMock ¶

type SubscriptionMock struct {
	// CloseFunc mocks the Close method.
	CloseFunc func() error

	// UnsubscribeFunc mocks the Unsubscribe method.
	UnsubscribeFunc func() error
	// contains filtered or unexported fields
}

SubscriptionMock is a mock implementation of Subscription.

    func TestSomethingThatUsesSubscription(t *testing.T) {

        // make and configure a mocked Subscription
        mockedSubscription := &SubscriptionMock{
            CloseFunc: func() error {
	               panic("TODO: mock out the Close method")
            },
            UnsubscribeFunc: func() error {
	               panic("TODO: mock out the Unsubscribe method")
            },
        }

        // TODO: use mockedSubscription in code that requires Subscription
        //       and then make assertions.

    }

func (mock *SubscriptionMock) Close() error

func (mock *SubscriptionMock) CloseCalls() []struct {
}

len(mockedSubscription.CloseCalls())

func (mock *SubscriptionMock) Unsubscribe() error

func (mock *SubscriptionMock) UnsubscribeCalls() []struct {
}

len(mockedSubscription.UnsubscribeCalls())