sender

type Hasher ¶

type Hasher interface {
	// SenderHash calculates the hash of a sender based on the given configuration
	SenderHash(config interface{}) (string, error)
}

type HasherMock ¶

type HasherMock struct {
	// SenderHashFunc mocks the SenderHash method.
	SenderHashFunc func(config interface{}) (string, error)
	// contains filtered or unexported fields
}

HasherMock is a mock implementation of Hasher.

func TestSomethingThatUsesHasher(t *testing.T) {

	// make and configure a mocked Hasher
	mockedHasher := &HasherMock{
		SenderHashFunc: func(config interface{}) (string, error) {
			panic("mock out the SenderHash method")
		},
	}

	// use mockedHasher in code that requires Hasher
	// and then make assertions.

}

func (mock *HasherMock) SenderHash(config interface{}) (string, error)

func (mock *HasherMock) SenderHashCalls() []struct {
	Config interface{}
}

len(mockedHasher.SenderHashCalls())

type InvalidConfigError ¶

type InvalidConfigError struct {
	Err error
}

func (e *InvalidConfigError) Error() string

func (e *InvalidConfigError) Unwrap() error

type NewSenderer ¶

type NewSenderer interface {
	Hasher
	// Returns an objec that implements the Sender interface
	NewSender(config interface{}) (Sender, error)
}

type NewSendererMock ¶

type NewSendererMock struct {
	// NewSenderFunc mocks the NewSender method.
	NewSenderFunc func(config interface{}) (Sender, error)

	// SenderHashFunc mocks the SenderHash method.
	SenderHashFunc func(config interface{}) (string, error)
	// contains filtered or unexported fields
}

NewSendererMock is a mock implementation of NewSenderer.

func TestSomethingThatUsesNewSenderer(t *testing.T) {

	// make and configure a mocked NewSenderer
	mockedNewSenderer := &NewSendererMock{
		NewSenderFunc: func(config interface{}) (Sender, error) {
			panic("mock out the NewSender method")
		},
		SenderHashFunc: func(config interface{}) (string, error) {
			panic("mock out the SenderHash method")
		},
	}

	// use mockedNewSenderer in code that requires NewSenderer
	// and then make assertions.

}

func (mock *NewSendererMock) NewSender(config interface{}) (Sender, error)

func (mock *NewSendererMock) NewSenderCalls() []struct {
	Config interface{}
}

len(mockedNewSenderer.NewSenderCalls())

func (mock *NewSendererMock) SenderHash(config interface{}) (string, error)

func (mock *NewSendererMock) SenderHashCalls() []struct {
	Config interface{}
}

len(mockedNewSenderer.SenderHashCalls())

type Sender ¶

type Sender interface {
	// Send consumes and event and sends it to the target
	Send(e event.Event)
	// Unwrap
	Unwrap() Sender
	// StopSending will stop any long running maintenance threads in the sender plugin.
	// Often this function does nothing.
	StopSending(ctx context.Context)
}

or Outputter[√] or Producer[x] or Publisher[√]

type SenderMock ¶

type SenderMock struct {
	// SendFunc mocks the Send method.
	SendFunc func(e event.Event)

	// StopSendingFunc mocks the StopSending method.
	StopSendingFunc func(ctx context.Context)

	// UnwrapFunc mocks the Unwrap method.
	UnwrapFunc func() Sender
	// contains filtered or unexported fields
}

SenderMock is a mock implementation of Sender.

func TestSomethingThatUsesSender(t *testing.T) {

	// make and configure a mocked Sender
	mockedSender := &SenderMock{
		SendFunc: func(e event.Event)  {
			panic("mock out the Send method")
		},
		StopSendingFunc: func(ctx context.Context)  {
			panic("mock out the StopSending method")
		},
		UnwrapFunc: func() Sender {
			panic("mock out the Unwrap method")
		},
	}

	// use mockedSender in code that requires Sender
	// and then make assertions.

}

func (mock *SenderMock) Send(e event.Event)

func (mock *SenderMock) SendCalls() []struct {
	E event.Event
}

len(mockedSender.SendCalls())

func (mock *SenderMock) StopSending(ctx context.Context)

func (mock *SenderMock) StopSendingCalls() []struct {
	Ctx context.Context
}

len(mockedSender.StopSendingCalls())

func (mock *SenderMock) Unwrap() Sender

func (mock *SenderMock) UnwrapCalls() []struct {
}

len(mockedSender.UnwrapCalls())