fix container copy FTs

.github/workflows/ci.yml

@@ -192,6 +192,9 @@ jobs:
             NOSQL_READONLY_TESTACCOUNT_TOKEN=$(az account get-access-token --scope "https://github-e2etests-sql-readonly.documents.azure.com/.default" -o tsv --query accessToken)
             echo "::add-mask::$NOSQL_READONLY_TESTACCOUNT_TOKEN"
             echo NOSQL_READONLY_TESTACCOUNT_TOKEN=$NOSQL_READONLY_TESTACCOUNT_TOKEN >> $GITHUB_ENV
+            NOSQL_CONTAINERCOPY_TESTACCOUNT_TOKEN=$(az account get-access-token --scope "https://github-e2etests-sql-containercopyonly.documents.azure.com/.default" -o tsv --query accessToken)
+            echo "::add-mask::$NOSQL_CONTAINERCOPY_TESTACCOUNT_TOKEN"
+            echo NOSQL_CONTAINERCOPY_TESTACCOUNT_TOKEN=$NOSQL_CONTAINERCOPY_TESTACCOUNT_TOKEN >> $GITHUB_ENV
             TABLE_TESTACCOUNT_TOKEN=$(az account get-access-token --scope "https://github-e2etests-tables.documents.azure.com/.default" -o tsv --query accessToken)
             echo "::add-mask::$TABLE_TESTACCOUNT_TOKEN"
             echo TABLE_TESTACCOUNT_TOKEN=$TABLE_TESTACCOUNT_TOKEN >> $GITHUB_ENV
@@ -210,6 +213,8 @@ jobs:
             # MONGO_READONLY_TESTACCOUNT_TOKEN=$(az account get-access-token --scope "https://github-e2etests-mongo-readonly.documents.azure.com/.default" -o tsv --query accessToken)
             # echo "::add-mask::$MONGO_READONLY_TESTACCOUNT_TOKEN"
             # echo MONGO_READONLY_TESTACCOUNT_TOKEN=$MONGO_READONLY_TESTACCOUNT_TOKEN >> $GITHUB_ENV
+      - name: List test files for shard ${{ matrix['shardIndex'] }} of ${{ matrix['shardTotal']}}
+        run: npx playwright test --shard=${{ matrix.shardIndex }}/${{ matrix.shardTotal }} --list
       - name: Run test shard ${{ matrix['shardIndex'] }} of ${{ matrix['shardTotal']}}
         run: npx playwright test --shard=${{ matrix.shardIndex }}/${{ matrix.shardTotal }} --workers=3
       - name: Upload blob report to GitHub Actions Artifacts

test/README.md

@@ -164,6 +164,9 @@ $ENV:NOSQL_TESTACCOUNT_TOKEN=az account get-access-token --scope "https://<accou
 # NoSQL API (Readonly)
 $ENV:NOSQL_READONLY_TESTACCOUNT_TOKEN=az account get-access-token --scope "https://<account name>.documents.azure.com/.default" -o tsv --query accessToken
 
+# NoSQL API (Container Copy)
+$ENV:NOSQL_CONTAINERCOPY_TESTACCOUNT_TOKEN=az account get-access-token --scope "https://<account name>.documents.azure.com/.default" -o tsv --query accessToken
+
 # Tables API
 $ENV:TABLE_TESTACCOUNT_TOKEN=az account get-access-token --scope "https://<account name>.documents.azure.com/.default" -o tsv --query accessToken
 

test/fx.ts

@@ -11,7 +11,7 @@ export interface TestNameOptions {
   prefixed?: boolean;
 }
 
-export function generateUniqueName(baseName, options?: TestNameOptions): string {
+export function generateUniqueName(baseName: string, options?: TestNameOptions): string {
   const length = options?.length ?? 1;
   const timestamp = options?.timestampped === undefined ? true : options.timestampped;
   const prefixed = options?.prefixed === undefined ? true : options.prefixed;
@@ -40,6 +40,7 @@ export enum TestAccount {
   Mongo32 = "Mongo32",
   SQL = "SQL",
   SQLReadOnly = "SQLReadOnly",
+  SQLContainerCopyOnly = "SQLContainerCopyOnly",
 }
 
 export const defaultAccounts: Record<TestAccount, string> = {
@@ -51,6 +52,7 @@ export const defaultAccounts: Record<TestAccount, string> = {
   [TestAccount.Mongo32]: "github-e2etests-mongo32",
   [TestAccount.SQL]: "github-e2etests-sql",
   [TestAccount.SQLReadOnly]: "github-e2etests-sql-readonly",
+  [TestAccount.SQLContainerCopyOnly]: "github-e2etests-sql-containercopyonly",
 };
 
 export const resourceGroupName = process.env.DE_TEST_RESOURCE_GROUP ?? "de-e2e-tests";
@@ -77,7 +79,14 @@ export function getAccountName(accountType: TestAccount) {
   );
 }
 
-export async function getTestExplorerUrl(accountType: TestAccount, iframeSrc?: string): Promise<string> {
+type TestExplorerUrlOptions = {
+  iframeSrc?: string;
+  enablecontainercopy?: boolean;
+};
+
+export async function getTestExplorerUrl(accountType: TestAccount, options?: TestExplorerUrlOptions): Promise<string> {
+  const { iframeSrc, enablecontainercopy } = options ?? {};
+
   // We can't retrieve AZ CLI credentials from the browser so we get them here.
   const token = await getAzureCLICredentialsToken();
   const accountName = getAccountName(accountType);
@@ -93,6 +102,7 @@ export async function getTestExplorerUrl(accountType: TestAccount, iframeSrc?: s
 
   const nosqlRbacToken = process.env.NOSQL_TESTACCOUNT_TOKEN;
   const nosqlReadOnlyRbacToken = process.env.NOSQL_READONLY_TESTACCOUNT_TOKEN;
+  const nosqlContainerCopyRbacToken = process.env.NOSQL_CONTAINERCOPY_TESTACCOUNT_TOKEN;
   const tableRbacToken = process.env.TABLE_TESTACCOUNT_TOKEN;
   const gremlinRbacToken = process.env.GREMLIN_TESTACCOUNT_TOKEN;
   const cassandraRbacToken = process.env.CASSANDRA_TESTACCOUNT_TOKEN;
@@ -108,6 +118,16 @@ export async function getTestExplorerUrl(accountType: TestAccount, iframeSrc?: s
       }
       break;
 
+    case TestAccount.SQLContainerCopyOnly:
+      if (nosqlContainerCopyRbacToken) {
+        params.set("nosqlRbacToken", nosqlContainerCopyRbacToken);
+        params.set("enableaaddataplane", "true");
+      }
+      if (enablecontainercopy) {
+        params.set("enablecontainercopy", "true");
+      }
+      break;
+
     case TestAccount.SQLReadOnly:
       if (nosqlReadOnlyRbacToken) {
         params.set("nosqlReadOnlyRbacToken", nosqlReadOnlyRbacToken);
@@ -165,6 +185,39 @@ export async function getTestExplorerUrl(accountType: TestAccount, iframeSrc?: s
   return `https://localhost:1234/testExplorer.html?${params.toString()}`;
 }
 
+type DropdownItemExpectations = {
+  ariaLabel?: string;
+  itemCount?: number;
+};
+
+type DropdownItemMatcher = {
+  name?: string;
+  position?: number;
+};
+
+export async function getDropdownItemByNameOrPosition(
+  frame: Frame,
+  matcher?: DropdownItemMatcher,
+  expectedOptions?: DropdownItemExpectations,
+): Promise<Locator> {
+  const dropdownItemsWrapper = frame.locator("div.ms-Dropdown-items");
+  if (expectedOptions?.ariaLabel) {
+    expect(await dropdownItemsWrapper.getAttribute("aria-label")).toEqual(expectedOptions.ariaLabel);
+  }
+  if (expectedOptions?.itemCount) {
+    const items = dropdownItemsWrapper.locator("button.ms-Dropdown-item[role='option']");
+    await expect(items).toHaveCount(expectedOptions.itemCount);
+  }
+  const containerDropdownItems = dropdownItemsWrapper.locator("button.ms-Dropdown-item[role='option']");
+  if (matcher?.name) {
+    return containerDropdownItems.filter({ hasText: matcher.name });
+  } else if (matcher?.position !== undefined) {
+    return containerDropdownItems.nth(matcher.position);
+  }
+  // Return first item if no matcher is provided
+  return containerDropdownItems.first();
+}
+
 /** Helper class that provides locator methods for TreeNode elements, on top of a Locator */
 class TreeNode {
   constructor(
@@ -515,7 +568,7 @@ export class DataExplorer {
   }
 
   /** Waits for the Data Explorer app to load */
-  static async waitForExplorer(page: Page) {
+  static async waitForExplorer(page: Page, options?: TestExplorerUrlOptions): Promise<DataExplorer> {
     const iframeElement = await page.getByTestId("DataExplorerFrame").elementHandle();
     if (iframeElement === null) {
       throw new Error("Explorer iframe not found");
@@ -527,15 +580,126 @@ export class DataExplorer {
       throw new Error("Explorer frame not found");
     }
 
-    await explorerFrame?.getByTestId("DataExplorerRoot").waitFor();
+    if (!options?.enablecontainercopy) {
+      await explorerFrame?.getByTestId("DataExplorerRoot").waitFor();
+    }
 
     return new DataExplorer(explorerFrame);
   }
 
   /** Opens the Data Explorer app using the specified test account (and optionally, the provided IFRAME src url). */
   static async open(page: Page, testAccount: TestAccount, iframeSrc?: string): Promise<DataExplorer> {
-    const url = await getTestExplorerUrl(testAccount, iframeSrc);
+    const url = await getTestExplorerUrl(testAccount, { iframeSrc });
     await page.goto(url);
     return DataExplorer.waitForExplorer(page);
   }
 }
+
+export async function waitForApiResponse(
+  page: Page,
+  urlPattern: string,
+  method?: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  payloadValidator?: (payload: any) => boolean,
+) {
+  try {
+    // Check if page is still valid before waiting
+    if (page.isClosed()) {
+      throw new Error(`Page is closed, cannot wait for API response: ${urlPattern}`);
+    }
+
+    return page.waitForResponse(
+      async (response) => {
+        const request = response.request();
+
+        if (!request.url().includes(urlPattern)) {
+          return false;
+        }
+
+        if (method && request.method() !== method) {
+          return false;
+        }
+
+        if (payloadValidator && (request.method() === "POST" || request.method() === "PUT")) {
+          const postData = request.postData();
+          if (postData) {
+            try {
+              const payload = JSON.parse(postData);
+              return payloadValidator(payload);
+            } catch {
+              return false;
+            }
+          }
+        }
+        return true;
+      },
+      { timeout: 60 * 1000 },
+    );
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Target page, context or browser has been closed")) {
+      console.warn("Page was closed while waiting for API response:", urlPattern);
+      throw new Error(`Page closed while waiting for API response: ${urlPattern}`);
+    }
+    throw error;
+  }
+}
+export async function interceptAndInspectApiRequest(
+  page: Page,
+  urlPattern: string,
+  method: string = "POST",
+  error: Error,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  errorValidator: (url?: string, payload?: any) => boolean,
+): Promise<void> {
+  await page.route(
+    (url) => url.pathname.includes(urlPattern),
+    async (route, request) => {
+      if (request.method() !== method) {
+        await route.continue();
+        return;
+      }
+      const postData = request.postData();
+      if (postData) {
+        try {
+          const payload = JSON.parse(postData);
+          if (errorValidator && errorValidator(request.url(), payload)) {
+            await route.fulfill({
+              status: 409,
+              contentType: "application/json",
+              body: JSON.stringify({
+                code: "Conflict",
+                message: error.message,
+              }),
+            });
+            return;
+          }
+        } catch (err) {
+          if (err instanceof Error && err.message.includes("not allowed")) {
+            throw err;
+          }
+        }
+      }
+
+      await route.continue();
+    },
+  );
+}
+
+export class ContainerCopy {
+  constructor(
+    public frame: Frame,
+    public wrapper: Locator,
+  ) {}
+
+  static async waitForContainerCopy(page: Page): Promise<ContainerCopy> {
+    const explorerFrame = await DataExplorer.waitForExplorer(page, { enablecontainercopy: true });
+    const containerCopyWrapper = explorerFrame.frame.locator("div#containerCopyWrapper");
+    return new ContainerCopy(explorerFrame.frame, containerCopyWrapper);
+  }
+
+  static async open(page: Page, testAccount: TestAccount, iframeSrc?: string): Promise<ContainerCopy> {
+    const url = await getTestExplorerUrl(testAccount, { iframeSrc, enablecontainercopy: true });
+    await page.goto(url);
+    return ContainerCopy.waitForContainerCopy(page);
+  }
+}

test/sql/containercopy.spec.ts

@@ -0,0 +1,651 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { expect, Frame, Locator, Page, test } from "@playwright/test";
+import { set } from "lodash";
+import { truncateName } from "../../src/Explorer/ContainerCopy/CopyJobUtils";
+import {
+  ContainerCopy,
+  getAccountName,
+  getDropdownItemByNameOrPosition,
+  interceptAndInspectApiRequest,
+  TestAccount,
+  waitForApiResponse,
+} from "../fx";
+import { createMultipleTestContainers } from "../testData";
+
+let page: Page;
+let wrapper: Locator = null!;
+let panel: Locator = null!;
+let frame: Frame = null!;
+let expectedCopyJobNameInitial: string = null!;
+let expectedJobName: string = "";
+let targetAccountName: string = "";
+let expectedSourceAccountName: string = "";
+let expectedSubscriptionName: string = "";
+
+test.beforeAll("Container Copy - Before All", async ({ browser }) => {
+  await createMultipleTestContainers({ accountType: TestAccount.SQLContainerCopyOnly, containerCount: 3 });
+
+  page = await browser.newPage();
+  ({ wrapper, frame } = await ContainerCopy.open(page, TestAccount.SQLContainerCopyOnly));
+  expectedJobName = `test_job_${Date.now()}`;
+  targetAccountName = getAccountName(TestAccount.SQLContainerCopyOnly);
+});
+
+test.afterEach("Container Copy - After Each", async () => {
+  await page.unroute(/.*/, (route) => route.continue());
+});
+
+test("Loading and verifying the content of the page", async () => {
+  expect(wrapper).not.toBeNull();
+  await expect(wrapper.getByTestId("CommandBar/Button:Create Copy Job")).toBeVisible();
+  await expect(wrapper.getByTestId("CommandBar/Button:Refresh")).toBeVisible();
+  await expect(wrapper.getByTestId("CommandBar/Button:Feedback")).toBeVisible();
+});
+
+test("Successfully create a copy job for offline migration", async () => {
+  expect(wrapper).not.toBeNull();
+  // Loading and verifying subscription & account dropdown
+
+  const createCopyJobButton = wrapper.getByTestId("CommandBar/Button:Create Copy Job");
+  await createCopyJobButton.click();
+  panel = frame.getByTestId("Panel:Create copy job");
+  await expect(panel).toBeVisible();
+
+  await page.waitForTimeout(10 * 1000);
+
+  const subscriptionDropdown = panel.getByTestId("subscription-dropdown");
+
+  const expectedAccountName = targetAccountName;
+  expectedSubscriptionName = await subscriptionDropdown.locator("span.ms-Dropdown-title").innerText();
+
+  await subscriptionDropdown.click();
+  const subscriptionItem = await getDropdownItemByNameOrPosition(
+    frame,
+    { name: expectedSubscriptionName },
+    { ariaLabel: "Subscription" },
+  );
+  await subscriptionItem.click();
+
+  // Load account dropdown based on selected subscription
+
+  const accountDropdown = panel.getByTestId("account-dropdown");
+  await expect(accountDropdown).toHaveText(new RegExp(expectedAccountName));
+  await accountDropdown.click();
+
+  const accountItem = await getDropdownItemByNameOrPosition(
+    frame,
+    { name: expectedAccountName },
+    { ariaLabel: "Account" },
+  );
+  await accountItem.click();
+
+  // Verifying online or offline checkbox functionality
+  /**
+   * This test verifies the functionality of the migration type checkbox that toggles between
+   * online and offline container copy modes. It ensures that:
+   * 1. When online mode is selected, the user is directed to a permissions screen
+   * 2. When offline mode is selected, the user bypasses the permissions screen
+   * 3. The UI correctly reflects the selected migration type throughout the workflow
+   */
+  const fluentUiCheckboxContainer = panel.getByTestId("migration-type-checkbox").locator("div.ms-Checkbox");
+  await fluentUiCheckboxContainer.click();
+  await panel.getByRole("button", { name: "Next" }).click();
+  await expect(panel.getByTestId("Panel:AssignPermissionsContainer")).toBeVisible();
+  await expect(panel.getByText("Online container copy", { exact: true })).toBeVisible();
+  await panel.getByRole("button", { name: "Previous" }).click();
+  await fluentUiCheckboxContainer.click();
+  await panel.getByRole("button", { name: "Next" }).click();
+  await expect(panel.getByTestId("Panel:SelectSourceAndTargetContainers")).toBeVisible();
+  await expect(panel.getByTestId("Panel:AssignPermissionsContainer")).not.toBeVisible();
+
+  // Verifying source and target container selection
+
+  const sourceContainerDropdown = panel.getByTestId("source-containerDropdown");
+  expect(sourceContainerDropdown).toBeVisible();
+  await expect(sourceContainerDropdown).toHaveClass(/(^|\s)is-disabled(\s|$)/);
+
+  const sourceDatabaseDropdown = panel.getByTestId("source-databaseDropdown");
+  await sourceDatabaseDropdown.click();
+
+  const sourceDbDropdownItem = await getDropdownItemByNameOrPosition(frame, { position: 0 }, { ariaLabel: "Database" });
+  await sourceDbDropdownItem.click();
+
+  await expect(sourceContainerDropdown).not.toHaveClass(/(^|\s)is-disabled(\s|$)/);
+  await sourceContainerDropdown.click();
+  const sourceContainerDropdownItem = await getDropdownItemByNameOrPosition(
+    frame,
+    { position: 0 },
+    { ariaLabel: "Container" },
+  );
+  await sourceContainerDropdownItem.click();
+
+  const targetContainerDropdown = panel.getByTestId("target-containerDropdown");
+  expect(targetContainerDropdown).toBeVisible();
+  await expect(targetContainerDropdown).toHaveClass(/(^|\s)is-disabled(\s|$)/);
+
+  const targetDatabaseDropdown = panel.getByTestId("target-databaseDropdown");
+  await targetDatabaseDropdown.click();
+  const targetDbDropdownItem = await getDropdownItemByNameOrPosition(frame, { position: 0 }, { ariaLabel: "Database" });
+  await targetDbDropdownItem.click();
+
+  await expect(targetContainerDropdown).not.toHaveClass(/(^|\s)is-disabled(\s|$)/);
+  await targetContainerDropdown.click();
+  const targetContainerDropdownItem1 = await getDropdownItemByNameOrPosition(
+    frame,
+    { position: 0 },
+    { ariaLabel: "Container" },
+  );
+  await targetContainerDropdownItem1.click();
+
+  await panel.getByRole("button", { name: "Next" }).click();
+
+  const errorContainer = panel.getByTestId("Panel:ErrorContainer");
+  await expect(errorContainer).toBeVisible();
+  await expect(errorContainer).toHaveText(/Source and destination containers cannot be the same/i);
+
+  // Reselect target container to be different from source container
+  await targetContainerDropdown.click();
+  const targetContainerDropdownItem2 = await getDropdownItemByNameOrPosition(
+    frame,
+    { position: 1 },
+    { ariaLabel: "Container" },
+  );
+  await targetContainerDropdownItem2.click();
+
+  const selectedSourceDatabase = await sourceDatabaseDropdown.innerText();
+  const selectedSourceContainer = await sourceContainerDropdown.innerText();
+  const selectedTargetDatabase = await targetDatabaseDropdown.innerText();
+  const selectedTargetContainer = await targetContainerDropdown.innerText();
+  expectedCopyJobNameInitial = `${truncateName(selectedSourceDatabase)}.${truncateName(
+    selectedSourceContainer,
+  )}_${truncateName(selectedTargetDatabase)}.${truncateName(selectedTargetContainer)}`;
+
+  await panel.getByRole("button", { name: "Next" }).click();
+
+  await expect(errorContainer).not.toBeVisible();
+  await expect(panel.getByTestId("Panel:PreviewCopyJob")).toBeVisible();
+
+  // Verifying the preview of the copy job
+  const previewContainer = panel.getByTestId("Panel:PreviewCopyJob");
+  await expect(previewContainer).toBeVisible();
+  await expect(previewContainer.getByTestId("source-subscription-name")).toHaveText(expectedSubscriptionName);
+  await expect(previewContainer.getByTestId("source-account-name")).toHaveText(expectedAccountName);
+  const jobNameInput = previewContainer.getByTestId("job-name-textfield");
+  await expect(jobNameInput).toHaveValue(new RegExp(expectedCopyJobNameInitial));
+  const primaryBtn = panel.getByRole("button", { name: "Copy", exact: true });
+  await expect(primaryBtn).not.toHaveClass(/(^|\s)is-disabled(\s|$)/);
+
+  await jobNameInput.fill("test job name");
+  await expect(primaryBtn).toHaveClass(/(^|\s)is-disabled(\s|$)/);
+
+  // Testing API request interception with duplicate job name
+  const duplicateJobName = "test-job-name-1";
+  await jobNameInput.fill(duplicateJobName);
+
+  const copyButton = panel.getByRole("button", { name: "Copy", exact: true });
+  const expectedErrorMessage = `Duplicate job name '${duplicateJobName}'`;
+  await interceptAndInspectApiRequest(
+    page,
+    `${expectedAccountName}/dataTransferJobs/${duplicateJobName}`,
+    "PUT",
+    new Error(expectedErrorMessage),
+    (url?: string) => url?.includes(duplicateJobName) ?? false,
+  );
+
+  let errorThrown = false;
+  try {
+    await copyButton.click();
+    await page.waitForTimeout(2000);
+  } catch (error: any) {
+    errorThrown = true;
+    expect(error.message).toContain("not allowed");
+  }
+  if (!errorThrown) {
+    const errorContainer = panel.getByTestId("Panel:ErrorContainer");
+    await expect(errorContainer).toBeVisible();
+    await expect(errorContainer).toHaveText(new RegExp(expectedErrorMessage, "i"));
+  }
+
+  await expect(panel).toBeVisible();
+
+  // Testing API request success with valid job name and verifying copy job creation
+
+  const validJobName = expectedJobName;
+
+  const copyJobCreationPromise = waitForApiResponse(
+    page,
+    `${expectedAccountName}/dataTransferJobs/${validJobName}`,
+    "PUT",
+  );
+
+  await jobNameInput.fill(validJobName);
+  await expect(copyButton).not.toHaveClass(/(^|\s)is-disabled(\s|$)/);
+
+  await copyButton.click();
+
+  const response = await copyJobCreationPromise;
+  expect(response.ok()).toBe(true);
+
+  await expect(panel).not.toBeVisible({ timeout: 10000 });
+
+  const jobsListContainer = wrapper.locator(".CopyJobListContainer .ms-DetailsList-contentWrapper .ms-List-page");
+  await jobsListContainer.waitFor({ state: "visible" });
+
+  const jobItem = jobsListContainer.getByText(validJobName);
+  await jobItem.waitFor({ state: "visible" });
+  await expect(jobItem).toBeVisible();
+
+  /* // Cancel the created job to clean up
+  
+  // Rapid polling to catch the job in running state
+  let attempts = 0;
+  const maxAttempts = 50; // Try for ~5 seconds
+  let jobCancelled = false;
+
+  while (attempts < maxAttempts && !jobCancelled) {
+    try {
+      // Look for the job row
+      const jobRow = jobsListContainer.locator(".ms-DetailsRow", { hasText: validJobName });
+
+      if (await jobRow.isVisible({ timeout: 100 })) {
+        const statusCell = jobRow.locator("[data-automationid='DetailsRowCell'][data-automation-key='CopyJobStatus']");
+        const statusText = await statusCell.textContent({ timeout: 100 });
+
+        // If job is still running/queued, try to cancel it
+        if (statusText && /running|queued|pending/i.test(statusText)) {
+          const actionMenuButton = wrapper.getByTestId(`CopyJobActionMenu/Button:${validJobName}`);
+          await actionMenuButton.click({ timeout: 1000 });
+
+          const cancelAction = frame.locator(".ms-ContextualMenu-list button:has-text('Cancel')");
+          if (await cancelAction.isVisible({ timeout: 1000 })) {
+            await cancelAction.click();
+
+            // Verify cancellation
+            await expect(statusCell).toContainText(/cancelled|canceled|failed/i, { timeout: 5000 });
+            jobCancelled = true;
+            break;
+          }
+        } else if (statusText && /completed|succeeded|finished/i.test(statusText)) {
+          // Job completed too fast, skip the test
+          // console.log(`Job ${validJobName} completed too quickly to test cancellation`);
+          test.skip(true, "Job completed too quickly for cancellation test");
+          return;
+        }
+      }
+
+      // Refresh the job list
+      const refreshButton = wrapper.getByTestId("CommandBar/Button:Refresh");
+      if (await refreshButton.isVisible({ timeout: 100 })) {
+        await refreshButton.click();
+        await page.waitForTimeout(100); // Small delay between attempts
+      }
+    } catch (error) {
+      // Continue trying if there's any error
+    }
+
+    attempts++;
+  }
+
+  if (!jobCancelled) {
+    // If we couldn't cancel in time, at least verify the job was created
+    const jobRow = jobsListContainer.locator(".ms-DetailsRow", { hasText: validJobName });
+    await expect(jobRow).toBeVisible({ timeout: 5000 });
+    test.skip(true, "Could not catch job in running state for cancellation test");
+  } */
+});
+
+/* test.skip("Pause a running copy job", async () => {
+  const jobsListContainer = wrapper.locator(".CopyJobListContainer .ms-DetailsList-contentWrapper .ms-List-page");
+  await jobsListContainer.waitFor({ state: "visible" });
+
+  const firstJobRow = jobsListContainer.locator(".ms-DetailsRow", { hasText: expectedJobName });
+  await firstJobRow.waitFor({ state: "visible" });
+
+  const actionMenuButton = wrapper.getByTestId(`CopyJobActionMenu/Button:${expectedJobName}`);
+  await actionMenuButton.waitFor({ state: "visible" });
+  await actionMenuButton.click();
+
+  const pauseAction = frame.locator(".ms-ContextualMenu-list button:has-text('Pause')");
+  await pauseAction.waitFor({ state: "visible" });
+  await pauseAction.click();
+
+  const updatedJobRow = jobsListContainer.locator(".ms-DetailsRow").filter({ hasText: expectedJobName });
+  const statusCell = updatedJobRow.locator("[data-automationid='DetailsRowCell'][data-automation-key='CopyJobStatus']");
+  await expect(statusCell).toContainText(/paused/i, { timeout: 10000 });
+});
+
+test.skip("Resume a paused copy job", async () => {
+  const jobsListContainer = wrapper.locator(".CopyJobListContainer .ms-DetailsList-contentWrapper .ms-List-page");
+  await jobsListContainer.waitFor({ state: "visible" });
+
+  const pausedJobRow = jobsListContainer.locator(".ms-DetailsRow", { hasText: expectedJobName });
+  await pausedJobRow.waitFor({ state: "visible" });
+
+  const statusCell = pausedJobRow.locator("[data-automationid='DetailsRowCell'][data-automation-key='CopyJobStatus']");
+  await expect(statusCell).toContainText(/paused/i);
+
+  const actionMenuButton = wrapper.getByTestId(`CopyJobActionMenu/Button:${expectedJobName}`);
+  await actionMenuButton.waitFor({ state: "visible" });
+  await actionMenuButton.click();
+
+  const resumeAction = frame.locator(".ms-ContextualMenu-list button:has-text('Resume')");
+  await resumeAction.waitFor({ state: "visible" });
+  await resumeAction.click();
+
+  await expect(statusCell).toContainText(/running|queued/i);
+}); */
+
+test("Create and Cancel a copy job", async () => {
+  expect(wrapper).not.toBeNull();
+  // Create a new job specifically for cancellation testing
+  const cancelJobName = `cancel_test_job_${Date.now()}`;
+
+  // Navigate to create job panel
+  const createCopyJobButton = wrapper.getByTestId("CommandBar/Button:Create Copy Job");
+  await createCopyJobButton.click();
+  panel = frame.getByTestId("Panel:Create copy job");
+
+  // Skip to container selection (offline mode for faster creation)
+  await panel.getByRole("button", { name: "Next" }).click();
+
+  // Select source containers quickly
+  const sourceDatabaseDropdown = panel.getByTestId("source-databaseDropdown");
+  await sourceDatabaseDropdown.click();
+  const sourceDatabaseDropdownItem = await getDropdownItemByNameOrPosition(
+    frame,
+    { position: 0 },
+    { ariaLabel: "Database" },
+  );
+  await sourceDatabaseDropdownItem.click();
+
+  const sourceContainerDropdown = panel.getByTestId("source-containerDropdown");
+  await sourceContainerDropdown.click();
+  const sourceContainerDropdownItem = await getDropdownItemByNameOrPosition(
+    frame,
+    { position: 0 },
+    { ariaLabel: "Container" },
+  );
+  await sourceContainerDropdownItem.click();
+
+  // Select target containers
+  const targetDatabaseDropdown = panel.getByTestId("target-databaseDropdown");
+  await targetDatabaseDropdown.click();
+  const targetDatabaseDropdownItem = await getDropdownItemByNameOrPosition(
+    frame,
+    { position: 0 },
+    { ariaLabel: "Database" },
+  );
+  await targetDatabaseDropdownItem.click();
+
+  const targetContainerDropdown = panel.getByTestId("target-containerDropdown");
+  await targetContainerDropdown.click();
+  const targetContainerDropdownItem = await getDropdownItemByNameOrPosition(
+    frame,
+    { position: 1 },
+    { ariaLabel: "Container" },
+  );
+  await targetContainerDropdownItem.click();
+
+  await panel.getByRole("button", { name: "Next" }).click();
+
+  // Set job name and create
+  const jobNameInput = panel.getByTestId("job-name-textfield");
+  await jobNameInput.fill(cancelJobName);
+
+  const copyButton = panel.getByRole("button", { name: "Copy", exact: true });
+
+  // Create job and immediately start polling for it
+  await copyButton.click();
+
+  // Wait for panel to close and job list to refresh
+  await expect(panel).not.toBeVisible({ timeout: 10000 });
+
+  const jobsListContainer = wrapper.locator(".CopyJobListContainer .ms-DetailsList-contentWrapper .ms-List-page");
+  await jobsListContainer.waitFor({ state: "visible" });
+});
+
+test("Verify Online or Offline Container Copy Permissions Panel", async () => {
+  expect(wrapper).not.toBeNull();
+
+  // Opening the Create Copy Job panel again to verify initial state
+  const createCopyJobButton = wrapper.getByTestId("CommandBar/Button:Create Copy Job");
+  await createCopyJobButton.click();
+  panel = frame.getByTestId("Panel:Create copy job");
+  await expect(panel).toBeVisible();
+  await expect(panel.getByRole("heading", { name: "Create copy job" })).toBeVisible();
+
+  // select different account dropdown
+
+  const accountDropdown = panel.getByTestId("account-dropdown");
+  await accountDropdown.click();
+
+  const dropdownItemsWrapper = frame.locator("div.ms-Dropdown-items");
+  expect(await dropdownItemsWrapper.getAttribute("aria-label")).toEqual("Account");
+
+  const allDropdownItems = await dropdownItemsWrapper.locator(`button.ms-Dropdown-item[role='option']`).all();
+
+  const filteredItems = [];
+  for (const item of allDropdownItems) {
+    const testContent = (await item.textContent()) ?? "";
+    if (testContent.trim() !== targetAccountName.trim()) {
+      filteredItems.push(item);
+    }
+  }
+
+  if (filteredItems.length > 0) {
+    const firstDropdownItem = filteredItems[0];
+    expectedSourceAccountName = (await firstDropdownItem.textContent()) ?? "";
+    await firstDropdownItem.click();
+  } else {
+    throw new Error("No dropdown items available after filtering");
+  }
+
+  const fluentUiCheckboxContainer = panel.getByTestId("migration-type-checkbox").locator("div.ms-Checkbox");
+  await fluentUiCheckboxContainer.click();
+
+  await panel.getByRole("button", { name: "Next" }).click();
+
+  // Verifying Assign Permissions panel for online copy
+
+  const permissionScreen = panel.getByTestId("Panel:AssignPermissionsContainer");
+  await expect(permissionScreen).toBeVisible();
+
+  await expect(permissionScreen.getByText("Online container copy", { exact: true })).toBeVisible();
+  await expect(permissionScreen.getByText("Cross-account container copy", { exact: true })).toBeVisible();
+
+  // Verify Point-in-Time Restore timer and refresh button workflow
+
+  await page.route(`**/Microsoft.DocumentDB/databaseAccounts/${expectedSourceAccountName}**`, async (route) => {
+    const mockData = {
+      identity: {
+        type: "SystemAssigned",
+        principalId: "00-11-22-33",
+      },
+      properties: {
+        defaultIdentity: "SystemAssignedIdentity",
+        backupPolicy: {
+          type: "Continuous",
+        },
+        capabilities: [{ name: "EnableOnlineContainerCopy" }],
+      },
+    };
+    if (route.request().method() === "GET") {
+      const response = await route.fetch();
+      const actualData = await response.json();
+      const mergedData = { ...actualData };
+
+      set(mergedData, "identity", mockData.identity);
+      set(mergedData, "properties.defaultIdentity", mockData.properties.defaultIdentity);
+      set(mergedData, "properties.backupPolicy", mockData.properties.backupPolicy);
+      set(mergedData, "properties.capabilities", mockData.properties.capabilities);
+
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify(mergedData),
+      });
+    } else {
+      await route.continue();
+    }
+  });
+
+  await expect(permissionScreen).toBeVisible();
+
+  const expandedOnlineAccordionHeader = permissionScreen
+    .getByTestId("permission-group-container-onlineConfigs")
+    .locator("button[aria-expanded='true']");
+  await expect(expandedOnlineAccordionHeader).toBeVisible();
+
+  const accordionItem = expandedOnlineAccordionHeader
+    .locator("xpath=ancestor::*[contains(@class, 'fui-AccordionItem') or contains(@data-test, 'accordion-item')]")
+    .first();
+
+  const accordionPanel = accordionItem.locator("[role='tabpanel'], .fui-AccordionPanel, [data-test*='panel']").first();
+
+  await page.clock.install({ time: new Date("2024-01-01T10:00:00Z") });
+
+  const pitrBtn = accordionPanel.getByTestId("pointInTimeRestore:PrimaryBtn");
+  await expect(pitrBtn).toBeVisible();
+  await pitrBtn.click();
+
+  page.context().on("page", async (newPage) => {
+    const expectedUrlEndPattern = new RegExp(
+      `/providers/Microsoft.(DocumentDB|DocumentDb)/databaseAccounts/${expectedSourceAccountName}/backupRestore`,
+    );
+    expect(newPage.url()).toMatch(expectedUrlEndPattern);
+    await newPage.close();
+  });
+
+  const loadingOverlay = frame.locator("[data-test='loading-overlay']");
+  await expect(loadingOverlay).toBeVisible();
+
+  const refreshBtn = accordionPanel.getByTestId("pointInTimeRestore:RefreshBtn");
+  await expect(refreshBtn).not.toBeVisible();
+
+  // Fast forward time by 11 minutes (11 * 60 * 1000ms = 660000ms)
+  await page.clock.fastForward(11 * 60 * 1000);
+
+  await expect(refreshBtn).toBeVisible();
+  await expect(pitrBtn).not.toBeVisible();
+
+  await refreshBtn.click();
+  await expect(loadingOverlay).toBeVisible();
+
+  await expect(loadingOverlay).toBeHidden({ timeout: 10 * 1000 });
+
+  // Veify Popover & Loading Overlay on permission screen with API mocks and accordion interactions
+
+  await page.route(
+    `**/Microsoft.DocumentDB/databaseAccounts/${expectedSourceAccountName}/sqlRoleAssignments*`,
+    async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({
+          value: [
+            {
+              principalId: "00-11-22-33",
+              roleDefinitionId: `Microsoft.DocumentDB/databaseAccounts/${expectedSourceAccountName}/77-88-99`,
+            },
+          ],
+        }),
+      });
+    },
+  );
+
+  await page.route("**/Microsoft.DocumentDB/databaseAccounts/*/77-88-99**", async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        value: [
+          {
+            name: "00000000-0000-0000-0000-000000000001",
+          },
+        ],
+      }),
+    });
+  });
+
+  await page.route(`**/Microsoft.DocumentDB/databaseAccounts/${targetAccountName}**`, async (route) => {
+    const mockData = {
+      identity: {
+        type: "SystemAssigned",
+        principalId: "00-11-22-33",
+      },
+      properties: {
+        defaultIdentity: "SystemAssignedIdentity",
+        backupPolicy: {
+          type: "Continuous",
+        },
+        capabilities: [{ name: "EnableOnlineContainerCopy" }],
+      },
+    };
+
+    if (route.request().method() === "PATCH") {
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({ status: "Succeeded" }),
+      });
+    } else if (route.request().method() === "GET") {
+      // Get the actual response and merge with mock data
+      const response = await route.fetch();
+      const actualData = await response.json();
+      const mergedData = { ...actualData };
+      set(mergedData, "identity", mockData.identity);
+      set(mergedData, "properties.defaultIdentity", mockData.properties.defaultIdentity);
+      set(mergedData, "properties.backupPolicy", mockData.properties.backupPolicy);
+      set(mergedData, "properties.capabilities", mockData.properties.capabilities);
+
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify(mergedData),
+      });
+    } else {
+      await route.continue();
+    }
+  });
+
+  await expect(permissionScreen).toBeVisible();
+
+  const expandedCrossAccordionHeader = permissionScreen
+    .getByTestId("permission-group-container-crossAccountConfigs")
+    .locator("button[aria-expanded='true']");
+  await expect(expandedCrossAccordionHeader).toBeVisible();
+
+  const crossAccordionItem = expandedCrossAccordionHeader
+    .locator("xpath=ancestor::*[contains(@class, 'fui-AccordionItem') or contains(@data-test, 'accordion-item')]")
+    .first();
+
+  const crossAccordionPanel = crossAccordionItem
+    .locator("[role='tabpanel'], .fui-AccordionPanel, [data-test*='panel']")
+    .first();
+
+  const toggleButton = crossAccordionPanel.getByTestId("btn-toggle");
+  await expect(toggleButton).toBeVisible();
+  await toggleButton.click();
+
+  const popover = frame.locator("[data-test='popover-container']");
+  await expect(popover).toBeVisible();
+
+  const yesButton = popover.getByRole("button", { name: /Yes/i });
+  const noButton = popover.getByRole("button", { name: /No/i });
+  await expect(yesButton).toBeVisible();
+  await expect(noButton).toBeVisible();
+
+  await yesButton.click();
+
+  await expect(loadingOverlay).toBeVisible();
+
+  await expect(loadingOverlay).toBeHidden({ timeout: 10 * 1000 });
+  await expect(popover).toBeHidden({ timeout: 10 * 1000 });
+
+  await panel.getByRole("button", { name: "Cancel" }).click();
+});
+
+test.afterAll("Container Copy - After All", async () => {
+  await page.unroute(/.*/, (route) => route.continue());
+  await page.close();
+});

test/sql/scaleAndSettings/changePartitionKey.spec.ts

@@ -1,5 +1,5 @@
 // import { expect, test } from "@playwright/test";
-// import { DataExplorer, TestAccount } from "../../fx";
+// import { DataExplorer, getDropdownItemByNameOrPosition, TestAccount } from "../../fx";
 // import { createTestSQLContainer, TestContainerContext } from "../../testData";
 
 // test.describe("Change Partition Key", () => {
@@ -83,8 +83,12 @@
 //     await changePkPanel.getByLabel("Use existing container").check();
 //     await changePkPanel.getByText("Choose an existing container").click();
 
-//     const containerDropdownItem = await explorer.getDropdownItemByName(newContainerId, "Existing Containers");
-//     await containerDropdownItem.click();
+// const containerDropdownItem = await getDropdownItemByNameOrPosition(
+//   explorer.frame,
+//   { name: newContainerId },
+//   { ariaLabel: "Existing Containers" },
+// );
+// await containerDropdownItem.click();
 
 //     await changePkPanel.getByTestId("Panel/OkButton").click();
 //     await explorer.frame.getByRole("button", { name: "Cancel" }).click();

test/testData.ts

@@ -80,6 +80,69 @@ type createTestSqlContainerConfig = {
   databaseName?: string;
 };
 
+type createMultipleTestSqlContainerConfig = {
+  containerCount?: number;
+  partitionKey?: string;
+  databaseName?: string;
+  accountType: TestAccount.SQLContainerCopyOnly | TestAccount.SQL;
+};
+
+export async function createMultipleTestContainers({
+  partitionKey = "/partitionKey",
+  databaseName = "",
+  containerCount = 1,
+  accountType = TestAccount.SQL,
+}: createMultipleTestSqlContainerConfig): Promise<TestContainerContext[]> {
+  const creationPromises: Promise<TestContainerContext>[] = [];
+
+  const databaseId = databaseName ? databaseName : generateUniqueName("db");
+  const credentials = getAzureCLICredentials();
+  const adaptedCredentials = new AzureIdentityCredentialAdapter(credentials);
+  const armClient = new CosmosDBManagementClient(adaptedCredentials, subscriptionId);
+  const accountName = getAccountName(accountType);
+  const account = await armClient.databaseAccounts.get(resourceGroupName, accountName);
+
+  const clientOptions: CosmosClientOptions = {
+    endpoint: account.documentEndpoint!,
+  };
+
+  const rbacToken =
+    accountType === TestAccount.SQL
+      ? process.env.NOSQL_TESTACCOUNT_TOKEN
+      : accountType === TestAccount.SQLContainerCopyOnly
+      ? process.env.NOSQL_CONTAINERCOPY_TESTACCOUNT_TOKEN
+      : "";
+  if (rbacToken) {
+    clientOptions.tokenProvider = async (): Promise<string> => {
+      const AUTH_PREFIX = `type=aad&ver=1.0&sig=`;
+      const authorizationToken = `${AUTH_PREFIX}${rbacToken}`;
+      return authorizationToken;
+    };
+  } else {
+    const keys = await armClient.databaseAccounts.listKeys(resourceGroupName, accountName);
+    clientOptions.key = keys.primaryMasterKey;
+  }
+
+  const client = new CosmosClient(clientOptions);
+  const { database } = await client.databases.createIfNotExists({ id: databaseId });
+
+  try {
+    for (let i = 0; i < containerCount; i++) {
+      const containerId = `testcontainer_${Date.now()}_${Math.random().toString(36).substring(6)}_${i}`;
+      creationPromises.push(
+        database.containers.createIfNotExists({ id: containerId, partitionKey }).then(({ container }) => {
+          return new TestContainerContext(armClient, client, database, container, new Map<string, TestItem>());
+        }),
+      );
+    }
+    const contexts = await Promise.all(creationPromises);
+    return contexts;
+  } catch (e) {
+    await database.delete();
+    throw e;
+  }
+}
+
 export async function createTestSQLContainer({
   includeTestData = false,
   partitionKey = "/partitionKey",

test/testExplorer/TestExplorer.ts

@@ -11,8 +11,12 @@ const accountName = urlSearchParams.get("accountName") || "portal-sql-runner-wes
 const selfServeType = urlSearchParams.get("selfServeType") || "example";
 const iframeSrc = urlSearchParams.get("iframeSrc") || "explorer.html?platform=Portal&disablePortalInitCache";
 const authToken = urlSearchParams.get("token");
+const enablecontainercopy = urlSearchParams.get("enablecontainercopy");
 
-const nosqlRbacToken = urlSearchParams.get("nosqlRbacToken") || process.env.NOSQL_TESTACCOUNT_TOKEN || "";
+const nosqlRbacToken =
+  urlSearchParams.get("nosqlRbacToken") ||
+  (enablecontainercopy ? process.env.NOSQL_CONTAINERCOPY_TESTACCOUNT_TOKEN : process.env.NOSQL_TESTACCOUNT_TOKEN) ||
+  "";
 const nosqlReadOnlyRbacToken =
   urlSearchParams.get("nosqlReadOnlyRbacToken") || process.env.NOSQL_READONLY_TESTACCOUNT_TOKEN || "";
 const tableRbacToken = urlSearchParams.get("tableRbacToken") || process.env.TABLE_TESTACCOUNT_TOKEN || "";
@@ -83,6 +87,7 @@ const initTestExplorer = async (): Promise<void> => {
       authorizationToken: `Bearer ${authToken}`,
       aadToken: rbacToken,
       features: {},
+      containerCopyEnabled: enablecontainercopy === "true",
       hasWriteAccess: true,
       csmEndpoint: "https://management.azure.com",
       dnsSuffix: "documents.azure.com",