@fluidframework/azure-end-to-end-tests 1.2.0-111554 → 1.2.0

package/src/test/TestDataObject.ts

@@ -2,67 +2,66 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-
 import { DataObject, DataObjectFactory, IDataObjectProps } from "@fluidframework/aqueduct";
-import { SharedCounter } from "@fluidframework/counter";
 import { IFluidHandle } from "@fluidframework/core-interfaces";
+import { SharedCounter } from "@fluidframework/counter";
 
 export class TestDataObject extends DataObject {
-    public static get Name(): string {
-        return "@fluid-example/test-data-object";
-    }
+	public static get Name(): string {
+		return "@fluid-example/test-data-object";
+	}
 
-    public static readonly factory = new DataObjectFactory(
-        TestDataObject.Name,
-        TestDataObject,
-        [],
-        {},
-    );
+	public static readonly factory = new DataObjectFactory(
+		TestDataObject.Name,
+		TestDataObject,
+		[],
+		{},
+	);
 
-    constructor(props: IDataObjectProps) {
-        super(props);
-    }
+	constructor(props: IDataObjectProps) {
+		super(props);
+	}
 }
 
 export class CounterTestDataObject extends DataObject {
-    private _counter: SharedCounter | undefined;
+	private _counter: SharedCounter | undefined;
 
-    /**
-     * Do setup work here
-     */
-    protected async initializingFirstTime(): Promise<void> {
-        const counter = SharedCounter.create(this.runtime);
-        this.root.set("counter-key", counter.handle);
-    }
+	/**
+	 * Do setup work here
+	 */
+	protected async initializingFirstTime(): Promise<void> {
+		const counter = SharedCounter.create(this.runtime);
+		this.root.set("counter-key", counter.handle);
+	}
 
-    protected async hasInitialized(): Promise<void> {
-        const counterHandle = this.root.get<IFluidHandle<SharedCounter>>("counter-key");
-        this._counter = await counterHandle?.get();
-    }
+	protected async hasInitialized(): Promise<void> {
+		const counterHandle = this.root.get<IFluidHandle<SharedCounter>>("counter-key");
+		this._counter = await counterHandle?.get();
+	}
 
-    public static get Name(): string {
-        return "@fluid-example/counter-test-data-object";
-    }
+	public static get Name(): string {
+		return "@fluid-example/counter-test-data-object";
+	}
 
-    public static readonly factory = new DataObjectFactory(
-        CounterTestDataObject.Name,
-        CounterTestDataObject,
-        [SharedCounter.getFactory()],
-        {},
-    );
+	public static readonly factory = new DataObjectFactory(
+		CounterTestDataObject.Name,
+		CounterTestDataObject,
+		[SharedCounter.getFactory()],
+		{},
+	);
 
-    public increment(): void {
-        this.counter.increment(1);
-    }
+	public increment(): void {
+		this.counter.increment(1);
+	}
 
-    public get value(): number {
-        return this.counter.value;
-    }
+	public get value(): number {
+		return this.counter.value;
+	}
 
-    private get counter(): SharedCounter {
-        if (this._counter === undefined) {
-            throw new Error("SharedCounter not initialized");
-        }
-        return this._counter;
-    }
+	private get counter(): SharedCounter {
+		if (this._counter === undefined) {
+			throw new Error("SharedCounter not initialized");
+		}
+		return this._counter;
+	}
 }

package/src/test/audience.spec.ts

@@ -2,7 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { strict as assert } from "assert";
+import { strict as assert } from "node:assert";
 
 import { AzureClient } from "@fluidframework/azure-client";
 import { AttachState } from "@fluidframework/container-definitions";
@@ -14,125 +14,125 @@ import { createAzureClient } from "./AzureClientFactory";
 import { waitForMember } from "./utils";
 
 describe("Fluid audience", () => {
-    const connectTimeoutMs = 1000;
-    let client: AzureClient;
-    let schema: ContainerSchema;
-
-    beforeEach(() => {
-        client = createAzureClient("test-user-id-1", "test-user-name-1");
-        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 containerId = await container.attach();
-
-        await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
-            durationMs: connectTimeoutMs,
-            errorMsg: "container connect() timeout",
-        });
-
-        assert.strictEqual(typeof containerId, "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, "test-user-id-1");
-        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 containerId = await container.attach();
-
-        await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
-            durationMs: connectTimeoutMs,
-            errorMsg: "container connect() timeout",
-        });
-
-        assert.strictEqual(typeof containerId, "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, "test-user-id-1");
-        assert.notStrictEqual(originalSelf, undefined, "We should have myself at this point.");
-
-        const client2 = createAzureClient("test-user-id-2", "test-user-name-2");
-        const { services: servicesGet } = await client2.getContainer(containerId, schema);
-
-        /* This is a workaround for a known bug, we should have one member (self) upon container connection */
-        const partner = await waitForMember(servicesGet.audience, "test-user-id-2");
-        assert.notStrictEqual(partner, undefined, "We should have partner at this point.");
-
-        const members = servicesGet.audience.getMembers();
-        assert.strictEqual(members.size, 2, "We should have two members at this point.");
-
-        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 containerId = await container.attach();
-
-        await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
-            durationMs: connectTimeoutMs,
-            errorMsg: "container connect() timeout",
-        });
-
-        const client2 = createAzureClient("test-user-id-2", "test-user-name-2");
-        const { services: servicesGet } = await client2.getContainer(containerId, schema);
-
-        /* This is a workaround for a known bug, we should have one member (self) upon container connection */
-        const partner = await waitForMember(servicesGet.audience, "test-user-id-2");
-        assert.notStrictEqual(partner, undefined, "We should have partner at this point.");
-
-        let members = servicesGet.audience.getMembers();
-        assert.strictEqual(members.size, 2, "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.");
-    });
+	const connectTimeoutMs = 1000;
+	let client: AzureClient;
+	let schema: ContainerSchema;
+
+	beforeEach(() => {
+		client = createAzureClient("test-user-id-1", "test-user-name-1");
+		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 containerId = await container.attach();
+
+		await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+			durationMs: connectTimeoutMs,
+			errorMsg: "container connect() timeout",
+		});
+
+		assert.strictEqual(typeof containerId, "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, "test-user-id-1");
+		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 containerId = await container.attach();
+
+		await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+			durationMs: connectTimeoutMs,
+			errorMsg: "container connect() timeout",
+		});
+
+		assert.strictEqual(typeof containerId, "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, "test-user-id-1");
+		assert.notStrictEqual(originalSelf, undefined, "We should have myself at this point.");
+
+		const client2 = createAzureClient("test-user-id-2", "test-user-name-2");
+		const { services: servicesGet } = await client2.getContainer(containerId, schema);
+
+		/* This is a workaround for a known bug, we should have one member (self) upon container connection */
+		const partner = await waitForMember(servicesGet.audience, "test-user-id-2");
+		assert.notStrictEqual(partner, undefined, "We should have partner at this point.");
+
+		const members = servicesGet.audience.getMembers();
+		assert.strictEqual(members.size, 2, "We should have two members at this point.");
+
+		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 containerId = await container.attach();
+
+		await timeoutPromise((resolve) => container.once("connected", () => resolve()), {
+			durationMs: connectTimeoutMs,
+			errorMsg: "container connect() timeout",
+		});
+
+		const client2 = createAzureClient("test-user-id-2", "test-user-name-2");
+		const { services: servicesGet } = await client2.getContainer(containerId, schema);
+
+		/* This is a workaround for a known bug, we should have one member (self) upon container connection */
+		const partner = await waitForMember(servicesGet.audience, "test-user-id-2");
+		assert.notStrictEqual(partner, undefined, "We should have partner at this point.");
+
+		let members = servicesGet.audience.getMembers();
+		assert.strictEqual(members.size, 2, "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.");
+	});
 });