filter

type Chain ¶

type Chain struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func (c *Chain) Add(f Filterer) error

func (c *Chain) Filter(e event.Event) []event.Event

func (c *Chain) Filterers() []Filterer

type Chainer ¶

type Chainer interface {
	Filterer

	// Add will add a filterer to the chain
	Add(f Filterer) error
	Filterers() []Filterer
}

Chainer TODO: https://github.com/xmidt-org/ears/issues/74

type ChainerMock ¶

type ChainerMock struct {
	// AddFunc mocks the Add method.
	AddFunc func(f Filterer) error

	// FilterFunc mocks the Filter method.
	FilterFunc func(e event.Event) []event.Event

	// FilterersFunc mocks the Filterers method.
	FilterersFunc func() []Filterer
	// contains filtered or unexported fields
}

ChainerMock is a mock implementation of Chainer.

func TestSomethingThatUsesChainer(t *testing.T) {

	// make and configure a mocked Chainer
	mockedChainer := &ChainerMock{
		AddFunc: func(f Filterer) error {
			panic("mock out the Add method")
		},
		FilterFunc: func(e event.Event) []event.Event {
			panic("mock out the Filter method")
		},
		FilterersFunc: func() []Filterer {
			panic("mock out the Filterers method")
		},
	}

	// use mockedChainer in code that requires Chainer
	// and then make assertions.

}

func (mock *ChainerMock) Add(f Filterer) error

func (mock *ChainerMock) AddCalls() []struct {
	F Filterer
}

len(mockedChainer.AddCalls())

func (mock *ChainerMock) Filter(e event.Event) []event.Event

func (mock *ChainerMock) FilterCalls() []struct {
	E event.Event
}

len(mockedChainer.FilterCalls())

func (mock *ChainerMock) Filterers() []Filterer

func (mock *ChainerMock) FilterersCalls() []struct {
}

len(mockedChainer.FilterersCalls())

type Filterer ¶

type Filterer interface {
	Filter(e event.Event) []event.Event
}

Filterer defines the interface that a filterer must implement TODO: https://github.com/xmidt-org/ears/issues/74

type FiltererMock ¶

type FiltererMock struct {
	// FilterFunc mocks the Filter method.
	FilterFunc func(e event.Event) []event.Event
	// contains filtered or unexported fields
}

FiltererMock is a mock implementation of Filterer.

func TestSomethingThatUsesFilterer(t *testing.T) {

	// make and configure a mocked Filterer
	mockedFilterer := &FiltererMock{
		FilterFunc: func(e event.Event) []event.Event {
			panic("mock out the Filter method")
		},
	}

	// use mockedFilterer in code that requires Filterer
	// and then make assertions.

}

func (mock *FiltererMock) Filter(e event.Event) []event.Event

func (mock *FiltererMock) FilterCalls() []struct {
	E event.Event
}

len(mockedFilterer.FilterCalls())

type Hasher ¶

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

Hasher defines the hashing interface that a receiver needs to implement

type HasherMock ¶

type HasherMock struct {
	// FiltererHashFunc mocks the FiltererHash method.
	FiltererHashFunc 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{
		FiltererHashFunc: func(config interface{}) (string, error) {
			panic("mock out the FiltererHash method")
		},
	}

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

}

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

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

len(mockedHasher.FiltererHashCalls())

type InvalidArgumentError ¶

type InvalidArgumentError struct {
	Err error
}

func (e *InvalidArgumentError) Error() string

func (e *InvalidArgumentError) Unwrap() error

type InvalidConfigError ¶

type InvalidConfigError struct {
	Err error
}

InvalidConfigError is returned when a configuration parameter results in a plugin error

func (e *InvalidConfigError) Error() string

func (e *InvalidConfigError) Unwrap() error

type NewFilterer ¶

type NewFilterer interface {
	Hasher

	// NewFilterer returns an object that implements the Filterer interface
	NewFilterer(config interface{}) (Filterer, error)
}

NewFilterer defines the interface on how to to create a new filterer

type NewFiltererMock ¶

type NewFiltererMock struct {
	// FiltererHashFunc mocks the FiltererHash method.
	FiltererHashFunc func(config interface{}) (string, error)

	// NewFiltererFunc mocks the NewFilterer method.
	NewFiltererFunc func(config interface{}) (Filterer, error)
	// contains filtered or unexported fields
}

NewFiltererMock is a mock implementation of NewFilterer.

func TestSomethingThatUsesNewFilterer(t *testing.T) {

	// make and configure a mocked NewFilterer
	mockedNewFilterer := &NewFiltererMock{
		FiltererHashFunc: func(config interface{}) (string, error) {
			panic("mock out the FiltererHash method")
		},
		NewFiltererFunc: func(config interface{}) (Filterer, error) {
			panic("mock out the NewFilterer method")
		},
	}

	// use mockedNewFilterer in code that requires NewFilterer
	// and then make assertions.

}

func (mock *NewFiltererMock) FiltererHash(config interface{}) (string, error)

func (mock *NewFiltererMock) FiltererHashCalls() []struct {
	Config interface{}
}

len(mockedNewFilterer.FiltererHashCalls())

func (mock *NewFiltererMock) NewFilterer(config interface{}) (Filterer, error)

func (mock *NewFiltererMock) NewFiltererCalls() []struct {
	Config interface{}
}

len(mockedNewFilterer.NewFiltererCalls())