Fill remaining test coverage gaps to restore 100%

Add tests for: submitForReview error cleanup paths, perfPowerMetrics
missing nested fields, checklist utils with undefined locale fields,
listBuilds lite mode, and diagnostics non-array callStacks. Remove
unreachable ?? fallbacks in submission-checklist-utils.

Author: nickustinov

src/lib/submission-checklist-utils.ts

@@ -44,8 +44,8 @@ export function computeChecklistFlags(
   primaryLocale: string,
 ): ChecklistFlags {
   return {
-    description: computeFieldIssues(localeData, primaryLocale, "description", FIELD_MIN_LIMITS.description ?? 10),
-    whatsNew: computeFieldIssues(localeData, primaryLocale, "whatsNew", FIELD_MIN_LIMITS.whatsNew ?? 4),
+    description: computeFieldIssues(localeData, primaryLocale, "description", FIELD_MIN_LIMITS.description),
+    whatsNew: computeFieldIssues(localeData, primaryLocale, "whatsNew", FIELD_MIN_LIMITS.whatsNew),
     keywords: computeFieldIssues(localeData, primaryLocale, "keywords", 1),
   };
 }

tests/unit/asc/analytics.test.ts

@@ -3168,6 +3168,29 @@ describe("fetchPerfPowerMetrics", () => {
     expect(result.metrics).toEqual([]);
   });
 
+  it("handles missing nested fields (metricCategories, metrics, datasets, points)", async () => {
+    mockCacheGet.mockReturnValue(null);
+
+    mockAscFetch.mockResolvedValueOnce({
+      productData: [
+        { platform: "iOS" }, // no metricCategories
+        { platform: "macOS", metricCategories: [
+          { identifier: "DISK" }, // no metrics
+          { identifier: "LAUNCH", metrics: [
+            { identifier: "launchTime", unit: { displayName: "ms" } }, // no datasets
+            { identifier: "hangRate", unit: { displayName: "s" }, datasets: [
+              { filterCriteria: { device: "all", percentile: "p50" } }, // no points
+            ] },
+          ] },
+        ] },
+      ],
+    });
+
+    const result = await fetchPerfPowerMetrics("app-perf-nested-null");
+    // All products have no usable data – every metric is skipped
+    expect(result.metrics).toEqual([]);
+  });
+
   it("handles missing filterCriteria and unit", async () => {
     mockCacheGet.mockReturnValue(null);
 

tests/unit/asc/testflight/builds.test.ts

@@ -871,6 +871,50 @@ describe("listBuilds – branch coverage", () => {
     expect(result[0].groupIds).toContain("group-single");
     expect(result[0].groupIds).not.toContain("group-null");
   });
+
+  it("skips group and metrics lookups in lite mode", async () => {
+    mockCacheGet.mockReturnValue(null);
+
+    mockAscFetch.mockImplementation((url: string) => {
+      if (url.startsWith("/v1/builds?")) {
+        return Promise.resolve({
+          data: [
+            {
+              id: "b1",
+              type: "builds",
+              attributes: {
+                version: "10",
+                uploadedDate: "2026-02-01T00:00:00Z",
+                expirationDate: null,
+                expired: false,
+                minOsVersion: null,
+                processingState: "VALID",
+                iconAssetToken: null,
+              },
+              relationships: {
+                preReleaseVersion: { data: { id: "prv-1", type: "preReleaseVersions" } },
+                buildBetaDetail: { data: { id: "bbd-1", type: "buildBetaDetails" } },
+                betaBuildLocalizations: { data: [] },
+              },
+            },
+          ],
+          included: [
+            { id: "prv-1", type: "preReleaseVersions", attributes: { version: "1.0", platform: "IOS" } },
+            { id: "bbd-1", type: "buildBetaDetails", attributes: { internalBuildState: "IN_BETA_TESTING", externalBuildState: null } },
+          ],
+        });
+      }
+      return Promise.resolve({ data: [] });
+    });
+
+    const result = await listBuilds("app-lite", false, { lite: true });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].groupIds).toEqual([]);
+    expect(result[0].metrics).toBeUndefined();
+    // listGroups should not have been called
+    expect(mockListGroups).not.toHaveBeenCalled();
+  });
 });
 
 // ── Branch coverage: fetchBuildMetrics edge cases ───────────────

tests/unit/asc/testflight/diagnostics.test.ts

@@ -289,6 +289,28 @@ describe("getDiagnosticLogs", () => {
     expect(root.subFrames![0].subFrames![0].symbolName).toBe("grandchild");
   });
 
+  it("handles non-array callStacks and callStackRootFrames gracefully", async () => {
+    mockAscFetch.mockResolvedValue({
+      data: [
+        {
+          attributes: {
+            callStackTree: [
+              { callStacks: "not-an-array" }, // non-array callStacks
+              { callStacks: [
+                { callStackRootFrames: "also-not-an-array" }, // non-array rootFrames
+                { /* missing callStackRootFrames */ },
+              ] },
+            ],
+          },
+        },
+      ],
+    });
+
+    const result = await getDiagnosticLogs("sig-1");
+    expect(result).toHaveLength(1);
+    expect(result[0].callStack).toEqual([]);
+  });
+
   it("returns empty array on error (best-effort)", async () => {
     const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
     mockAscFetch.mockRejectedValue(new Error("network error"));

tests/unit/asc/version-mutations.test.ts

@@ -177,6 +177,44 @@ describe("version-mutations", () => {
       const step3Body = JSON.parse(mockAscFetch.mock.calls[2][1].body);
       expect(step3Body.data.attributes.submitted).toBe(true);
     });
+
+    it("cleans up dangling submission when step 2 fails", async () => {
+      mockAscFetch
+        .mockResolvedValueOnce({ data: { id: "sub-1" } }) // step 1: create
+        .mockRejectedValueOnce(new Error("add item failed")) // step 2: fails
+        .mockResolvedValueOnce(null); // cleanup DELETE
+
+      await expect(submitForReview("app-1", "ver-1", "IOS")).rejects.toThrow("add item failed");
+
+      expect(mockAscFetch).toHaveBeenCalledWith(
+        "/v1/reviewSubmissions/sub-1",
+        expect.objectContaining({ method: "DELETE" }),
+      );
+    });
+
+    it("cleans up dangling submission when step 3 fails", async () => {
+      mockAscFetch
+        .mockResolvedValueOnce({ data: { id: "sub-1" } }) // step 1: create
+        .mockResolvedValueOnce({}) // step 2: add item
+        .mockRejectedValueOnce(new Error("confirm failed")) // step 3: fails
+        .mockResolvedValueOnce(null); // cleanup DELETE
+
+      await expect(submitForReview("app-1", "ver-1", "IOS")).rejects.toThrow("confirm failed");
+
+      expect(mockAscFetch).toHaveBeenCalledWith(
+        "/v1/reviewSubmissions/sub-1",
+        expect.objectContaining({ method: "DELETE" }),
+      );
+    });
+
+    it("still throws original error when cleanup DELETE also fails", async () => {
+      mockAscFetch
+        .mockResolvedValueOnce({ data: { id: "sub-1" } }) // step 1: create
+        .mockRejectedValueOnce(new Error("add item failed")) // step 2: fails
+        .mockRejectedValueOnce(new Error("delete also failed")); // cleanup also fails
+
+      await expect(submitForReview("app-1", "ver-1", "IOS")).rejects.toThrow("add item failed");
+    });
   });
 
   describe("releaseVersion", () => {

tests/unit/submission-checklist-utils.test.ts

@@ -100,6 +100,24 @@ describe("computeFieldIssues", () => {
     const result = computeFieldIssues(data, "en-US", "description", 10);
     expect(result).toEqual({ status: "missing", localesWithIssues: [] });
   });
+
+  it("treats undefined field on primary locale as length 0", () => {
+    // Field key absent entirely – exercises the ?.length ?? 0 fallback
+    const data = { "en-US": { keywords: "ok", whatsNew: "ok" } as LocaleFields };
+    const result = computeFieldIssues(data, "en-US", "description", 10);
+    expect(result).toEqual({ status: "missing", localesWithIssues: [] });
+  });
+
+  it("treats undefined field on secondary locale as length 0", () => {
+    const data = makeLocaleData({
+      "en-US": { description: "A valid description text" },
+    });
+    // Manually add a secondary locale missing the description field
+    data["it"] = { keywords: "k", whatsNew: "w", promotionalText: "", supportUrl: "", marketingUrl: "" } as LocaleFields;
+    const result = computeFieldIssues(data, "en-US", "description", 10);
+    expect(result.status).toBe("warn");
+    expect(result.localesWithIssues).toEqual(["it"]);
+  });
 });
 
 describe("computeChecklistFlags", () => {