@fluidframework/test-utils 2.0.0-rc.1.0.6 → 2.0.0-rc.2.0.1

package/lib/testObjectProvider.js

@@ -0,0 +1,636 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { waitContainerToCatchUp as waitContainerToCatchUp_original, } from "@fluidframework/container-loader";
+import { v4 as uuid } from "uuid";
+import { createChildLogger, createMultiSinkLogger, } from "@fluidframework/telemetry-utils";
+import { LoaderContainerTracker } from "./loaderContainerTracker.js";
+import { LocalCodeLoader } from "./localCodeLoader.js";
+import { createAndAttachContainer } from "./localLoader.js";
+const defaultCodeDetails = {
+    package: "defaultTestPackage",
+    config: {},
+};
+/**
+ * @internal
+ */
+export var DataObjectFactoryType;
+(function (DataObjectFactoryType) {
+    DataObjectFactoryType[DataObjectFactoryType["Primed"] = 0] = "Primed";
+    DataObjectFactoryType[DataObjectFactoryType["Test"] = 1] = "Test";
+})(DataObjectFactoryType || (DataObjectFactoryType = {}));
+/**
+ * @internal
+ */
+export const createDocumentId = () => uuid();
+/**
+ * Document ID is treated differently by test drivers. The key difference is in generating
+ * a new container ID and accessing the container in multi-instance test cases.
+ */
+function getDocumentIdStrategy(type) {
+    let documentId = createDocumentId();
+    switch (type) {
+        case "odsp":
+            return {
+                get: () => documentId,
+                update: () => { },
+                reset: () => {
+                    documentId = createDocumentId();
+                },
+            };
+        default:
+            return {
+                get: () => documentId,
+                update: (resolvedUrl) => {
+                    // Extract the document ID from the resolved container's URL and reset the ID property
+                    documentId = resolvedUrl?.id ?? documentId;
+                },
+                reset: () => {
+                    documentId = createDocumentId();
+                },
+            };
+    }
+}
+/**
+ * This class tracks events. It allows specifying expected events, which will be looked for in order.
+ * 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
+ */
+export class EventAndErrorTrackingLogger {
+    constructor(baseLogger) {
+        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 = [];
+    }
+    registerExpectedEvent(...orderedExpectedEvents) {
+        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");
+        }
+        this.expectedEvents.push(...orderedExpectedEvents.map((event, index) => ({ index, event })));
+    }
+    send(event) {
+        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]) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches) {
+                // we found an expected event
+                // so remove it from the list of expected events
+                // and if it is an error, change it to generic
+                // this helps keep our telemetry clear of
+                // expected errors.
+                this.expectedEvents.shift();
+                if (event.category === "error") {
+                    event.category = "generic";
+                }
+            }
+        }
+        if (event.category === "error") {
+            // 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);
+    }
+    reportAndClearTrackedEvents() {
+        const expectedNotFound = this.expectedEvents.splice(0, this.expectedEvents.length);
+        const unexpectedErrors = this.unexpectedErrors.splice(0, this.unexpectedErrors.length);
+        return {
+            expectedNotFound,
+            unexpectedErrors,
+        };
+    }
+}
+/**
+ * Shared base class for test object provider.  Contain code for loader and container creation and loading
+ * @internal
+ */
+export class TestObjectProvider {
+    /**
+     * Manage objects for loading and creating container, including the driver, loader, and OpProcessingController
+     * @param createFluidEntryPoint - callback to create a fluidEntryPoint, with an optional set of channel name
+     * and factory for TestFluidObject
+     */
+    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();
+        // 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(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;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.createLoader}
+     */
+    createLoader(packageEntries, loaderProps) {
+        const logger = createMultiSinkLogger({
+            loggers: [this.logger, loaderProps?.logger],
+        });
+        const loader = new this.LoaderConstructor({
+            ...loaderProps,
+            logger,
+            codeLoader: loaderProps?.codeLoader ?? new LocalCodeLoader(packageEntries),
+            urlResolver: loaderProps?.urlResolver ?? this.urlResolver,
+            documentServiceFactory: loaderProps?.documentServiceFactory ?? this.documentServiceFactory,
+        });
+        this._loaderContainerTracker.add(loader);
+        return loader;
+    }
+    /**
+     * {@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 createAndAttachContainer(defaultCodeDetails, loader, this.driver.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.createDetachedContainer}
+     */
+    async createDetachedContainer(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);
+        return loader.createDetachedContainer(defaultCodeDetails);
+    }
+    /**
+     * {@inheritdoc ITestObjectProvider.attachDetachedContainer}
+     */
+    async attachDetachedContainer(container) {
+        if (this._documentCreated) {
+            throw new Error("Only one container/document can be created. To load the container/document use loadContainer");
+        }
+        await container.attach(this.driver.createCreateNewRequest(this.documentId));
+        this._documentCreated = true;
+        this._documentIdStrategy.update(container.resolvedUrl);
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.loadContainer}
+     */
+    async loadContainer(entryPoint, loaderProps, requestHeader) {
+        const loader = this.createLoader([[defaultCodeDetails, entryPoint]], loaderProps);
+        return this.resolveContainer(loader, requestHeader);
+    }
+    async resolveContainer(loader, headers) {
+        return loader.resolve({
+            url: await this.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.makeTestLoader(testContainerConfig);
+        const container = await createAndAttachContainer(defaultCodeDetails, loader, this.driver.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) {
+        const loader = this.makeTestLoader(testContainerConfig);
+        const container = await this.resolveContainer(loader, requestHeader);
+        await this.waitContainerToCatchUp(container);
+        return container;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.reset}
+     */
+    reset() {
+        this._loaderContainerTracker.reset();
+        this._documentServiceFactory = undefined;
+        this._urlResolver = undefined;
+        this._documentIdStrategy.reset();
+        const logError = getUnexpectedLogErrorException(this._logger);
+        if (logError) {
+            throw logError;
+        }
+        this._logger = undefined;
+        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 waitContainerToCatchUp_original(container);
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.updateDocumentId}
+     */
+    updateDocumentId(resolvedUrl) {
+        this._documentIdStrategy.update(resolvedUrl);
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.resetLoaderContainerTracker}
+     */
+    resetLoaderContainerTracker(syncSummarizerClients = false) {
+        this._loaderContainerTracker.reset();
+        this._loaderContainerTracker = new LoaderContainerTracker(syncSummarizerClients);
+    }
+}
+/**
+ * Implements {@link ITestObjectProvider}, but uses different versions to create and load containers.
+ *
+ * @internal
+ */
+export 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();
+        // Since documentId doesn't change we can only create/make one container. Call the load functions instead.
+        this._documentCreated = false;
+        /**
+         * Used to determine which APIs to use when creating a loader.
+         *
+         * The first load will always use the create APIs, and then useCreateApi will be set to false to ensure all
+         * subsequent loads use the load APIs.
+         */
+        this.useCreateApi = true;
+        this._documentIdStrategy = getDocumentIdStrategy(driverForCreating.type);
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.logger}
+     */
+    get logger() {
+        if (this._logger === undefined) {
+            this._logger = new EventAndErrorTrackingLogger(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.useCreateApi ? this.driverForCreating : this.driverForLoading;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.createFluidEntryPoint}
+     */
+    get createFluidEntryPoint() {
+        return this.useCreateApi
+            ? this.createFluidEntryPointForCreating
+            : this.createFluidEntryPointForLoading;
+    }
+    createLoaderForCreating(packageEntries, loaderProps) {
+        const logger = createMultiSinkLogger({
+            loggers: [this.logger, loaderProps?.logger],
+        });
+        const loader = new this.LoaderConstructorForCreating({
+            ...loaderProps,
+            logger,
+            codeLoader: loaderProps?.codeLoader ?? new LocalCodeLoader(packageEntries),
+            urlResolver: loaderProps?.urlResolver ?? this.urlResolver,
+            documentServiceFactory: loaderProps?.documentServiceFactory ?? this.documentServiceFactory,
+        });
+        this._loaderContainerTracker.add(loader);
+        return loader;
+    }
+    createLoaderForLoading(packageEntries, loaderProps) {
+        const logger = createMultiSinkLogger({
+            loggers: [this.logger, loaderProps?.logger],
+        });
+        const loader = new this.LoaderConstructorForLoading({
+            ...loaderProps,
+            logger,
+            codeLoader: loaderProps?.codeLoader ?? new LocalCodeLoader(packageEntries),
+            urlResolver: loaderProps?.urlResolver ?? this.urlResolver,
+            documentServiceFactory: loaderProps?.documentServiceFactory ?? this.documentServiceFactory,
+        });
+        this._loaderContainerTracker.add(loader);
+        return loader;
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.createLoader}
+     */
+    createLoader(packageEntries, loaderProps) {
+        if (this.useCreateApi) {
+            // After we create the first loader, we can set this.useCreateApi to false.
+            this.useCreateApi = false;
+            return this.createLoaderForCreating(packageEntries, loaderProps);
+        }
+        return 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 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.createDetachedContainer}
+     */
+    async createDetachedContainer(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);
+        return loader.createDetachedContainer(defaultCodeDetails);
+    }
+    /**
+     * {@inheritdoc ITestObjectProvider.attachDetachedContainer}
+     */
+    async attachDetachedContainer(container) {
+        if (this._documentCreated) {
+            throw new Error("Only one container/document can be created. To load the container/document use loadContainer");
+        }
+        await container.attach(this.driver.createCreateNewRequest(this.documentId));
+        this._documentCreated = true;
+        this._documentIdStrategy.update(container.resolvedUrl);
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.loadContainer}
+     */
+    async loadContainer(entryPoint, loaderProps, requestHeader) {
+        const driver = this.useCreateApi ? 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 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.useCreateApi ? 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.useCreateApi = true;
+        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 waitContainerToCatchUp_original(container);
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.updateDocumentId}
+     */
+    updateDocumentId(resolvedUrl) {
+        this._documentIdStrategy.update(resolvedUrl);
+    }
+    /**
+     * {@inheritDoc ITestObjectProvider.resetLoaderContainerTracker}
+     */
+    resetLoaderContainerTracker(syncSummarizerClients = false) {
+        this._loaderContainerTracker.reset();
+        this._loaderContainerTracker = new LoaderContainerTracker(syncSummarizerClients);
+    }
+}
+/**
+ * @internal
+ */
+export function getUnexpectedLogErrorException(logger, prefix) {
+    if (logger === undefined) {
+        return;
+    }
+    const results = logger.reportAndClearTrackedEvents();
+    if (results.unexpectedErrors.length > 0) {
+        return new Error(`${prefix ?? ""}Unexpected Errors in Logs:\n${JSON.stringify(results.unexpectedErrors, undefined, 2)}`);
+    }
+    if (results.expectedNotFound.length > 0) {
+        return new Error(`${prefix ?? ""}Expected Events not found:\n${JSON.stringify(results.expectedNotFound, undefined, 2)}`);
+    }
+}
+//# sourceMappingURL=testObjectProvider.js.map