internal

type ChainContractTestSuite struct {
	TestCases []ContractTestCase
}

type ContainerConfig struct {
	Image        string
	ExposedPorts []string
	Env          map[string]string
	Cmd          []string
	WaitStrategy wait.Strategy
	Timeout      time.Duration
}

type ContainerManager struct {
	Container tc.Container
	Config    ContainerConfig
}

type ContainerTestSuite struct {
	// contains filtered or unexported fields
}

type ContractExpected struct {
	EntityCount      int                         // Expected number of entities returned
	ShouldError      bool                        // Whether the call should return an error
	ErrorCode        connect.Code                // Expected error code if ShouldError is true
	EntityValidation []EntityValidationRule      // Rules for validating returned entities
	ChainValidation  []EntityChainValidationRule // Rules for validating entity chains
}

type ContractInput struct {
	Entities []*entity.Entity
	Tokens   []*entity.Token // For CreateEntityChainsFromTokens tests
}

type ContractTestCase struct {
	Name        string
	Description string
	Input       ContractInput
	Expected    ContractExpected
}

type ContractTestDataSet struct {
	Users   []TestUser
	Clients []TestClient
}

type ContractTestSuite struct {
	TestCases []ContractTestCase
}

type ERSImplementation interface {
	ResolveEntities(ctx context.Context, req *connect.Request[entityresolutionV2.ResolveEntitiesRequest]) (*connect.Response[entityresolutionV2.ResolveEntitiesResponse], error)
	CreateEntityChainsFromTokens(ctx context.Context, req *connect.Request[entityresolutionV2.CreateEntityChainsFromTokensRequest]) (*connect.Response[entityresolutionV2.CreateEntityChainsFromTokensResponse], error)
}

type ERSTestAdapter interface {
	// GetScopeName returns the human-readable name for this ERS scope (e.g., "LDAP", "SQL")
	GetScopeName() string

	// SetupTestData injects the provided test data into the backend data store
	// Each implementation handles this differently:
	// - LDAP: Creates LDAP entries via LDAP operations
	// - SQL: Inserts rows into database tables
	// - Claims: Sets up JWT signing keys and test claims
	SetupTestData(ctx context.Context, testDataSet *ContractTestDataSet) error

	// CreateERSService creates and returns a configured ERS service instance
	// ready for testing with the injected test data
	CreateERSService(ctx context.Context) (ERSImplementation, error)

	// TeardownTestData cleans up any test data and resources
	// This is called after tests complete to ensure clean state
	TeardownTestData(ctx context.Context) error
}

type EntityChainValidationRule struct {
	EphemeralID               string   // Expected ephemeral ID
	EntityCount               int      // Expected number of entities in the chain
	EntityTypes               []string // Expected entity types in order
	EntityCategories          []string // Expected entity categories in order (CATEGORY_ENVIRONMENT, CATEGORY_SUBJECT)
	RequireConsistentOrdering bool     // Whether entity order must be consistent across implementations
}

type EntityValidationRule struct {
	Index           int                    // Which entity in the response to validate
	EphemeralID     string                 // Expected ephemeral ID
	RequiredFields  map[string]interface{} // Fields that must be present with specific values
	ForbiddenFields []string               // Fields that must not be present
	MinFieldCount   int                    // Minimum number of fields in additional properties
}

type FlexibleChainValidationRule struct {
	Description         string
	Expectations        []FlexibleEntityChainExpectation
	AllowPartialSuccess bool // Some chains can fail if others succeed
	MinSuccessCount     int  // Minimum number of successful chains
}

type FlexibleEntityChainExpectation struct {
	EphemeralID             string
	MinEntityCount          int      // At least this many entities
	MaxEntityCount          int      // At most this many entities (0 = no limit)
	RequiredEntityTypes     []string // Must contain these entity types
	RequiredClaims          []string // Must contain these claim keys
	RequiredCategories      []string // Must contain these categories
	ForbiddenClaims         []string // Must NOT contain these claim keys
	AllowImplementationGaps bool     // Accept implementation differences
}

type MockTestDataInjector struct {
	// contains filtered or unexported fields
}

type TestClient struct {
	ClientID    string
	DisplayName string
	Description string
	DN          string
}

type TestConfig struct {
	// Service Endpoints
	KeycloakURL  string
	KeycloakPort int
	PostgresHost string
	PostgresPort int
	LDAPHost     string
	LDAPPort     int

	// Authentication
	AdminUser     string
	AdminPassword string
	Realm         string
	ClientID      string
	ClientSecret  string

	// Test Behavior
	ContainerStartupTimeout time.Duration
	ContainerRunTimeout     time.Duration
	TestDataVariation       bool // Enable varied test data generation
	JWTValidityDuration     time.Duration

	// Test Data
	EmailDomains    []string
	TestUserCount   int
	TestClientCount int
}

type TestDataGenerator struct {
	// contains filtered or unexported fields
}

type TestDataInjector interface {
	InjectTestData(ctx context.Context, dataSet *ContractTestDataSet) error
	CleanupTestData(ctx context.Context) error
	ValidateTestData(ctx context.Context, dataSet *ContractTestDataSet) error
}

type TestDataScenario struct {
	Name         string
	UserCount    int
	ClientCount  int
	EmailDomains []string

	// JWT claim variations
	IncludeClientID   bool
	IncludeEmail      bool
	IncludeUsername   bool
	IncludeEmptyUsers bool // Test edge case with missing claims

	// Strategy testing
	StrategyTypes []string // Which strategies should be triggered
}

type TestGroup struct {
	Name        string
	DisplayName string
	Description string
	Members     []string
	DN          string
}

type TestUser struct {
	Username    string
	Email       string
	DisplayName string
	Password    string
	Groups      []string
	DN          string
}