Fix flaky test TestActionDispatcher/Cancel_queued_action (#5364)

* Fix flaky test `TestActionDispatcher/Cancel_queued_action`

Here's the reason the test was flaky.
The flaky `queueAssertExpectations(t)` call asserts that
the queue's functions `DequeueActions` and `Save` functions are called.
These functions are indeed called during the `Dispatch` function call, but only after cancel actions are dispatched.
The test structure was the following:
1. Call the manager's `Dispatch` method in a goroutine.
2. Wait for the registered handler's `Handle` method to be called.
3. Assert that the queue's methods have been called.

Since the queue's methods are called during the `Dispatch` method AFTER the `Handle` method is called
for the Cancel action, the queue assertions may or may not succeed, depending on their timing.

To fix this, I have restructured the test to:
1. Call the `Dispatch` method in a goroutine.
2. Wait for the `Dispatch` method to end by waiting on the `dispatchCompleted` channel.
3. Confirm that the `Dispatch` method didn't instead block on the errors channel, which would indicate that the dispatcher dispatched an action other than the Cancel action (dispatcher never puts anything on the errors channel for dispatched Cancel actions).
4. Assert that `Handle` has been called and that the queue's methods have been called. At this point, the queue assertions are not prone to timing, as we have waited for the `Dispatch` method to complete.

* Remove unnecessary handler registration

This handler is already registered as default.

* Narrow down mock parameters

Replaces `mock.Anything` parameters with specific variables.

Author: andrzej-stencel

internal/pkg/agent/application/dispatcher/dispatcher_test.go

@@ -231,41 +231,38 @@ func TestActionDispatcher(t *testing.T) {
 	})
 
 	t.Run("Cancel queued action", func(t *testing.T) {
-		def := &mockHandler{}
-		calledCh := make(chan bool)
-		call := def.On("Handle", mock.Anything, mock.Anything, mock.Anything).Return(nil).Once()
-		call.RunFn = func(_ mock.Arguments) {
-			calledCh <- true
-		}
-
 		queue := &mockQueue{}
 		queue.On("Save").Return(nil).Once()
 		queue.On("DequeueActions").Return([]fleetapi.ScheduledAction{}).Once()
 
-		d, err := New(nil, t.TempDir(), def, queue)
-		require.NoError(t, err)
-		err = d.Register(&mockAction{}, def)
-		require.NoError(t, err)
-
 		action := &mockAction{}
 		action.On("Type").Return(fleetapi.ActionTypeCancel)
 		action.On("ID").Return("id")
 
 		dispatchCtx, cancelFn := context.WithCancel(context.Background())
 		defer cancelFn()
-		go d.Dispatch(dispatchCtx, detailsSetter, ack, action)
+
+		def := &mockHandler{}
+		def.On("Handle", dispatchCtx, action, ack).Return(nil).Once()
+
+		d, err := New(nil, t.TempDir(), def, queue)
+		require.NoError(t, err)
+
+		dispatchCompleted := make(chan struct{})
+		go func() {
+			d.Dispatch(dispatchCtx, detailsSetter, ack, action)
+			dispatchCompleted <- struct{}{}
+		}()
+
 		select {
 		case err := <-d.Errors():
 			t.Fatalf("Unexpected error: %v", err)
-		case <-calledCh:
-			// Handle was called, expected
-		case <-time.After(1 * time.Second):
-			t.Fatal("mock Handle never called")
+		case <-dispatchCompleted:
+			// OK, expected to complete the dispatch without blocking on the errors channel
 		}
+
 		def.AssertExpectations(t)
-		// Flaky assertion: https://github.com/elastic/elastic-agent/issues/3137
-		// TODO: re-enabled when fixed
-		// queue.AssertExpectations(t)
+		queue.AssertExpectations(t)
 	})
 
 	t.Run("Retrieve actions from queue", func(t *testing.T) {