Function TestOneToManyReconciliationNoMatches

reconciliation_test.go:141–195

(t *testing.T)

}

func TestOneToManyReconciliationNoMatches(t *testing.T) {
	cnf := &config.Configuration{
		Redis: config.RedisConfig{
			Dns: "localhost:6379",
		},
		Transaction: config.TransactionConfig{
			BatchSize:  100000,
			MaxWorkers: 1,
		},
		Queue: config.QueueConfig{
			WebhookQueue:   "webhook_queue",
			NumberOfQueues: 1,
		},
	}
	config.ConfigStore.Store(cnf)
	mockDS := new(mocks.MockDataSource)
	ledgerforge := &LedgerForge{datasource: mockDS}

	ctx := context.Background()
	externalTxns := []*model.Transaction{
		{TransactionID: "ext1", Amount: 300, CreatedAt: time.Now(), Description: "External 1 Internal 1 2 3", Reference: "REF1", Currency: "USD"},
	}
	internalTxns := []*model.Transaction{
		{TransactionID: "int1", Amount: 100, CreatedAt: time.Now().Add(-1 * time.Hour), Description: "Internal 1", Reference: "REF1-A", Currency: "USD"},
		{TransactionID: "int2", Amount: 150, CreatedAt: time.Now(), Description: "Internal 2", Reference: "REF1-B", Currency: "USD"},
		{TransactionID: "int3", Amount: 54, CreatedAt: time.Now().Add(1 * time.Hour), Description: "Internal 3", Reference: "REF1-C", Currency: "USD"},
	}

	groupedInternalTxns := map[string][]*model.Transaction{
		"parent_transaction": internalTxns,
	}

	emptyGroup := map[string][]*model.Transaction{}

	mockDS.On("GroupTransactions", mock.Anything, mock.Anything, 100000, int64(0)).Return(groupedInternalTxns, nil)
	mockDS.On("GroupTransactions", mock.Anything, mock.Anything, 100000, int64(100000)).Return(emptyGroup, nil)

	matchingRules := []model.MatchingRule{
		{
			RuleID: "parent_transaction",
			Criteria: []model.MatchingCriteria{
				{Field: "amount", Operator: "equals", AllowableDrift: 0.01}, // 1% drift allowed
				{Field: "description", Operator: "contains"},
				{Field: "reference", Operator: "contains"},
				{Field: "currency", Operator: "equals"},
			},
		},
	}

	matches, unmatched := ledgerforge.oneToManyReconciliation(ctx, externalTxns, "parent_transaction", matchingRules, false)

	assert.Equal(t, 0, len(matches), "Expected 3 matches")
	assert.Equal(t, 1, len(unmatched), "Expected 0 unmatched transactions")
	mockDS.AssertExpectations(t)
}

func TestManyToOneReconciliationUsesUploadID(t *testing.T) {
	cnf := &config.Configuration{