Function TestLineageAllocationStrategies

lineage_integration_test.go:566–865

(t *testing.T)

}

func TestLineageAllocationStrategies(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping lineage integration test in short mode")
	}

	ctx := context.Background()
	pollInterval := 200 * time.Millisecond
	pollTimeout := 15 * time.Second

	cnf := &config.Configuration{
		Redis: config.RedisConfig{
			Dns: "localhost:6379",
		},
		DataSource: config.DataSourceConfig{
			Dns: "postgres://postgres:password@localhost:5432/ledgerforge?sslmode=disable",
		},
		Queue: config.QueueConfig{
			WebhookQueue:     "webhook_queue_test",
			IndexQueue:       "index_queue_test",
			TransactionQueue: "transaction_queue_test",
			NumberOfQueues:   1,
		},
		Server: config.ServerConfig{
			SecretKey: "test-secret",
		},
		Transaction: config.TransactionConfig{
			BatchSize:        100,
			MaxQueueSize:     1000,
			LockDuration:     time.Second * 30,
			IndexQueuePrefix: "test_index",
		},
	}
	config.ConfigStore.Store(cnf)

	ds, err := database.NewDataSource(cnf)
	require.NoError(t, err, "Failed to create datasource")

	ledgerforge, err := NewLedgerForge(ds)
	require.NoError(t, err, "Failed to create LedgerForge instance")

	// Start the lineage outbox processor to process lineage entries asynchronously
	processor := NewLineageOutboxProcessor(ledgerforge).WithPollInterval(100 * time.Millisecond)
	processor.Start(ctx)
	defer processor.Stop()

	suffix := fmt.Sprintf("%d", time.Now().UnixNano())

	t.Run("LIFO Allocation", func(t *testing.T) {
		identity, err := ds.CreateIdentity(model.Identity{
			FirstName: fmt.Sprintf("LIFO_%s", suffix),
			LastName:  "User",
			Category:  "individual",
		})
		require.NoError(t, err)

		balance, err := ds.CreateBalance(model.Balance{
			Currency:           "USD",
			LedgerID:           GeneralLedgerID,