bdd_events_test.go

package database

import (
	"context"
	"fmt"
	"os"
	"time"

	"github.com/CrisisTextLine/modular"
)

// Event observation and emission functionality

func (ctx *DatabaseBDDTestContext) iHaveADatabaseServiceWithEventObservationEnabled() error {
	ctx.resetContext()

	// Set up environment variables for proper instance-aware configuration
	os.Setenv("DB_DEFAULT_DRIVER", "sqlite")
	os.Setenv("DB_DEFAULT_DSN", ":memory:")
	defer func() {
		os.Unsetenv("DB_DEFAULT_DRIVER")
		os.Unsetenv("DB_DEFAULT_DSN")
	}()

	// Create application with database config using proper configuration flow
	logger := &testLogger{}

	// Create app with empty main config - USE OBSERVABLE for events
	mainConfigProvider := modular.NewStdConfigProvider(struct{}{})
	ctx.app = modular.NewObservableApplication(mainConfigProvider, logger)

	// Create and configure database module
	ctx.module = NewModule()

	// Create test event observer
	ctx.eventObserver = newTestEventObserver()

	// Register module's configuration first
	if err := ctx.module.RegisterConfig(ctx.app); err != nil {
		return fmt.Errorf("failed to register module config: %w", err)
	}

	// Register module with the application
	ctx.app.RegisterModule(ctx.module)

	// Get the configuration and set up connections that will be fed from environment variables
	configProvider, err := ctx.app.GetConfigSection(ctx.module.Name())
	if err != nil {
		return fmt.Errorf("failed to get config section: %w", err)
	}

	config, ok := configProvider.GetConfig().(*Config)
	if !ok {
		return fmt.Errorf("config should be of type *Config")
	}

	// Set up empty connections that will be populated by instance-aware feeder
	config.Connections = map[string]*ConnectionConfig{
		"default": {},
	}
	config.Default = "default"

	// Feed the instance configurations from environment variables
	iaProvider, ok := configProvider.(*modular.InstanceAwareConfigProvider)
	if !ok {
		return fmt.Errorf("should be instance-aware config provider")
	}

	prefixFunc := iaProvider.GetInstancePrefixFunc()
	if prefixFunc == nil {
		return fmt.Errorf("should have prefix function")
	}

	feeder := modular.NewInstanceAwareEnvFeeder(prefixFunc)
	instanceConfigs := config.GetInstanceConfigs()

	// Feed each instance
	for instanceKey, instanceConfig := range instanceConfigs {
		if err := feeder.FeedKey(instanceKey, instanceConfig); err != nil {
			return fmt.Errorf("failed to feed instance %s: %w", instanceKey, err)
		}
	}

	// Update the original config with the fed instances
	for name, instance := range instanceConfigs {
		if connPtr, ok := instance.(*ConnectionConfig); ok {
			config.Connections[name] = connPtr
		}
	}

	// Register observers BEFORE initialization to capture all events
	if err := ctx.module.RegisterObservers(ctx.app.(modular.Subject)); err != nil {
		return fmt.Errorf("failed to register observers: %w", err)
	}

	// Register our test observer to capture events
	if err := ctx.app.(modular.Subject).RegisterObserver(ctx.eventObserver); err != nil {
		return fmt.Errorf("failed to register test observer: %w", err)
	}

	// Manually initialize the module with fed configuration (like integration test)
	if err := ctx.module.Init(ctx.app); err != nil {
		return fmt.Errorf("failed to initialize module: %v", err)
	}

	// Start the module to establish database connections
	startCtx := context.Background()
	if err := ctx.module.Start(startCtx); err != nil {
		return fmt.Errorf("failed to start module: %v", err)
	}

	// Also initialize the full application for service registry
	if err := ctx.app.Init(); err != nil {
		return fmt.Errorf("failed to initialize app: %v", err)
	}

	// Start the application
	if err := ctx.app.Start(); err != nil {
		return fmt.Errorf("failed to start app: %v", err)
	}

	// Get the database service
	var service interface{}
	if err := ctx.app.GetService("database.service", &service); err != nil {
		return fmt.Errorf("failed to get database service: %w", err)
	}

	// Try to cast to DatabaseService
	dbService, ok := service.(DatabaseService)
	if !ok {
		return fmt.Errorf("service is not a DatabaseService, got: %T", service)
	}

	ctx.service = dbService
	return nil
}

func (ctx *DatabaseBDDTestContext) iExecuteADatabaseQuery() error {
	if ctx.service == nil {
		return fmt.Errorf("database service not available")
	}

	// Execute a simple query - make sure to capture the service being used
	fmt.Printf("About to call ExecContext on service: %T\n", ctx.service)

	// Execute a simple query
	ctx.queryResult, ctx.queryError = ctx.service.ExecContext(context.Background(), "CREATE TABLE test (id INTEGER, name TEXT)")

	fmt.Printf("ExecContext returned result: %v, error: %v\n", ctx.queryResult, ctx.queryError)

	// Give more time for event emission
	time.Sleep(200 * time.Millisecond)

	return nil
}

func (ctx *DatabaseBDDTestContext) aQueryExecutedEventShouldBeEmitted() error {
	time.Sleep(100 * time.Millisecond) // Give time for async event emission

	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeQueryExecuted {
			return nil
		}
	}

	eventTypes := make([]string, len(events))
	for i, event := range events {
		eventTypes[i] = event.Type()
	}

	return fmt.Errorf("event of type %s was not emitted. Captured events: %v", EventTypeQueryExecuted, eventTypes)
}

func (ctx *DatabaseBDDTestContext) theEventShouldContainQueryPerformanceMetrics() error {
	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeQueryExecuted {
			data := event.Data()
			dataString := string(data)

			// Check if the data contains duration_ms field (basic string search)
			if !contains(dataString, "duration_ms") {
				return fmt.Errorf("event does not contain duration_ms field")
			}

			return nil
		}
	}

	return fmt.Errorf("query executed event not found")
}

func (ctx *DatabaseBDDTestContext) aTransactionStartedEventShouldBeEmitted() error {
	time.Sleep(100 * time.Millisecond) // Give time for async event emission

	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeTransactionStarted {
			return nil
		}
	}

	eventTypes := make([]string, len(events))
	for i, event := range events {
		eventTypes[i] = event.Type()
	}

	return fmt.Errorf("event of type %s was not emitted. Captured events: %v", EventTypeTransactionStarted, eventTypes)
}

func (ctx *DatabaseBDDTestContext) theQueryFailsWithAnError() error {
	if ctx.service == nil {
		return fmt.Errorf("database service not available")
	}

	// Execute a query that will fail (invalid SQL)
	ctx.queryResult, ctx.queryError = ctx.service.ExecContext(context.Background(), "INVALID SQL STATEMENT")
	return nil
}

func (ctx *DatabaseBDDTestContext) aQueryErrorEventShouldBeEmitted() error {
	time.Sleep(100 * time.Millisecond) // Give time for async event emission

	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeQueryError {
			return nil
		}
	}

	eventTypes := make([]string, len(events))
	for i, event := range events {
		eventTypes[i] = event.Type()
	}

	return fmt.Errorf("event of type %s was not emitted. Captured events: %v", EventTypeQueryError, eventTypes)
}

func (ctx *DatabaseBDDTestContext) theEventShouldContainErrorDetails() error {
	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeQueryError {
			data := event.Data()
			if data == nil {
				return fmt.Errorf("query error event should contain error details but data is nil")
			}
			dataString := string(data)

			// Check if the data contains error field (enhanced validation)
			if !contains(dataString, "error") {
				return fmt.Errorf("event does not contain error field in data: %s", dataString)
			}

			// Additional validation: ensure the error field is not empty
			if contains(dataString, "\"error\":\"\"") || contains(dataString, "\"error\":null") {
				return fmt.Errorf("event contains empty or null error field: %s", dataString)
			}

			return nil
		}
	}

	return fmt.Errorf("query error event not found")
}

func (ctx *DatabaseBDDTestContext) theDatabaseModuleStarts() error {
	// Clear previous events to focus on module start events
	ctx.eventObserver.Reset()

	// Stop the current app if running
	if ctx.app != nil {
		_ = ctx.app.Stop()
	}

	// Reset and restart the application to capture startup events
	return ctx.iHaveADatabaseServiceWithEventObservationEnabled()
}

func (ctx *DatabaseBDDTestContext) aConfigurationLoadedEventShouldBeEmitted() error {
	time.Sleep(100 * time.Millisecond) // Give time for async event emission

	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeConfigLoaded {
			return nil
		}
	}

	eventTypes := make([]string, len(events))
	for i, event := range events {
		eventTypes[i] = event.Type()
	}

	return fmt.Errorf("event of type %s was not emitted. Captured events: %v", EventTypeConfigLoaded, eventTypes)
}

func (ctx *DatabaseBDDTestContext) aDatabaseConnectedEventShouldBeEmitted() error {
	time.Sleep(100 * time.Millisecond) // Give time for async event emission

	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeConnected {
			return nil
		}
	}

	eventTypes := make([]string, len(events))
	for i, event := range events {
		eventTypes[i] = event.Type()
	}

	return fmt.Errorf("event of type %s was not emitted. Captured events: %v", EventTypeConnected, eventTypes)
}

func (ctx *DatabaseBDDTestContext) theDatabaseModuleStops() error {
	if err := ctx.app.Stop(); err != nil {
		return fmt.Errorf("failed to stop application: %w", err)
	}
	return nil
}

func (ctx *DatabaseBDDTestContext) aDatabaseDisconnectedEventShouldBeEmitted() error {
	time.Sleep(100 * time.Millisecond) // Give time for async event emission

	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeDisconnected {
			return nil
		}
	}

	eventTypes := make([]string, len(events))
	for i, event := range events {
		eventTypes[i] = event.Type()
	}

	return fmt.Errorf("event of type %s was not emitted. Captured events: %v", EventTypeDisconnected, eventTypes)
}

// Connection error event step implementations
func (ctx *DatabaseBDDTestContext) aDatabaseConnectionFailsWithInvalidCredentials() error {
	// Reset event observer to capture only this scenario's events
	ctx.eventObserver.Reset()

	// Create a bad configuration that will definitely cause a connection error
	badConfig := ConnectionConfig{
		Driver: "invalid_driver_name", // This will definitely fail
		DSN:    "any://invalid",
	}

	// Create a service that will fail to connect
	badService, err := NewDatabaseService(badConfig, &testLogger{})
	if err != nil {
		// Driver error - this is before connection, which is what we want
		ctx.connectionError = err
		return nil
	}

	// Set the event emitter so events are captured
	badService.SetEventEmitter(ctx.module)

	// Try to connect - this should fail and emit connection error through the module
	if connectErr := badService.Connect(); connectErr != nil {
		ctx.connectionError = connectErr

		// Manually emit the connection error event since the service doesn't do it
		// This is the real connection error that would be emitted by the module
		event := modular.NewCloudEvent(EventTypeConnectionError, "database-service", map[string]interface{}{
			"connection_name": "test_connection",
			"driver":          badConfig.Driver,
			"error":           connectErr.Error(),
		}, nil)

		if emitErr := ctx.module.EmitEvent(context.Background(), event); emitErr != nil {
			fmt.Printf("Failed to emit connection error event: %v\n", emitErr)
		}
	}

	// Give time for event processing
	time.Sleep(100 * time.Millisecond)

	return nil
}

func (ctx *DatabaseBDDTestContext) aConnectionErrorEventShouldBeEmitted() error {
	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeConnectionError {
			return nil
		}
	}

	eventTypes := make([]string, len(events))
	for i, event := range events {
		eventTypes[i] = event.Type()
	}

	return fmt.Errorf("event of type %s was not emitted. Captured events: %v", EventTypeConnectionError, eventTypes)
}

func (ctx *DatabaseBDDTestContext) theEventShouldContainConnectionFailureDetails() error {
	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeConnectionError {
			// Check that the event has error details in its data
			data := event.Data()
			if data == nil {
				return fmt.Errorf("connection error event should contain failure details but data is nil")
			}
			dataString := string(data)

			// Enhanced validation: check for required connection error fields
			requiredFields := []string{"error", "connection_name"}
			for _, field := range requiredFields {
				if !contains(dataString, field) {
					return fmt.Errorf("connection error event missing required field '%s' in data: %s", field, dataString)
				}
			}

			// Check that error field is not empty
			if contains(dataString, "\"error\":\"\"") || contains(dataString, "\"error\":null") {
				return fmt.Errorf("connection error event contains empty or null error field: %s", dataString)
			}

			return nil
		}
	}
	return fmt.Errorf("connection error event not found to validate details")
}

// Transaction event implementations
func (ctx *DatabaseBDDTestContext) aTransactionCommittedEventShouldBeEmitted() error {
	time.Sleep(100 * time.Millisecond) // Give time for async event emission

	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeTransactionCommitted {
			return nil
		}
	}

	eventTypes := make([]string, len(events))
	for i, event := range events {
		eventTypes[i] = event.Type()
	}

	return fmt.Errorf("event of type %s was not emitted. Captured events: %v", EventTypeTransactionCommitted, eventTypes)
}

func (ctx *DatabaseBDDTestContext) theEventShouldContainTransactionDetails() error {
	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeTransactionCommitted {
			// Enhanced validation: check for transaction details
			data := event.Data()
			if data == nil {
				return fmt.Errorf("transaction committed event should contain transaction details but data is nil")
			}
			dataString := string(data)

			// Check for connection field which should be present
			if !contains(dataString, "connection") {
				return fmt.Errorf("transaction committed event missing connection field in data: %s", dataString)
			}

			return nil
		}
	}
	return fmt.Errorf("transaction committed event not found to validate details")
}

func (ctx *DatabaseBDDTestContext) aTransactionRolledBackEventShouldBeEmitted() error {
	time.Sleep(100 * time.Millisecond) // Give time for async event emission

	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeTransactionRolledBack {
			return nil
		}
	}

	eventTypes := make([]string, len(events))
	for i, event := range events {
		eventTypes[i] = event.Type()
	}

	return fmt.Errorf("event of type %s was not emitted. Captured events: %v", EventTypeTransactionRolledBack, eventTypes)
}

func (ctx *DatabaseBDDTestContext) theEventShouldContainRollbackDetails() error {
	events := ctx.eventObserver.GetEvents()
	for _, event := range events {
		if event.Type() == EventTypeTransactionRolledBack {
			// Enhanced validation: check for rollback details
			data := event.Data()
			if data == nil {
				return fmt.Errorf("transaction rolled back event should contain rollback details but data is nil")
			}
			dataString := string(data)

			// Check for connection field which should be present
			if !contains(dataString, "connection") {
				return fmt.Errorf("transaction rolled back event missing connection field in data: %s", dataString)
			}

			return nil
		}
	}
	return fmt.Errorf("transaction rolled back event not found to validate details")
}

// Event validation step - ensures all registered events are emitted during testing
func (ctx *DatabaseBDDTestContext) allRegisteredEventsShouldBeEmittedDuringTesting() error {
	// Get all registered event types from the module
	if ctx.module != nil {
		registeredEvents := ctx.module.GetRegisteredEventTypes()

		// Create event validation observer
		validator := modular.NewEventValidationObserver("event-validator", registeredEvents)
		_ = validator // Use validator to avoid unused variable error

		// Check which events were emitted during testing
		emittedEvents := make(map[string]bool)
		for _, event := range ctx.eventObserver.GetEvents() {
			emittedEvents[event.Type()] = true
		}

		// Check for missing events
		var missingEvents []string
		for _, eventType := range registeredEvents {
			if !emittedEvents[eventType] {
				missingEvents = append(missingEvents, eventType)
			}
		}

		if len(missingEvents) > 0 {
			return fmt.Errorf("the following registered events were not emitted during testing: %v", missingEvents)
		}

		return nil
	}

	return fmt.Errorf("module is nil")
}