fix tests

Signed-off-by: Alex Wu <c.alexwu@gmail.com>

Author: popojk

actions/k8s/recovery_test.go

@@ -110,7 +110,6 @@ func TestResolveRecoveredFrom_HitStampsSourceResult(t *testing.T) {
 	runClient, c := newGateTestClient(t)
 	runClient.EXPECT().LookupAction(mock.Anything, mock.Anything).
 		Return(lookupResponse(&workflow.LookupActionResponse{
-			Found:       true,
 			Phase:       common.ActionPhase_ACTION_PHASE_SUCCEEDED,
 			Attempts:    2,
 			CacheStatus: core.CatalogCacheStatus_CACHE_HIT,
@@ -141,7 +140,6 @@ func TestResolveRecoveredFrom_SignalledConditionIsAHit(t *testing.T) {
 	}
 	runClient.EXPECT().LookupAction(mock.Anything, mock.Anything).
 		Return(lookupResponse(&workflow.LookupActionResponse{
-			Found:  true,
 			Phase:  common.ActionPhase_ACTION_PHASE_SUCCEEDED,
 			Output: signal,
 		}), nil).Once()
@@ -163,7 +161,6 @@ func TestResolveRecoveredFrom_RecoveredSourceIsAHit(t *testing.T) {
 	runClient, c := newGateTestClient(t)
 	runClient.EXPECT().LookupAction(mock.Anything, mock.Anything).
 		Return(lookupResponse(&workflow.LookupActionResponse{
-			Found:     true,
 			Phase:     common.ActionPhase_ACTION_PHASE_RECOVERED,
 			OutputUri: "s3://bucket/r0/a1/1/outputs.pb",
 		}), nil).Once()
@@ -175,20 +172,32 @@ func TestResolveRecoveredFrom_RecoveredSourceIsAHit(t *testing.T) {
 	assert.Equal(t, "s3://bucket/r0/a1/1/outputs.pb", got.OutputUri)
 }
 
-func TestResolveRecoveredFrom_MissAndUnusableSourcesRunFresh(t *testing.T) {
+// A source run that never had this action reports NOT_FOUND. That is an ordinary recovery
+// outcome, not a lookup failure, so it runs fresh without touching the failure counter —
+// the distinction TestResolveRecoveredFrom_LookupFailureRunsFresh covers from the other side.
+func TestResolveRecoveredFrom_MissingActionRunsFresh(t *testing.T) {
+	runClient, c := newGateTestClient(t)
+	runClient.EXPECT().LookupAction(mock.Anything, mock.Anything).
+		Return(nil, connect.NewError(connect.CodeNotFound, assert.AnError)).Once()
+
+	got := c.resolveRecoveredFrom(context.Background(),
+		taskActionWith(recoveryContextFor("r1")), childAction("a1"), false)
+	assert.Nil(t, got)
+}
+
+func TestResolveRecoveredFrom_UnusableSourcesRunFresh(t *testing.T) {
 	for _, tc := range []struct {
 		name string
 		resp *workflow.LookupActionResponse
 	}{
-		{"missing", &workflow.LookupActionResponse{Found: false}},
 		{"failed", &workflow.LookupActionResponse{
-			Found: true, Phase: common.ActionPhase_ACTION_PHASE_FAILED, OutputUri: "s3://x",
+			Phase: common.ActionPhase_ACTION_PHASE_FAILED, OutputUri: "s3://x",
 		}},
 		{"aborted", &workflow.LookupActionResponse{
-			Found: true, Phase: common.ActionPhase_ACTION_PHASE_ABORTED, OutputUri: "s3://x",
+			Phase: common.ActionPhase_ACTION_PHASE_ABORTED, OutputUri: "s3://x",
 		}},
 		{"succeeded without outputs", &workflow.LookupActionResponse{
-			Found: true, Phase: common.ActionPhase_ACTION_PHASE_SUCCEEDED,
+			Phase: common.ActionPhase_ACTION_PHASE_SUCCEEDED,
 		}},
 	} {
 		t.Run(tc.name, func(t *testing.T) {

executor/test/integration/setup_test.go

@@ -22,6 +22,7 @@ package integration
 
 import (
 	"context"
+	"errors"
 	"log"
 	"os"
 	"path/filepath"
@@ -222,9 +223,9 @@ func (r *recordingRunClient) RecordActionEvents(_ context.Context, _ *connect.Re
 	return connect.NewResponse(&workflow.RecordActionEventsResponse{}), nil
 }
 
-// No run under test is a recovery, so every lookup is a miss.
+// No run under test is a recovery, so every lookup is a miss — reported as NOT_FOUND.
 func (r *recordingRunClient) LookupAction(_ context.Context, _ *connect.Request[workflow.LookupActionRequest]) (*connect.Response[workflow.LookupActionResponse], error) {
-	return connect.NewResponse(&workflow.LookupActionResponse{Found: false}), nil
+	return nil, connect.NewError(connect.CodeNotFound, errors.New("no recovery source under test"))
 }
 
 func (r *recordingRunClient) RecordActionStream(_ context.Context) *connect.BidiStreamForClient[workflow.RecordActionStreamRequest, workflow.RecordActionStreamResponse] {

runs/service/recovery_test.go

@@ -123,17 +123,19 @@ func lookupActionID(run, name string) *common.ActionIdentifier {
 	return &common.ActionIdentifier{Run: sourceRunID(run), Name: name}
 }
 
-func TestLookupAction_MissingActionIsNotAnError(t *testing.T) {
+// A miss is NOT_FOUND, and the caller keys its fail-open path off exactly that code
+// (actions/k8s/recovery.go), so the code itself is the contract — not just "an error".
+func TestLookupAction_MissingActionIsNotFound(t *testing.T) {
 	actionRepo, svc := newRecoveryTestService(t)
 	actionID := lookupActionID("r1", "a5")
 
 	actionRepo.On("GetAction", mock.Anything, matchActionID(actionID)).
 		Return(nil, interfaces.ErrActionNotFound).Once()
 
-	resp, err := svc.LookupAction(context.Background(),
+	_, err := svc.LookupAction(context.Background(),
 		connect.NewRequest(&workflow.LookupActionRequest{ActionId: actionID}))
-	require.NoError(t, err)
-	assert.False(t, resp.Msg.GetFound())
+	require.Error(t, err)
+	assert.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 }
 
 // A failing lookup must stay distinguishable from a miss: the caller counts them separately.
@@ -170,7 +172,6 @@ func TestLookupAction_TaskActionReadsLastAttemptOutputs(t *testing.T) {
 	resp, err := svc.LookupAction(context.Background(),
 		connect.NewRequest(&workflow.LookupActionRequest{ActionId: actionID}))
 	require.NoError(t, err)
-	assert.True(t, resp.Msg.GetFound())
 	assert.Equal(t, common.ActionPhase_ACTION_PHASE_SUCCEEDED, resp.Msg.GetPhase())
 	assert.Equal(t, uint32(2), resp.Msg.GetAttempts())
 	assert.Equal(t, core.CatalogCacheStatus_CACHE_HIT, resp.Msg.GetCacheStatus())
@@ -245,7 +246,6 @@ func TestLookupAction_NoOutputsYieldsEmptyURI(t *testing.T) {
 	resp, err := svc.LookupAction(context.Background(),
 		connect.NewRequest(&workflow.LookupActionRequest{ActionId: actionID}))
 	require.NoError(t, err)
-	assert.True(t, resp.Msg.GetFound())
 	assert.Empty(t, resp.Msg.GetOutputUri())
 }