manifold/database/limit_test.go

package database

import (
	"bytes"
	"os"
	"testing"

	"manifold.mleku.dev/event"
	"manifold.mleku.dev/filter"
)

// TestLimitFunctionality tests the limit functionality in QueryEvents.
func TestLimitFunctionality(t *testing.T) {
	// Create a temporary directory for the database
	tempDir, err := os.MkdirTemp("", "manifold-test-db-limit")
	if err != nil {
		t.Fatalf("Failed to create temp directory: %v", err)
	}
	defer os.RemoveAll(tempDir)

	// Create a new database
	db := New()
	if err = db.Init(tempDir); err != nil {
		t.Fatalf("Failed to initialize database: %v", err)
	}
	defer db.Close()

	// Generate test events
	var events []*event.E
	events, err = generateTestEvents(10)
	if err != nil {
		t.Fatalf("Failed to generate test events: %v", err)
	}

	// Store events in the database
	for _, ev := range events {
		if err = db.StoreEvent(ev); err != nil {
			t.Fatalf("Failed to store event: %v", err)
		}
	}

	// First, get all events without a limit
	f1 := filter.F{}
	allResults, err := db.QueryEvents(&f1)
	if err != nil {
		t.Fatalf("QueryEvents failed: %v", err)
	}

	// Total number of events
	totalCount := len(allResults)
	if totalCount == 0 {
		t.Fatalf("No events found in database")
	}

	// Set a limit less than the total count
	limit := totalCount / 2
	if limit < 1 {
		limit = 1
	}

	// Create filter with limit
	f2 := filter.F{
		Limit: limit,
	}

	// Query events with limit
	limitedResults, err := db.QueryEvents(&f2)
	if err != nil {
		t.Fatalf("QueryEvents with limit failed: %v", err)
	}

	// Verify results count matches the limit
	if len(limitedResults) != limit {
		t.Fatalf("Expected %d events (limit), got %d", limit, len(limitedResults))
	}

	// Verify the limited results are the same as the first N events from all results
	for i := 0; i < limit; i++ {
		if !bytes.Equal(limitedResults[i], allResults[i]) {
			t.Fatalf("Limited result at index %d doesn't match all results", i)
		}
	}
}