@fluidframework/container-runtime 2.0.0-dev-rc.3.0.0.250606 → 2.0.0-dev-rc.3.0.0.253463

package/lib/test/gc/gcConfigs.spec.js

@@ -1,689 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { strict as assert } from "assert";
-import { MockLogger, createChildLogger, mixinMonitoringContext, } from "@fluidframework/telemetry-utils";
-import { useFakeTimers } from "sinon";
-import { GCNodeType, GarbageCollector, defaultInactiveTimeoutMs, defaultSessionExpiryDurationMs, defaultSweepGracePeriodMs, disableDatastoreSweepKey, gcDisableDataStoreSweepOptionName, gcDisableThrowOnTombstoneLoadOptionName, gcGenerationOptionName, gcTestModeKey, gcVersionUpgradeToV4Key, nextGCVersion, oneDayMs, runGCKey, runSessionExpiryKey, runSweepKey, stableGCVersion, throwOnTombstoneLoadOverrideKey, } from "../../gc/index.js";
-import { pkgVersion } from "../../packageVersion.js";
-import { createTestConfigProvider } from "./gcUnitTestHelpers.js";
-describe("Garbage Collection configurations", () => {
-    const testPkgPath = ["testPkg"];
-    const configProvider = createTestConfigProvider();
-    let mockLogger;
-    let mc;
-    let clock;
-    // The default GC data returned by `getGCData` on which GC is run. Update this to update the referenced graph.
-    let defaultGCData = { gcNodes: {} };
-    const customSessionExpiryDurationMs = defaultSessionExpiryDurationMs + 1;
-    const testOverrideInactiveTimeoutKey = "Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs";
-    const testOverrideTombstoneTimeoutKey = "Fluid.GarbageCollection.TestOverride.TombstoneTimeoutMs";
-    const testOverrideSessionExpiryMsKey = "Fluid.GarbageCollection.TestOverride.SessionExpiryMs";
-    let gc;
-    const createGcWithPrivateMembers = (gcMetadata, gcOptions, isSummarizerClient) => {
-        const metadata = gcMetadata && {
-            summaryFormatVersion: 1,
-            message: undefined,
-            ...gcMetadata,
-        };
-        return createGarbageCollector({ metadata, gcOptions }, undefined /* gcBlobsMap */, undefined /* closeFn */, isSummarizerClient);
-    };
-    function createGarbageCollector(createParams = {}, gcBlobsMap = new Map(), closeFn = () => { }, isSummarizerClient = true) {
-        const getNodeType = (nodePath) => {
-            if (nodePath.split("/").length !== 2) {
-                return GCNodeType.Other;
-            }
-            return GCNodeType.DataStore;
-        };
-        // The runtime to be passed to the garbage collector.
-        const gcRuntime = {
-            updateStateBeforeGC: async () => { },
-            getGCData: async (fullGC) => defaultGCData,
-            updateUsedRoutes: (usedRoutes) => {
-                return { totalNodeCount: 0, unusedNodeCount: 0 };
-            },
-            deleteSweepReadyNodes: (sweepReadyRoutes) => {
-                return [];
-            },
-            updateTombstonedRoutes: (tombstoneRoutes) => { },
-            getNodeType,
-            getCurrentReferenceTimestampMs: () => Date.now(),
-            closeFn,
-        };
-        return GarbageCollector.create({
-            ...createParams,
-            runtime: gcRuntime,
-            gcOptions: createParams.gcOptions ?? {},
-            baseSnapshot: createParams.baseSnapshot,
-            baseLogger: createChildLogger({ logger: mc.logger }),
-            existing: createParams.metadata !== undefined /* existing */,
-            metadata: createParams.metadata,
-            createContainerMetadata: {
-                createContainerRuntimeVersion: pkgVersion,
-                createContainerTimestamp: Date.now(),
-            },
-            isSummarizerClient,
-            readAndParseBlob: async (id) => gcBlobsMap.get(id),
-            getNodePackagePath: async (nodeId) => testPkgPath,
-            getLastSummaryTimestampMs: () => Date.now(),
-            submitMessage: (message) => { },
-        });
-    }
-    before(() => {
-        clock = useFakeTimers();
-    });
-    beforeEach(() => {
-        gc = undefined;
-        mockLogger = new MockLogger();
-        // To ensure inactive timeout is less than tombstone timeout.
-        configProvider.set(testOverrideInactiveTimeoutKey, 1);
-        mc = mixinMonitoringContext(mockLogger, configProvider);
-    });
-    afterEach(() => {
-        clock.reset();
-        configProvider.clear();
-        defaultGCData = { gcNodes: {} };
-        gc?.dispose();
-    });
-    after(() => {
-        clock.restore();
-    });
-    describe("Existing container", () => {
-        it("No metadata", () => {
-            gc = createGcWithPrivateMembers({});
-            assert(!gc.configs.gcEnabled, "gcEnabled incorrect");
-            assert(!gc.configs.shouldRunGC, "shouldRunGC incorrect");
-            assert(gc.configs.sweepEnabled, "sweepEnabled incorrect");
-            assert.equal(gc.configs.shouldRunSweep, "NO", "shouldRunSweep incorrect");
-            assert(gc.configs.sessionExpiryTimeoutMs === undefined, "sessionExpiryTimeoutMs incorrect");
-            assert(gc.configs.tombstoneTimeoutMs === undefined, "tombstoneTimeoutMs incorrect");
-            assert.equal(gc.summaryStateTracker.latestSummaryGCVersion, 0, "latestSummaryGCVersion incorrect");
-        });
-        it("gcFeature 0", () => {
-            gc = createGcWithPrivateMembers({ gcFeature: 0 });
-            assert(!gc.configs.gcEnabled, "gcEnabled incorrect");
-            assert.equal(gc.summaryStateTracker.latestSummaryGCVersion, 0, "latestSummaryGCVersion incorrect");
-        });
-        it("gcFeature 0, Sweep enabled via gcGeneration", () => {
-            gc = createGcWithPrivateMembers({ gcFeature: 0, gcFeatureMatrix: { gcGeneration: 0 } }, { [gcGenerationOptionName]: 0 });
-            assert(!gc.configs.gcEnabled, "gcEnabled incorrect");
-            assert(gc.configs.sweepEnabled, "sweepEnabled incorrect");
-            assert.equal(gc.summaryStateTracker.latestSummaryGCVersion, 0, "latestSummaryGCVersion incorrect");
-        });
-        it("gcFeature 1", () => {
-            gc = createGcWithPrivateMembers({ gcFeature: 1 });
-            assert(gc.configs.gcEnabled, "gcEnabled incorrect");
-            assert.equal(gc.summaryStateTracker.latestSummaryGCVersion, 1, "latestSummaryGCVersion incorrect");
-        });
-        it("sweepEnabled value ignored", () => {
-            gc = createGcWithPrivateMembers({ sweepEnabled: true }, { [gcGenerationOptionName]: 1 });
-            assert(!gc.configs.sweepEnabled, "sweepEnabled incorrect");
-        });
-        it("sessionExpiryTimeoutMs set (tombstoneTimeoutMs unset)", () => {
-            gc = createGcWithPrivateMembers({
-                sessionExpiryTimeoutMs: customSessionExpiryDurationMs,
-            });
-            assert.equal(gc.configs.sessionExpiryTimeoutMs, customSessionExpiryDurationMs, "sessionExpiryTimeoutMs incorrect");
-            assert.equal(gc.configs.tombstoneTimeoutMs, customSessionExpiryDurationMs + 6 * oneDayMs, "tombstoneTimeoutMs incorrect");
-        });
-        it("tombstoneTimeoutMs set", () => {
-            gc = createGcWithPrivateMembers({ tombstoneTimeoutMs: 123 });
-            assert.equal(gc.configs.tombstoneTimeoutMs, 123, "tombstoneTimeoutMs incorrect");
-        });
-        it("Metadata Roundtrip", () => {
-            const inputMetadata = {
-                sweepEnabled: true,
-                gcFeature: 1,
-                sessionExpiryTimeoutMs: customSessionExpiryDurationMs,
-                tombstoneTimeoutMs: 123,
-                gcFeatureMatrix: { gcGeneration: 1 },
-            };
-            gc = createGcWithPrivateMembers(inputMetadata, {
-                [gcGenerationOptionName]: 2, // 2 should not replace already-persisted value of 1
-            });
-            const outputMetadata = gc.getMetadata();
-            const expectedOutputMetadata = {
-                ...inputMetadata,
-                sweepEnabled: false,
-                gcFeature: stableGCVersion,
-            };
-            assert.deepEqual(outputMetadata, expectedOutputMetadata, "getMetadata returned different metadata than loaded from");
-        });
-        it("Metadata Roundtrip - old file with tombstoneGeneration", () => {
-            const inputMetadata = {
-                sweepEnabled: true,
-                gcFeature: 1,
-                sessionExpiryTimeoutMs: customSessionExpiryDurationMs,
-                tombstoneTimeoutMs: 123,
-                gcFeatureMatrix: { tombstoneGeneration: 1 }, // legacy file before gcGeneration
-            };
-            gc = createGcWithPrivateMembers(inputMetadata, {
-                [gcGenerationOptionName]: 2, // Will not be persisted - legacy file will only ever be stamped with tombstoneGeneration
-            });
-            const outputMetadata = gc.getMetadata();
-            const expectedOutputMetadata = {
-                ...inputMetadata,
-                sweepEnabled: false,
-                gcFeature: stableGCVersion,
-            };
-            assert.deepEqual(outputMetadata, expectedOutputMetadata, "getMetadata returned different metadata than loaded from");
-        });
-        it("Metadata Roundtrip transition to gcGeneration from tombstoneGeneration", () => {
-            const inputMetadata = {
-                sweepEnabled: true,
-                gcFeature: 1,
-                sessionExpiryTimeoutMs: customSessionExpiryDurationMs,
-                tombstoneTimeoutMs: 123,
-                gcFeatureMatrix: { gcGeneration: 1 },
-            };
-            // An app may write both Generation options to ease the transition. Only gcGeneration will be persisted
-            // (and previous to the change introducing gcGeneration, only tombstoneGeneration would have been persisted).
-            gc = createGcWithPrivateMembers(inputMetadata, {
-                [gcGenerationOptionName]: 1,
-                gcTombstoneGeneration: 1, // Legacy - will not be persisted but is ok to pass in
-            });
-            const outputMetadata = gc.getMetadata();
-            const expectedOutputMetadata = {
-                ...inputMetadata,
-                sweepEnabled: false,
-                gcFeature: stableGCVersion,
-            };
-            assert.deepEqual(outputMetadata, expectedOutputMetadata, "getMetadata returned different metadata than loaded from");
-        });
-        it("Metadata Roundtrip with GC version upgrade to v4 enabled", () => {
-            configProvider.set(gcVersionUpgradeToV4Key, true);
-            const inputMetadata = {
-                sweepEnabled: true,
-                gcFeature: 1,
-                sessionExpiryTimeoutMs: customSessionExpiryDurationMs,
-                tombstoneTimeoutMs: 123,
-                gcFeatureMatrix: { gcGeneration: 1 },
-            };
-            gc = createGcWithPrivateMembers(inputMetadata);
-            const outputMetadata = gc.getMetadata();
-            const expectedOutputMetadata = {
-                ...inputMetadata,
-                sweepEnabled: false,
-                gcFeature: nextGCVersion,
-            };
-            assert.deepEqual(outputMetadata, expectedOutputMetadata, "getMetadata returned different metadata than loaded from");
-        });
-        it("Metadata Roundtrip with GC version upgrade to v4 disabled", () => {
-            configProvider.set(gcVersionUpgradeToV4Key, false);
-            const inputMetadata = {
-                sweepEnabled: true,
-                gcFeature: 1,
-                sessionExpiryTimeoutMs: customSessionExpiryDurationMs,
-                tombstoneTimeoutMs: 123,
-                gcFeatureMatrix: { gcGeneration: 1 },
-            };
-            gc = createGcWithPrivateMembers(inputMetadata);
-            const outputMetadata = gc.getMetadata();
-            const expectedOutputMetadata = {
-                ...inputMetadata,
-                sweepEnabled: false,
-                gcFeature: stableGCVersion,
-            };
-            assert.deepEqual(outputMetadata, expectedOutputMetadata, "getMetadata returned different metadata than loaded from");
-        });
-    });
-    describe("New Container", () => {
-        it("No options", () => {
-            gc = createGcWithPrivateMembers(undefined /* metadata */, {});
-            assert(gc.configs.gcEnabled, "gcEnabled incorrect");
-            assert(gc.configs.shouldRunGC, "shouldRunGC incorrect");
-            assert(gc.configs.sweepEnabled, "sweepEnabled incorrect"); // Sweep is always allowed for a new container
-            assert.equal(gc.configs.shouldRunSweep, "NO", "shouldRunSweep incorrect");
-            assert(gc.configs.sessionExpiryTimeoutMs !== undefined, "sessionExpiryTimeoutMs incorrect");
-            assert(gc.configs.tombstoneTimeoutMs !== undefined, "tombstoneTimeoutMs incorrect");
-            assert.equal(gc.summaryStateTracker.latestSummaryGCVersion, stableGCVersion, "latestSummaryGCVersion incorrect");
-        });
-        it("gcAllowed true", () => {
-            gc = createGcWithPrivateMembers(undefined /* metadata */, { gcAllowed: true });
-            assert(gc.configs.gcEnabled, "gcEnabled incorrect");
-        });
-        it("gcAllowed false", () => {
-            gc = createGcWithPrivateMembers(undefined /* metadata */, { gcAllowed: false });
-            assert(!gc.configs.gcEnabled, "gcEnabled incorrect");
-        });
-        it("Sweep enabled via gcGeneration, gcAllowed true", () => {
-            gc = createGcWithPrivateMembers(undefined /* metadata */, {
-                gcAllowed: true,
-                [gcGenerationOptionName]: 1,
-            });
-            assert(gc.configs.gcEnabled, "gcEnabled incorrect");
-            assert(gc.configs.sweepEnabled, "sweepEnabled incorrect");
-            assert(gc.configs.tombstoneTimeoutMs !== undefined, "tombstoneTimeoutMs incorrect");
-            assert(gc.configs.sessionExpiryTimeoutMs !== undefined, "sessionExpiryTimeoutMs incorrect");
-        });
-        it("Sweep enabled via gcGeneration, gcAllowed true, sessionExpiry off", () => {
-            configProvider.set(runSessionExpiryKey, false);
-            gc = createGcWithPrivateMembers(undefined /* metadata */, {
-                gcAllowed: true,
-                [gcGenerationOptionName]: 1,
-            });
-            assert(gc.configs.gcEnabled, "gcEnabled incorrect");
-            assert(gc.configs.sweepEnabled, "sweepEnabled incorrect");
-            assert(gc.configs.sessionExpiryTimeoutMs === undefined, "sessionExpiryTimeoutMs incorrect");
-            assert(gc.configs.tombstoneTimeoutMs === undefined, "tombstoneTimeoutMs incorrect");
-        });
-        it("TestOverride.TombstoneTimeoutMs set, sessionExpiry on", () => {
-            configProvider.set(testOverrideTombstoneTimeoutKey, 123);
-            gc = createGcWithPrivateMembers(undefined /* metadata */, {});
-            assert(gc.configs.sweepEnabled, "sweepEnabled incorrect");
-            assert(gc.configs.sessionExpiryTimeoutMs === defaultSessionExpiryDurationMs, "sessionExpiryTimeoutMs incorrect");
-            assert(gc.configs.tombstoneTimeoutMs === 123, "tombstoneTimeoutMs incorrect");
-        });
-        it("TestOverride.TombstoneTimeoutMs set, sessionExpiry off", () => {
-            configProvider.set(testOverrideTombstoneTimeoutKey, 123);
-            configProvider.set(runSessionExpiryKey, false);
-            gc = createGcWithPrivateMembers(undefined /* metadata */, {});
-            assert(gc.configs.sweepEnabled, "sweepEnabled incorrect");
-            assert(gc.configs.sessionExpiryTimeoutMs === undefined, "sessionExpiryTimeoutMs incorrect");
-            assert(gc.configs.tombstoneTimeoutMs === 123, "tombstoneTimeoutMs incorrect");
-        });
-        it("Metadata Roundtrip", () => {
-            const expectedMetadata = {
-                sweepEnabled: false,
-                gcFeature: stableGCVersion,
-                sessionExpiryTimeoutMs: defaultSessionExpiryDurationMs,
-                tombstoneTimeoutMs: defaultSessionExpiryDurationMs + 6 * oneDayMs,
-                gcFeatureMatrix: { gcGeneration: 2 },
-            };
-            gc = createGcWithPrivateMembers(undefined /* metadata */, {
-                [gcGenerationOptionName]: 2,
-            });
-            const outputMetadata = gc.getMetadata();
-            assert.deepEqual(outputMetadata, expectedMetadata, "getMetadata returned different metadata than expected");
-        });
-        it("Metadata Roundtrip with GC version upgrade to v4 enabled", () => {
-            configProvider.set(gcVersionUpgradeToV4Key, true);
-            const expectedMetadata = {
-                sweepEnabled: false,
-                gcFeature: nextGCVersion,
-                sessionExpiryTimeoutMs: defaultSessionExpiryDurationMs,
-                tombstoneTimeoutMs: defaultSessionExpiryDurationMs + 6 * oneDayMs,
-                gcFeatureMatrix: undefined,
-            };
-            gc = createGcWithPrivateMembers(undefined /* metadata */, {});
-            const outputMetadata = gc.getMetadata();
-            assert.deepEqual(outputMetadata, expectedMetadata, "getMetadata returned different metadata than expected");
-        });
-        it("Metadata Roundtrip transition to gcGeneration from tombstoneGeneration", () => {
-            const expectedMetadata = {
-                sweepEnabled: false,
-                gcFeature: stableGCVersion,
-                sessionExpiryTimeoutMs: defaultSessionExpiryDurationMs,
-                tombstoneTimeoutMs: defaultSessionExpiryDurationMs + 6 * oneDayMs,
-                gcFeatureMatrix: {
-                    gcGeneration: 2,
-                    // tombstoneGeneration will not be persisted
-                },
-            };
-            // An app may write both Generation options to ease the transition. Only gcGeneration will be persisted
-            // (and previous to the change introducing gcGeneration, only tombstoneGeneration would have been persisted).
-            gc = createGcWithPrivateMembers(undefined /* metadata */, {
-                [gcGenerationOptionName]: 2,
-                gcTombstoneGeneration: 2, // Legacy - will not be persisted but is ok to pass in
-            });
-            const outputMetadata = gc.getMetadata();
-            assert.deepEqual(outputMetadata, expectedMetadata, "getMetadata returned different metadata than expected");
-        });
-    });
-    describe("Session Expiry and Tombstone Timeout", () => {
-        beforeEach(() => {
-            configProvider.set("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs", 1); // To ensure it's less than tombstone timeout
-        });
-        // Config sources for Session Expiry:
-        // 1. defaultSessionExpiryDurationMs in code
-        // 2. IGCRuntimeOptions.sessionExpiryTimeoutMs
-        // 3. IGCMetadata.sessionExpiryTimeoutMs
-        // 4. "Fluid.GarbageCollection.TestOverride.SessionExpiryMs" setting
-        // Config sources for Tombstone Timeout:
-        // 1. IGCMetadata.tombstoneTimeoutMs
-        // 2. IGCMetadata_Deprecated.sweepTimeoutMs (backfill from before two-stage sweep)
-        // 3. Computed from Session Expiry, fixed upper bound for Snapshot Expiry and a fixed buffer (on create, or to backfill existing)
-        // 4. "Fluid.GarbageCollection.TestOverride.TombstoneTimeoutMs" setting (only applicable on create)
-        it("defaultSessionExpiryDurationMs", () => {
-            gc = createGcWithPrivateMembers();
-            assert.equal(gc.configs.sessionExpiryTimeoutMs, defaultSessionExpiryDurationMs, "sessionExpiryTimeoutMs incorrect");
-            assert.equal(gc.sessionExpiryTimer.defaultTimeout, defaultSessionExpiryDurationMs, "sessionExpiryTimer incorrect");
-            assert.equal(gc.configs.tombstoneTimeoutMs, defaultSessionExpiryDurationMs + 6 * oneDayMs, "tombstoneTimeoutMs incorrect");
-        });
-        it("defaultSessionExpiryDurationMs, TestOverride.TombstoneTimeoutMs set", () => {
-            configProvider.set(testOverrideTombstoneTimeoutKey, 7890);
-            gc = createGcWithPrivateMembers();
-            assert.equal(gc.configs.sessionExpiryTimeoutMs, defaultSessionExpiryDurationMs, "sessionExpiryTimeoutMs incorrect");
-            assert.equal(gc.sessionExpiryTimer.defaultTimeout, defaultSessionExpiryDurationMs, "sessionExpiryTimer incorrect");
-            assert.equal(gc.configs.tombstoneTimeoutMs, 7890, "tombstoneTimeoutMs incorrect");
-        });
-        it("gcAllowed off, session expiry off", () => {
-            gc = gc = createGcWithPrivateMembers(undefined /* metadata */, {
-                gcAllowed: false,
-            });
-            assert.equal(gc.configs.sessionExpiryTimeoutMs, undefined, "sessionExpiryTimeoutMs incorrect");
-            assert.equal(gc.sessionExpiryTimer, undefined, "sessionExpiryTimer incorrect");
-            assert.equal(gc.configs.tombstoneTimeoutMs, undefined, "tombstoneTimeoutMs incorrect");
-        });
-        it("IGCRuntimeOptions.sessionExpiryTimeoutMs", () => {
-            gc = createGcWithPrivateMembers(undefined /* metadata */, {
-                sessionExpiryTimeoutMs: 123,
-            });
-            assert.equal(gc.configs.sessionExpiryTimeoutMs, 123, "sessionExpiryTimeoutMs incorrect");
-            assert.equal(gc.sessionExpiryTimer.defaultTimeout, 123, "sessionExpiryTimer incorrect");
-            assert.equal(gc.configs.tombstoneTimeoutMs, 123 + 6 * oneDayMs, "tombstoneTimeoutMs incorrect");
-        });
-        it("IGCMetadata.sessionExpiryTimeoutMs, backfill tombstoneTimeoutMs", () => {
-            configProvider.set(testOverrideTombstoneTimeoutKey, 1337); // Should be ignored
-            gc = createGcWithPrivateMembers({ sessionExpiryTimeoutMs: 456 } /* metadata */);
-            assert.equal(gc.configs.sessionExpiryTimeoutMs, 456, "sessionExpiryTimeoutMs incorrect");
-            assert.equal(gc.sessionExpiryTimer.defaultTimeout, 456, "sessionExpiryTimer incorrect");
-            assert.equal(gc.configs.tombstoneTimeoutMs, 456 + 6 * oneDayMs, "tombstoneTimeoutMs incorrect");
-        });
-        it("IGCMetadata.sessionExpiryTimeoutMs and IGCMetadata.tombstoneTimeoutMs", () => {
-            configProvider.set(testOverrideTombstoneTimeoutKey, 1337); // Should be ignored
-            gc = createGcWithPrivateMembers({ sessionExpiryTimeoutMs: 456, tombstoneTimeoutMs: 789 } /* metadata */);
-            assert.equal(gc.configs.sessionExpiryTimeoutMs, 456, "sessionExpiryTimeoutMs incorrect");
-            assert.equal(gc.sessionExpiryTimer.defaultTimeout, 456, "sessionExpiryTimer incorrect");
-            assert.equal(gc.configs.tombstoneTimeoutMs, 789, "tombstoneTimeoutMs incorrect");
-        });
-        it("IGCMetadata.tombstoneTimeoutMs only", () => {
-            configProvider.set(testOverrideTombstoneTimeoutKey, 1337); // Should be ignored
-            // This could happen if you used TestOverride.TombstoneTimeoutMs but had SessionExpiry disabled, then loaded that container.
-            gc = createGcWithPrivateMembers({ tombstoneTimeoutMs: 789 } /* metadata */);
-            assert.equal(gc.configs.sessionExpiryTimeoutMs, undefined, "sessionExpiryTimeoutMs incorrect");
-            assert.equal(gc.sessionExpiryTimer, undefined, "sessionExpiryTimer incorrect");
-            assert.equal(gc.configs.tombstoneTimeoutMs, 789, "tombstoneTimeoutMs incorrect");
-        });
-        it("IGCMetadata.tombstoneTimeoutMs - backfill from sweepTimeoutMs", () => {
-            configProvider.set(testOverrideTombstoneTimeoutKey, 1337); // Should be ignored
-            const metadata = {
-                sweepTimeoutMs: 789, // Snapshot was generated by code built before the rename
-            };
-            gc = createGcWithPrivateMembers(metadata);
-            assert.equal(gc.configs.sessionExpiryTimeoutMs, undefined, "sessionExpiryTimeoutMs incorrect");
-            assert.equal(gc.sessionExpiryTimer, undefined, "sessionExpiryTimer incorrect");
-            assert.equal(gc.configs.tombstoneTimeoutMs, 789, "tombstoneTimeoutMs incorrect");
-        });
-        it("RunSessionExpiry setting turned off", () => {
-            configProvider.set(runSessionExpiryKey, false);
-            configProvider.set(testOverrideSessionExpiryMsKey, 123); // This override should be ignored
-            gc = createGcWithPrivateMembers();
-            assert.equal(gc.configs.sessionExpiryTimeoutMs, undefined, "sessionExpiryTimeoutMs should be undefined if runSessionExpiryKey setting is false");
-            assert.equal(gc.sessionExpiryTimer, undefined, "sessionExpiryTimer should be undefined if it's disabled");
-            assert.equal(gc.configs.tombstoneTimeoutMs, undefined, "tombstoneTimeoutMs incorrect");
-        });
-        it("RunSessionExpiry setting turned off, TestOverride.TombstoneTimeoutMs set", () => {
-            configProvider.set(runSessionExpiryKey, false);
-            configProvider.set(testOverrideTombstoneTimeoutKey, 7890);
-            configProvider.set(testOverrideSessionExpiryMsKey, 123); // This override should be ignored
-            gc = createGcWithPrivateMembers();
-            assert.equal(gc.configs.sessionExpiryTimeoutMs, undefined, "sessionExpiryTimeoutMs should be undefined if runSessionExpiryKey setting is false");
-            assert.equal(gc.sessionExpiryTimer, undefined, "sessionExpiryTimer should be undefined if it's disabled");
-            assert.equal(gc.configs.tombstoneTimeoutMs, 7890, "tombstoneTimeoutMs incorrect");
-        });
-        function testSessionExpiryMsOverride() {
-            const expectedTombstoneTimeoutMs = defaultSessionExpiryDurationMs + 6 * oneDayMs;
-            assert(!!gc, "PRECONDITION: gc must be set before calling this helper");
-            assert.equal(gc.configs.sessionExpiryTimeoutMs, defaultSessionExpiryDurationMs, "sessionExpiryTimeoutMs incorrect");
-            assert.equal(gc.sessionExpiryTimer.defaultTimeout, 789, "sessionExpiry used for timer should be the override value");
-            assert.equal(gc.configs.tombstoneTimeoutMs, expectedTombstoneTimeoutMs, "tombstoneTimeoutMs incorrect");
-            const expectedMetadata = {
-                sweepEnabled: false,
-                gcFeature: stableGCVersion,
-                sessionExpiryTimeoutMs: defaultSessionExpiryDurationMs,
-                tombstoneTimeoutMs: expectedTombstoneTimeoutMs,
-                gcFeatureMatrix: undefined,
-            };
-            const outputMetadata = gc.getMetadata();
-            assert.deepEqual(outputMetadata, expectedMetadata, "getMetadata returned different metadata than expected");
-        }
-        it("TestOverride.SessionExpiryMs setting applied to timeout but not written to file - New Container", () => {
-            configProvider.set(testOverrideSessionExpiryMsKey, 789);
-            gc = createGcWithPrivateMembers();
-            testSessionExpiryMsOverride();
-        });
-        it("TestOverride.SessionExpiryMs setting applied to timeout but not written to file - Existing Container", () => {
-            configProvider.set(testOverrideSessionExpiryMsKey, 789);
-            gc = createGcWithPrivateMembers({
-                sessionExpiryTimeoutMs: defaultSessionExpiryDurationMs,
-                gcFeature: 1,
-            } /* metadata */);
-            testSessionExpiryMsOverride();
-        });
-    });
-    describe("Session Behavior (e.g. 'shouldRun' fields)", () => {
-        beforeEach(() => {
-            configProvider.set("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs", 1); // To ensure it's less than tombstone timeout
-        });
-        describe("shouldRunGC", () => {
-            const testCases = [
-                { gcEnabled: false, disableGC: true, runGC: true, expectedResult: true },
-                { gcEnabled: true, disableGC: false, runGC: false, expectedResult: false },
-                { gcEnabled: true, disableGC: true, expectedResult: false },
-                { gcEnabled: true, disableGC: false, expectedResult: true },
-                { gcEnabled: true, expectedResult: true },
-                { gcEnabled: false, expectedResult: false },
-            ];
-            testCases.forEach((testCase) => {
-                it(`Test Case ${JSON.stringify(testCase)}`, () => {
-                    configProvider.set(runGCKey, testCase.runGC);
-                    gc = createGcWithPrivateMembers(undefined /* metadata */, {
-                        gcAllowed: testCase.gcEnabled,
-                        disableGC: testCase.disableGC,
-                    });
-                    assert.equal(gc.configs.gcEnabled, testCase.gcEnabled, "PRECONDITION: gcEnabled set incorrectly");
-                    assert.equal(gc.configs.shouldRunGC, testCase.expectedResult, "shouldRunGC not set as expected");
-                });
-            });
-            it("shouldRunGC should be true when gcVersionInEffect is newer than gcVersionInBaseSnapshot", () => {
-                const gcVersionInBaseSnapshot = stableGCVersion - 1;
-                gc = createGcWithPrivateMembers({ gcFeature: gcVersionInBaseSnapshot });
-                assert.equal(gc.configs.gcEnabled, true, "PRECONDITION: gcEnabled set incorrectly");
-                assert.equal(gc.configs.shouldRunGC, true, "shouldRunGC should be true");
-                assert.equal(gc.configs.gcVersionInBaseSnapshot, gcVersionInBaseSnapshot, "gcVersionInBaseSnapshot set incorrectly");
-            });
-            it("shouldRunGC should be false when gcVersionInEffect is older than gcVersionInBaseSnapshot", () => {
-                const gcVersionInBaseSnapshot = nextGCVersion + 1;
-                gc = createGcWithPrivateMembers({ gcFeature: gcVersionInBaseSnapshot });
-                assert.equal(gc.configs.gcEnabled, true, "PRECONDITION: gcEnabled set incorrectly");
-                assert.equal(gc.configs.shouldRunGC, false, "shouldRunGC should be false");
-                assert.equal(gc.configs.gcVersionInBaseSnapshot, gcVersionInBaseSnapshot, "gcVersionInBaseSnapshot set incorrectly");
-            });
-        });
-        describe("shouldRunSweep", () => {
-            const testCases = [
-                {
-                    shouldRunGC: false,
-                    sweepEnabled_doc: true,
-                    sweepEnabled_session: true,
-                    disableDataStoreSweep: "viaGCOption",
-                    shouldRunSweep: true,
-                    expectedShouldRunSweep: "NO",
-                },
-                {
-                    shouldRunGC: true,
-                    sweepEnabled_doc: false,
-                    sweepEnabled_session: true,
-                    disableDataStoreSweep: "viaGCOption",
-                    expectedShouldRunSweep: "NO",
-                },
-                {
-                    shouldRunGC: true,
-                    sweepEnabled_doc: true,
-                    sweepEnabled_session: false,
-                    disableDataStoreSweep: "viaGCOption",
-                    expectedShouldRunSweep: "NO",
-                },
-                {
-                    shouldRunGC: true,
-                    sweepEnabled_doc: true,
-                    sweepEnabled_session: true,
-                    shouldRunSweep: false,
-                    disableDataStoreSweep: "viaGCOption",
-                    expectedShouldRunSweep: "NO",
-                },
-                {
-                    shouldRunGC: true,
-                    sweepEnabled_doc: true,
-                    sweepEnabled_session: false,
-                    shouldRunSweep: true,
-                    expectedShouldRunSweep: "YES",
-                },
-                {
-                    shouldRunGC: true,
-                    sweepEnabled_doc: true,
-                    sweepEnabled_session: true,
-                    expectedShouldRunSweep: "YES",
-                },
-                {
-                    shouldRunGC: true,
-                    sweepEnabled_doc: true,
-                    sweepEnabled_session: true,
-                    disableDataStoreSweep: "viaGCOption",
-                    expectedShouldRunSweep: "ONLY_BLOBS",
-                },
-                {
-                    shouldRunGC: true,
-                    sweepEnabled_doc: true,
-                    sweepEnabled_session: true,
-                    disableDataStoreSweep: "viaConfigProvider",
-                    expectedShouldRunSweep: "ONLY_BLOBS",
-                },
-                {
-                    shouldRunGC: true,
-                    sweepEnabled_doc: true,
-                    sweepEnabled_session: true,
-                    shouldRunSweep: true,
-                    disableDataStoreSweep: "viaGCOption",
-                    expectedShouldRunSweep: "ONLY_BLOBS",
-                },
-            ];
-            testCases.forEach((testCase, index) => {
-                it(`Test Case ${JSON.stringify(testCase)}`, () => {
-                    configProvider.set(runGCKey, testCase.shouldRunGC);
-                    configProvider.set(runSweepKey, testCase.shouldRunSweep);
-                    configProvider.set(disableDatastoreSweepKey, testCase.disableDataStoreSweep === "viaConfigProvider");
-                    gc = createGcWithPrivateMembers({
-                        gcFeatureMatrix: { gcGeneration: 1 },
-                        sessionExpiryTimeoutMs: defaultSessionExpiryDurationMs,
-                    } /* metadata */, {
-                        [gcDisableDataStoreSweepOptionName]: testCase.disableDataStoreSweep === "viaGCOption",
-                        enableGCSweep: testCase.sweepEnabled_session ? true : undefined,
-                        [gcGenerationOptionName]: testCase.sweepEnabled_doc ? 1 : 2,
-                    } /* gcOptions */);
-                    assert.equal(gc.configs.shouldRunGC, testCase.shouldRunGC, "PRECONDITION: shouldRunGC set incorrectly");
-                    assert.equal(gc.configs.sweepEnabled, testCase.sweepEnabled_doc, "PRECONDITION: sweepEnabled set incorrectly");
-                    assert.equal(gc.configs.shouldRunSweep, testCase.expectedShouldRunSweep, `shouldRunSweep not set as expected`);
-                });
-            });
-        });
-        describe("inactiveTimeoutMs", () => {
-            beforeEach(() => {
-                // Remove setting added in outer describe block
-                configProvider.set("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs", undefined);
-            });
-            const testCases = [
-                { testOverride: 123, option: 456, expectedResult: 123 },
-                { option: 456, expectedResult: 456 },
-                { expectedResult: defaultInactiveTimeoutMs },
-            ];
-            testCases.forEach((testCase) => {
-                it(`Test Case ${JSON.stringify(testCase)}`, () => {
-                    configProvider.set("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs", testCase.testOverride);
-                    gc = createGcWithPrivateMembers(undefined /* metadata */, {
-                        inactiveTimeoutMs: testCase.option,
-                    });
-                    assert.equal(gc.configs.inactiveTimeoutMs, testCase.expectedResult, "inactiveTimeoutMs not set as expected");
-                });
-            });
-            it("inactiveTimeout must not be greater than tombstoneTimeout", () => {
-                configProvider.set("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs", Number.MAX_VALUE);
-                assert.throws(() => {
-                    gc = createGcWithPrivateMembers();
-                }, (e) => e.errorType === "usageError", "inactiveTimeout must not be greater than tombstoneTimeout");
-            });
-        });
-        describe("sweepGracePeriodMs", () => {
-            const testCases = [
-                { option: 123, expectedResult: 123 },
-                { option: 0, expectedResult: 0 },
-                { option: undefined, expectedResult: defaultSweepGracePeriodMs },
-            ];
-            testCases.forEach((testCase) => {
-                it(`Test Case ${JSON.stringify(testCase)}`, () => {
-                    gc = createGcWithPrivateMembers({} /* metadata */, {
-                        sweepGracePeriodMs: testCase.option,
-                    });
-                    assert.equal(gc.configs.sweepGracePeriodMs, testCase.expectedResult);
-                });
-            });
-            it("sweepGracePeriodMs must be non-negative", () => {
-                assert.throws(() => {
-                    gc = createGcWithPrivateMembers({} /* metadata */, {
-                        sweepGracePeriodMs: -1,
-                    });
-                }, (e) => e.errorType === "usageError", "sweepGracePeriodMs must be non-negative");
-            });
-        });
-        describe("testMode", () => {
-            const testCases = [
-                { setting: true, option: false, expectedResult: true },
-                { setting: false, option: true, expectedResult: false },
-                { option: true, expectedResult: true },
-                { expectedResult: false },
-            ];
-            testCases.forEach((testCase) => {
-                it(`Test Case ${JSON.stringify(testCase)}`, () => {
-                    configProvider.set(gcTestModeKey, testCase.setting);
-                    gc = createGcWithPrivateMembers(undefined /* metadata */, {
-                        runGCInTestMode: testCase.option,
-                    });
-                    assert.equal(gc.configs.testMode, testCase.expectedResult, "testMode not set as expected");
-                });
-            });
-        });
-    });
-    describe("throwOnTombstoneLoad (using new container)", () => {
-        beforeEach(() => {
-            configProvider.set(testOverrideSessionExpiryMsKey, defaultSessionExpiryDurationMs); // Required for sweep to be enabled
-        });
-        it("gcDisableThrowOnTombstoneLoad true", () => {
-            gc = createGcWithPrivateMembers(undefined /* metadata */, { enableGCSweep: true, [gcDisableThrowOnTombstoneLoadOptionName]: true }, false /* isSummarizerClient */);
-            assert.equal(gc.configs.throwOnTombstoneLoad, false, "throwOnTombstoneLoad incorrect");
-        });
-        it("gcDisableThrowOnTombstoneLoad false", () => {
-            gc = createGcWithPrivateMembers(undefined /* metadata */, { enableGCSweep: true, [gcDisableThrowOnTombstoneLoadOptionName]: false }, false /* isSummarizerClient */);
-            assert.equal(gc.configs.throwOnTombstoneLoad, true, "throwOnTombstoneLoad incorrect");
-        });
-        it("gcDisableThrowOnTombstoneLoad undefined", () => {
-            gc = createGcWithPrivateMembers(undefined /* metadata */, {
-                enableGCSweep: true,
-                [gcDisableThrowOnTombstoneLoadOptionName]: undefined,
-            }, false /* isSummarizerClient */);
-            assert.equal(gc.configs.throwOnTombstoneLoad, true, "throwOnTombstoneLoad incorrect");
-        });
-        it("gcDisableThrowOnTombstoneLoad undefined - Sweep Disabled does not interfere", () => {
-            configProvider.set(runSweepKey, false); // Disable Sweep
-            gc = createGcWithPrivateMembers(undefined /* metadata */, { [gcDisableThrowOnTombstoneLoadOptionName]: undefined }, false /* isSummarizerClient */);
-            assert.equal(gc.configs.throwOnTombstoneLoad, true, "throwOnTombstoneLoad incorrect");
-        });
-        it("Old 'enable' option false (ignored)", () => {
-            const gcThrowOnTombstoneLoadOptionName_old = "gcThrowOnTombstoneLoad";
-            gc = createGcWithPrivateMembers(undefined /* metadata */, { enableGCSweep: true, [gcThrowOnTombstoneLoadOptionName_old]: false }, false /* isSummarizerClient */);
-            assert.equal(gc.configs.throwOnTombstoneLoad, true, "throwOnTombstoneLoad incorrect");
-        });
-        it("throwOnTombstoneLoad enabled via override", () => {
-            configProvider.set(throwOnTombstoneLoadOverrideKey, true);
-            gc = createGcWithPrivateMembers(undefined /* metadata */, { enableGCSweep: true, [gcDisableThrowOnTombstoneLoadOptionName]: true }, false /* isSummarizerClient */);
-            assert.equal(gc.configs.throwOnTombstoneLoad, true, "throwOnTombstoneLoad incorrect");
-        });
-        it("throwOnTombstoneLoad disabled via override", () => {
-            configProvider.set(throwOnTombstoneLoadOverrideKey, false);
-            gc = createGcWithPrivateMembers(undefined /* metadata */, { enableGCSweep: true, [gcDisableThrowOnTombstoneLoadOptionName]: false }, false /* isSummarizerClient */);
-            assert.equal(gc.configs.throwOnTombstoneLoad, false, "throwOnTombstoneLoad incorrect");
-        });
-    });
-});
-//# sourceMappingURL=gcConfigs.spec.js.map