@fluidframework/azure-end-to-end-tests 1.1.0-101037

package/src/test/ddsTests.spec.ts

@@ -0,0 +1,246 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { strict as assert } from "assert";
+import { IFluidHandle } from "@fluidframework/core-interfaces";
+import { ContainerSchema } from "@fluidframework/fluid-static";
+import { SharedMap } from "@fluidframework/map";
+import { timeoutPromise } from "@fluidframework/test-utils";
+import { AzureClient } from "@fluidframework/azure-client";
+import { createAzureClient } from "./AzureClientFactory";
+import { TestDataObject, CounterTestDataObject } from "./TestDataObject";
+import { mapWait } from "./utils";
+
+describe("Fluid data updates", () => {
+    const connectTimeoutMs = 1000;
+    let client: AzureClient;
+    let schema: ContainerSchema;
+
+    beforeEach(() => {
+        client = createAzureClient();
+        schema = {
+            initialObjects: {
+                map1: SharedMap,
+            },
+        };
+    });
+
+    /**
+     * Scenario: test when an Azure Client container is created,
+     * it can set the initial objects.
+     *
+     * Expected behavior: an error should not be thrown nor should a rejected promise
+     * be returned.
+     */
+    it("can set DDSes as initial objects for a container", async () => {
+        const { container: newContainer } = await client.createContainer(schema);
+        const containerId = await newContainer.attach();
+
+        await timeoutPromise((resolve) => newContainer.once("connected", () => resolve()), {
+            durationMs: connectTimeoutMs,
+            errorMsg: "container connect() timeout",
+        });
+
+        const resources = client.getContainer(containerId, schema);
+        await assert.doesNotReject(
+            resources,
+            () => true,
+            "container cannot be retrieved from Azure Fluid Relay",
+        );
+
+        const { container } = await resources;
+        assert.deepStrictEqual(
+            Object.keys(container.initialObjects),
+            Object.keys(schema.initialObjects),
+        );
+    });
+
+    /**
+     * Scenario: test if initialObjects passed into the container functions correctly.
+     *
+     * Expected behavior: initialObjects value loaded in two different containers should mirror
+     * each other after value is changed.
+     */
+    it("can change DDSes within initialObjects value", async () => {
+        const { container } = await client.createContainer(schema);
+        const containerId = await container.attach();
+
+        await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+            durationMs: connectTimeoutMs,
+            errorMsg: "container connect() timeout",
+        });
+
+        const initialObjectsCreate = container.initialObjects;
+        const map1Create = initialObjectsCreate.map1 as SharedMap;
+        map1Create.set("new-key", "new-value");
+        const valueCreate: string | undefined = map1Create.get("new-key");
+
+        const { container: containerGet } = await client.getContainer(containerId, schema);
+        const map1Get = containerGet.initialObjects.map1 as SharedMap;
+        const valueGet: string | undefined = await mapWait(map1Get, "new-key");
+        assert.strictEqual(valueGet, valueCreate, "container can't change initial objects");
+    });
+
+    /**
+     * Scenario: test if we can create DataObjects through initialObjects schema.
+     *
+     * Expected behavior: DataObjects can be retrieved from the original and loaded container.
+     */
+    it("can set DataObjects as initial objects for a container", async () => {
+        const doSchema: ContainerSchema = {
+            initialObjects: {
+                mdo1: TestDataObject,
+                mdo2: CounterTestDataObject,
+            },
+        };
+        const { container } = await client.createContainer(doSchema);
+        const containerId = await container.attach();
+
+        await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+            durationMs: connectTimeoutMs,
+            errorMsg: "container connect() timeout",
+        });
+
+        const initialObjectsCreate = container.initialObjects;
+        assert(
+            initialObjectsCreate.mdo1 instanceof TestDataObject,
+            "container returns the wrong type for mdo1",
+        );
+        assert(
+            initialObjectsCreate.mdo2 instanceof CounterTestDataObject,
+            "container returns the wrong type for mdo2",
+        );
+
+        const { container: containerGet } = await client.getContainer(containerId, doSchema);
+        const initialObjectsGet = containerGet.initialObjects;
+        assert(
+            initialObjectsGet.mdo1 instanceof TestDataObject,
+            "container returns the wrong type for mdo1",
+        );
+        assert(
+            initialObjectsCreate.mdo2 instanceof CounterTestDataObject,
+            "container returns the wrong type for mdo2",
+        );
+    });
+
+    /**
+     * Scenario: test if we can create multiple DataObjects of the same type
+     *
+     * Expected behavior: DataObjects of the same type can be retrieved from the
+     * original and loaded container.
+     * TODO: Known bug that needs to be re-tested once fixed.
+     */
+    it("can use multiple DataObjects of the same type", async () => {
+        const doSchema: ContainerSchema = {
+            initialObjects: {
+                mdo1: TestDataObject,
+                mdo2: CounterTestDataObject,
+                mdo3: CounterTestDataObject,
+            },
+        };
+        const { container } = await client.createContainer(doSchema);
+        const containerId = await container.attach();
+
+        await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+            durationMs: connectTimeoutMs,
+            errorMsg: "container connect() timeout",
+        });
+
+        const initialObjectsCreate = container.initialObjects;
+        assert(
+            initialObjectsCreate.mdo1 instanceof TestDataObject,
+            "container returns the wrong type for mdo1",
+        );
+        assert(
+            initialObjectsCreate.mdo2 instanceof CounterTestDataObject,
+            "container returns the wrong type for mdo2",
+        );
+        assert(
+            initialObjectsCreate.mdo3 instanceof CounterTestDataObject,
+            "container returns the wrong type for mdo3",
+        );
+
+        const { container: containerGet } = await client.getContainer(containerId, doSchema);
+        const initialObjectsGet = containerGet.initialObjects;
+        assert(
+            initialObjectsGet.mdo1 instanceof TestDataObject,
+            "container returns the wrong type for mdo1",
+        );
+        assert(
+            initialObjectsCreate.mdo2 instanceof CounterTestDataObject,
+            "container returns the wrong type for mdo2",
+        );
+        assert(
+            initialObjectsCreate.mdo3 instanceof CounterTestDataObject,
+            "container returns the wrong type for mdo3",
+        );
+    });
+
+    /**
+     * Scenario: test if we can change DataObject value contained within initialObjects
+     *
+     * Expected behavior: DataObject changes are correctly reflected on original and loaded containers
+     */
+    it("can change DataObjects within initialObjects value", async () => {
+        const doSchema: ContainerSchema = {
+            initialObjects: {
+                mdo1: TestDataObject,
+                mdo2: CounterTestDataObject,
+            },
+        };
+        const { container } = await client.createContainer(doSchema);
+        const initialObjectsCreate = container.initialObjects;
+        const mdo2 = initialObjectsCreate.mdo2 as CounterTestDataObject;
+        mdo2.increment();
+        mdo2.increment();
+        mdo2.increment();
+
+        assert.strictEqual(mdo2.value, 3);
+
+        const containerId = await container.attach();
+
+        await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+            durationMs: connectTimeoutMs,
+            errorMsg: "container connect() timeout",
+        });
+
+        const { container: containerGet } = await client.getContainer(containerId, doSchema);
+        const initialObjectsGet = containerGet.initialObjects;
+        const mdo2get = initialObjectsGet.mdo2 as CounterTestDataObject;
+
+        assert.strictEqual(mdo2get.value, 3);
+
+        mdo2get.increment();
+        mdo2get.increment();
+        assert.strictEqual(mdo2get.value, 5);
+    });
+
+    /**
+     * Scenario: test if the optional schema parameter, dynamicObjectTypes (custom data objects),
+     * can be added during runtime and be returned by the container.
+     *
+     * Expected behavior: added loadable object can be retrieved from the container. Loadable
+     * object's id and container config ID should be identical since it's now attached to
+     * the container.
+     */
+    it("can create/add loadable objects (custom data object) dynamically during runtime", async () => {
+        const dynamicSchema: ContainerSchema = {
+            initialObjects: {
+                map1: SharedMap,
+            },
+            dynamicObjectTypes: [TestDataObject],
+        };
+
+        const { container } = await client.createContainer(dynamicSchema);
+
+        const newDo = await container.create(TestDataObject);
+        assert.ok(newDo?.handle);
+
+        const map1 = container.initialObjects.map1 as SharedMap;
+        map1.set("new-pair-id", newDo.handle);
+        const handle: IFluidHandle | undefined = await map1.get("new-pair-id");
+        const obj: unknown = await handle?.get();
+        assert.ok(obj, "container added dynamic objects incorrectly");
+    });
+});

package/src/test/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "extends": "@fluidframework/build-common/ts-common-config.json",
+    "compilerOptions": {
+        "declaration": false,
+        "declarationMap": false,
+        "rootDir": "../",
+        "outDir": "../../dist",
+        "types": [
+            "mocha",
+            "@fluidframework/test-driver-definitions",
+        ]
+    },
+    "include": [
+        "./**/*",
+        "../*"
+    ]
+}

package/src/test/utils.ts

@@ -0,0 +1,48 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { IMember } from "fluid-framework";
+
+import { AzureMember, IAzureAudience } from "@fluidframework/azure-client";
+import { ISharedMap, IValueChanged } from "@fluidframework/map";
+
+export const waitForMember = async (
+    audience: IAzureAudience,
+    userId: string,
+): Promise<AzureMember> => {
+    const allMembers = audience.getMembers();
+    const member = allMembers.get(userId);
+    if (member !== undefined) {
+        return member;
+    }
+    return new Promise((resolve) => {
+        const handler = (clientId: string, newMember: IMember): void => {
+            if (newMember.userId === userId) {
+                resolve(newMember as AzureMember);
+            }
+        };
+        audience.on("memberAdded", handler);
+    });
+};
+
+export const mapWait = async <T>(map: ISharedMap, key: string): Promise<T> => {
+    const maybeValue = map.get<T>(key);
+    if (maybeValue !== undefined) {
+        return maybeValue;
+    }
+
+    return new Promise((resolve) => {
+        const handler = (changed: IValueChanged): void => {
+            if (changed.key === key) {
+                map.off("valueChanged", handler);
+                const value = map.get<T>(changed.key);
+                if (value === undefined) {
+                    throw new Error("Unexpected valueChanged result");
+                }
+                resolve(value);
+            }
+        };
+        map.on("valueChanged", handler);
+    });
+};