Merge branch 'master' into users/sakshig/testIndexingPolicy

test/CORSBypass.ts

@@ -2,20 +2,54 @@ import { Page } from "@playwright/test";
 
 export async function setupCORSBypass(page: Page) {
   await page.route("**/api/mongo/explorer{,/**}", async (route) => {
+    const request = route.request();
+    const origin = request.headers()["origin"];
+
+    // If there's no origin, it's not a CORS request. Let it proceed without modification.
+    if (!origin) {
+      await route.continue();
+      return;
+    }
+
+    //// Handle preflight (OPTIONS) requests separately.
+    // These should not be forwarded to the target server.
+    if (request.method() === "OPTIONS") {
+      await route.fulfill({
+        status: 204, // No Content
+        headers: {
+          "Access-Control-Allow-Origin": origin,
+          "Access-Control-Allow-Credentials": "true",
+          "Access-Control-Allow-Methods": "GET,POST,PUT,DELETE,OPTIONS,HEAD",
+          "Access-Control-Request-Headers": "*, x-ms-continuation",
+          "Access-Control-Max-Age": "86400", // Cache preflight response for 1 day
+          Vary: "Origin",
+        },
+      });
+      return;
+    }
+
+    // Handle the actual GET/POST request
     const response = await route.fetch({
       headers: {
-        ...route.request().headers(),
+        ...request.headers(),
       },
     });
 
+    const responseHeaders = response.headers();
+    // Clean up any pre-existing CORS headers from the real response to avoid conflicts.
+    delete responseHeaders["access-control-allow-origin"];
+    delete responseHeaders["access-control-allow-credentials"];
+
     await route.fulfill({
       status: response.status(),
       headers: {
-        ...response.headers(),
-        "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Methods": "*",
+        ...responseHeaders,
+        "Access-Control-Allow-Origin": origin,
+        "Access-Control-Allow-Credentials": "true",
+        "Access-Control-Allow-Methods": "GET,POST,PUT,DELETE,OPTIONS,HEAD",
         "Access-Control-Allow-Headers": "*",
-        "Access-Control-Allow-Credentials": "*",
+        "Access-Control-Expose-Headers": "x-ms-continuation,x-ms-request-charge,x-ms-session-token",
+        Vary: "Origin",
       },
       body: await response.body(),
     });

test/fx.ts

@@ -250,7 +250,7 @@ class TreeNode {
       // Try three times to wait for the node to expand.
       for (let i = 0; i < RETRY_COUNT; i++) {
         try {
-          await tree.waitFor({ state: "visible" });
+          await tree.waitFor({ state: "visible", timeout: 30000 });
           // The tree has expanded, let's get out of here
           return true;
         } catch {

test/mongo/pagination.spec.ts

@@ -0,0 +1,132 @@
+import { expect, test } from "@playwright/test";
+import { setupCORSBypass } from "../CORSBypass";
+import { DataExplorer, QueryTab, TestAccount, CommandBarButton, Editor } from "../fx";
+import { serializeMongoToJson } from "../testData";
+
+const databaseId = "test-e2etests-mongo-pagination";
+const collectionId = "test-coll-mongo-pagination";
+let explorer: DataExplorer = null!;
+
+test.setTimeout(5 * 60 * 1000);
+
+test.describe("Test Mongo Pagination", () => {
+  let queryTab: QueryTab;
+  let queryEditor: Editor;
+
+  test.beforeEach("Open query tab", async ({ page }) => {
+    await setupCORSBypass(page);
+    explorer = await DataExplorer.open(page, TestAccount.MongoReadonly);
+
+    const containerNode = await explorer.waitForContainerNode(databaseId, collectionId);
+    await containerNode.expand();
+
+    const containerMenuNode = await explorer.waitForContainerDocumentsNode(databaseId, collectionId);
+    await containerMenuNode.openContextMenu();
+    await containerMenuNode.contextMenuItem("New Query").click();
+
+    queryTab = explorer.queryTab("tab0");
+    queryEditor = queryTab.editor();
+    await queryEditor.locator.waitFor({ timeout: 30 * 1000 });
+    await queryTab.executeCTA.waitFor();
+    await explorer.frame.getByTestId("NotificationConsole/ExpandCollapseButton").click();
+    await explorer.frame.getByTestId("NotificationConsole/Contents").waitFor();
+  });
+
+  test("should execute a query and load more results", async ({ page }) => {
+    const query = "{}";
+
+    await queryEditor.locator.click();
+    await queryEditor.setText(query);
+
+    const executeQueryButton = explorer.commandBarButton(CommandBarButton.ExecuteQuery);
+    await executeQueryButton.click();
+
+    // Wait for query execution to complete
+    await expect(queryTab.resultsView).toBeVisible({ timeout: 60000 });
+    await expect(queryTab.resultsEditor.locator).toBeAttached({ timeout: 30000 });
+
+    // Get initial results
+    const resultText = await queryTab.resultsEditor.text();
+
+    if (!resultText || resultText.trim() === "" || resultText.trim() === "[]") {
+      throw new Error("Query returned no results - the collection appears to be empty");
+    }
+
+    const resultData = serializeMongoToJson(resultText);
+
+    if (resultData.length === 0) {
+      throw new Error("Parsed results contain 0 documents - collection is empty");
+    }
+
+    if (resultData.length < 100) {
+      expect(resultData.length).toBeGreaterThan(0);
+      return;
+    }
+
+    expect(resultData.length).toBe(100);
+
+    // Pagination test
+    let totalPagesLoaded = 1;
+    const maxLoadMoreAttempts = 10;
+
+    for (let loadMoreAttempts = 0; loadMoreAttempts < maxLoadMoreAttempts; loadMoreAttempts++) {
+      const loadMoreButton = queryTab.resultsView.getByText("Load more");
+
+      try {
+        await expect(loadMoreButton).toBeVisible({ timeout: 5000 });
+      } catch {
+        // Load more button not visible - pagination complete
+        break;
+      }
+
+      const beforeClickText = await queryTab.resultsEditor.text();
+      const beforeClickHash = Buffer.from(beforeClickText || "")
+        .toString("base64")
+        .substring(0, 50);
+
+      await loadMoreButton.click();
+
+      // Wait for content to update
+      let editorContentChanged = false;
+      for (let waitAttempt = 1; waitAttempt <= 3; waitAttempt++) {
+        await page.waitForTimeout(2000);
+
+        const currentEditorText = await queryTab.resultsEditor.text();
+        const currentHash = Buffer.from(currentEditorText || "")
+          .toString("base64")
+          .substring(0, 50);
+
+        if (currentHash !== beforeClickHash) {
+          editorContentChanged = true;
+          break;
+        }
+      }
+
+      if (editorContentChanged) {
+        totalPagesLoaded++;
+      } else {
+        // No content change detected, stop pagination
+        break;
+      }
+
+      await page.waitForTimeout(1000);
+    }
+
+    // Final verification
+    const finalIndicator = queryTab.resultsView.locator("text=/\\d+ - \\d+/");
+    const finalIndicatorText = await finalIndicator.textContent();
+
+    if (finalIndicatorText) {
+      const match = finalIndicatorText.match(/(\d+) - (\d+)/);
+      if (match) {
+        const totalDocuments = parseInt(match[2]);
+        expect(totalDocuments).toBe(405);
+        expect(totalPagesLoaded).toBe(5);
+      } else {
+        throw new Error(`Invalid results indicator format: ${finalIndicatorText}`);
+      }
+    } else {
+      expect(totalPagesLoaded).toBe(5);
+    }
+  });
+});

test/sql/containercopy/offlineMigration.spec.ts

@@ -9,9 +9,10 @@ import {
   TestAccount,
   waitForApiResponse,
 } from "../../fx";
-import { createMultipleTestContainers } from "../../testData";
+import { createMultipleTestContainers, TestContainerContext } from "../../testData";
 
 test.describe("Container Copy - Offline Migration", () => {
+  let contexts: TestContainerContext[];
   let page: Page;
   let wrapper: Locator;
   let panel: Locator;
@@ -22,7 +23,7 @@ test.describe("Container Copy - Offline Migration", () => {
   let expectedCopyJobNameInitial: string;
 
   test.beforeEach("Setup for offline migration test", async ({ browser }) => {
-    await createMultipleTestContainers({ accountType: TestAccount.SQLContainerCopyOnly, containerCount: 2 });
+    contexts = await createMultipleTestContainers({ accountType: TestAccount.SQLContainerCopyOnly, containerCount: 2 });
 
     page = await browser.newPage();
     ({ wrapper, frame } = await ContainerCopy.open(page, TestAccount.SQLContainerCopyOnly));
@@ -33,6 +34,7 @@ test.describe("Container Copy - Offline Migration", () => {
   test.afterEach("Cleanup after offline migration test", async () => {
     await page.unroute(/.*/, (route) => route.continue());
     await page.close();
+    await Promise.all(contexts.map((context) => context?.dispose()));
   });
 
   test("Successfully create and manage offline migration copy job", async () => {

test/sql/containercopy/onlineMigration.spec.ts

@@ -7,9 +7,10 @@ import {
   TestAccount,
   waitForApiResponse,
 } from "../../fx";
-import { createMultipleTestContainers } from "../../testData";
+import { createMultipleTestContainers, TestContainerContext } from "../../testData";
 
 test.describe("Container Copy - Online Migration", () => {
+  let contexts: TestContainerContext[];
   let page: Page;
   let wrapper: Locator;
   let panel: Locator;
@@ -17,7 +18,7 @@ test.describe("Container Copy - Online Migration", () => {
   let targetAccountName: string;
 
   test.beforeEach("Setup for online migration test", async ({ browser }) => {
-    await createMultipleTestContainers({ accountType: TestAccount.SQLContainerCopyOnly, containerCount: 2 });
+    contexts = await createMultipleTestContainers({ accountType: TestAccount.SQLContainerCopyOnly, containerCount: 2 });
 
     page = await browser.newPage();
     ({ wrapper, frame } = await ContainerCopy.open(page, TestAccount.SQLContainerCopyOnly));
@@ -27,6 +28,7 @@ test.describe("Container Copy - Online Migration", () => {
   test.afterEach("Cleanup after online migration test", async () => {
     await page.unroute(/.*/, (route) => route.continue());
     await page.close();
+    await Promise.all(contexts.map((context) => context?.dispose()));
   });
 
   test("Successfully create and manage online migration copy job", async () => {

test/sql/resourceToken.spec.ts

@@ -2,7 +2,6 @@ import { expect, test } from "@playwright/test";
 
 import { CosmosDBManagementClient } from "@azure/arm-cosmosdb";
 import { CosmosClient, PermissionMode } from "@azure/cosmos";
-import { AzureIdentityCredentialAdapter } from "@azure/ms-rest-js";
 import {
   DataExplorer,
   TestAccount,
@@ -18,8 +17,7 @@ test("SQL account using Resource token", async ({ page }) => {
   test.skip(nosqlAccountRbacToken.length > 0, "Resource tokens not supported when using data plane RBAC.");
 
   const credentials = getAzureCLICredentials();
-  const adaptedCredentials = new AzureIdentityCredentialAdapter(credentials);
-  const armClient = new CosmosDBManagementClient(adaptedCredentials, subscriptionId);
+  const armClient = new CosmosDBManagementClient(credentials, subscriptionId);
   const accountName = getAccountName(TestAccount.SQL);
   const account = await armClient.databaseAccounts.get(resourceGroupName, accountName);
   const keys = await armClient.databaseAccounts.listKeys(resourceGroupName, accountName);

test/testData.ts

@@ -1,9 +1,15 @@
-import crypto from "crypto";
-
 import { CosmosDBManagementClient } from "@azure/arm-cosmosdb";
-import { BulkOperationType, Container, CosmosClient, CosmosClientOptions, Database, JSONObject } from "@azure/cosmos";
-import { AzureIdentityCredentialAdapter } from "@azure/ms-rest-js";
-
+import {
+  BulkOperationType,
+  Container,
+  CosmosClient,
+  CosmosClientOptions,
+  Database,
+  ErrorResponse,
+  JSONObject,
+} from "@azure/cosmos";
+import { Buffer } from "node:buffer";
+import { webcrypto } from "node:crypto";
 import {
   generateUniqueName,
   getAccountName,
@@ -12,6 +18,7 @@ import {
   subscriptionId,
   TestAccount,
 } from "./fx";
+globalThis.crypto = webcrypto as Crypto;
 
 export interface TestItem {
   id: string;
@@ -60,8 +67,9 @@ function createTestItems(): TestItem[] {
 
 // Document IDs cannot contain '/', '\', or '#'
 function createSafeRandomString(byteLength: number): string {
-  return crypto
-    .randomBytes(byteLength)
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+  return Buffer.from(bytes)
     .toString("base64")
     .replace(/[/\\#]/g, "_");
 }
@@ -78,7 +86,14 @@ export class TestContainerContext {
   ) {}
 
   async dispose() {
-    await this.database.delete();
+    try {
+      await this.database.delete();
+    } catch (error) {
+      if (error instanceof ErrorResponse && error.code === 404) {
+        return; // Resource already deleted, ignore
+      }
+      throw error; // Re-throw other errors
+    }
   }
 }
 
@@ -104,8 +119,7 @@ async function createCosmosClientForSQLAccount(
   accountType: TestAccount.SQL | TestAccount.SQLContainerCopyOnly = TestAccount.SQL,
 ): Promise<{ armClient: CosmosDBManagementClient; client: CosmosClient }> {
   const credentials = getAzureCLICredentials();
-  const adaptedCredentials = new AzureIdentityCredentialAdapter(credentials);
-  const armClient = new CosmosDBManagementClient(adaptedCredentials, subscriptionId);
+  const armClient = new CosmosDBManagementClient(credentials, subscriptionId);
   const accountName = getAccountName(accountType);
   const account = await armClient.databaseAccounts.get(resourceGroupName, accountName);
 
@@ -232,7 +246,7 @@ export async function createTestSQLContainer({
 }
 
 export const setPartitionKeys = (partitionKeys: PartitionKey[]) => {
-  const result = {};
+  const result: Record<string, unknown> = {};
 
   partitionKeys.forEach((partitionKey) => {
     const { key: keyPath, value: keyValue } = partitionKey;
@@ -245,7 +259,7 @@ export const setPartitionKeys = (partitionKeys: PartitionKey[]) => {
         current[key] = keyValue;
       } else {
         current[key] = current[key] || {};
-        current = current[key];
+        current = current[key] as Record<string, unknown>;
       }
     });
   });