implement reporter

also introduce gomock and tests

internal/mocks/mocks_gen.go

@@ -0,0 +1,296 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: git.naterciomoniz.net/applications/broker2anexoj/internal (interfaces: RecordReader,Record)
+//
+// Generated by this command:
+//
+//	mockgen -destination=mocks/mocks_gen.go -package=mocks -typed . RecordReader,Record
+//
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+	big "math/big"
+	reflect "reflect"
+	time "time"
+
+	internal "git.naterciomoniz.net/applications/broker2anexoj/internal"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockRecordReader is a mock of RecordReader interface.
+type MockRecordReader struct {
+	ctrl     *gomock.Controller
+	recorder *MockRecordReaderMockRecorder
+	isgomock struct{}
+}
+
+// MockRecordReaderMockRecorder is the mock recorder for MockRecordReader.
+type MockRecordReaderMockRecorder struct {
+	mock *MockRecordReader
+}
+
+// NewMockRecordReader creates a new mock instance.
+func NewMockRecordReader(ctrl *gomock.Controller) *MockRecordReader {
+	mock := &MockRecordReader{ctrl: ctrl}
+	mock.recorder = &MockRecordReaderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRecordReader) EXPECT() *MockRecordReaderMockRecorder {
+	return m.recorder
+}
+
+// ReadRecord mocks base method.
+func (m *MockRecordReader) ReadRecord() (internal.Record, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReadRecord")
+	ret0, _ := ret[0].(internal.Record)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ReadRecord indicates an expected call of ReadRecord.
+func (mr *MockRecordReaderMockRecorder) ReadRecord() *MockRecordReaderReadRecordCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRecord", reflect.TypeOf((*MockRecordReader)(nil).ReadRecord))
+	return &MockRecordReaderReadRecordCall{Call: call}
+}
+
+// MockRecordReaderReadRecordCall wrap *gomock.Call
+type MockRecordReaderReadRecordCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockRecordReaderReadRecordCall) Return(arg0 internal.Record, arg1 error) *MockRecordReaderReadRecordCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockRecordReaderReadRecordCall) Do(f func() (internal.Record, error)) *MockRecordReaderReadRecordCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockRecordReaderReadRecordCall) DoAndReturn(f func() (internal.Record, error)) *MockRecordReaderReadRecordCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// MockRecord is a mock of Record interface.
+type MockRecord struct {
+	ctrl     *gomock.Controller
+	recorder *MockRecordMockRecorder
+	isgomock struct{}
+}
+
+// MockRecordMockRecorder is the mock recorder for MockRecord.
+type MockRecordMockRecorder struct {
+	mock *MockRecord
+}
+
+// NewMockRecord creates a new mock instance.
+func NewMockRecord(ctrl *gomock.Controller) *MockRecord {
+	mock := &MockRecord{ctrl: ctrl}
+	mock.recorder = &MockRecordMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRecord) EXPECT() *MockRecordMockRecorder {
+	return m.recorder
+}
+
+// Price mocks base method.
+func (m *MockRecord) Price() *big.Float {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Price")
+	ret0, _ := ret[0].(*big.Float)
+	return ret0
+}
+
+// Price indicates an expected call of Price.
+func (mr *MockRecordMockRecorder) Price() *MockRecordPriceCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Price", reflect.TypeOf((*MockRecord)(nil).Price))
+	return &MockRecordPriceCall{Call: call}
+}
+
+// MockRecordPriceCall wrap *gomock.Call
+type MockRecordPriceCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockRecordPriceCall) Return(arg0 *big.Float) *MockRecordPriceCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockRecordPriceCall) Do(f func() *big.Float) *MockRecordPriceCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockRecordPriceCall) DoAndReturn(f func() *big.Float) *MockRecordPriceCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Quantity mocks base method.
+func (m *MockRecord) Quantity() *big.Float {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Quantity")
+	ret0, _ := ret[0].(*big.Float)
+	return ret0
+}
+
+// Quantity indicates an expected call of Quantity.
+func (mr *MockRecordMockRecorder) Quantity() *MockRecordQuantityCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quantity", reflect.TypeOf((*MockRecord)(nil).Quantity))
+	return &MockRecordQuantityCall{Call: call}
+}
+
+// MockRecordQuantityCall wrap *gomock.Call
+type MockRecordQuantityCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockRecordQuantityCall) Return(arg0 *big.Float) *MockRecordQuantityCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockRecordQuantityCall) Do(f func() *big.Float) *MockRecordQuantityCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockRecordQuantityCall) DoAndReturn(f func() *big.Float) *MockRecordQuantityCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Side mocks base method.
+func (m *MockRecord) Side() internal.Side {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Side")
+	ret0, _ := ret[0].(internal.Side)
+	return ret0
+}
+
+// Side indicates an expected call of Side.
+func (mr *MockRecordMockRecorder) Side() *MockRecordSideCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Side", reflect.TypeOf((*MockRecord)(nil).Side))
+	return &MockRecordSideCall{Call: call}
+}
+
+// MockRecordSideCall wrap *gomock.Call
+type MockRecordSideCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockRecordSideCall) Return(arg0 internal.Side) *MockRecordSideCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockRecordSideCall) Do(f func() internal.Side) *MockRecordSideCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockRecordSideCall) DoAndReturn(f func() internal.Side) *MockRecordSideCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Symbol mocks base method.
+func (m *MockRecord) Symbol() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Symbol")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Symbol indicates an expected call of Symbol.
+func (mr *MockRecordMockRecorder) Symbol() *MockRecordSymbolCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Symbol", reflect.TypeOf((*MockRecord)(nil).Symbol))
+	return &MockRecordSymbolCall{Call: call}
+}
+
+// MockRecordSymbolCall wrap *gomock.Call
+type MockRecordSymbolCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockRecordSymbolCall) Return(arg0 string) *MockRecordSymbolCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockRecordSymbolCall) Do(f func() string) *MockRecordSymbolCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockRecordSymbolCall) DoAndReturn(f func() string) *MockRecordSymbolCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Timestamp mocks base method.
+func (m *MockRecord) Timestamp() time.Time {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Timestamp")
+	ret0, _ := ret[0].(time.Time)
+	return ret0
+}
+
+// Timestamp indicates an expected call of Timestamp.
+func (mr *MockRecordMockRecorder) Timestamp() *MockRecordTimestampCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockRecord)(nil).Timestamp))
+	return &MockRecordTimestampCall{Call: call}
+}
+
+// MockRecordTimestampCall wrap *gomock.Call
+type MockRecordTimestampCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockRecordTimestampCall) Return(arg0 time.Time) *MockRecordTimestampCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockRecordTimestampCall) Do(f func() time.Time) *MockRecordTimestampCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockRecordTimestampCall) DoAndReturn(f func() time.Time) *MockRecordTimestampCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}