@fluid-experimental/odsp-end-to-end-tests 2.0.0-dev.7.4.0.221926

package/src/test/audience.spec.ts

@@ -0,0 +1,186 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { strict as assert } from "node:assert";
+
+import { OdspClient } from "@fluid-experimental/odsp-client";
+import { AttachState } from "@fluidframework/container-definitions";
+import { ContainerSchema } from "@fluidframework/fluid-static";
+import { SharedMap } from "@fluidframework/map";
+import { timeoutPromise } from "@fluidframework/test-utils";
+
+import { ConnectionState } from "@fluidframework/container-loader";
+import { ConfigTypes, IConfigProviderBase } from "@fluidframework/core-interfaces";
+import { createOdspClient, OdspTestCredentials } from "./OdspClientFactory";
+import { waitForMember } from "./utils";
+
+const configProvider = (settings: Record<string, ConfigTypes>): IConfigProviderBase => ({
+	getRawConfig: (name: string): ConfigTypes => settings[name],
+});
+
+/**
+ * Default test credentials for odsp-client.
+ */
+const client1Creds: OdspTestCredentials = {
+	clientId: "process.env.odsp__client__client__id",
+	clientSecret: "process.env.odsp__client__client__secret",
+	username: "process.env.odsp__client__login__username",
+	password: "process.env.odsp__client__login__password",
+};
+
+const client2Creds: OdspTestCredentials = {
+	clientId: "process.env.odsp__client2__client__id",
+	clientSecret: "process.env.odsp__client2__client__secret",
+	username: "process.env.odsp__client2__login__username",
+	password: "process.env.odsp__client2__login__password",
+};
+
+describe("Fluid audience", () => {
+	const connectTimeoutMs = 10_000;
+	let client: OdspClient;
+	let schema: ContainerSchema;
+
+	beforeEach(() => {
+		client = createOdspClient(client1Creds);
+		schema = {
+			initialObjects: {
+				map1: SharedMap,
+			},
+		};
+	});
+
+	/**
+	 * Scenario: Find original member/self
+	 *
+	 * Expected behavior: container should have a single member upon creation.
+	 */
+	it("can find original member", async () => {
+		const { container, services } = await client.createContainer(schema);
+		const itemId = await container.attach();
+
+		if (container.connectionState !== ConnectionState.Connected) {
+			await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+				durationMs: connectTimeoutMs,
+				errorMsg: "container connect() timeout",
+			});
+		}
+
+		assert.strictEqual(typeof itemId, "string", "Attach did not return a string ID");
+		assert.strictEqual(
+			container.attachState,
+			AttachState.Attached,
+			"Container is not attached after attach is called",
+		);
+
+		/* This is a workaround for a known bug, we should have one member (self) upon container connection */
+		const myself = await waitForMember(services.audience, client1Creds.username);
+		assert.notStrictEqual(myself, undefined, "We should have myself at this point.");
+
+		const members = services.audience.getMembers();
+		assert.strictEqual(members.size, 1, "We should have only one member at this point.");
+	});
+
+	/**
+	 * Scenario: Find partner member
+	 *
+	 * Expected behavior: upon resolving container, the partner member should be able
+	 * to resolve original member.
+	 */
+	it("can find partner member", async () => {
+		const { container, services } = await client.createContainer(schema);
+		const itemId = await container.attach();
+
+		if (container.connectionState !== ConnectionState.Connected) {
+			await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+				durationMs: connectTimeoutMs,
+				errorMsg: "container connect() timeout",
+			});
+		}
+
+		assert.strictEqual(typeof itemId, "string", "Attach did not return a string ID");
+		assert.strictEqual(
+			container.attachState,
+			AttachState.Attached,
+			"Container is not attached after attach is called",
+		);
+
+		/* This is a workaround for a known bug, we should have one member (self) upon container connection */
+		const originalSelf = await waitForMember(services.audience, client1Creds.username);
+		assert.notStrictEqual(originalSelf, undefined, "We should have myself at this point.");
+
+		// pass client2 credentials
+		const client2 = createOdspClient(
+			client2Creds,
+			undefined,
+			configProvider({
+				"Fluid.Container.ForceWriteConnection": true,
+			}),
+		);
+		const { services: servicesGet } = await client2.getContainer(itemId, schema);
+
+		/* This is a workaround for a known bug, we should have one member (self) upon container connection */
+		const partner = await waitForMember(servicesGet.audience, client2Creds.username);
+		assert.notStrictEqual(partner, undefined, "We should have partner at this point.");
+
+		const members = servicesGet.audience.getMembers();
+		// TODO: uncomment this. One more test creds are required
+		// assert.strictEqual(members.size, 2, "We should have two members at this point.");
+		assert.strictEqual(members.size, 1, "We should have two members at this point.");
+
+		// TODO: login using a different M365 account
+		// assert.notStrictEqual(
+		// 	partner?.userId,
+		// 	originalSelf?.userId,
+		// 	"Self and partner should have different IDs",
+		// );
+	});
+
+	/**
+	 * Scenario: Partner should be able to observe change in audience
+	 *
+	 * Expected behavior: upon 1 partner leaving, other parther should observe
+	 * memberRemoved event and have correct partner count.
+	 */
+	it("can observe member leaving", async () => {
+		const { container } = await client.createContainer(schema);
+		const itemId = await container.attach();
+
+		if (container.connectionState !== ConnectionState.Connected) {
+			await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+				durationMs: connectTimeoutMs,
+				errorMsg: "container connect() timeout",
+			});
+		}
+
+		// pass client2 siteUrl and driveId
+		const client2 = createOdspClient(
+			client2Creds,
+			undefined,
+			configProvider({
+				"Fluid.Container.ForceWriteConnection": true,
+			}),
+		);
+		const { services: servicesGet } = await client2.getContainer(itemId, schema);
+
+		/* This is a workaround for a known bug, we should have one member (self) upon container connection */
+		const partner = await waitForMember(servicesGet.audience, client2Creds.username);
+		assert.notStrictEqual(partner, undefined, "We should have partner at this point.");
+
+		let members = servicesGet.audience.getMembers();
+		// TODO: uncomment this. One more test creds are required
+		// assert.strictEqual(members.size, 2, "We should have two members at this point.");
+		assert.strictEqual(members.size, 1, "We should have two members at this point.");
+
+		container.disconnect();
+
+		await new Promise<void>((resolve) => {
+			servicesGet.audience.on("memberRemoved", () => {
+				resolve();
+			});
+		});
+
+		members = servicesGet.audience.getMembers();
+		assert.strictEqual(members.size, 1, "We should have one member left at this point.");
+	});
+});

package/src/test/containerCreate.spec.ts

@@ -0,0 +1,156 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { strict as assert } from "node:assert";
+
+import { OdspClient } from "@fluid-experimental/odsp-client";
+import { AttachState } from "@fluidframework/container-definitions";
+import { ContainerSchema } from "@fluidframework/fluid-static";
+import { SharedMap } from "@fluidframework/map";
+import { timeoutPromise } from "@fluidframework/test-utils";
+
+import { ConnectionState } from "@fluidframework/container-loader";
+import { OdspTestCredentials, createOdspClient } from "./OdspClientFactory";
+
+const clientCreds: OdspTestCredentials = {
+	clientId: "process.env.odsp__client__client__id",
+	clientSecret: "process.env.odsp__client__client__secret",
+	username: "process.env.odsp__client__login__username",
+	password: "process.env.odsp__client__login__password",
+};
+
+describe("Container create scenarios", () => {
+	const connectTimeoutMs = 10_000;
+	let client: OdspClient;
+	let schema: ContainerSchema;
+
+	beforeEach(() => {
+		client = createOdspClient(clientCreds);
+		schema = {
+			initialObjects: {
+				map1: SharedMap,
+			},
+		};
+	});
+
+	/**
+	 * Scenario: test when an Odsp Client container is created,
+	 * it is initially detached.
+	 *
+	 * Expected behavior: an error should not be thrown nor should a rejected promise
+	 * be returned.
+	 */
+	it("Created container is detached", async () => {
+		const { container } = await client.createContainer(schema);
+		assert.strictEqual(
+			container.attachState,
+			AttachState.Detached,
+			"Container should be detached",
+		);
+
+		// Make sure we can attach.
+		const itemId = await container.attach();
+		assert.strictEqual(typeof itemId, "string", "Attach did not return a string ID");
+	});
+
+	/**
+	 * Scenario: Test attaching a container.
+	 *
+	 * Expected behavior: an error should not be thrown nor should a rejected promise
+	 * be returned.
+	 */
+	it("can attach a container", async () => {
+		const { container } = await client.createContainer(schema);
+		const itemId = await container.attach();
+
+		if (container.connectionState !== ConnectionState.Connected) {
+			await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+				durationMs: connectTimeoutMs,
+				errorMsg: "container connect() timeout",
+			});
+		}
+
+		assert.strictEqual(typeof itemId, "string", "Attach did not return a string ID");
+		assert.strictEqual(
+			container.attachState,
+			AttachState.Attached,
+			"Container is not attached after attach is called",
+		);
+	});
+
+	/**
+	 * Scenario: Test if attaching a container twice fails.
+	 *
+	 * Expected behavior: an error should not be thrown nor should a rejected promise
+	 * be returned.
+	 */
+	it("cannot attach a container twice", async () => {
+		const { container } = await client.createContainer(schema);
+		const itemId = await container.attach();
+
+		if (container.connectionState !== ConnectionState.Connected) {
+			await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+				durationMs: connectTimeoutMs,
+				errorMsg: "container connect() timeout",
+			});
+		}
+
+		assert.strictEqual(typeof itemId, "string", "Attach did not return a string ID");
+		assert.strictEqual(
+			container.attachState,
+			AttachState.Attached,
+			"Container is attached after attach is called",
+		);
+		await assert.rejects(container.attach(), () => true, "Container should not attach twice");
+	});
+
+	/**
+	 * Scenario: test if Odsp Client can get an existing container.
+	 *
+	 * Expected behavior: an error should not be thrown nor should a rejected promise
+	 * be returned.
+	 */
+	it("can retrieve existing ODSP container successfully", async () => {
+		const { container: newContainer } = await client.createContainer(schema);
+		const itemId = await newContainer.attach();
+
+		if (newContainer.connectionState !== ConnectionState.Connected) {
+			await timeoutPromise((resolve) => newContainer.once("connected", () => resolve()), {
+				durationMs: connectTimeoutMs,
+				errorMsg: "container connect() timeout",
+			});
+		}
+
+		const resources = client.getContainer(itemId, schema);
+		await assert.doesNotReject(
+			resources,
+			() => true,
+			"container cannot be retrieved from ODSP",
+		);
+	});
+
+	/**
+	 * Scenario: test if Odsp Client can get a non-exiting container.
+	 *
+	 * Expected behavior: an error should be thrown when trying to get a non-existent container.
+	 */
+	it("cannot load improperly created container (cannot load a non-existent container)", async () => {
+		const containerAndServicesP = client.getContainer("containerConfig", schema);
+
+		const errorFn = (error: Error): boolean => {
+			assert.notStrictEqual(error.message, undefined, "Odsp Client error is undefined");
+			assert.strict(
+				error.message.startsWith("ODSP fetch error [400]"),
+				`Unexpected error: ${error.message}`,
+			);
+			return true;
+		};
+
+		await assert.rejects(
+			containerAndServicesP,
+			errorFn,
+			"Odsp Client can load a non-existent container",
+		);
+	});
+});

package/src/test/ddsTests.spec.ts

@@ -0,0 +1,267 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { strict as assert } from "node:assert";
+
+import { OdspClient } from "@fluid-experimental/odsp-client";
+import { IFluidHandle } from "@fluidframework/core-interfaces";
+import { ContainerSchema } from "@fluidframework/fluid-static";
+import { SharedMap } from "@fluidframework/map";
+import { timeoutPromise } from "@fluidframework/test-utils";
+
+import { ConnectionState } from "@fluidframework/container-loader";
+import { OdspTestCredentials, createOdspClient } from "./OdspClientFactory";
+import { CounterTestDataObject, TestDataObject } from "./TestDataObject";
+import { mapWait } from "./utils";
+
+const clientCreds: OdspTestCredentials = {
+	clientId: "process.env.odsp__client__client__id",
+	clientSecret: "process.env.odsp__client__client__secret",
+	username: "process.env.odsp__client__login__username",
+	password: "process.env.odsp__client__login__password",
+};
+
+describe("Fluid data updates", () => {
+	const connectTimeoutMs = 10_000;
+	let client: OdspClient;
+	let schema: ContainerSchema;
+
+	beforeEach(() => {
+		client = createOdspClient(clientCreds);
+		schema = {
+			initialObjects: {
+				map1: SharedMap,
+			},
+		};
+	});
+
+	/**
+	 * Scenario: test when an Odsp 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 itemId = await newContainer.attach();
+
+		if (newContainer.connectionState !== ConnectionState.Connected) {
+			await timeoutPromise((resolve) => newContainer.once("connected", () => resolve()), {
+				durationMs: connectTimeoutMs,
+				errorMsg: "container connect() timeout",
+			});
+		}
+
+		const resources = client.getContainer(itemId, schema);
+		await assert.doesNotReject(
+			resources,
+			() => true,
+			"container cannot be retrieved from ODSP",
+		);
+
+		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 itemId = await container.attach();
+
+		if (container.connectionState !== ConnectionState.Connected) {
+			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(itemId, 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 itemId = await container.attach();
+
+		if (container.connectionState !== ConnectionState.Connected) {
+			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(itemId, 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 itemId = await container.attach();
+
+		if (container.connectionState !== ConnectionState.Connected) {
+			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(itemId, 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 itemId = await container.attach();
+
+		if (container.connectionState !== ConnectionState.Connected) {
+			await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+				durationMs: connectTimeoutMs,
+				errorMsg: "container connect() timeout",
+			});
+		}
+
+		const { container: containerGet } = await client.getContainer(itemId, 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);
+		await container.attach();
+
+		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,9 @@
+{
+	"extends": ["../../../../../../common/build/build-common/tsconfig.test.json"],
+	"include": ["./**/*", "../*"],
+	"compilerOptions": {
+		"rootDir": "../",
+		"outDir": "../../dist",
+		"types": ["mocha"],
+	},
+}

package/src/test/utils.ts

@@ -0,0 +1,48 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { OdspMember, IOdspAudience } from "@fluid-experimental/odsp-client";
+import { IMember } from "@fluidframework/fluid-static";
+import { ISharedMap, IValueChanged } from "@fluidframework/map";
+
+export const waitForMember = async (
+	audience: IOdspAudience,
+	username: string,
+): Promise<OdspMember> => {
+	const allMembers = audience.getMembers();
+	const member = allMembers.get(username);
+	if (member !== undefined) {
+		return member;
+	}
+	return new Promise((resolve) => {
+		const handler = (clientId: string, newMember: IMember): void => {
+			if (newMember.userId === username) {
+				resolve(newMember as OdspMember);
+			}
+		};
+		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);
+	});
+};