This is the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

Integration Test Index

    This document provides an index of all integration tests annotated with @Sample.

    These server also as sample for various use cases. Your are encouraged to improve both the tests and/or descriptions.

    Contents

    CRDMappingInTestExtensionIT

    Custom CRD Mapping in Test Extension

    Demonstrates how to manually specify and apply Custom Resource Definitions (CRDs) in integration tests using the LocallyRunOperatorExtension. This test verifies that CRDs can be loaded from specified file paths and properly registered with the Kubernetes API server during test execution.

    Package: io.javaoperatorsdk.operator

    ConcurrencyIT

    Concurrent Reconciliation of Multiple Resources

    Demonstrates the operator’s ability to handle concurrent reconciliation of multiple resources. The test creates, updates, and deletes many resources simultaneously to verify proper handling of concurrent operations, ensuring thread safety and correct resource state management under load.

    Package: io.javaoperatorsdk.operator.baseapi

    InformerErrorHandlerStartIT

    Operator Startup with Informer Errors

    Demonstrates that the operator can start successfully even when informers encounter errors during startup, such as insufficient access rights. By setting stopOnInformerErrorDuringStartup to false, the operator gracefully handles permission errors and continues initialization, allowing it to operate with partial access.

    Package: io.javaoperatorsdk.operator.baseapi

    LeaderElectionPermissionIT

    Leader Election with Insufficient Permissions

    Verifies that the operator fails gracefully when leader election is configured but the service account lacks permissions to access lease resources. This test ensures proper error handling and messaging when RBAC permissions are insufficient for leader election functionality.

    Package: io.javaoperatorsdk.operator.baseapi

    BuiltInResourceCleanerIT

    Cleanup handler for built-in Kubernetes resources

    Demonstrates how to implement cleanup handlers (finalizers) for built-in Kubernetes resources like Service and Pod. These resources don’t use generation the same way as custom resources, so this sample shows the proper approach to handle their lifecycle and cleanup logic.

    Package: io.javaoperatorsdk.operator.baseapi.builtinresourcecleaner

    ChangeNamespaceIT

    Dynamically Changing Watched Namespaces

    Demonstrates how to dynamically change the set of namespaces that an operator watches at runtime. This feature allows operators to add or remove namespaces from their watch list, including switching between specific namespaces and watching all namespaces. The test verifies that resources in newly added namespaces are reconciled and resources in removed namespaces are no longer watched.

    Package: io.javaoperatorsdk.operator.baseapi.changenamespace

    CleanerForReconcilerIT

    Implementing Cleanup Logic with Cleaner Interface

    Demonstrates how to implement cleanup logic for custom resources using the Cleaner interface. When a reconciler implements Cleaner, the framework automatically adds a finalizer to resources and calls the cleanup method when the resource is deleted. This pattern is useful for cleaning up external resources or performing custom deletion logic. The test verifies finalizer handling, cleanup execution, and the ability to reschedule cleanup operations.

    Package: io.javaoperatorsdk.operator.baseapi.cleanerforreconciler

    CleanupConflictIT

    Cleanup Finalizer Removal Without Conflicts

    Tests that finalizers are removed correctly during cleanup without causing conflicts, even when multiple finalizers are present and removed concurrently. This verifies the operator’s ability to handle finalizer updates safely during resource deletion.

    Package: io.javaoperatorsdk.operator.baseapi.cleanupconflict

    ClusterScopedResourceIT

    Cluster-scoped resource reconciliation

    Demonstrates how to reconcile cluster-scoped custom resources (non-namespaced). This test shows CRUD operations on cluster-scoped resources and verifies that dependent resources are created, updated, and properly cleaned up when the primary resource is deleted.

    Package: io.javaoperatorsdk.operator.baseapi.clusterscopedresource

    ConcurrentFinalizerRemovalIT

    Concurrent Finalizer Removal by Multiple Reconcilers

    Demonstrates safe concurrent finalizer removal when multiple reconcilers manage the same resource with different finalizers. Tests that finalizers can be removed concurrently without conflicts or race conditions, ensuring proper cleanup even when multiple controllers are involved.

    Package: io.javaoperatorsdk.operator.baseapi.concurrentfinalizerremoval

    CreateUpdateInformerEventSourceEventFilterIT

    Event filtering for create and update operations

    Shows how to configure event filters on informer event sources to control which create and update events trigger reconciliation. This is useful for preventing unnecessary reconciliation loops when dependent resources are modified by the controller itself.

    Package: io.javaoperatorsdk.operator.baseapi.createupdateeventfilter

    PreviousAnnotationDisabledIT

    Event Filtering with Previous Annotation Disabled

    Tests event filtering behavior when the previous annotation feature for dependent resources is disabled. Verifies that update events are properly received and handled even without the annotation tracking mechanism that compares previous resource states.

    Package: io.javaoperatorsdk.operator.baseapi.createupdateeventfilter

    KubernetesResourceStatusUpdateIT

    Reconciling Non-Custom Kubernetes Resources with Status Updates

    Demonstrates how to reconcile standard Kubernetes resources (like Deployments) instead of custom resources, and how to update their status subresource. This pattern is useful when building operators that manage native Kubernetes resources rather than custom resource definitions. The test verifies that the operator can watch, reconcile, and update the status of a Deployment resource.

    Package: io.javaoperatorsdk.operator.baseapi.deployment

    DynamicGenericEventSourceRegistrationIT

    Dynamic Generic Event Source Registration

    Demonstrates dynamic registration of generic event sources during runtime. The test verifies that event sources can be dynamically added to a reconciler and properly trigger reconciliation when the associated resources change, enabling flexible event source management.

    Package: io.javaoperatorsdk.operator.baseapi.dynamicgenericeventsourceregistration

    ErrorStatusHandlerIT

    Error Status Handler for Failed Reconciliations

    Demonstrates how to implement error status handlers that update resource status when reconciliations fail. The test verifies that error messages are properly recorded in the resource status after each failed retry attempt. This provides visibility into reconciliation failures and helps with debugging operator issues.

    Package: io.javaoperatorsdk.operator.baseapi.errorstatushandler

    EventSourceIT

    Custom Event Source for Periodic Reconciliation

    Demonstrates how to implement custom event sources that trigger reconciliation on a periodic basis. The test verifies that reconciliations are triggered at regular intervals by a timer-based event source. This enables operators to perform periodic checks or updates independent of resource changes.

    Package: io.javaoperatorsdk.operator.baseapi.event

    FilterIT

    Filtering Events for Primary and Secondary Resources

    Demonstrates how to implement event filters for both primary custom resources and secondary dependent resources. The test verifies that resource updates matching specific filter criteria are ignored and don’t trigger reconciliation. This helps reduce unnecessary reconciliation executions and improve operator efficiency.

    Package: io.javaoperatorsdk.operator.baseapi.filter

    GenericKubernetesResourceHandlingIT

    Working with GenericKubernetesResource for Dynamic Resource Types

    Demonstrates how to use GenericKubernetesResource to work with Kubernetes resources dynamically without requiring compile-time type definitions. This approach is useful when building operators that need to manage arbitrary Kubernetes resources or when the resource types are not known at compile time. The test shows how to handle generic resources as dependent resources in a reconciler.

    Package: io.javaoperatorsdk.operator.baseapi.generickubernetesresourcehandling

    GracefulStopIT

    Graceful Operator Shutdown with Reconciliation Timeout

    Demonstrates how to configure graceful shutdown behavior with reconciliation termination timeouts. The test verifies that in-progress reconciliations are allowed to complete when the operator stops. This ensures clean shutdown without interrupting ongoing reconciliation work.

    Package: io.javaoperatorsdk.operator.baseapi.gracefulstop

    InformerEventSourceIT

    Using Informer Event Source to Watch Secondary Resources

    Demonstrates how to use InformerEventSource to watch changes in secondary resources (ConfigMaps) and trigger reconciliation when those resources are created, updated, or deleted. The test verifies that the reconciler responds to ConfigMap changes and updates the primary resource status accordingly.

    Package: io.javaoperatorsdk.operator.baseapi.informereventsource

    InformerRemoteClusterIT

    Watching resources in a remote Kubernetes cluster

    Demonstrates how to configure an informer event source to watch resources in a different Kubernetes cluster from where the operator is running. This enables multi-cluster scenarios where an operator in one cluster manages resources in another cluster.

    Package: io.javaoperatorsdk.operator.baseapi.informerremotecluster

    LabelSelectorIT

    Label Selector for Custom Resource Filtering

    Demonstrates how to configure label selectors to filter which custom resources an operator watches. The test verifies that only resources with matching labels trigger reconciliation. This allows operators to selectively manage a subset of custom resources based on their labels.

    Package: io.javaoperatorsdk.operator.baseapi.labelselector

    LeaderElectionChangeNamespaceIT

    Leader election with namespace change handling

    Tests that when an operator is not elected as leader, changing the watched namespaces does not start processing. This ensures that only the leader operator actively reconciles resources, preventing conflicts in multi-instance deployments with leader election.

    Package: io.javaoperatorsdk.operator.baseapi.leaderelectionchangenamespace

    ManualObservedGenerationIT

    Manually managing observedGeneration in status

    Shows how to manually track and update the observedGeneration field in status to indicate which generation of the resource spec has been successfully processed. This is useful for providing clear feedback to users about reconciliation progress.

    Package: io.javaoperatorsdk.operator.baseapi.manualobservedgeneration

    MaxIntervalIT

    Maximum Reconciliation Interval Configuration

    Demonstrates how to configure a maximum interval for periodic reconciliation triggers. The test verifies that reconciliation is automatically triggered at the configured interval even when there are no resource changes, enabling periodic validation and drift detection.

    Package: io.javaoperatorsdk.operator.baseapi.maxinterval

    MaxIntervalAfterRetryIT

    Maximum Reconciliation Interval After Retry

    Tests that reconciliation is repeatedly triggered based on the maximum interval setting even after retries. This ensures periodic reconciliation continues at the configured maximum interval, maintaining eventual consistency regardless of retry attempts.

    Package: io.javaoperatorsdk.operator.baseapi.maxintervalafterretry

    MultipleReconcilerSameTypeIT

    Multiple reconcilers for the same resource type

    Demonstrates how to register multiple reconcilers for the same custom resource type, with each reconciler handling different resources based on label selectors or other criteria. This enables different processing logic for different subsets of the same resource type.

    Package: io.javaoperatorsdk.operator.baseapi.multiplereconcilersametype

    MultipleSecondaryEventSourceIT

    Managing Multiple Secondary Event Sources

    Demonstrates how to configure and use multiple secondary event sources for a single reconciler. The test verifies that the reconciler is triggered by changes to different secondary resources and handles events from multiple sources correctly, including periodic event sources.

    Package: io.javaoperatorsdk.operator.baseapi.multiplesecondaryeventsource

    MultiVersionCRDIT

    Handling Multiple CRD Versions

    Demonstrates how to work with Custom Resource Definitions that have multiple API versions. The test shows how to configure multiple reconcilers for different versions of the same CRD, handle version-specific schemas, and deal with incompatible version conversions. It also demonstrates error handling through InformerStoppedHandler when deserialization fails due to schema incompatibilities between versions.

    Package: io.javaoperatorsdk.operator.baseapi.multiversioncrd

    NextReconciliationImminentIT

    Skipping status updates when next reconciliation is imminent

    Shows how to use the nextReconciliationImminent flag to skip status updates when another reconciliation event is already pending. This optimization prevents unnecessary status patch operations when rapid consecutive reconciliations occur.

    Package: io.javaoperatorsdk.operator.baseapi.nextreconciliationimminent

    PatchResourceAndStatusNoSSAIT

    Patching resource and status without Server-Side Apply

    Demonstrates how to patch both the primary resource metadata/spec and status subresource using traditional JSON merge patch instead of Server-Side Apply. This shows the legacy approach for updating resources when SSA is disabled.

    Package: io.javaoperatorsdk.operator.baseapi.patchresourceandstatusnossa

    PatchResourceAndStatusWithSSAIT

    Patching resource and status with Server-Side Apply

    Demonstrates how to use Server-Side Apply (SSA) to patch both the primary resource and its status subresource. SSA provides better conflict resolution and field management tracking compared to traditional merge patches, making it the recommended approach for resource updates.

    Package: io.javaoperatorsdk.operator.baseapi.patchresourcewithssa

    PatchResourceWithSSAIT

    Patching Resources with Server-Side Apply (SSA)

    Demonstrates how to use Server-Side Apply (SSA) for patching primary resources in Kubernetes. The test verifies that the reconciler can patch resources using SSA, which provides better conflict resolution and field management compared to traditional update approaches, including proper handling of managed fields.

    Package: io.javaoperatorsdk.operator.baseapi.patchresourcewithssa

    PerResourcePollingEventSourceIT

    Per-resource polling event source implementation

    Shows how to implement a per-resource polling event source where each primary resource has its own polling schedule to fetch external state. This is useful for integrating with external systems that don’t support event-driven notifications.

    Package: io.javaoperatorsdk.operator.baseapi.perresourceeventsource

    PrimaryIndexerIT

    Using Primary Indexer for Secondary Resource Mapping

    Demonstrates how to use primary indexers to efficiently map secondary resources back to their primary resources. When a secondary resource (like a ConfigMap) changes, the primary indexer allows the framework to determine which primary resources should be reconciled. This pattern enables efficient one-to-many and many-to-many relationships between primary and secondary resources without polling or full scans.

    Package: io.javaoperatorsdk.operator.baseapi.primaryindexer

    PrimaryToSecondaryIT

    Primary to Secondary Resource Mapping

    Demonstrates many-to-one mapping between primary and secondary resources where multiple primary resources can reference the same secondary resource. The test verifies that changes in the secondary resource trigger reconciliation of all related primary resources, enabling shared resource patterns.

    Package: io.javaoperatorsdk.operator.baseapi.primarytosecondary

    PrimaryToSecondaryMissingIT

    Issues When Primary-to-Secondary Mapper Is Missing

    Demonstrates the problems that occur when accessing secondary resources without a proper PrimaryToSecondaryMapper configured. The test shows that accessing secondary resources through the context fails without the mapper, while direct cache access works as a workaround, highlighting the importance of proper mapper configuration.

    Package: io.javaoperatorsdk.operator.baseapi.primarytosecondary

    RateLimitIT

    Rate Limiting Reconciliation Executions

    Demonstrates how to implement rate limiting to control how frequently reconciliations execute. The test shows that multiple rapid resource updates are batched and executed at a controlled rate. This prevents overwhelming the system when resources change frequently.

    Package: io.javaoperatorsdk.operator.baseapi.ratelimit

    RetryIT

    Automatic Retry for Failed Reconciliations

    Demonstrates how to configure automatic retry logic for reconciliations that fail temporarily. The test shows that failed executions are automatically retried with configurable intervals and max attempts. After a specified number of retries, the reconciliation succeeds and updates the resource status accordingly.

    Package: io.javaoperatorsdk.operator.baseapi.retry

    RetryMaxAttemptIT

    Maximum Retry Attempts Configuration

    Demonstrates how to configure a maximum number of retry attempts for failed reconciliations. The test verifies that the operator stops retrying after reaching the configured maximum attempts. This prevents infinite retry loops when reconciliations consistently fail.

    Package: io.javaoperatorsdk.operator.baseapi.retry

    ReconcilerExecutorIT

    Basic reconciler execution

    Demonstrates the basic reconciler execution flow including resource creation, status updates, and cleanup. This test verifies that a reconciler can create dependent resources (ConfigMap), update status, and properly handle cleanup when resources are deleted.

    Package: io.javaoperatorsdk.operator.baseapi.simple

    SSAFinalizerIssueIT

    Server-Side Apply Finalizer Field Manager Issue

    Demonstrates a potential issue with Server-Side Apply (SSA) when adding finalizers. When a resource is created with the same field manager used by the controller, adding a finalizer can unexpectedly remove other spec fields, showcasing field manager ownership conflicts in SSA.

    Package: io.javaoperatorsdk.operator.baseapi.ssaissue.finalizer

    SSASpecUpdateIT

    Server-Side Apply Finalizer Removal on Spec Update

    Demonstrates an issue with Server-Side Apply (SSA) where updating the resource spec without explicitly including the finalizer causes the finalizer to be removed. This highlights the importance of including all desired fields when using SSA to avoid unintended field removal.

    Package: io.javaoperatorsdk.operator.baseapi.ssaissue.specupdate

    StartupSecondaryAccessIT

    Accessing Secondary Resources During Operator Startup

    Verifies that reconcilers can properly access all secondary resources during operator startup, even when a large number of secondary resources exist. The test ensures that the informer cache is fully synchronized before reconciliation begins, allowing access to all related resources.

    Package: io.javaoperatorsdk.operator.baseapi.startsecondaryaccess

    StatusPatchCacheIT

    Status patch caching for consistency

    Demonstrates how the framework caches status patches to ensure consistency when status is updated frequently. The cache guarantees that status values are monotonically increasing and always reflect the most recent state, even with rapid successive updates.

    Package: io.javaoperatorsdk.operator.baseapi.statuscache

    StatusPatchNotLockingForNonSSAIT

    Status Patching Without Optimistic Locking for Non-SSA

    Tests status update behavior when not using Server-Side Apply (SSA), verifying that optimistic locking is not enforced on status patches. The test also demonstrates proper field deletion when values are set to null, ensuring correct status management without SSA optimistic locking.

    Package: io.javaoperatorsdk.operator.baseapi.statuspatchnonlocking

    StatusPatchSSAMigrationIT

    Migrating Status Patching from Non-SSA to SSA

    Demonstrates the process and challenges of migrating status patching from traditional update methods to Server-Side Apply (SSA). Tests show a known Kubernetes issue where field deletion doesn’t work correctly during migration, and provides a workaround by removing managed field entries from the previous update method.

    Package: io.javaoperatorsdk.operator.baseapi.statuspatchnonlocking

    StatusUpdateLockingIT

    Status Update Locking and Concurrency Control

    Demonstrates how the framework handles concurrent status updates and ensures no optimistic locking conflicts occur when updating status subresources. The test verifies that status updates can proceed independently of spec updates without causing version conflicts or requiring retries.

    Package: io.javaoperatorsdk.operator.baseapi.statusupdatelocking

    SubResourceUpdateIT

    Status Subresource Updates

    Demonstrates how to properly update the status subresource of custom resources. The test verifies that status updates are handled correctly without triggering unnecessary reconciliations, and that concurrent spec and status updates are managed properly with optimistic locking and retry mechanisms.

    Package: io.javaoperatorsdk.operator.baseapi.subresource

    UnmodifiableDependentPartIT

    Unmodifiable Parts in Dependent Resources

    Demonstrates how to preserve certain parts of a dependent resource from being modified during updates while allowing other parts to change. This test shows that initial data can be marked as unmodifiable and will remain unchanged even when the primary resource spec is updated, enabling partial update control.

    Package: io.javaoperatorsdk.operator.baseapi.unmodifiabledependentpart

    UpdateStatusInCleanupAndRescheduleIT

    Update Status in Cleanup and Reschedule

    Tests the ability to update resource status during cleanup and reschedule the cleanup operation. This demonstrates that cleanup methods can perform status updates and request to be called again after a delay, enabling multi-step cleanup processes with status tracking.

    Package: io.javaoperatorsdk.operator.baseapi.updatestatusincleanupandreschedule

    BulkDependentDeleterIT

    Bulk Dependent Resource Deleter Implementation

    Demonstrates implementation of a bulk dependent resource with custom deleter logic. This test extends BulkDependentTestBase to verify that bulk dependent resources can implement custom deletion strategies, managing multiple resources efficiently during cleanup operations.

    Package: io.javaoperatorsdk.operator.dependent.bulkdependent

    BulkDependentWithConditionIT

    Bulk Dependent Resources with Ready Conditions

    Tests bulk dependent resources with preconditions that control when reconciliation occurs. This demonstrates using ready conditions to ensure bulk operations only execute when the primary resource is in the appropriate state, coordinating complex multi-resource management.

    Package: io.javaoperatorsdk.operator.dependent.bulkdependent.condition

    BulkExternalDependentIT

    Managing External Bulk Resources

    Demonstrates managing multiple external resources (non-Kubernetes) using bulk dependent resources. This pattern allows operators to manage a variable number of external resources based on primary resource specifications, handling creation, updates, and deletion of external resources at scale.

    Package: io.javaoperatorsdk.operator.dependent.bulkdependent.external

    ManagedBulkDependentIT

    Bulk Dependent Resources with Managed Workflow

    Demonstrates how to manage bulk dependent resources using the managed workflow approach. This test extends the base bulk dependent test to show how multiple instances of the same type of dependent resource can be created and managed together. The managed workflow handles the orchestration of creating, updating, and deleting multiple dependent resources based on the primary resource specification.

    Package: io.javaoperatorsdk.operator.dependent.bulkdependent.managed

    ReadOnlyBulkDependentIT

    Read-Only Bulk Dependent Resources

    Demonstrates how to use read-only bulk dependent resources to observe and react to multiple existing resources without managing them. This test shows how an operator can monitor a collection of resources created externally and update the custom resource status based on their state, without creating or modifying them.

    Package: io.javaoperatorsdk.operator.dependent.bulkdependent.readonly

    StandaloneBulkDependentIT

    Standalone Bulk Dependent Resources

    Demonstrates how to use standalone bulk dependent resources to manage multiple resources of the same type efficiently. This test shows how bulk operations can be performed on a collection of resources without individual reconciliation cycles, improving performance when managing many similar resources.

    Package: io.javaoperatorsdk.operator.dependent.bulkdependent.standalone

    CleanerForManagedDependentResourcesOnlyIT

    Cleanup handlers for managed dependent resources

    Shows how to implement cleanup logic for managed dependent resources using the Cleaner interface. The framework automatically adds finalizers and invokes the cleanup method when the primary resource is deleted, ensuring proper cleanup of dependent resources.

    Package: io.javaoperatorsdk.operator.dependent.cleanermanageddependent

    CreateOnlyIfNotExistingDependentWithSSAIT

    Create-Only Dependent Resources with Server-Side Apply

    Demonstrates how to configure a dependent resource that is only created if it doesn’t exist, using Server-Side Apply (SSA). This test shows that when a resource already exists, the dependent resource implementation will not modify it, preserving any external changes.

    Package: io.javaoperatorsdk.operator.dependent.createonlyifnotexistsdependentwithssa

    DependentAnnotationSecondaryMapperIT

    Annotation-Based Secondary Resource Mapping for Dependents

    Demonstrates using annotations instead of owner references to map secondary resources to primary resources in dependent resources. This approach is useful when owner references cannot be used (e.g., cross-namespace or cluster-scoped relationships), using special annotations to establish the relationship.

    Package: io.javaoperatorsdk.operator.dependent.dependentannotationsecondarymapper

    DependentCustomMappingAnnotationIT

    Custom Annotation Keys for Resource Mapping

    Tests custom annotation-based mapping for dependent resources using configurable annotation keys instead of the default ones. This allows developers to customize which annotations are used to establish relationships between primary and secondary resources, providing flexibility for different naming conventions or avoiding conflicts.

    Package: io.javaoperatorsdk.operator.dependent.dependentcustommappingannotation

    DependentDifferentNamespaceIT

    Dependent Resources in Different Namespaces

    Demonstrates how to manage dependent resources in a namespace different from the primary resource. This test shows how to configure dependent resources to be created in a specific namespace rather than inheriting the namespace from the primary resource. The test verifies full CRUD operations for a ConfigMap that lives in a different namespace than the custom resource that manages it.

    Package: io.javaoperatorsdk.operator.dependent.dependentdifferentnamespace

    DependentFilterIT

    Filtering Reconciliation Triggers from Dependent Resources

    Demonstrates how to filter events from dependent resources to prevent unnecessary reconciliation triggers. This test shows how to configure filters on dependent resources so that only specific changes trigger a reconciliation of the primary resource. The test verifies that updates to filtered fields in the dependent resource do not cause the reconciler to execute, improving efficiency and avoiding reconciliation loops.

    Package: io.javaoperatorsdk.operator.dependent.dependentfilter

    DependentOperationEventFilterIT

    Event filtering for dependent resource operations

    Demonstrates how to configure event filters on dependent resources to prevent reconciliation loops. When a dependent resource is created or updated by the controller, the filter prevents those events from triggering unnecessary reconciliations.

    Package: io.javaoperatorsdk.operator.dependent.dependentoperationeventfiltering

    DependentReInitializationIT

    Reusing Dependent Resource Instances Across Tests

    Demonstrates that dependent resource instances can be safely reused across multiple operator start/stop cycles. This is particularly useful in CDI-managed environments like Quarkus, where dependent resources are managed as beans and should be reusable across test executions.

    Package: io.javaoperatorsdk.operator.dependent.dependentreinitialization

    DependentResourceCrossRefIT

    Dependent Resources with Cross-References

    Tests dependent resources that reference each other, creating interdependencies between multiple secondary resources. The test verifies that resources with circular or cross-references can be safely created, managed, and deleted without causing issues, even under concurrent operations with multiple primary resources.

    Package: io.javaoperatorsdk.operator.dependent.dependentresourcecrossref

    DependentSSAMatchingIT

    Server-Side Apply (SSA) with Dependent Resources

    Demonstrates how to use Server-Side Apply (SSA) with dependent resources and field manager matching. This test shows how SSA allows multiple controllers to manage different fields of the same resource without conflicts. The test verifies that changes made by different field managers are properly isolated, and that the operator only updates its own fields when changes occur, preserving fields managed by other controllers.

    Package: io.javaoperatorsdk.operator.dependent.dependentssa

    DependentSSAMigrationIT

    Migrating Dependent Resources from Legacy to SSA

    Demonstrates migrating dependent resource management from legacy update methods to Server-Side Apply (SSA). Tests show bidirectional migration scenarios and field manager handling, including using the default fabric8 field manager to avoid creating duplicate managed field entries during migration.

    Package: io.javaoperatorsdk.operator.dependent.dependentssa

    ExternalStateDependentIT

    External State Tracking in Dependent Resources

    Demonstrates managing dependent resources with external state that needs to be tracked independently of Kubernetes resources. This pattern allows operators to maintain state information for external systems or resources, ensuring proper reconciliation even when the external state differs from the desired Kubernetes resource state.

    Package: io.javaoperatorsdk.operator.dependent.externalstate

    ExternalStateIT

    Managing External Resources with Persistent State

    Demonstrates how to manage external resources (outside of Kubernetes) while maintaining their state in Kubernetes resources. This test shows a pattern for reconciling external systems by storing external resource identifiers in a ConfigMap. The test verifies that external resources can be created, updated, and deleted in coordination with Kubernetes resources, with the ConfigMap serving as a state store for external resource IDs.

    Package: io.javaoperatorsdk.operator.dependent.externalstate

    ExternalStateBulkIT

    Bulk External State Management with Persistent State

    Demonstrates managing multiple external resources with persistent state tracking using bulk dependent resources. This combines external state management with bulk operations, allowing operators to track and reconcile a variable number of external resources with persistent state that survives operator restarts.

    Package: io.javaoperatorsdk.operator.dependent.externalstate.externalstatebulkdependent

    GenericKubernetesDependentManagedIT

    Generic Kubernetes Dependent Resource (Managed)

    Demonstrates how to use GenericKubernetesResource as a managed dependent resource. This test shows how to work with generic Kubernetes resources that don’t have a specific Java model class, allowing the operator to manage any Kubernetes resource type dynamically.

    Package: io.javaoperatorsdk.operator.dependent.generickubernetesresource.generickubernetesdependentresourcemanaged

    GenericKubernetesDependentStandaloneIT

    Generic Kubernetes Resource as Standalone Dependent

    Tests using GenericKubernetesResource as a standalone dependent resource. This approach allows operators to manage arbitrary Kubernetes resources without requiring specific Java classes for each resource type, providing flexibility for managing various resource types dynamically.

    Package: io.javaoperatorsdk.operator.dependent.generickubernetesresource.generickubernetesdependentstandalone

    KubernetesDependentGarbageCollectionIT

    Kubernetes Native Garbage Collection for Dependent Resources

    Demonstrates how to leverage Kubernetes native garbage collection for dependent resources using owner references. This test shows how dependent resources are automatically cleaned up by Kubernetes when the owner resource is deleted, and how to conditionally create or delete dependent resources based on the primary resource state. Owner references ensure that dependent resources don’t outlive their owners.

    Package: io.javaoperatorsdk.operator.dependent.kubernetesdependentgarbagecollection

    MultipleDependentResourceIT

    Managing Multiple Dependent Resources

    Demonstrates how to manage multiple dependent resources from a single reconciler. This test shows how a single custom resource can create, update, and delete multiple ConfigMaps (or other Kubernetes resources) as dependents. The test verifies that all dependent resources are created together, updated together when the primary resource changes, and properly cleaned up when the primary resource is deleted.

    Package: io.javaoperatorsdk.operator.dependent.multipledependentresource

    MultipleDependentResourceWithNoDiscriminatorIT

    Multiple Dependents of Same Type Without Discriminator

    Demonstrates managing multiple dependent resources of the same type (ConfigMaps) without using discriminators. The framework uses resource names to differentiate between them, simplifying configuration when distinct names are sufficient for identification.

    Package: io.javaoperatorsdk.operator.dependent.multipledependentresourcewithsametype

    MultipleDependentSameTypeMultiInformerIT

    Multiple Managed Dependents of Same Type with Multi-Informer

    Tests managing multiple dependent resources of the same type using separate informers for each. This approach allows for independent event handling and caching for resources of the same type, useful when different caching strategies or event filtering is needed for different instances.

    Package: io.javaoperatorsdk.operator.dependent.multipledependentsametypemultiinformer

    MultipleManagedDependentNoDiscriminatorIT

    Multiple Managed Dependents of Same Type Without Discriminator

    Demonstrates managing multiple managed dependent resources of the same type without explicit discriminators. The test verifies complete CRUD operations on multiple ConfigMaps, showing that resource names alone can differentiate between dependents when a discriminator is not needed.

    Package: io.javaoperatorsdk.operator.dependent.multipledrsametypenodiscriminator

    MultipleManagedDependentSameTypeIT

    Managing Multiple Dependent Resources of the Same Type

    Demonstrates how to manage multiple dependent resources of the same type from a single reconciler. This test shows how multiple ConfigMaps with the same type can be created, updated, and deleted as dependent resources of a custom resource, verifying proper CRUD operations and garbage collection.

    Package: io.javaoperatorsdk.operator.dependent.multiplemanageddependentsametype

    MultipleManagedExternalDependentSameTypeIT

    Multiple Managed External Dependents of Same Type

    Tests managing multiple external (non-Kubernetes) dependent resources of the same type. This demonstrates that operators can manage multiple instances of external resources simultaneously, handling their lifecycle including creation, updates, and deletion.

    Package: io.javaoperatorsdk.operator.dependent.multiplemanagedexternaldependenttype

    MultiOwnerDependentTriggeringIT

    Dependent Resource Shared by Multiple Owners

    Demonstrates a dependent resource (ConfigMap) that is managed by multiple primary resources simultaneously. Tests verify that updates from any owner trigger proper reconciliation, owner references are correctly maintained, and the shared resource properly aggregates data from all owners.

    Package: io.javaoperatorsdk.operator.dependent.multipleupdateondependent

    PrevAnnotationBlockReconcilerIT

    Blocking Previous Annotation for Specific Resource Types

    Tests the previous annotation blocklist feature, which prevents storing previous resource state annotations for specific resource types like Deployments. This optimization avoids unnecessary reconciliation loops for resources that have server-side mutations, improving performance and stability.

    Package: io.javaoperatorsdk.operator.dependent.prevblocklist

    DependentPrimaryIndexerIT

    Primary Resource Indexer with Dependent Resources

    Extends PrimaryIndexerIT to test primary resource indexing functionality with dependent resources. Demonstrates how custom indexes on primary resources can be used to efficiently query and access resources within dependent resource implementations, enabling performant lookups.

    Package: io.javaoperatorsdk.operator.dependent.primaryindexer

    PrimaryToSecondaryDependentIT

    Primary to Secondary Dependent Resource

    Demonstrates how to configure dependencies between dependent resources where one dependent resource (secondary) depends on another dependent resource (primary). This test shows how a Secret’s creation can be conditioned on the state of a ConfigMap, illustrating the use of reconcile preconditions and dependent resource chaining.

    Package: io.javaoperatorsdk.operator.dependent.primarytosecondaydependent

    OperatorRestartIT

    Operator restart and state recovery

    Tests that an operator can be stopped and restarted while maintaining correct behavior. After restart, the operator should resume processing existing resources without losing track of their state, demonstrating proper state recovery and persistence.

    Package: io.javaoperatorsdk.operator.dependent.restart

    ServiceStrictMatcherIT

    Strict matching for Service resources

    Shows how to use a strict matcher for Service dependent resources that correctly handles Service-specific fields. This prevents unnecessary updates when Kubernetes adds default values or modifies certain fields, avoiding reconciliation loops.

    Package: io.javaoperatorsdk.operator.dependent.servicestrictmatcher

    SpecialResourcesDependentIT

    Handling special Kubernetes resources without spec

    Demonstrates how to handle special built-in Kubernetes resources like ServiceAccount that don’t have a spec field. These resources require different handling approaches since their configuration is stored directly in the resource body rather than in a spec section.

    Package: io.javaoperatorsdk.operator.dependent.specialresourcesdependent

    SSAWithLegacyMatcherIT

    Using Legacy Resource Matcher with SSA

    Demonstrates using the legacy resource matcher with Server-Side Apply (SSA). The legacy matcher provides backward compatibility for matching logic while using SSA for updates, ensuring that resource comparisons work correctly even when migrating from traditional update methods to SSA.

    Package: io.javaoperatorsdk.operator.dependent.ssalegacymatcher

    StandaloneDependentResourceIT

    Standalone Dependent Resources

    Demonstrates how to use standalone dependent resources that are managed independently without explicit workflow configuration. This test shows how dependent resources can be created and managed programmatically, with the dependent resource handling CRUD operations on a Kubernetes Deployment. The test verifies both creation and update scenarios, including cache updates when the dependent resource state changes.

    Package: io.javaoperatorsdk.operator.dependent.standalonedependent

    StatefulSetDesiredSanitizerIT

    Sanitizing StatefulSet desired state for SSA

    Shows how to properly sanitize StatefulSet resources before using Server-Side Apply. StatefulSets have immutable fields and server-managed fields that need to be removed from the desired state to prevent conflicts and unnecessary updates.

    Package: io.javaoperatorsdk.operator.dependent.statefulsetdesiredsanitizer

    ComplexWorkflowIT

    Complex Workflow with Multiple Dependents

    Demonstrates a complex workflow with multiple dependent resources (StatefulSets and Services) that have dependencies on each other. This test shows how to orchestrate the reconciliation of interconnected dependent resources in a specific order.

    Package: io.javaoperatorsdk.operator.workflow.complexdependent

    CRDPresentActivationConditionIT

    Workflow Activation Based on CRD Presence

    Tests workflow activation conditions that depend on the presence of specific Custom Resource Definitions (CRDs). Dependent resources are only created when their corresponding CRDs exist in the cluster, allowing operators to gracefully handle optional dependencies and multi-cluster scenarios.

    Package: io.javaoperatorsdk.operator.workflow.crdpresentactivation

    WorkflowActivationConditionIT

    Workflow Functions on Vanilla Kubernetes Despite Inactive Resources

    Verifies that workflows function correctly on vanilla Kubernetes even when they include resources that are not available on the platform (like OpenShift Routes). The operator successfully reconciles by skipping inactive dependents based on activation conditions, demonstrating platform-agnostic operator design.

    Package: io.javaoperatorsdk.operator.workflow.getnonactivesecondary

    ManagedDependentDeleteConditionIT

    Managed Dependent Delete Condition

    Demonstrates how to use delete conditions to control when dependent resources can be deleted. This test shows how the primary resource deletion can be blocked until dependent resources are properly cleaned up, ensuring graceful shutdown and preventing orphaned resources.

    Package: io.javaoperatorsdk.operator.workflow.manageddependentdeletecondition

    MultipleDependentWithActivationIT

    Multiple Dependents with Activation Conditions

    Demonstrates how to use activation conditions with multiple dependent resources. This test shows how different dependent resources can be dynamically enabled or disabled based on runtime conditions, allowing flexible workflow behavior that adapts to changing requirements.

    Package: io.javaoperatorsdk.operator.workflow.multipledependentwithactivation

    OrderedManagedDependentIT

    Ordered Managed Dependent Resources

    Demonstrates how to control the order of reconciliation for managed dependent resources. This test verifies that dependent resources are reconciled in a specific sequence, ensuring proper orchestration when dependencies have ordering requirements.

    Package: io.javaoperatorsdk.operator.workflow.orderedmanageddependent

    WorkflowActivationCleanupIT

    Workflow Activation Cleanup

    Demonstrates how workflow cleanup is handled when activation conditions are involved. This test verifies that resources are properly cleaned up on operator startup even when marked for deletion, ensuring no orphaned resources remain after restarts.

    Package: io.javaoperatorsdk.operator.workflow.workflowactivationcleanup

    WorkflowActivationConditionIT

    Workflow Activation Condition

    Demonstrates how to use activation conditions to conditionally enable or disable parts of a workflow. This test shows how the workflow can adapt to different environments (e.g., vanilla Kubernetes vs. OpenShift) by activating only the relevant dependent resources based on runtime conditions.

    Package: io.javaoperatorsdk.operator.workflow.workflowactivationcondition

    WorkflowAllFeatureIT

    Comprehensive workflow with reconcile and delete conditions

    Demonstrates a complete workflow implementation including reconcile conditions, delete conditions, and ready conditions. Shows how to control when dependent resources are created or deleted based on conditions, and how to coordinate dependencies that must wait for others to be ready.

    Package: io.javaoperatorsdk.operator.workflow.workflowallfeature

    WorkflowExplicitCleanupIT

    Explicit Workflow Cleanup Invocation

    Tests explicit workflow cleanup invocation, demonstrating that workflow cleanup is called even when using explicit workflow invocation mode. This ensures that dependent resources are properly cleaned up during deletion regardless of how the workflow is invoked, maintaining consistent cleanup behavior.

    Package: io.javaoperatorsdk.operator.workflow.workflowexplicitcleanup

    WorkflowExplicitInvocationIT

    Workflow Explicit Invocation

    Demonstrates how to explicitly control when a workflow is invoked rather than having it run automatically on every reconciliation. This test shows how to programmatically trigger workflow execution and how cleanup is still performed even with explicit invocation.

    Package: io.javaoperatorsdk.operator.workflow.workflowexplicitinvocation

    WorkflowMultipleActivationIT

    Dynamic Workflow Activation and Deactivation

    Tests dynamic activation and deactivation of workflow dependents based on changing conditions. Demonstrates that dependents can be conditionally activated or deactivated during the resource lifecycle, with proper cleanup and recreation, and verifies that inactive dependents don’t trigger reconciliation or maintain informers.

    Package: io.javaoperatorsdk.operator.workflow.workflowmultipleactivation

    WorkflowSilentExceptionHandlingIT

    Silent Workflow Exception Handling in Reconciler

    Demonstrates handling workflow exceptions silently within the reconciler rather than propagating them. Tests verify that exceptions from dependent resources during both reconciliation and cleanup are captured in the result object, allowing custom error handling logic without failing the entire reconciliation.

    Package: io.javaoperatorsdk.operator.workflow.workflowsilentexceptionhandling