@fluidframework/test-utils 1.4.0-115997 → 2.0.0-dev-rc.1.0.0.224419

package/dist/testObjectProvider.js

@@ -4,9 +4,8 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUnexpectedLogErrorException = exports.TestObjectProvider = exports.EventAndErrorTrackingLogger = exports.createDocumentId = exports.DataObjectFactoryType = void 0;
+exports.getUnexpectedLogErrorException = exports.TestObjectProviderWithVersionedLoad = exports.TestObjectProvider = exports.EventAndErrorTrackingLogger = exports.createDocumentId = exports.DataObjectFactoryType = void 0;
 const container_loader_1 = require("@fluidframework/container-loader");
-const driver_utils_1 = require("@fluidframework/driver-utils");
 const uuid_1 = require("uuid");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 const loaderContainerTracker_1 = require("./loaderContainerTracker");
@@ -16,11 +15,17 @@ const defaultCodeDetails = {
     package: "defaultTestPackage",
     config: {},
 };
+/**
+ * @internal
+ */
 var DataObjectFactoryType;
 (function (DataObjectFactoryType) {
     DataObjectFactoryType[DataObjectFactoryType["Primed"] = 0] = "Primed";
     DataObjectFactoryType[DataObjectFactoryType["Test"] = 1] = "Test";
-})(DataObjectFactoryType = exports.DataObjectFactoryType || (exports.DataObjectFactoryType = {}));
+})(DataObjectFactoryType || (exports.DataObjectFactoryType = DataObjectFactoryType = {}));
+/**
+ * @internal
+ */
 const createDocumentId = () => (0, uuid_1.v4)();
 exports.createDocumentId = createDocumentId;
 /**
@@ -34,18 +39,20 @@ function getDocumentIdStrategy(type) {
             return {
                 get: () => documentId,
                 update: () => { },
-                reset: () => { documentId = (0, exports.createDocumentId)(); },
+                reset: () => {
+                    documentId = (0, exports.createDocumentId)();
+                },
             };
         default:
             return {
                 get: () => documentId,
                 update: (resolvedUrl) => {
-                    var _a;
                     // Extract the document ID from the resolved container's URL and reset the ID property
-                    (0, driver_utils_1.ensureFluidResolvedUrl)(resolvedUrl);
-                    documentId = (_a = resolvedUrl.id) !== null && _a !== void 0 ? _a : documentId;
+                    documentId = resolvedUrl?.id ?? documentId;
+                },
+                reset: () => {
+                    documentId = (0, exports.createDocumentId)();
                 },
-                reset: () => { documentId = (0, exports.createDocumentId)(); },
             };
     }
 }
@@ -54,11 +61,24 @@ function getDocumentIdStrategy(type) {
  * It also tracks all unexpected errors.
  * At any point you call reportAndClearTrackedEvents which will provide all unexpected errors, and
  * any expected events that have not occurred.
+ * @internal
  */
-class EventAndErrorTrackingLogger extends telemetry_utils_1.TelemetryLogger {
+class EventAndErrorTrackingLogger {
     constructor(baseLogger) {
-        super();
         this.baseLogger = baseLogger;
+        /**
+         * Even if these error events are logged, tests should still be allowed to pass
+         * Additionally, if downgrade is true, then log as generic (e.g. to avoid polluting the e2e test logs)
+         */
+        this.allowedErrors = [
+            // This log was removed in current version as unnecessary, but it's still present in previous versions
+            {
+                eventName: "fluid:telemetry:Container:NoRealStorageInDetachedContainer",
+                downgrade: true,
+            },
+            // This log's category changes depending on the op latency. test results shouldn't be affected but if we see lots we'd like an alert from the logs.
+            { eventName: "fluid:telemetry:OpPerf:OpRoundtripTime" },
+        ];
         this.expectedEvents = [];
         this.unexpectedErrors = [];
     }
@@ -66,15 +86,14 @@ class EventAndErrorTrackingLogger extends telemetry_utils_1.TelemetryLogger {
         if (this.expectedEvents.length !== 0) {
             // we don't have to error here. just no reason not to. given the events must be
             // ordered it could be tricky to figure out problems around multiple registrations.
-            throw new Error("Expected events already registered.\n"
-                + "Call reportAndClearTrackedEvents to clear them before registering more");
+            throw new Error("Expected events already registered.\n" +
+                "Call reportAndClearTrackedEvents to clear them before registering more");
         }
         this.expectedEvents.push(...orderedExpectedEvents.map((event, index) => ({ index, event })));
     }
     send(event) {
-        var _a;
-        const ee = (_a = this.expectedEvents[0]) === null || _a === void 0 ? void 0 : _a.event;
-        if ((ee === null || ee === void 0 ? void 0 : ee.eventName) === event.eventName) {
+        const ee = this.expectedEvents[0]?.event;
+        if (ee?.eventName === event.eventName) {
             let matches = true;
             for (const key of Object.keys(ee)) {
                 if (ee[key] !== event[key]) {
@@ -95,7 +114,14 @@ class EventAndErrorTrackingLogger extends telemetry_utils_1.TelemetryLogger {
             }
         }
         if (event.category === "error") {
-            this.unexpectedErrors.push(event);
+            // Check to see if this error is allowed and if its category should be downgraded
+            const allowedError = this.allowedErrors.find(({ eventName }) => eventName === event.eventName);
+            if (allowedError === undefined) {
+                this.unexpectedErrors.push(event);
+            }
+            else if (allowedError.downgrade) {
+                event.category = "generic";
+            }
         }
         this.baseLogger.send(event);
     }
@@ -111,6 +137,7 @@ class EventAndErrorTrackingLogger extends telemetry_utils_1.TelemetryLogger {
 exports.EventAndErrorTrackingLogger = EventAndErrorTrackingLogger;
 /**
  * Shared base class for test object provider.  Contain code for loader and container creation and loading
+ * @internal
  */
 class TestObjectProvider {
     /**
@@ -118,76 +145,104 @@ class TestObjectProvider {
      * @param createFluidEntryPoint - callback to create a fluidEntryPoint, with an optional set of channel name
      * and factory for TestFluidObject
      */
-    constructor(LoaderConstructor, driver, createFluidEntryPoint) {
+    constructor(LoaderConstructor, 
+    /**
+     * {@inheritDoc ITestObjectProvider.driver}
+     */
+    driver, 
+    /**
+     * {@inheritDoc ITestObjectProvider.createFluidEntryPoint}
+     */
+    createFluidEntryPoint) {
         this.LoaderConstructor = LoaderConstructor;
         this.driver = driver;
         this.createFluidEntryPoint = createFluidEntryPoint;
+        /**
+         * {@inheritDoc ITestObjectProvider."type"}
+         */
+        this.type = "TestObjectProvider";
         this._loaderContainerTracker = new loaderContainerTracker_1.LoaderContainerTracker();
         // Since documentId doesn't change we can only create/make one container. Call the load functions instead.
         this._documentCreated = false;
         this._documentIdStrategy = getDocumentIdStrategy(driver.type);
     }
+    /**
+     * {@inheritDoc ITestObjectProvider.logger}
+     */
     get logger() {
         if (this._logger === undefined) {
-            this._logger = new EventAndErrorTrackingLogger(telemetry_utils_1.ChildLogger.create(getTestLogger === null || getTestLogger === void 0 ? void 0 : getTestLogger(), undefined, {
-                all: {
-                    driverType: this.driver.type,
-                    driverEndpointName: this.driver.endpointName,
-                    driverTenantName: this.driver.tenantName,
-                    driverUserIndex: this.driver.userIndex,
+            this._logger = new EventAndErrorTrackingLogger((0, telemetry_utils_1.createChildLogger)({
+                logger: getTestLogger?.(),
+                properties: {
+                    all: {
+                        driverType: this.driver.type,
+                        driverEndpointName: this.driver.endpointName,
+                        driverTenantName: this.driver.tenantName,
+                        driverUserIndex: this.driver.userIndex,
+                    },
                 },
             }));
         }
         return this._logger;
     }
+    set logger(logger) {
+        this._logger = logger;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.documentServiceFactory}
+     */
     get documentServiceFactory() {
         if (!this._documentServiceFactory) {
             this._documentServiceFactory = this.driver.createDocumentServiceFactory();
         }
         return this._documentServiceFactory;
     }
+    /**
+     * {@inheritDoc ITestObjectProvider.urlResolver}
+     */
     get urlResolver() {
         if (!this._urlResolver) {
             this._urlResolver = this.driver.createUrlResolver();
         }
         return this._urlResolver;
     }
+    /**
+     * {@inheritDoc ITestObjectProvider.documentId}
+     */
     get documentId() {
         return this._documentIdStrategy.get();
     }
+    /**
+     * {@inheritDoc ITestObjectProvider.defaultCodeDetails}
+     */
     get defaultCodeDetails() {
         return defaultCodeDetails;
     }
+    /**
+     * {@inheritDoc ITestObjectProvider.opProcessingController}
+     */
     get opProcessingController() {
         return this._loaderContainerTracker;
     }
     /**
-     * Create a loader. Containers created/loaded through this loader will be added to the OpProcessingController.
-     *
-     * Only the version of the loader will vary based on compat config. The version of
-     * containerRuntime/dataRuntime used in fluidEntryPoint will be used as is from what is passed in.
-     *
-     * @param packageEntries - list of code details and fluidEntryPoint pairs.
+     * {@inheritDoc ITestObjectProvider.createLoader}
      */
     createLoader(packageEntries, loaderProps) {
-        var _a, _b, _c;
-        const multiSinkLogger = new telemetry_utils_1.MultiSinkLogger();
-        multiSinkLogger.addLogger(this.logger);
-        if ((loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.logger) !== undefined) {
-            multiSinkLogger.addLogger(loaderProps.logger);
-        }
-        const loader = new this.LoaderConstructor(Object.assign(Object.assign({}, loaderProps), { logger: multiSinkLogger, codeLoader: (_a = loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.codeLoader) !== null && _a !== void 0 ? _a : new localCodeLoader_1.LocalCodeLoader(packageEntries), urlResolver: (_b = loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.urlResolver) !== null && _b !== void 0 ? _b : this.urlResolver, documentServiceFactory: (_c = loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.documentServiceFactory) !== null && _c !== void 0 ? _c : this.documentServiceFactory }));
+        const logger = (0, telemetry_utils_1.createMultiSinkLogger)({
+            loggers: [this.logger, loaderProps?.logger],
+        });
+        const loader = new this.LoaderConstructor({
+            ...loaderProps,
+            logger,
+            codeLoader: loaderProps?.codeLoader ?? new localCodeLoader_1.LocalCodeLoader(packageEntries),
+            urlResolver: loaderProps?.urlResolver ?? this.urlResolver,
+            documentServiceFactory: loaderProps?.documentServiceFactory ?? this.documentServiceFactory,
+        });
         this._loaderContainerTracker.add(loader);
         return loader;
     }
     /**
-     * Create a container using a default document id and code details.
-     * Container created is automatically added to the OpProcessingController to manage op flow
-     *
-     * Only the version of the loader will vary based on compat config. The version of
-     * containerRuntime/dataRuntime used in fluidEntryPoint will be used as is from what is passed in.
-     *
-     * @param packageEntries - list of code details and fluidEntryPoint pairs.
+     * {@inheritDoc ITestObjectProvider.createContainer}
      */
     async createContainer(entryPoint, loaderProps) {
         if (this._documentCreated) {
@@ -201,22 +256,27 @@ class TestObjectProvider {
         this._documentIdStrategy.update(container.resolvedUrl);
         return container;
     }
+    /**
+     * {@inheritDoc ITestObjectProvider.loadContainer}
+     */
     async loadContainer(entryPoint, loaderProps, requestHeader) {
         const loader = this.createLoader([[defaultCodeDetails, entryPoint]], loaderProps);
-        return loader.resolve({ url: await this.driver.createContainerUrl(this.documentId), headers: requestHeader });
+        return this.resolveContainer(loader, requestHeader);
+    }
+    async resolveContainer(loader, headers) {
+        return loader.resolve({
+            url: await this.driver.createContainerUrl(this.documentId),
+            headers,
+        });
     }
     /**
-     * Make a test loader. Containers created/loaded through this loader will be added to the OpProcessingController.
-     * The version of the loader/containerRuntime/dataRuntime may vary based on compat config of the current run
-     * @param testContainerConfig - optional configuring the test Container
+     * {@inheritDoc ITestObjectProvider.makeTestLoader}
      */
     makeTestLoader(testContainerConfig) {
-        return this.createLoader([[defaultCodeDetails, this.createFluidEntryPoint(testContainerConfig)]], testContainerConfig === null || testContainerConfig === void 0 ? void 0 : testContainerConfig.loaderProps);
+        return this.createLoader([[defaultCodeDetails, this.createFluidEntryPoint(testContainerConfig)]], testContainerConfig?.loaderProps);
     }
     /**
-     * Make a container using a default document id and code details
-     * Container loaded is automatically added to the OpProcessingController to manage op flow
-     * @param testContainerConfig - optional configuring the test Container
+     * {@inheritDoc ITestObjectProvider.makeTestContainer}
      */
     async makeTestContainer(testContainerConfig) {
         if (this._documentCreated) {
@@ -231,20 +291,17 @@ class TestObjectProvider {
         return container;
     }
     /**
-     * Load a container using a default document id and code details.
-     * IContainer loaded is automatically added to the OpProcessingController to manage op flow
-     * @param testContainerConfig - optional configuring the test Container
-     * @param requestHeader - optional headers to be supplied to the loader
+     * {@inheritDoc ITestObjectProvider.loadTestContainer}
      */
     async loadTestContainer(testContainerConfig, requestHeader) {
         const loader = this.makeTestLoader(testContainerConfig);
-        const container = await loader.resolve({
-            url: await this.driver.createContainerUrl(this.documentId),
-            headers: requestHeader,
-        });
+        const container = await this.resolveContainer(loader, requestHeader);
         await this.waitContainerToCatchUp(container);
         return container;
     }
+    /**
+     * {@inheritDoc ITestObjectProvider.reset}
+     */
     reset() {
         this._loaderContainerTracker.reset();
         this._documentServiceFactory = undefined;
@@ -257,6 +314,9 @@ class TestObjectProvider {
         this._logger = undefined;
         this._documentCreated = false;
     }
+    /**
+     * {@inheritDoc ITestObjectProvider.ensureSynchronized}
+     */
     async ensureSynchronized() {
         return this._loaderContainerTracker.ensureSynchronized();
     }
@@ -270,25 +330,281 @@ class TestObjectProvider {
         }
         return (0, container_loader_1.waitContainerToCatchUp)(container);
     }
+    /**
+     * {@inheritDoc ITestObjectProvider.updateDocumentId}
+     */
     updateDocumentId(resolvedUrl) {
         this._documentIdStrategy.update(resolvedUrl);
     }
+    /**
+     * {@inheritDoc ITestObjectProvider.resetLoaderContainerTracker}
+     */
     resetLoaderContainerTracker(syncSummarizerClients = false) {
         this._loaderContainerTracker.reset();
         this._loaderContainerTracker = new loaderContainerTracker_1.LoaderContainerTracker(syncSummarizerClients);
     }
 }
 exports.TestObjectProvider = TestObjectProvider;
+/**
+ * Implements {@link ITestObjectProvider}, but uses different versions to create and load containers.
+ *
+ * @internal
+ */
+class TestObjectProviderWithVersionedLoad {
+    constructor(LoaderConstructorForCreating, LoaderConstructorForLoading, driverForCreating, driverForLoading, createFluidEntryPointForCreating, createFluidEntryPointForLoading) {
+        this.LoaderConstructorForCreating = LoaderConstructorForCreating;
+        this.LoaderConstructorForLoading = LoaderConstructorForLoading;
+        this.driverForCreating = driverForCreating;
+        this.driverForLoading = driverForLoading;
+        this.createFluidEntryPointForCreating = createFluidEntryPointForCreating;
+        this.createFluidEntryPointForLoading = createFluidEntryPointForLoading;
+        /**
+         * {@inheritDoc ITestObjectProvider."type"}
+         */
+        this.type = "TestObjectProviderWithVersionedLoad";
+        this._loaderContainerTracker = new loaderContainerTracker_1.LoaderContainerTracker();
+        // Since documentId doesn't change we can only create/make one container. Call the load functions instead.
+        this._documentCreated = false;
+        /**
+         * `_loadCount` is used to alternate which version we load the next container with.
+         * loadCount is even then we will load with the "create" version, and if odd we load with the "load" version.
+         * After each test we will reset loadCount to 0 to ensure we always create the first container with the create version.
+         *
+         * Note: This will only affect tests that load a container more than two times.
+         */
+        this._loadCount = 0;
+        this._documentIdStrategy = getDocumentIdStrategy(driverForCreating.type);
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.logger}
+     */
+    get logger() {
+        if (this._logger === undefined) {
+            this._logger = new EventAndErrorTrackingLogger((0, telemetry_utils_1.createChildLogger)({
+                logger: getTestLogger?.(),
+            }));
+        }
+        return this._logger;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.documentServiceFactory}
+     */
+    get documentServiceFactory() {
+        if (!this._documentServiceFactory) {
+            this._documentServiceFactory = this.driverForCreating.createDocumentServiceFactory();
+        }
+        return this._documentServiceFactory;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.urlResolver}
+     */
+    get urlResolver() {
+        if (!this._urlResolver) {
+            this._urlResolver = this.driverForCreating.createUrlResolver();
+        }
+        return this._urlResolver;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.documentId}
+     */
+    get documentId() {
+        return this._documentIdStrategy.get();
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.defaultCodeDetails}
+     */
+    get defaultCodeDetails() {
+        return defaultCodeDetails;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.opProcessingController}
+     */
+    get opProcessingController() {
+        return this._loaderContainerTracker;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.driver}
+     */
+    get driver() {
+        return this.nextLoaderShouldCreate() ? this.driverForCreating : this.driverForLoading;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.createFluidEntryPoint}
+     */
+    get createFluidEntryPoint() {
+        return this.nextLoaderShouldCreate()
+            ? this.createFluidEntryPointForCreating
+            : this.createFluidEntryPointForLoading;
+    }
+    createLoaderForCreating(packageEntries, loaderProps) {
+        const logger = (0, telemetry_utils_1.createMultiSinkLogger)({
+            loggers: [this.logger, loaderProps?.logger],
+        });
+        const loader = new this.LoaderConstructorForCreating({
+            ...loaderProps,
+            logger,
+            codeLoader: loaderProps?.codeLoader ?? new localCodeLoader_1.LocalCodeLoader(packageEntries),
+            urlResolver: loaderProps?.urlResolver ?? this.urlResolver,
+            documentServiceFactory: loaderProps?.documentServiceFactory ?? this.documentServiceFactory,
+        });
+        this._loaderContainerTracker.add(loader);
+        return loader;
+    }
+    createLoaderForLoading(packageEntries, loaderProps) {
+        const logger = (0, telemetry_utils_1.createMultiSinkLogger)({
+            loggers: [this.logger, loaderProps?.logger],
+        });
+        const loader = new this.LoaderConstructorForLoading({
+            ...loaderProps,
+            logger,
+            codeLoader: loaderProps?.codeLoader ?? new localCodeLoader_1.LocalCodeLoader(packageEntries),
+            urlResolver: loaderProps?.urlResolver ?? this.urlResolver,
+            documentServiceFactory: loaderProps?.documentServiceFactory ?? this.documentServiceFactory,
+        });
+        this._loaderContainerTracker.add(loader);
+        return loader;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.createLoader}
+     */
+    createLoader(packageEntries, loaderProps) {
+        return this.nextLoaderShouldCreate(/** increment */ true)
+            ? this.createLoaderForCreating(packageEntries, loaderProps)
+            : this.createLoaderForLoading(packageEntries, loaderProps);
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.createContainer}
+     */
+    async createContainer(entryPoint, loaderProps) {
+        if (this._documentCreated) {
+            throw new Error("Only one container/document can be created. To load the container/document use loadContainer");
+        }
+        const loader = this.createLoader([[defaultCodeDetails, entryPoint]], loaderProps);
+        const container = await (0, localLoader_1.createAndAttachContainer)(defaultCodeDetails, loader, this.driverForCreating.createCreateNewRequest(this.documentId));
+        this._documentCreated = true;
+        // r11s driver will generate a new ID for the new container.
+        // update the document ID with the actual ID of the attached container.
+        this._documentIdStrategy.update(container.resolvedUrl);
+        return container;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.loadContainer}
+     */
+    async loadContainer(entryPoint, loaderProps, requestHeader) {
+        const driver = this.nextLoaderShouldCreate()
+            ? this.driverForCreating
+            : this.driverForLoading;
+        const loader = this.createLoader([[defaultCodeDetails, entryPoint]], loaderProps);
+        return this.resolveContainer(loader, requestHeader, driver);
+    }
+    async resolveContainer(loader, headers, driver) {
+        return loader.resolve({
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            url: await driver.createContainerUrl(this.documentId),
+            headers,
+        });
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.makeTestLoader}
+     */
+    makeTestLoader(testContainerConfig) {
+        return this.createLoader([[defaultCodeDetails, this.createFluidEntryPoint(testContainerConfig)]], testContainerConfig?.loaderProps);
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.makeTestContainer}
+     */
+    async makeTestContainer(testContainerConfig) {
+        if (this._documentCreated) {
+            throw new Error("Only one container/document can be created. To load the container/document use loadTestContainer");
+        }
+        const loader = this.createLoader([[defaultCodeDetails, this.createFluidEntryPoint(testContainerConfig)]], testContainerConfig?.loaderProps);
+        const container = await (0, localLoader_1.createAndAttachContainer)(defaultCodeDetails, loader, this.driverForCreating.createCreateNewRequest(this.documentId));
+        this._documentCreated = true;
+        // r11s driver will generate a new ID for the new container.
+        // update the document ID with the actual ID of the attached container.
+        this._documentIdStrategy.update(container.resolvedUrl);
+        return container;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.loadTestContainer}
+     */
+    async loadTestContainer(testContainerConfig, requestHeader) {
+        // Keep track of which Loader we are about to use so we can pass the correct driver through
+        const driver = this.nextLoaderShouldCreate()
+            ? this.driverForCreating
+            : this.driverForLoading;
+        const loader = this.makeTestLoader(testContainerConfig);
+        const container = await this.resolveContainer(loader, requestHeader, driver);
+        await this.waitContainerToCatchUp(container);
+        return container;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.reset}
+     */
+    reset() {
+        this._loadCount = 0;
+        this._loaderContainerTracker.reset();
+        this._logger = undefined;
+        this._documentServiceFactory = undefined;
+        this._urlResolver = undefined;
+        this._documentIdStrategy.reset();
+        const logError = getUnexpectedLogErrorException(this._logger);
+        if (logError) {
+            throw logError;
+        }
+        this._documentCreated = false;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.ensureSynchronized}
+     */
+    async ensureSynchronized() {
+        return this._loaderContainerTracker.ensureSynchronized();
+    }
+    async waitContainerToCatchUp(container) {
+        // The original waitContainerToCatchUp() from container loader uses either Container.resume()
+        // or Container.connect() as part of its implementation. However, resume() was deprecated
+        // and eventually replaced with connect(). To avoid issues during LTS compatibility testing
+        // with older container versions issues, we use resume() when connect() is unavailable.
+        if (container.connect === undefined) {
+            container.connect = container.resume;
+        }
+        return (0, container_loader_1.waitContainerToCatchUp)(container);
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.updateDocumentId}
+     */
+    updateDocumentId(resolvedUrl) {
+        this._documentIdStrategy.update(resolvedUrl);
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.resetLoaderContainerTracker}
+     */
+    resetLoaderContainerTracker(syncSummarizerClients = false) {
+        this._loaderContainerTracker.reset();
+        this._loaderContainerTracker = new loaderContainerTracker_1.LoaderContainerTracker(syncSummarizerClients);
+    }
+    nextLoaderShouldCreate(increment = false) {
+        const shouldCreate = this._loadCount % 2 === 0;
+        if (increment) {
+            this._loadCount++;
+        }
+        return shouldCreate;
+    }
+}
+exports.TestObjectProviderWithVersionedLoad = TestObjectProviderWithVersionedLoad;
+/**
+ * @internal
+ */
 function getUnexpectedLogErrorException(logger, prefix) {
     if (logger === undefined) {
         return;
     }
     const results = logger.reportAndClearTrackedEvents();
     if (results.unexpectedErrors.length > 0) {
-        return new Error(`${prefix !== null && prefix !== void 0 ? prefix : ""}Unexpected Errors in Logs:\n${JSON.stringify(results.unexpectedErrors, undefined, 2)}`);
+        return new Error(`${prefix ?? ""}Unexpected Errors in Logs:\n${JSON.stringify(results.unexpectedErrors, undefined, 2)}`);
     }
     if (results.expectedNotFound.length > 0) {
-        return new Error(`${prefix !== null && prefix !== void 0 ? prefix : ""}Expected Events not found:\n${JSON.stringify(results.expectedNotFound, undefined, 2)}`);
+        return new Error(`${prefix ?? ""}Expected Events not found:\n${JSON.stringify(results.expectedNotFound, undefined, 2)}`);
     }
 }
 exports.getUnexpectedLogErrorException = getUnexpectedLogErrorException;