fix(testflight): preserve post-upload notes recovery

Author: rudrankriyam

internal/asc/output_publish.go

@@ -5,6 +5,16 @@ import (
 	"strings"
 )
 
+// TestNotesRecovery describes a shell-neutral retry after a build exists but
+// setting its What to Test notes fails.
+type TestNotesRecovery struct {
+	BuildID        string   `json:"buildId"`
+	Locale         string   `json:"locale"`
+	SubmittedNotes string   `json:"submittedNotes"`
+	Command        string   `json:"command"`
+	Arguments      []string `json:"arguments"`
+}
+
 func testFlightPublishResultRows(result *TestFlightPublishResult) ([]string, [][]string) {
 	headers := []string{"Build ID", "Version", "Build Number", "Processing", "Groups", "Uploaded", "Notified", "Notification Action", "Beta Review Submitted", "Beta Review Submission ID"}
 	notified := ""

internal/asc/publish.go

@@ -74,6 +74,7 @@ type TestFlightPublishResult struct {
 	FailureStage           string                            `json:"failureStage,omitempty"`
 	Failure                string                            `json:"failure,omitempty"`
 	CompletedStages        []string                          `json:"completedStages,omitempty"`
+	Recovery               *TestNotesRecovery                `json:"recovery,omitempty"`
 	Mode                   PublishMode                       `json:"mode,omitempty"`
 	BuildID                string                            `json:"buildId"`
 	BuildVersion           string                            `json:"buildVersion,omitempty"`

internal/cli/builds/builds_commands.go

@@ -365,7 +365,7 @@ Examples:
 					if testNotesValue != "" {
 						fmt.Fprintf(os.Stderr, "Build %s discovered; setting What to Test notes...\n", buildResp.Data.ID)
 						if _, err := shared.UpsertBetaBuildLocalization(requestCtx, client, buildResp.Data.ID, localeValue, testNotesValue); err != nil {
-							return fmt.Errorf("builds upload: %w", err)
+							return fmt.Errorf("builds upload: %w", shared.NewTestNotesRecoveryError(buildResp.Data.ID, localeValue, testNotesValue, err))
 						}
 					}
 

internal/cli/cmdtest/builds_upload_wait_test.go

@@ -330,6 +330,88 @@ func TestBuildsUploadTestNotesWritesBeforeProcessingCompletes(t *testing.T) {
 	}
 }
 
+func TestBuildsUploadTestNotesFailurePreservesDiscoveredBuildRecoveryContext(t *testing.T) {
+	setupAuth(t)
+	t.Setenv("ASC_CONFIG_PATH", filepath.Join(t.TempDir(), "nonexistent.json"))
+	testNotes := "Line one\nLine two\x1b[31m"
+
+	ipaPath := writeBuildUploadIPA(t, "com.example.demo")
+
+	originalTransport := http.DefaultTransport
+	t.Cleanup(func() {
+		http.DefaultTransport = originalTransport
+	})
+
+	http.DefaultTransport = roundTripFunc(func(req *http.Request) (*http.Response, error) {
+		switch {
+		case req.Method == http.MethodGet && req.URL.Path == "/v1/apps/123456789":
+			return jsonResponse(http.StatusOK, `{"data":{"type":"apps","id":"123456789","attributes":{"name":"Demo","bundleId":"com.example.demo"}}}`)
+		case req.Method == http.MethodPost && req.URL.Path == "/v1/buildUploads":
+			return jsonResponse(http.StatusOK, `{"data":{"type":"buildUploads","id":"upload-1","attributes":{"cfBundleShortVersionString":"1.0.0","cfBundleVersion":"42","platform":"IOS"}}}`)
+		case req.Method == http.MethodPost && req.URL.Path == "/v1/buildUploadFiles":
+			return jsonResponse(http.StatusOK, `{"data":{"type":"buildUploadFiles","id":"file-1","attributes":{"fileName":"app.ipa","fileSize":4,"uti":"com.apple.itunes.ipa","assetType":"ASSET","uploadOperations":[{"method":"PUT","url":"https://upload.example.com/part-1","length":4,"offset":0,"requestHeaders":[{"name":"Content-Type","value":"application/octet-stream"}]}]}}}`)
+		case req.Method == http.MethodPut && req.URL.Host == "upload.example.com":
+			return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(strings.NewReader("")), Header: http.Header{}}, nil
+		case req.Method == http.MethodPatch && req.URL.Path == "/v1/buildUploadFiles/file-1":
+			return jsonResponse(http.StatusOK, `{"data":{"type":"buildUploadFiles","id":"file-1","attributes":{"uploaded":true}}}`)
+		case req.Method == http.MethodGet && req.URL.Path == "/v1/buildUploads/upload-1":
+			return jsonResponse(http.StatusOK, `{"data":{"type":"buildUploads","id":"upload-1","relationships":{"build":{"data":{"type":"builds","id":"build-1"}}}}}`)
+		case req.Method == http.MethodGet && req.URL.Path == "/v1/builds/build-1":
+			return jsonResponse(http.StatusOK, `{"data":{"type":"builds","id":"build-1","attributes":{"version":"42","processingState":"PROCESSING"}}}`)
+		case req.Method == http.MethodGet && req.URL.Path == "/v1/builds/build-1/betaBuildLocalizations":
+			return jsonResponse(http.StatusOK, `{"data":[]}`)
+		case req.Method == http.MethodPost && req.URL.Path == "/v1/betaBuildLocalizations":
+			return jsonResponse(http.StatusUnprocessableEntity, `{"errors":[{"status":"422","code":"ENTITY_ERROR.ATTRIBUTE.INVALID","title":"The provided entity has an invalid attribute","detail":"What to Test was rejected by the server"}]}`)
+		default:
+			t.Fatalf("unexpected request: %s %s", req.Method, req.URL.String())
+			return nil, nil
+		}
+	})
+
+	root := RootCommand("1.2.3")
+	root.FlagSet.SetOutput(io.Discard)
+
+	var runErr error
+	stdout, _ := captureOutput(t, func() {
+		if err := root.Parse([]string{
+			"builds", "upload",
+			"--app", "123456789",
+			"--ipa", ipaPath,
+			"--version", "1.0.0",
+			"--build-number", "42",
+			"--test-notes", testNotes,
+			"--locale", "en-US",
+			"--poll-interval", "1ms",
+		}); err != nil {
+			t.Fatalf("parse error: %v", err)
+		}
+		runErr = root.Run(context.Background())
+	})
+
+	if runErr == nil {
+		t.Fatal("expected test notes rejection after upload")
+	}
+	if stdout != "" {
+		t.Fatalf("expected no new structured output contract on failure, got %q", stdout)
+	}
+	wantParts := []string{
+		`build "build-1" is available`,
+		`locale "en-US"`,
+		"The provided entity has an invalid attribute: What to Test was rejected by the server",
+		"retry without uploading the build again",
+		"reuse the original notes",
+		"asc builds test-notes create --build-id BUILD_ID --locale LOCALE --whats-new NOTES",
+	}
+	for _, want := range wantParts {
+		if !strings.Contains(runErr.Error(), want) {
+			t.Fatalf("expected recovery error to contain %q, got %v", want, runErr)
+		}
+	}
+	if asc.HasInterpretedTerminalSequence(runErr.Error()) || strings.Contains(runErr.Error(), "Line one") {
+		t.Fatalf("expected sanitized human recovery without embedded notes, got %q", runErr)
+	}
+}
+
 func TestBuildsUploadPostCommitVerificationUsesFreshTimeoutWindow(t *testing.T) {
 	setupAuth(t)
 	t.Setenv("ASC_CONFIG_PATH", filepath.Join(t.TempDir(), "nonexistent.json"))

internal/cli/publish/publish.go

@@ -403,7 +403,9 @@ Examples:
 
 			if testNotesValue != "" {
 				if _, err := shared.UpsertBetaBuildLocalization(requestCtx, client, buildResp.Data.ID, localeValue, testNotesValue); err != nil {
-					return reportPartialFailure(publishFailureStageTestNotes, fmt.Errorf("publish testflight: %w", err))
+					recoveryErr := shared.NewTestNotesRecoveryError(buildResp.Data.ID, localeValue, testNotesValue, err)
+					result.Recovery = recoveryErr.Recovery()
+					return reportPartialFailure(publishFailureStageTestNotes, fmt.Errorf("publish testflight: %w", recoveryErr))
 				}
 				completedStages = append(completedStages, publishCompletedStageTestNotes)
 			}

internal/cli/publish/publish_local_build_test.go

@@ -774,6 +774,149 @@ func TestPublishTestFlightUploadReportsStructuredRecoveryResultAfterBetaReviewFa
 	}
 }
 
+func TestPublishTestFlightUploadTestNotesFailurePreservesStructuredRecoveryContext(t *testing.T) {
+	restore := overridePublishCommandTestHooks(t)
+	defer restore()
+	testNotes := "Line one\nLine two\x1b[31m"
+
+	getPublishASCClientFn = func(time.Duration) (*asc.Client, error) { return newPublishCommandTestClient(t), nil }
+	resolvePublishAppIDWithLookupFn = func(_ context.Context, _ *asc.Client, _ string) (string, error) {
+		return "app-123", nil
+	}
+	validatePublishIPAPathFn = func(string) (os.FileInfo, error) {
+		return newPublishTestFileInfo(t)
+	}
+	uploadCalls := 0
+	uploadBuildAndWaitForIDFn = func(_ context.Context, _ *asc.Client, _ string, _ string, _ os.FileInfo, version, buildNumber string, _ asc.Platform, _ time.Duration, _ time.Duration, _ bool) (*publishUploadResult, error) {
+		uploadCalls++
+		return &publishUploadResult{
+			Build: &asc.BuildResponse{Data: asc.Resource[asc.BuildAttributes]{
+				ID: "build-123",
+				Attributes: asc.BuildAttributes{
+					Version:         buildNumber,
+					ProcessingState: asc.BuildProcessingStateProcessing,
+				},
+			}},
+			Version:     version,
+			BuildNumber: buildNumber,
+		}, nil
+	}
+	waitForPublishBuildProcessingFn = func(context.Context, *asc.Client, string, time.Duration) (*asc.BuildResponse, error) {
+		return &asc.BuildResponse{Data: asc.Resource[asc.BuildAttributes]{
+			ID: "build-123",
+			Attributes: asc.BuildAttributes{
+				Version:         "42",
+				ProcessingState: asc.BuildProcessingStateValid,
+			},
+		}}, nil
+	}
+
+	originalTransport := http.DefaultTransport
+	t.Cleanup(func() { http.DefaultTransport = originalTransport })
+	requestCount := 0
+	http.DefaultTransport = publishCommandRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+		requestCount++
+		switch requestCount {
+		case 1:
+			if req.Method != http.MethodGet || req.URL.Path != "/v1/apps/app-123/betaGroups" {
+				t.Fatalf("unexpected request %d: %s %s", requestCount, req.Method, req.URL.String())
+			}
+			return publishCommandJSONResponse(http.StatusOK, `{"data":[{"type":"betaGroups","id":"group-1","attributes":{"name":"External","isInternalGroup":false}}]}`)
+		case 2:
+			if req.Method != http.MethodGet || req.URL.Path != "/v1/builds/build-123/betaBuildLocalizations" {
+				t.Fatalf("unexpected request %d: %s %s", requestCount, req.Method, req.URL.String())
+			}
+			return publishCommandJSONResponse(http.StatusOK, `{"data":[]}`)
+		case 3:
+			if req.Method != http.MethodPost || req.URL.Path != "/v1/betaBuildLocalizations" {
+				t.Fatalf("unexpected request %d: %s %s", requestCount, req.Method, req.URL.String())
+			}
+			return publishCommandJSONResponse(http.StatusUnprocessableEntity, `{"errors":[{"status":"422","code":"ENTITY_ERROR.ATTRIBUTE.INVALID","title":"The provided entity has an invalid attribute","detail":"What to Test was rejected by the server"}]}`)
+		default:
+			t.Fatalf("unexpected request %d: %s %s", requestCount, req.Method, req.URL.String())
+			return nil, nil
+		}
+	})
+
+	cmd := PublishTestFlightCommand()
+	cmd.FlagSet.SetOutput(io.Discard)
+	if err := cmd.FlagSet.Parse([]string{
+		"--app", "app-123",
+		"--ipa", "Demo.ipa",
+		"--version", "1.2.3",
+		"--build-number", "42",
+		"--group", "External",
+		"--test-notes", testNotes,
+		"--locale", "en-US",
+		"--output", "json",
+	}); err != nil {
+		t.Fatalf("parse flags: %v", err)
+	}
+
+	var runErr error
+	stdout, _ := capturePublishCommandOutput(t, func() error {
+		runErr = cmd.Exec(context.Background(), nil)
+		return runErr
+	})
+	if runErr == nil {
+		t.Fatal("expected post-upload test notes rejection")
+	}
+	if uploadCalls != 1 {
+		t.Fatalf("upload calls = %d, want 1", uploadCalls)
+	}
+	wantParts := []string{
+		`build "build-123" is available`,
+		`locale "en-US"`,
+		"The provided entity has an invalid attribute: What to Test was rejected by the server",
+		"retry without uploading the build again",
+		"reuse the original notes",
+		"asc builds test-notes create --build-id BUILD_ID --locale LOCALE --whats-new NOTES",
+	}
+	for _, want := range wantParts {
+		if !strings.Contains(runErr.Error(), want) {
+			t.Fatalf("expected recovery error to contain %q, got %v", want, runErr)
+		}
+	}
+	if asc.HasInterpretedTerminalSequence(runErr.Error()) || strings.Contains(runErr.Error(), "Line one") {
+		t.Fatalf("expected sanitized human recovery without embedded notes, got %q", runErr)
+	}
+
+	var result asc.TestFlightPublishResult
+	if err := json.Unmarshal([]byte(stdout), &result); err != nil {
+		t.Fatalf("decode partial publish result: %v\nstdout=%s", err, stdout)
+	}
+	if result.Status != publishPartialStatus || result.FailureStage != publishFailureStageTestNotes {
+		t.Fatalf("unexpected partial status: status=%q stage=%q", result.Status, result.FailureStage)
+	}
+	if result.BuildID != "build-123" || !result.Uploaded {
+		t.Fatalf("expected recoverable uploaded build, got buildId=%q uploaded=%t", result.BuildID, result.Uploaded)
+	}
+	wantCompleted := []string{publishCompletedStageUpload, publishCompletedStageBuildProcessing}
+	if !slices.Equal(result.CompletedStages, wantCompleted) {
+		t.Fatalf("completed stages = %v, want %v", result.CompletedStages, wantCompleted)
+	}
+	for _, want := range wantParts {
+		if !strings.Contains(result.Failure, want) {
+			t.Fatalf("expected structured failure to contain %q, got %q", want, result.Failure)
+		}
+	}
+	if result.Recovery == nil {
+		t.Fatalf("expected typed test-notes recovery, got %#v", result)
+	}
+	if result.Recovery.BuildID != "build-123" || result.Recovery.Locale != "en-US" || result.Recovery.SubmittedNotes != testNotes {
+		t.Fatalf("structured recovery lost exact values: %#v", result.Recovery)
+	}
+	wantArguments := []string{
+		"builds", "test-notes", "create",
+		"--build-id", "build-123",
+		"--locale", "en-US",
+		"--whats-new", testNotes,
+	}
+	if result.Recovery.Command != "asc" || !slices.Equal(result.Recovery.Arguments, wantArguments) {
+		t.Fatalf("structured recovery command = %q %#v, want asc %#v", result.Recovery.Command, result.Recovery.Arguments, wantArguments)
+	}
+}
+
 func TestPublishTestFlightUploadReportsTerminalProcessingStateAfterWaitFailure(t *testing.T) {
 	restore := overridePublishCommandTestHooks(t)
 	defer restore()

internal/cli/shared/test_notes.go

@@ -52,3 +52,59 @@ func UpsertBetaBuildLocalization(ctx context.Context, client *asc.Client, buildI
 	}
 	return client.CreateBetaBuildLocalization(ctx, buildID, attrs)
 }
+
+// TestNotesRecoveryError preserves a discovered build and the exact retry
+// arguments while keeping its human-facing diagnostic terminal-safe.
+type TestNotesRecoveryError struct {
+	buildID string
+	locale  string
+	notes   string
+	cause   error
+}
+
+// NewTestNotesRecoveryError returns recovery context for a failed post-upload
+// What to Test request.
+func NewTestNotesRecoveryError(buildID, locale, notes string, cause error) *TestNotesRecoveryError {
+	return &TestNotesRecoveryError{
+		buildID: buildID,
+		locale:  locale,
+		notes:   notes,
+		cause:   cause,
+	}
+}
+
+func (e *TestNotesRecoveryError) Error() string {
+	buildID := asc.SanitizeTerminalText(e.buildID)
+	locale := asc.SanitizeTerminalText(e.locale)
+	cause := "unknown error"
+	if e.cause != nil {
+		cause = asc.SanitizeTerminalText(e.cause.Error())
+	}
+	return fmt.Sprintf(
+		"build %q is available, but setting What to Test notes for locale %q failed: %s; retry without uploading the build again and reuse the original notes: asc builds test-notes create --build-id BUILD_ID --locale LOCALE --whats-new NOTES",
+		buildID,
+		locale,
+		cause,
+	)
+}
+
+// Unwrap preserves API error status and exit classification.
+func (e *TestNotesRecoveryError) Unwrap() error {
+	return e.cause
+}
+
+// Recovery returns exact, shell-neutral retry data for structured output.
+func (e *TestNotesRecoveryError) Recovery() *asc.TestNotesRecovery {
+	return &asc.TestNotesRecovery{
+		BuildID:        e.buildID,
+		Locale:         e.locale,
+		SubmittedNotes: e.notes,
+		Command:        "asc",
+		Arguments: []string{
+			"builds", "test-notes", "create",
+			"--build-id", e.buildID,
+			"--locale", e.locale,
+			"--whats-new", e.notes,
+		},
+	}
+}