How to test controller's reconciliation function that requeues?

[hellt]

Hi all,
I am trying to figure out how ginkgo tests are supposed to test Reconcile function that requeues in the middle of its operation.

Suppose you have a reconcile function that creates a k8s resource for each CR, e.g a Pod or Deployment. I see that it is suggested to requeue after you made such resource.
For example, operator SDK says this is needed to "ensure state" - https://github.com/operator-framework/operator-sdk/blob/9d2f672c8e5bb0af8d0b5955cfa673aad21f1281/testdata/go/v3/memcached-operator/controllers/memcached_controller.go#L224-L227.

This will mean that reconcile function will return before it reached the other steps (such as updating statuses). In a regular cluster where controller is installed, the reconcile func will be called again, but how to do that in the controller_test.go?
How do we re-invoke the reconcile function should it return with a requeue?

And maybe a bigger question - why do the examples show two different techniques

1. When Reconcile function is registered with manager and tests do not call the reconcile function directly
2. When manager is not created, and controller tests call out Reconcile function directly.

[camilamacedo86]

Hi @hellt ,

1. Testing Reconciliation with Requeue

If I understand your question when testing reconciliation functions that requeue, you can simulate the requeue behavior by repeatedly invoking the reconciliation function until it no longer returns a requeue result. This simulates what would happen in a real cluster.

With Ginkgo and ENVTEST, I think you could do something like:

```go
It("should reconcile and handle requeue", func() {
    req := reconcile.Request{
        NamespacedName: types.NamespacedName{Name: "yourCRName", Namespace: "default"},
    }
    // Using Eventually to repeatedly reconcile until no requeue is returned
    Eventually(func() bool {
        res, err := reconciler.Reconcile(context.TODO(), req)
        // You can adjust this condition based on your specific requirements
        return err == nil && !res.Requeue
    }, timeout).Should(BeTrue())
})

It would not be recommend use fake client but you might able to do the same doing something like

```go
import (
    "context"
    "testing"

    "github.com/go-logr/logr/testing"
    "github.com/stretchr/testify/require"
    "sigs.k8s.io/controller-runtime/pkg/client/fake"
    "sigs.k8s.io/controller-runtime/pkg/reconcile"
)

func TestReconcileWithFakeClient(t *testing.T) {
    // Create a fake client to mock API calls
    cl := fake.NewFakeClient()

    // Create an instance of your reconciler
    r := &YourReconciler{
        Client: cl,
        Log:    testing.NullLogger{},
    }

    req := reconcile.Request{
        NamespacedName: types.NamespacedName{Name: "yourCRName", Namespace: "default"},
    }

    maxRequeues := 5
    for i := 0; i < maxRequeues; i++ {
        res, err := r.Reconcile(context.TODO(), req)

        // Break if there's no requeue
        if err != nil {
            require.FailNow(t, "Failed to reconcile", err)
        }
        if !res.Requeue {
            break
        }
    }
}

For new users, looking at the scaffolded tests by Kubebuilder's DeployImage plugin can be very helpful. It offers a clear example of how to test controllers, including how to test them out. You can check it out it:

• Doc about the plugin: https://book.kubebuilder.io/plugins/deploy-image-plugin-v1-alpha
• See the sample under testdata: https://github.com/kubernetes-sigs/kubebuilder/tree/master/testdata/project-v4-with-deploy-image
• Check the controller and its tests for a better idea.

Hope this helps!

I am closing this one as sorted out
However, feel free to reopen if you see that fits