From 0f94a90882657057b66ee4284d15483293a7a502 Mon Sep 17 00:00:00 2001 From: MaysWind Date: Fri, 8 Aug 2025 16:48:21 +0800 Subject: [PATCH] add unit tests --- .../datatable/basic_data_table_test.go | 65 +++++ ...table_to_common_data_table_wrapper_test.go | 108 ++++++++ ..._to_transaction_data_table_wrapper_test.go | 220 +++++++++++++++ ..._to_transaction_data_table_wrapper_test.go | 258 ++++++++++++++++++ 4 files changed, 651 insertions(+) create mode 100644 pkg/converters/datatable/basic_data_table_test.go create mode 100644 pkg/converters/datatable/basic_data_table_to_common_data_table_wrapper_test.go create mode 100644 pkg/converters/datatable/basic_data_table_to_transaction_data_table_wrapper_test.go create mode 100644 pkg/converters/datatable/common_data_table_to_transaction_data_table_wrapper_test.go diff --git a/pkg/converters/datatable/basic_data_table_test.go b/pkg/converters/datatable/basic_data_table_test.go new file mode 100644 index 00000000..30d3739e --- /dev/null +++ b/pkg/converters/datatable/basic_data_table_test.go @@ -0,0 +1,65 @@ +package datatable + +type testBasicDataTable struct { + headerColumns []string + rows []*testBasicDataTableRow +} + +type testBasicDataTableRow struct { + rowId string + rowColumns []string +} + +type testBasicDataTableRowIterator struct { + rows []*testBasicDataTableRow + currentIndex int +} + +func (t *testBasicDataTable) HeaderColumnNames() []string { + return t.headerColumns +} + +func (t *testBasicDataTable) DataRowCount() int { + return len(t.rows) +} + +func (t *testBasicDataTable) DataRowIterator() BasicDataTableRowIterator { + return &testBasicDataTableRowIterator{ + rows: t.rows, + currentIndex: -1, + } +} + +func (r *testBasicDataTableRow) ColumnCount() int { + return len(r.rowColumns) +} + +func (r *testBasicDataTableRow) GetData(columnIndex int) string { + if columnIndex < 0 || columnIndex >= len(r.rowColumns) { + return "" + } + + return r.rowColumns[columnIndex] +} + +func (t *testBasicDataTableRowIterator) HasNext() bool { + return t.currentIndex+1 < len(t.rows) +} + +func (t *testBasicDataTableRowIterator) CurrentRowId() string { + if t.currentIndex >= len(t.rows) { + return "" + } + + return t.rows[t.currentIndex].rowId +} + +func (t *testBasicDataTableRowIterator) Next() BasicDataTableRow { + if t.currentIndex+1 >= len(t.rows) { + return nil + } + + t.currentIndex++ + row := t.rows[t.currentIndex] + return row +} diff --git a/pkg/converters/datatable/basic_data_table_to_common_data_table_wrapper_test.go b/pkg/converters/datatable/basic_data_table_to_common_data_table_wrapper_test.go new file mode 100644 index 00000000..8622b162 --- /dev/null +++ b/pkg/converters/datatable/basic_data_table_to_common_data_table_wrapper_test.go @@ -0,0 +1,108 @@ +package datatable + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestBasicDataTableToCommonDataTableWrapper_HeaderColumnCount(t *testing.T) { + columns := []string{"Col1", "Col2", "Col3"} + basicDataTable := &testBasicDataTable{ + headerColumns: columns, + rows: []*testBasicDataTableRow{}, + } + + commonDataTable := CreateNewCommonDataTableFromBasicDataTable(basicDataTable) + assert.Equal(t, len(columns), commonDataTable.HeaderColumnCount()) +} + +func TestBasicDataTableToCommonDataTableWrapper_HasColumn(t *testing.T) { + columns := []string{"Col1", "Col2", "Col3"} + basicDataTable := &testBasicDataTable{ + headerColumns: columns, + rows: []*testBasicDataTableRow{}, + } + + commonDataTable := CreateNewCommonDataTableFromBasicDataTable(basicDataTable) + + assert.True(t, commonDataTable.HasColumn("Col1")) + assert.True(t, commonDataTable.HasColumn("Col2")) + assert.True(t, commonDataTable.HasColumn("Col3")) + + assert.False(t, commonDataTable.HasColumn("Col4")) + assert.False(t, commonDataTable.HasColumn("")) +} + +func TestBasicDataTableToCommonDataTableWrapper_DataRowCount(t *testing.T) { + columns := []string{"Col1", "Col2", "Col3"} + rows := []*testBasicDataTableRow{ + { + rowId: "1", + rowColumns: []string{"A1", "B1", "C1"}, + }, + { + rowId: "2", + rowColumns: []string{"A2", "B2", "C2"}, + }, + { + rowId: "3", + rowColumns: []string{"A3", "B3", "C3"}, + }, + } + + basicDataTable := &testBasicDataTable{ + headerColumns: columns, + rows: rows, + } + + commonDataTable := CreateNewCommonDataTableFromBasicDataTable(basicDataTable) + assert.Equal(t, len(rows), commonDataTable.DataRowCount()) +} + +func TestBasicDataTableToCommonDataTableWrapper_DataRowIterator(t *testing.T) { + columns := []string{"Col1", "Col2", "Col3"} + rows := []*testBasicDataTableRow{ + { + rowId: "1", + rowColumns: []string{"A1", "B1", "C1"}, + }, + { + rowId: "2", + rowColumns: []string{"A2", "B2", "C2"}, + }, + } + + basicDataTable := &testBasicDataTable{ + headerColumns: columns, + rows: rows, + } + + commonDataTable := CreateNewCommonDataTableFromBasicDataTable(basicDataTable) + iterator := commonDataTable.DataRowIterator() + + assert.True(t, iterator.HasNext()) + firstRow := iterator.Next() + assert.NotNil(t, firstRow) + assert.Equal(t, len(columns), firstRow.ColumnCount()) + assert.True(t, firstRow.HasData("Col1")) + assert.True(t, firstRow.HasData("Col2")) + assert.True(t, firstRow.HasData("Col3")) + assert.Equal(t, "A1", firstRow.GetData("Col1")) + assert.Equal(t, "B1", firstRow.GetData("Col2")) + assert.Equal(t, "C1", firstRow.GetData("Col3")) + + assert.True(t, iterator.HasNext()) + secondRow := iterator.Next() + assert.NotNil(t, secondRow) + assert.Equal(t, len(columns), secondRow.ColumnCount()) + assert.True(t, secondRow.HasData("Col1")) + assert.True(t, secondRow.HasData("Col2")) + assert.True(t, secondRow.HasData("Col3")) + assert.Equal(t, "A2", secondRow.GetData("Col1")) + assert.Equal(t, "B2", secondRow.GetData("Col2")) + assert.Equal(t, "C2", secondRow.GetData("Col3")) + + assert.False(t, iterator.HasNext()) + assert.Nil(t, iterator.Next()) +} diff --git a/pkg/converters/datatable/basic_data_table_to_transaction_data_table_wrapper_test.go b/pkg/converters/datatable/basic_data_table_to_transaction_data_table_wrapper_test.go new file mode 100644 index 00000000..a4f8b885 --- /dev/null +++ b/pkg/converters/datatable/basic_data_table_to_transaction_data_table_wrapper_test.go @@ -0,0 +1,220 @@ +package datatable + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/mayswind/ezbookkeeping/pkg/errs" +) + +type testTransactionDataRowParser struct { +} + +func (p *testTransactionDataRowParser) Parse(rowData map[TransactionDataTableColumn]string) (map[TransactionDataTableColumn]string, bool, error) { + rowData[TRANSACTION_DATA_TABLE_DESCRIPTION] = "Test Description" + return rowData, true, nil +} + +func (p *testTransactionDataRowParser) GetAddedColumns() []TransactionDataTableColumn { + return []TransactionDataTableColumn{TRANSACTION_DATA_TABLE_DESCRIPTION} +} + +func TestBasicDataTableToTransactionDataTableWrapper_HasColumn(t *testing.T) { + columns := []string{"TransactionTime", "TransactionType", "Amount"} + basicDataTable := &testBasicDataTable{ + headerColumns: columns, + rows: []*testBasicDataTableRow{}, + } + + columnMapping := map[TransactionDataTableColumn]string{ + TRANSACTION_DATA_TABLE_TRANSACTION_TIME: "TransactionTime", + TRANSACTION_DATA_TABLE_TRANSACTION_TYPE: "TransactionType", + TRANSACTION_DATA_TABLE_AMOUNT: "Amount", + } + + transactionDataTable := CreateNewTransactionDataTableFromBasicDataTable(basicDataTable, columnMapping) + + assert.True(t, transactionDataTable.HasColumn(TRANSACTION_DATA_TABLE_TRANSACTION_TIME)) + assert.True(t, transactionDataTable.HasColumn(TRANSACTION_DATA_TABLE_TRANSACTION_TYPE)) + assert.True(t, transactionDataTable.HasColumn(TRANSACTION_DATA_TABLE_AMOUNT)) + + assert.False(t, transactionDataTable.HasColumn(TRANSACTION_DATA_TABLE_DESCRIPTION)) + assert.False(t, transactionDataTable.HasColumn(TRANSACTION_DATA_TABLE_CATEGORY)) +} + +func TestBasicDataTableToTransactionDataTableWrapper_TransactionRowCount(t *testing.T) { + columns := []string{"TransactionTime", "TransactionType", "Amount"} + rows := []*testBasicDataTableRow{ + { + rowId: "1", + rowColumns: []string{"2024-01-01", "1", "100"}, + }, + { + rowId: "2", + rowColumns: []string{"2024-01-02", "2", "200"}, + }, + { + rowId: "3", + rowColumns: []string{"2024-01-03", "1", "300"}, + }, + } + + basicDataTable := &testBasicDataTable{ + headerColumns: columns, + rows: rows, + } + + columnMapping := map[TransactionDataTableColumn]string{ + TRANSACTION_DATA_TABLE_TRANSACTION_TIME: "TransactionTime", + TRANSACTION_DATA_TABLE_TRANSACTION_TYPE: "TransactionType", + TRANSACTION_DATA_TABLE_AMOUNT: "Amount", + } + + transactionDataTable := CreateNewTransactionDataTableFromBasicDataTable(basicDataTable, columnMapping) + assert.Equal(t, len(rows), transactionDataTable.TransactionRowCount()) +} + +func TestBasicDataTableToTransactionDataTableWrapper_TransactionRowIterator(t *testing.T) { + columns := []string{"TransactionTime", "TransactionType", "Amount"} + rows := []*testBasicDataTableRow{ + { + rowId: "1", + rowColumns: []string{"2024-01-01", "1", "100"}, + }, + { + rowId: "2", + rowColumns: []string{"2024-01-02", "2", "200"}, + }, + } + + basicDataTable := &testBasicDataTable{ + headerColumns: columns, + rows: rows, + } + + columnMapping := map[TransactionDataTableColumn]string{ + TRANSACTION_DATA_TABLE_TRANSACTION_TIME: "TransactionTime", + TRANSACTION_DATA_TABLE_TRANSACTION_TYPE: "TransactionType", + TRANSACTION_DATA_TABLE_AMOUNT: "Amount", + } + + transactionDataTable := CreateNewTransactionDataTableFromBasicDataTable(basicDataTable, columnMapping) + iterator := transactionDataTable.TransactionRowIterator() + + assert.True(t, iterator.HasNext()) + firstRow, err := iterator.Next(nil, nil) + assert.Nil(t, err) + assert.NotNil(t, firstRow) + assert.True(t, firstRow.IsValid()) + assert.Equal(t, "2024-01-01", firstRow.GetData(TRANSACTION_DATA_TABLE_TRANSACTION_TIME)) + assert.Equal(t, "1", firstRow.GetData(TRANSACTION_DATA_TABLE_TRANSACTION_TYPE)) + assert.Equal(t, "100", firstRow.GetData(TRANSACTION_DATA_TABLE_AMOUNT)) + + assert.True(t, iterator.HasNext()) + secondRow, err := iterator.Next(nil, nil) + assert.Nil(t, err) + assert.NotNil(t, secondRow) + assert.True(t, secondRow.IsValid()) + assert.Equal(t, "2024-01-02", secondRow.GetData(TRANSACTION_DATA_TABLE_TRANSACTION_TIME)) + assert.Equal(t, "2", secondRow.GetData(TRANSACTION_DATA_TABLE_TRANSACTION_TYPE)) + assert.Equal(t, "200", secondRow.GetData(TRANSACTION_DATA_TABLE_AMOUNT)) + + assert.False(t, iterator.HasNext()) + emptyRow, err := iterator.Next(nil, nil) + assert.Nil(t, err) + assert.Nil(t, emptyRow) +} + +func TestBasicDataTableToTransactionDataTableWrapper_TransactionRowIterator_EmptyRow(t *testing.T) { + columns := []string{"TransactionTime", "TransactionType", "Amount"} + rows := []*testBasicDataTableRow{ + { + rowId: "1", + rowColumns: []string{""}, + }, + } + + basicDataTable := &testBasicDataTable{ + headerColumns: columns, + rows: rows, + } + + columnMapping := map[TransactionDataTableColumn]string{ + TRANSACTION_DATA_TABLE_TRANSACTION_TIME: "TransactionTime", + TRANSACTION_DATA_TABLE_TRANSACTION_TYPE: "TransactionType", + TRANSACTION_DATA_TABLE_AMOUNT: "Amount", + } + + transactionDataTable := CreateNewTransactionDataTableFromBasicDataTable(basicDataTable, columnMapping) + iterator := transactionDataTable.TransactionRowIterator() + + assert.True(t, iterator.HasNext()) + row, err := iterator.Next(nil, nil) + assert.Nil(t, err) + assert.NotNil(t, row) + assert.False(t, row.IsValid()) +} + +func TestBasicDataTableToTransactionDataTableWrapper_TransactionRowIterator_InvalidRow(t *testing.T) { + columns := []string{"TransactionTime", "TransactionType", "Amount"} + rows := []*testBasicDataTableRow{ + { + rowId: "1", + rowColumns: []string{"2024-01-01", "1"}, + }, + } + + basicDataTable := &testBasicDataTable{ + headerColumns: columns, + rows: rows, + } + + columnMapping := map[TransactionDataTableColumn]string{ + TRANSACTION_DATA_TABLE_TRANSACTION_TIME: "TransactionTime", + TRANSACTION_DATA_TABLE_TRANSACTION_TYPE: "TransactionType", + TRANSACTION_DATA_TABLE_AMOUNT: "Amount", + } + + transactionDataTable := CreateNewTransactionDataTableFromBasicDataTable(basicDataTable, columnMapping) + iterator := transactionDataTable.TransactionRowIterator() + + assert.True(t, iterator.HasNext()) + row, err := iterator.Next(nil, nil) + assert.NotNil(t, err) + assert.Equal(t, errs.ErrFewerFieldsInDataRowThanInHeaderRow, err) + assert.Nil(t, row) +} + +func TestBasicDataTableToTransactionDataTableWrapper_TransactionRowIterator_WithRowParserAddedColumn(t *testing.T) { + columns := []string{"TransactionTime", "TransactionType", "Amount"} + rows := []*testBasicDataTableRow{ + { + rowId: "1", + rowColumns: []string{"2024-01-01", "1", "100"}, + }, + } + + basicDataTable := &testBasicDataTable{ + headerColumns: columns, + rows: rows, + } + + columnMapping := map[TransactionDataTableColumn]string{ + TRANSACTION_DATA_TABLE_TRANSACTION_TIME: "TransactionTime", + TRANSACTION_DATA_TABLE_TRANSACTION_TYPE: "TransactionType", + TRANSACTION_DATA_TABLE_AMOUNT: "Amount", + TRANSACTION_DATA_TABLE_DESCRIPTION: "Description", + } + + transactionDataTable := CreateNewTransactionDataTableFromBasicDataTableWithRowParser(basicDataTable, columnMapping, &testTransactionDataRowParser{}) + assert.True(t, transactionDataTable.HasColumn(TRANSACTION_DATA_TABLE_DESCRIPTION)) + + iterator := transactionDataTable.TransactionRowIterator() + assert.True(t, iterator.HasNext()) + row, err := iterator.Next(nil, nil) + assert.Nil(t, err) + assert.NotNil(t, row) + assert.True(t, row.IsValid()) + assert.Equal(t, "Test Description", row.GetData(TRANSACTION_DATA_TABLE_DESCRIPTION)) +} diff --git a/pkg/converters/datatable/common_data_table_to_transaction_data_table_wrapper_test.go b/pkg/converters/datatable/common_data_table_to_transaction_data_table_wrapper_test.go new file mode 100644 index 00000000..c8ad5864 --- /dev/null +++ b/pkg/converters/datatable/common_data_table_to_transaction_data_table_wrapper_test.go @@ -0,0 +1,258 @@ +package datatable + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/mayswind/ezbookkeeping/pkg/core" + "github.com/mayswind/ezbookkeeping/pkg/errs" + "github.com/mayswind/ezbookkeeping/pkg/models" +) + +type testCommonDataTable struct { + headerColumns []string + dataRows []*testCommonDataTableRow +} + +type testCommonDataTableRow struct { + rowId string + rowData map[string]string +} + +type testCommonDataTableRowIterator struct { + dataTable *testCommonDataTable + currentIndex int +} + +func (t *testCommonDataTable) DataRowCount() int { + return len(t.dataRows) +} + +func (t *testCommonDataTable) HeaderColumnCount() int { + return len(t.headerColumns) +} + +func (t *testCommonDataTable) HasColumn(columnName string) bool { + for _, header := range t.headerColumns { + if header == columnName { + return true + } + } + return false +} + +func (t *testCommonDataTable) DataRowIterator() CommonDataTableRowIterator { + return &testCommonDataTableRowIterator{ + dataTable: t, + currentIndex: -1, + } +} + +func (t *testCommonDataTableRow) GetData(dataKey string) string { + return t.rowData[dataKey] +} + +func (t *testCommonDataTableRow) HasData(dataKey string) bool { + _, exists := t.rowData[dataKey] + return exists +} + +func (t *testCommonDataTableRow) ColumnCount() int { + return len(t.rowData) +} + +func (t *testCommonDataTableRowIterator) HasNext() bool { + return t.currentIndex+1 < len(t.dataTable.dataRows) +} + +func (t *testCommonDataTableRowIterator) Next() CommonDataTableRow { + if !t.HasNext() { + return nil + } + + t.currentIndex++ + return t.dataTable.dataRows[t.currentIndex] +} + +func (t *testCommonDataTableRowIterator) CurrentRowId() string { + if t.currentIndex < 0 || t.currentIndex >= len(t.dataTable.dataRows) { + return "" + } + + return t.dataTable.dataRows[t.currentIndex].rowId +} + +type testCommonTransactionDataRowParser struct { + returnError bool +} + +func (p *testCommonTransactionDataRowParser) Parse(ctx core.Context, user *models.User, dataRow CommonDataTableRow, rowId string) (map[TransactionDataTableColumn]string, bool, error) { + if p.returnError { + return nil, false, errs.ErrOperationFailed + } + + rowData := make(map[TransactionDataTableColumn]string) + rowData[TRANSACTION_DATA_TABLE_TRANSACTION_TIME] = dataRow.GetData("TransactionTime") + rowData[TRANSACTION_DATA_TABLE_TRANSACTION_TYPE] = dataRow.GetData("TransactionType") + rowData[TRANSACTION_DATA_TABLE_AMOUNT] = dataRow.GetData("Amount") + rowData[TRANSACTION_DATA_TABLE_DESCRIPTION] = "Test Description" + return rowData, true, nil +} + +func TestCommonDataTableToTransactionDataTableWrapper_HasColumn(t *testing.T) { + basicDataTable := &testCommonDataTable{ + headerColumns: []string{"TransactionTime", "TransactionType", "Amount"}, + dataRows: []*testCommonDataTableRow{}, + } + + supportedColumns := map[TransactionDataTableColumn]bool{ + TRANSACTION_DATA_TABLE_TRANSACTION_TIME: true, + TRANSACTION_DATA_TABLE_TRANSACTION_TYPE: true, + TRANSACTION_DATA_TABLE_AMOUNT: true, + } + + transactionDataTable := CreateNewTransactionDataTableFromCommonDataTable(basicDataTable, supportedColumns, &testCommonTransactionDataRowParser{}) + + assert.True(t, transactionDataTable.HasColumn(TRANSACTION_DATA_TABLE_TRANSACTION_TIME)) + assert.True(t, transactionDataTable.HasColumn(TRANSACTION_DATA_TABLE_TRANSACTION_TYPE)) + assert.True(t, transactionDataTable.HasColumn(TRANSACTION_DATA_TABLE_AMOUNT)) + + assert.False(t, transactionDataTable.HasColumn(TRANSACTION_DATA_TABLE_CATEGORY)) + assert.False(t, transactionDataTable.HasColumn(TRANSACTION_DATA_TABLE_DESCRIPTION)) +} + +func TestCommonDataTableToTransactionDataTableWrapper_TransactionRowCount(t *testing.T) { + rows := []*testCommonDataTableRow{ + { + rowId: "1", + rowData: map[string]string{ + "TransactionTime": "2024-01-01", + "TransactionType": "1", + "Amount": "100", + }, + }, + { + rowId: "2", + rowData: map[string]string{ + "TransactionTime": "2024-01-02", + "TransactionType": "2", + "Amount": "200", + }, + }, + { + rowId: "3", + rowData: map[string]string{ + "TransactionTime": "2024-01-03", + "TransactionType": "1", + "Amount": "300", + }, + }, + } + + basicDataTable := &testCommonDataTable{ + headerColumns: []string{"TransactionTime", "TransactionType", "Amount"}, + dataRows: rows, + } + + supportedColumns := map[TransactionDataTableColumn]bool{ + TRANSACTION_DATA_TABLE_TRANSACTION_TIME: true, + TRANSACTION_DATA_TABLE_TRANSACTION_TYPE: true, + TRANSACTION_DATA_TABLE_AMOUNT: true, + } + + transactionDataTable := CreateNewTransactionDataTableFromCommonDataTable(basicDataTable, supportedColumns, &testCommonTransactionDataRowParser{}) + assert.Equal(t, len(rows), transactionDataTable.TransactionRowCount()) +} + +func TestCommonDataTableToTransactionDataTableWrapper_TransactionRowIterator(t *testing.T) { + rows := []*testCommonDataTableRow{ + { + rowId: "1", + rowData: map[string]string{ + "TransactionTime": "2024-01-01", + "TransactionType": "1", + "Amount": "100", + }, + }, + { + rowId: "2", + rowData: map[string]string{ + "TransactionTime": "2024-01-02", + "TransactionType": "2", + "Amount": "200", + }, + }, + } + + basicDataTable := &testCommonDataTable{ + headerColumns: []string{"TransactionTime", "TransactionType", "Amount"}, + dataRows: rows, + } + + supportedColumns := map[TransactionDataTableColumn]bool{ + TRANSACTION_DATA_TABLE_TRANSACTION_TIME: true, + TRANSACTION_DATA_TABLE_TRANSACTION_TYPE: true, + TRANSACTION_DATA_TABLE_AMOUNT: true, + } + + transactionDataTable := CreateNewTransactionDataTableFromCommonDataTable(basicDataTable, supportedColumns, &testCommonTransactionDataRowParser{}) + iterator := transactionDataTable.TransactionRowIterator() + + assert.True(t, iterator.HasNext()) + firstRow, err := iterator.Next(nil, nil) + assert.Nil(t, err) + assert.NotNil(t, firstRow) + assert.True(t, firstRow.IsValid()) + assert.Equal(t, "2024-01-01", firstRow.GetData(TRANSACTION_DATA_TABLE_TRANSACTION_TIME)) + assert.Equal(t, "1", firstRow.GetData(TRANSACTION_DATA_TABLE_TRANSACTION_TYPE)) + assert.Equal(t, "100", firstRow.GetData(TRANSACTION_DATA_TABLE_AMOUNT)) + assert.Equal(t, "", firstRow.GetData(TRANSACTION_DATA_TABLE_DESCRIPTION)) + + assert.True(t, iterator.HasNext()) + secondRow, err := iterator.Next(nil, nil) + assert.Nil(t, err) + assert.NotNil(t, secondRow) + assert.True(t, secondRow.IsValid()) + assert.Equal(t, "2024-01-02", secondRow.GetData(TRANSACTION_DATA_TABLE_TRANSACTION_TIME)) + assert.Equal(t, "2", secondRow.GetData(TRANSACTION_DATA_TABLE_TRANSACTION_TYPE)) + assert.Equal(t, "200", secondRow.GetData(TRANSACTION_DATA_TABLE_AMOUNT)) + assert.Equal(t, "", secondRow.GetData(TRANSACTION_DATA_TABLE_DESCRIPTION)) + + assert.False(t, iterator.HasNext()) + emptyRow, err := iterator.Next(nil, nil) + assert.Nil(t, err) + assert.Nil(t, emptyRow) +} + +func TestCommonDataTableToTransactionDataTableWrapper_TransactionRowIterator_EOF(t *testing.T) { + rows := []*testCommonDataTableRow{ + { + rowId: "1", + rowData: map[string]string{ + "TransactionTime": "2024-01-01", + "TransactionType": "1", + "Amount": "100", + }, + }, + } + + basicDataTable := &testCommonDataTable{ + headerColumns: []string{"TransactionTime", "TransactionType", "Amount"}, + dataRows: rows, + } + + supportedColumns := map[TransactionDataTableColumn]bool{ + TRANSACTION_DATA_TABLE_TRANSACTION_TIME: true, + TRANSACTION_DATA_TABLE_TRANSACTION_TYPE: true, + TRANSACTION_DATA_TABLE_AMOUNT: true, + } + + transactionDataTable := CreateNewTransactionDataTableFromCommonDataTable(basicDataTable, supportedColumns, &testCommonTransactionDataRowParser{returnError: true}) + iterator := transactionDataTable.TransactionRowIterator() + + assert.True(t, iterator.HasNext()) + row, err := iterator.Next(nil, nil) + assert.EqualError(t, err, errs.ErrOperationFailed.Message) + assert.Nil(t, row) +}