From bb93798c0fa78d7de073351e7181a9dc4a780d93 Mon Sep 17 00:00:00 2001 From: Natercio Moniz Date: Thu, 13 Nov 2025 11:27:52 +0000 Subject: [PATCH 1/3] add Fees and Taxes to the Record type --- internal/generate.go | 2 +- internal/mocks/mocks_gen.go | 142 +++++++++++++++++++++++++++++++++- internal/record.go | 2 + internal/report.go | 15 ++++ internal/reporter.go | 5 -- internal/trading212/record.go | 8 ++ 6 files changed, 166 insertions(+), 8 deletions(-) create mode 100644 internal/report.go diff --git a/internal/generate.go b/internal/generate.go index 9e087fd..a0a9c26 100644 --- a/internal/generate.go +++ b/internal/generate.go @@ -1,3 +1,3 @@ package internal -//go:generate mockgen -destination=mocks/mocks_gen.go -package=mocks -typed . RecordReader,Record +//go:generate go tool mockgen -destination=mocks/mocks_gen.go -package=mocks -typed . RecordReader,Record,ReportWriter diff --git a/internal/mocks/mocks_gen.go b/internal/mocks/mocks_gen.go index 04325d7..64430ee 100644 --- a/internal/mocks/mocks_gen.go +++ b/internal/mocks/mocks_gen.go @@ -1,9 +1,9 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: git.naterciomoniz.net/applications/broker2anexoj/internal (interfaces: RecordReader,Record) +// Source: git.naterciomoniz.net/applications/broker2anexoj/internal (interfaces: RecordReader,Record,ReportWriter) // // Generated by this command: // -// mockgen -destination=mocks/mocks_gen.go -package=mocks -typed . RecordReader,Record +// mockgen -destination=mocks/mocks_gen.go -package=mocks -typed . RecordReader,Record,ReportWriter // // Package mocks is a generated GoMock package. @@ -105,6 +105,44 @@ func (m *MockRecord) EXPECT() *MockRecordMockRecorder { return m.recorder } +// Fees mocks base method. +func (m *MockRecord) Fees() *big.Float { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Fees") + ret0, _ := ret[0].(*big.Float) + return ret0 +} + +// Fees indicates an expected call of Fees. +func (mr *MockRecordMockRecorder) Fees() *MockRecordFeesCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fees", reflect.TypeOf((*MockRecord)(nil).Fees)) + return &MockRecordFeesCall{Call: call} +} + +// MockRecordFeesCall wrap *gomock.Call +type MockRecordFeesCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockRecordFeesCall) Return(arg0 *big.Float) *MockRecordFeesCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockRecordFeesCall) Do(f func() *big.Float) *MockRecordFeesCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockRecordFeesCall) DoAndReturn(f func() *big.Float) *MockRecordFeesCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + // Price mocks base method. func (m *MockRecord) Price() *big.Float { m.ctrl.T.Helper() @@ -257,6 +295,44 @@ func (c *MockRecordSymbolCall) DoAndReturn(f func() string) *MockRecordSymbolCal return c } +// Taxes mocks base method. +func (m *MockRecord) Taxes() *big.Float { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Taxes") + ret0, _ := ret[0].(*big.Float) + return ret0 +} + +// Taxes indicates an expected call of Taxes. +func (mr *MockRecordMockRecorder) Taxes() *MockRecordTaxesCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Taxes", reflect.TypeOf((*MockRecord)(nil).Taxes)) + return &MockRecordTaxesCall{Call: call} +} + +// MockRecordTaxesCall wrap *gomock.Call +type MockRecordTaxesCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockRecordTaxesCall) Return(arg0 *big.Float) *MockRecordTaxesCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockRecordTaxesCall) Do(f func() *big.Float) *MockRecordTaxesCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockRecordTaxesCall) DoAndReturn(f func() *big.Float) *MockRecordTaxesCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + // Timestamp mocks base method. func (m *MockRecord) Timestamp() time.Time { m.ctrl.T.Helper() @@ -294,3 +370,65 @@ func (c *MockRecordTimestampCall) DoAndReturn(f func() time.Time) *MockRecordTim c.Call = c.Call.DoAndReturn(f) return c } + +// MockReportWriter is a mock of ReportWriter interface. +type MockReportWriter struct { + ctrl *gomock.Controller + recorder *MockReportWriterMockRecorder + isgomock struct{} +} + +// MockReportWriterMockRecorder is the mock recorder for MockReportWriter. +type MockReportWriterMockRecorder struct { + mock *MockReportWriter +} + +// NewMockReportWriter creates a new mock instance. +func NewMockReportWriter(ctrl *gomock.Controller) *MockReportWriter { + mock := &MockReportWriter{ctrl: ctrl} + mock.recorder = &MockReportWriterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockReportWriter) EXPECT() *MockReportWriterMockRecorder { + return m.recorder +} + +// Write mocks base method. +func (m *MockReportWriter) Write(arg0 internal.ReportItem) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Write", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Write indicates an expected call of Write. +func (mr *MockReportWriterMockRecorder) Write(arg0 any) *MockReportWriterWriteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockReportWriter)(nil).Write), arg0) + return &MockReportWriterWriteCall{Call: call} +} + +// MockReportWriterWriteCall wrap *gomock.Call +type MockReportWriterWriteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockReportWriterWriteCall) Return(arg0 error) *MockReportWriterWriteCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockReportWriterWriteCall) Do(f func(internal.ReportItem) error) *MockReportWriterWriteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockReportWriterWriteCall) DoAndReturn(f func(internal.ReportItem) error) *MockReportWriterWriteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/internal/record.go b/internal/record.go index 68b2301..9fa5d68 100644 --- a/internal/record.go +++ b/internal/record.go @@ -12,6 +12,8 @@ type Record interface { Price() *big.Float Quantity() *big.Float Timestamp() time.Time + Fees() *big.Float + Taxes() *big.Float } type RecordQueue struct { diff --git a/internal/report.go b/internal/report.go new file mode 100644 index 0000000..6cc582d --- /dev/null +++ b/internal/report.go @@ -0,0 +1,15 @@ +package internal + +import ( + "errors" +) + +type RecordReader interface { + // ReadRecord should return Records until an error is found. + ReadRecord() (Record, error) +} + +type ReportWriter interface { + // ReportWriter writes report items + Write(ReportItem) error +} diff --git a/internal/reporter.go b/internal/reporter.go index 1004b17..9d18964 100644 --- a/internal/reporter.go +++ b/internal/reporter.go @@ -9,11 +9,6 @@ import ( "sync" ) -type RecordReader interface { - // ReadRecord should return Records until an error is found. - ReadRecord() (Record, error) -} - // Reporter consumes each record to produce ReportItem. type Reporter struct { reader RecordReader diff --git a/internal/trading212/record.go b/internal/trading212/record.go index 4fa598d..403f631 100644 --- a/internal/trading212/record.go +++ b/internal/trading212/record.go @@ -39,6 +39,14 @@ func (r Record) Timestamp() time.Time { return r.timestamp } +func (r Record) Fees() *big.Float { + return new(big.Float) // FIX: +} + +func (r Record) Taxes() *big.Float { + return new(big.Float) // FIX: +} + type RecordReader struct { reader *csv.Reader } From 8e2163cce619372e20a73b3392c2a53a4450e016 Mon Sep 17 00:00:00 2001 From: Natercio Moniz Date: Thu, 13 Nov 2025 12:12:24 +0000 Subject: [PATCH 2/3] parse trading212 record fees --- internal/trading212/record.go | 34 ++++++++++++++++++++++++++++-- internal/trading212/record_test.go | 30 ++++++++++++++------------ 2 files changed, 48 insertions(+), 16 deletions(-) diff --git a/internal/trading212/record.go b/internal/trading212/record.go index 403f631..1bc2ad5 100644 --- a/internal/trading212/record.go +++ b/internal/trading212/record.go @@ -17,6 +17,8 @@ type Record struct { quantity *big.Float price *big.Float timestamp time.Time + fees *big.Float + taxes *big.Float } func (r Record) Symbol() string { @@ -40,11 +42,11 @@ func (r Record) Timestamp() time.Time { } func (r Record) Fees() *big.Float { - return new(big.Float) // FIX: + return r.fees } func (r Record) Taxes() *big.Float { - return new(big.Float) // FIX: + return r.taxes } type RecordReader struct { @@ -98,12 +100,29 @@ func (rr RecordReader) ReadRecord() (internal.Record, error) { return Record{}, fmt.Errorf("parse record timestamp: %w", err) } + convertionFee, err := parseOptinalDecimal(raw[16]) + if err != nil { + return Record{}, fmt.Errorf("parse record convertion fee: %w", err) + } + + stampDutyTax, err := parseOptinalDecimal(raw[14]) + if err != nil { + return Record{}, fmt.Errorf("parse record stamp duty tax: %w", err) + } + + frenchTxTax, err := parseOptinalDecimal(raw[18]) + if err != nil { + return Record{}, fmt.Errorf("parse record french transaction tax: %w", err) + } + return Record{ symbol: raw[2], side: side, quantity: qant, price: price, timestamp: ts, + fees: convertionFee, + taxes: new(big.Float).Add(stampDutyTax, frenchTxTax), }, nil } } @@ -114,3 +133,14 @@ func parseDecimal(s string) (*big.Float, error) { f, _, err := big.ParseFloat(s, 10, 128, big.ToZero) return f, err } + +// parseOptinalDecimal behaves the same as parseDecimal but returns 0 when len(s) is 0 instead of +// error. +// Using this function helps avoid issues around converting values due to sligh parameter changes. +func parseOptinalDecimal(s string) (*big.Float, error) { + if len(s) == 0 { + return new(big.Float), nil + } + + return parseDecimal(s) +} diff --git a/internal/trading212/record_test.go b/internal/trading212/record_test.go index d1b0f1c..0eac006 100644 --- a/internal/trading212/record_test.go +++ b/internal/trading212/record_test.go @@ -24,75 +24,69 @@ func TestRecordReader_ReadRecord(t *testing.T) { wantErr: true, }, { - name: "well formed buy", - r: bytes.NewBufferString(`Market buy,2025-07-03 10:44:29,SYM123456ABXY,ABXY,"Aspargus Brocoli",EOF987654321,2.4387014200,7.3690000000,USD,1.17995999,,"EUR",15.25,"EUR",,,0.02,"EUR",,`), + name: "well-formed buy", + r: bytes.NewBufferString(`Market buy,2025-07-03 10:44:29,SYM123456ABXY,ABXY,"Aspargus Brocoli",EOF987654321,2.4387014200,7.3690000000,USD,1.17995999,,"EUR",15.25,"EUR",0.25,"EUR",0.02,"EUR",,`), want: Record{ symbol: "SYM123456ABXY", side: internal.SideBuy, quantity: ShouldParseDecimal(t, "2.4387014200"), price: ShouldParseDecimal(t, "7.3690000000"), timestamp: time.Date(2025, 7, 3, 10, 44, 29, 0, time.UTC), + fees: ShouldParseDecimal(t, "0.02"), + taxes: ShouldParseDecimal(t, "0.25"), }, - wantErr: false, }, { - name: "well formed sell", - r: bytes.NewBufferString(`Market sell,2025-08-04 11:45:30,IE000GA3D489,ABXY,"Aspargus Brocoli",EOF987654321,2.4387014200,7.9999999999,USD,1.17995999,,"EUR",15.25,"EUR",,,0.02,"EUR",,`), + name: "well-formed sell", + r: bytes.NewBufferString(`Market sell,2025-08-04 11:45:30,IE000GA3D489,ABXY,"Aspargus Brocoli",EOF987654321,2.4387014200,7.9999999999,USD,1.17995999,,"EUR",15.25,"EUR",,,0.02,"EUR",0.1,"EUR"`), want: Record{ symbol: "IE000GA3D489", side: internal.SideSell, quantity: ShouldParseDecimal(t, "2.4387014200"), price: ShouldParseDecimal(t, "7.9999999999"), timestamp: time.Date(2025, 8, 4, 11, 45, 30, 0, time.UTC), + fees: ShouldParseDecimal(t, "0.02"), + taxes: ShouldParseDecimal(t, "0.1"), }, - wantErr: false, }, { name: "malformed side", r: bytes.NewBufferString(`Aljksdaf Balsjdkf,2025-08-04 11:45:39,IE000GA3D489,ABXY,"Aspargus Brocoli",EOF987654321,2.4387014200,7.9999999999,USD,1.17995999,,"EUR",15.25,"EUR",,,0.02,"EUR",,`), - want: Record{}, wantErr: true, }, { name: "empty side", r: bytes.NewBufferString(`,2025-08-04 11:45:39,IE000GA3D489,ABXY,"Aspargus Brocoli",EOF987654321,0x1234,7.9999999999,USD,1.17995999,,"EUR",15.25,"EUR",,,0.02,"EUR",,`), - want: Record{}, wantErr: true, }, { name: "malformed qantity", r: bytes.NewBufferString(`Market sell,2025-08-04 11:45:39,IE000GA3D489,ABXY,"Aspargus Brocoli",EOF987654321,0x1234,7.9999999999,USD,1.17995999,,"EUR",15.25,"EUR",,,0.02,"EUR",,`), - want: Record{}, wantErr: true, }, { name: "empty qantity", r: bytes.NewBufferString(`Market sell,2025-08-04 11:45:39,IE000GA3D489,ABXY,"Aspargus Brocoli",EOF987654321,,7.9999999999,USD,1.17995999,,"EUR",15.25,"EUR",,,0.02,"EUR",,`), - want: Record{}, wantErr: true, }, { name: "malformed price", r: bytes.NewBufferString(`Market sell,2025-08-04 11:45:39,IE000GA3D489,ABXY,"Aspargus Brocoli",EOF987654321,2.4387014200,0b101010,USD,1.17995999,,"EUR",15.25,"EUR",,,0.02,"EUR",,`), - want: Record{}, wantErr: true, }, { name: "empty price", r: bytes.NewBufferString(`Market sell,2025-08-04 11:45:39,IE000GA3D489,ABXY,"Aspargus Brocoli",EOF987654321,2.4387014200,,USD,1.17995999,,"EUR",15.25,"EUR",,,0.02,"EUR",,`), - want: Record{}, wantErr: true, }, { name: "malformed timestamp", r: bytes.NewBufferString(`Market sell,2006-01-02T15:04:05Z07:00,IE000GA3D489,ABXY,"Aspargus Brocoli",EOF987654321,2.4387014200,7.9999999999,USD,1.17995999,,"EUR",15.25,"EUR",,,0.02,"EUR",,`), - want: Record{}, wantErr: true, }, { name: "empty timestamp", r: bytes.NewBufferString(`Market sell,,IE000GA3D489,ABXY,"Aspargus Brocoli",EOF987654321,2.4387014200,7.9999999999,USD,1.17995999,,"EUR",15.25,"EUR",,,0.02,"EUR",,`), - want: Record{}, wantErr: true, }, } @@ -130,6 +124,14 @@ func TestRecordReader_ReadRecord(t *testing.T) { if !got.Timestamp().Equal(tt.want.timestamp) { t.Fatalf("want timestamp %v but got %v", tt.want.timestamp, got.Timestamp()) } + + if got.Fees().Cmp(tt.want.fees) != 0 { + t.Fatalf("want fees %v but got %v", tt.want.fees, got.Fees()) + } + + if got.Taxes().Cmp(tt.want.taxes) != 0 { + t.Fatalf("want taxes %v but got %v", tt.want.taxes, got.Taxes()) + } }) } } From 7450c0d571664c543aefe806e26d98583c1d7885 Mon Sep 17 00:00:00 2001 From: Natercio Moniz Date: Thu, 13 Nov 2025 13:47:41 +0000 Subject: [PATCH 3/3] fix unused imports --- internal/report.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/internal/report.go b/internal/report.go index 6cc582d..bef2e8f 100644 --- a/internal/report.go +++ b/internal/report.go @@ -1,9 +1,5 @@ package internal -import ( - "errors" -) - type RecordReader interface { // ReadRecord should return Records until an error is found. ReadRecord() (Record, error)