@b2bc-devkit/sheetorm 1.0.3 → 1.2.0

package/dist/npm/testing/RuntimeParity.js

@@ -14,10 +14,10 @@
  *   every Jest `test()` block.  Each handler exercises the same logic but using
  *   real Google Sheets API calls instead of mocks.
  * - {@link RuntimeParity} — public API (static methods) invoked from GAS menu:
- *   - `runStageOne()` / `runStageTwo()` / `runStageThree()` — execute test subsets.
+ *   - `runStageOne()` / `runStageTwo()` / `runStageThree()` / `runStageFour()` — execute test subsets.
  *   - `validate()` — cross-check collected results against {@link ParityCatalog}.
  *
- * Tests are split into three stages to stay within the 6-minute GAS execution
+ * Tests are split into four stages to stay within the 6-minute GAS execution
  * time limit.  Each stage persists results to a `__parity_results_*` sheet so
  * that `validate()` can aggregate them later.
  *
@@ -2975,6 +2975,161 @@ const runtimeSuiteHandlers = {
                 }
                 assertTrue(threw, "save() should throw when indexed schema has no indexTableName");
             },
+            "protects sheet on first save when isProtected returns true": (ctx) => {
+                const adapter = ctx.state.getAdapter();
+                const suffix = ctx.state.nextTableName("prot");
+                Registry.reset();
+                resetDecoratorCaches();
+                Registry.getInstance().configure({ adapter });
+                class ProtectedNote extends BaseRecord {
+                    static get tableName() {
+                        return `ProtNote_${suffix}`;
+                    }
+                    static isProtected() {
+                        return true;
+                    }
+                    static protectedFor() {
+                        return ["alice@example.com", "bob@example.com"];
+                    }
+                }
+                const note = new ProtectedNote();
+                note.body = "secret";
+                note.save();
+                // Verify the sheet was created and protected
+                const spreadsheet = ctx.state.getSpreadsheet();
+                const sheet = spreadsheet.getSheetByName(`ProtNote_${suffix}`);
+                assertTrue(sheet !== null, "protected sheet should exist");
+                const protections = sheet.getProtections(SpreadsheetApp.ProtectionType.SHEET);
+                assertTrue(protections.length > 0, "sheet should have at least one protection");
+                const editors = protections[0].getEditors().map((e) => e.getEmail());
+                assertTrue(editors.includes("alice@example.com"), "alice should be an editor");
+                assertTrue(editors.includes("bob@example.com"), "bob should be an editor");
+            },
+            "does not protect sheet when isProtected returns false": (ctx) => {
+                const { Car } = setup(ctx);
+                const car = new Car();
+                car.make = "Toyota";
+                car.model = "Corolla";
+                car.save();
+                const spreadsheet = ctx.state.getSpreadsheet();
+                const sheet = spreadsheet.getSheetByName(Car.tableName);
+                assertTrue(sheet !== null, "sheet should exist");
+                const protections = sheet.getProtections(SpreadsheetApp.ProtectionType.SHEET);
+                assertEqual(protections.length, 0, "unprotected sheet should have no protections");
+            },
+            "does not re-protect sheet on subsequent saves": (ctx) => {
+                const adapter = ctx.state.getAdapter();
+                const suffix = ctx.state.nextTableName("reprot");
+                Registry.reset();
+                resetDecoratorCaches();
+                Registry.getInstance().configure({ adapter });
+                class TrackedProtected extends BaseRecord {
+                    static get tableName() {
+                        return `Tracked_${suffix}`;
+                    }
+                    static isProtected() {
+                        return true;
+                    }
+                    static protectedFor() {
+                        return ["admin@example.com"];
+                    }
+                }
+                const item1 = new TrackedProtected();
+                item1.value = "first";
+                item1.save();
+                const spreadsheet = ctx.state.getSpreadsheet();
+                const sheet = spreadsheet.getSheetByName(`Tracked_${suffix}`);
+                assertTrue(sheet !== null, "sheet should exist");
+                const protsBefore = sheet.getProtections(SpreadsheetApp.ProtectionType.SHEET);
+                assertEqual(protsBefore.length, 1, "should have exactly one protection after first save");
+                const item2 = new TrackedProtected();
+                item2.value = "second";
+                item2.save();
+                const protsAfter = sheet.getProtections(SpreadsheetApp.ProtectionType.SHEET);
+                assertEqual(protsAfter.length, 1, "should still have exactly one protection after second save");
+            },
+            "protects sheet with empty editors list": (ctx) => {
+                const adapter = ctx.state.getAdapter();
+                const suffix = ctx.state.nextTableName("locked");
+                Registry.reset();
+                resetDecoratorCaches();
+                Registry.getInstance().configure({ adapter });
+                class LockedSheet extends BaseRecord {
+                    static get tableName() {
+                        return `Locked_${suffix}`;
+                    }
+                    static isProtected() {
+                        return true;
+                    }
+                }
+                const item = new LockedSheet();
+                item.data = "locked";
+                item.save();
+                const spreadsheet = ctx.state.getSpreadsheet();
+                const sheet = spreadsheet.getSheetByName(`Locked_${suffix}`);
+                assertTrue(sheet !== null, "sheet should exist");
+                const protections = sheet.getProtections(SpreadsheetApp.ProtectionType.SHEET);
+                assertTrue(protections.length > 0, "sheet should be protected even with no editors");
+            },
+            "hides sheet on first save when isHidden returns true": (ctx) => {
+                const adapter = ctx.state.getAdapter();
+                const suffix = ctx.state.nextTableName("hidden");
+                Registry.reset();
+                resetDecoratorCaches();
+                Registry.getInstance().configure({ adapter });
+                class HiddenLog extends BaseRecord {
+                    static get tableName() {
+                        return `HidLog_${suffix}`;
+                    }
+                    static isHidden() {
+                        return true;
+                    }
+                }
+                const log = new HiddenLog();
+                log.entry = "secret log";
+                log.save();
+                const spreadsheet = ctx.state.getSpreadsheet();
+                const sheet = spreadsheet.getSheetByName(`HidLog_${suffix}`);
+                assertTrue(sheet !== null, "hidden sheet should exist");
+                assertTrue(sheet.isSheetHidden(), "sheet should be hidden");
+            },
+            "does not hide sheet when isHidden returns false": (ctx) => {
+                const { Car } = setup(ctx);
+                const car = new Car();
+                car.make = "Toyota";
+                car.model = "Corolla";
+                car.save();
+                const spreadsheet = ctx.state.getSpreadsheet();
+                const sheet = spreadsheet.getSheetByName(Car.tableName);
+                assertTrue(sheet !== null, "sheet should exist");
+                assertTrue(!sheet.isSheetHidden(), "sheet should not be hidden");
+            },
+            "does not re-hide sheet on subsequent saves": (ctx) => {
+                const adapter = ctx.state.getAdapter();
+                const suffix = ctx.state.nextTableName("rehid");
+                Registry.reset();
+                resetDecoratorCaches();
+                Registry.getInstance().configure({ adapter });
+                class TrackedHidden extends BaseRecord {
+                    static get tableName() {
+                        return `TrkHid_${suffix}`;
+                    }
+                    static isHidden() {
+                        return true;
+                    }
+                }
+                const item1 = new TrackedHidden();
+                item1.value = "first";
+                item1.save();
+                const spreadsheet = ctx.state.getSpreadsheet();
+                const sheet = spreadsheet.getSheetByName(`TrkHid_${suffix}`);
+                assertTrue(sheet !== null, "sheet should exist");
+                assertTrue(sheet.isSheetHidden(), "sheet should be hidden after first save");
+                const item2 = new TrackedHidden();
+                item2.value = "second";
+                item2.save();
+                assertTrue(sheet.isSheetHidden(), "sheet should still be hidden after second save");
+            },
         };
     })(),
     "sheet-repository.test.ts": {
@@ -3996,14 +4151,20 @@ function runTestsStageOne() {
     validateTests();
     return runTestsForSuites(ParityCatalog.SUITES.slice(0, 4));
 }
-/** Stage 2: serialization, uuid, record (~126 tests, ~250s). */
+/** Stage 2: serialization, uuid (~52 tests, ~60s). */
 function runTestsStageTwo() {
     SheetOrmLogger.verbose = false;
     validateTests();
-    return runTestsForSuites(ParityCatalog.SUITES.slice(4, 7));
+    return runTestsForSuites(ParityCatalog.SUITES.slice(4, 6));
 }
-/** Stage 3: sheet-repository (~35 tests, ~120s). */
+/** Stage 3: record (~81 tests, ~250s). */
 function runTestsStageThree() {
+    SheetOrmLogger.verbose = false;
+    validateTests();
+    return runTestsForSuites(ParityCatalog.SUITES.slice(6, 7));
+}
+/** Stage 4: sheet-repository (~35 tests, ~120s). */
+function runTestsStageFour() {
     SheetOrmLogger.verbose = false;
     validateTests();
     return runTestsForSuites(ParityCatalog.SUITES.slice(7));
@@ -4019,10 +4180,12 @@ export class RuntimeParity {
 }
 /** Execute stage-one parity tests (cache, index-store, query, query-engine). */
 RuntimeParity.runStageOne = runTestsStageOne;
-/** Execute stage-two parity tests (serialization, uuid, record). */
+/** Execute stage-two parity tests (serialization, uuid). */
 RuntimeParity.runStageTwo = runTestsStageTwo;
-/** Execute stage-three parity tests (sheet-repository). */
+/** Execute stage-three parity tests (record). */
 RuntimeParity.runStageThree = runTestsStageThree;
+/** Execute stage-four parity tests (sheet-repository). */
+RuntimeParity.runStageFour = runTestsStageFour;
 /** Cross-check that all ParityCatalog case IDs have runtime handlers. */
 RuntimeParity.validate = validateTests;
 /** Complete list of runtime parity case IDs (for external cross-reference). */