Improve test coverage to ~100% for @azure/core-amqp (Azure#38174)

## Changes

### New test files
- checkNetworkConnection.spec.ts (browser)
- checkNetworkMocked.spec.ts (node, mocked network)
- errors.spec.ts (browser)
- hmacSha256.spec.ts (browser)
- retryNetworkDown.spec.ts (node)
- runtimeInfo.spec.ts (browser)
- typeGuards.spec.ts
- utils.spec.ts

### Expanded existing tests
- cbs.spec.ts: connection error paths, session close errors
- context.spec.ts: extracted properties/webSocketOptions into typed
consts
- errors.spec.ts: translate edge cases, mapping coverage
- lock.spec.ts: timeout and release paths
- message.spec.ts: header/properties encoding edge cases
- pipeline.spec.ts: policy ordering
- requestResponse.spec.ts: retry, timeout, cleanup callbacks
- retry.spec.ts: all retry modes and error paths
- tokenProvider.spec.ts: token refresh edge cases

### Test quality improvements
- Replaced hand-rolled counters with vi.fn() + toHaveBeenCalledTimes()
- Replaced boolean tracking flags with vi.fn() + toHaveBeenCalled()
- Replaced try/catch + assert.fail with rejects.toThrow()
- Removed unnecessary as any casts
- Extracted non-null assertions into typed consts

---------

Co-authored-by: Deyaaeldeen Almahallawi <deyaa@microsoft.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 3 people

sdk/core/core-amqp/test/internal/browser/checkNetworkConnection.spec.ts

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { describe, it, assert } from "vitest";
+import { checkNetworkConnection } from "../../../src/util/checkNetworkConnection.common.js";
+
+describe("checkNetworkConnection (browser)", function () {
+  it("returns a boolean reflecting navigator.onLine", async function () {
+    const result = await checkNetworkConnection("hostname.example.com");
+    assert.isBoolean(result);
+    // In a browser test environment, navigator.onLine should be true
+    assert.equal(result, self.navigator.onLine);
+  });
+});

sdk/core/core-amqp/test/internal/browser/errors.spec.ts

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { describe, it, assert } from "vitest";
+import { translate, MessagingError } from "../../../src/errors.js";
+
+describe("translate - isBrowserWebsocketError (browser)", function () {
+  it("translates a WebSocket error event into a MessagingError", function () {
+    const ws = Object.create(WebSocket.prototype);
+    const errorEvent = new Event("error");
+    Object.defineProperty(errorEvent, "target", { value: ws, writable: false });
+
+    const result = translate(errorEvent);
+
+    assert.instanceOf(result, MessagingError);
+    assert.equal(result.code, "ServiceCommunicationError");
+    assert.isFalse(result.retryable);
+    assert.include(result.message, "Websocket");
+  });
+
+  it("does not treat a plain error as a browser websocket error", function () {
+    const plainError = new Error("not a websocket error");
+    const result = translate(plainError);
+
+    // A plain Error should be returned as-is, not wrapped as ServiceCommunicationError
+    assert.equal(result, plainError);
+  });
+});

sdk/core/core-amqp/test/internal/browser/hmacSha256.spec.ts

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { describe, it, assert } from "vitest";
+import { signString } from "../../../src/util/hmacSha256.common.js";
+
+describe("signString (browser - Web Crypto)", function () {
+  it("produces a URL-encoded base64 HMAC-SHA256 signature", async function () {
+    const signature = await signString("testKey", "testMessage");
+    assert.strictEqual(signature, "8N7PlLvnGgnE2gFU7%2BAkSxmAc02cXFkOLlFD5gTuOjo%3D");
+    assert.strictEqual(
+      decodeURIComponent(signature),
+      "8N7PlLvnGgnE2gFU7+AkSxmAc02cXFkOLlFD5gTuOjo=",
+    );
+  });
+
+  it("returns consistent results for the same inputs", async function () {
+    const sig1 = await signString("key", "data");
+    const sig2 = await signString("key", "data");
+    assert.equal(sig1, sig2);
+  });
+
+  it("returns different results for different keys", async function () {
+    const sig1 = await signString("key1", "data");
+    const sig2 = await signString("key2", "data");
+    assert.notEqual(sig1, sig2);
+  });
+});

sdk/core/core-amqp/test/internal/browser/runtimeInfo.spec.ts

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { describe, it, assert } from "vitest";
+import { getPlatformInfo, getFrameworkInfo } from "../../../src/util/runtimeInfo-browser.mjs";
+
+describe("runtimeInfo (browser)", function () {
+  it("getPlatformInfo returns a string containing 'javascript-Browser'", function () {
+    const info = getPlatformInfo();
+    assert.include(info, "javascript-Browser");
+    assert.match(info, /^\(javascript-Browser-.+\)$/);
+  });
+
+  it("getFrameworkInfo returns a string starting with 'Browser/'", function () {
+    const info = getFrameworkInfo();
+    assert.match(info, /^Browser\/.+/);
+  });
+});

sdk/core/core-amqp/test/internal/errors.spec.ts

@@ -33,7 +33,7 @@ describe("Errors", function () {
       ];
 
       for (let i = 0; i < cases.length; i++) {
-        const translatedError = Errors.translate(cases[i].input as any);
+        const translatedError = Errors.translate(cases[i].input);
 
         assert.equal(translatedError.name, "Error");
         assert.equal(
@@ -68,20 +68,22 @@ describe("Errors", function () {
             "'Error: getaddrinfo ENOTFOUND example.invalid\n    at GetAddrInfoReqWrap.onlookupall [as oncomplete] (node:dns:118:26)\n    at GetAddrInfoReqWrap.callbackTrampoline (node:internal/async_hooks:130:17)'",
         },
       };
-      const translatedError = Errors.translate(testError) as Errors.MessagingError;
+      const translatedError = Errors.translate(testError);
+      assert.instanceOf(translatedError, Errors.MessagingError);
       assert.equal(testError.error.message, translatedError.message);
       assert.equal(translatedError.name, "MessagingError");
       assert.equal(translatedError.code, "ENOTFOUND");
       assert.equal(translatedError.code, testError.error.code);
       assert.equal(translatedError.message, testError.error.message);
       assert.equal(translatedError.stack, testError.error.stack);
-      assert.equal(translatedError.retryable, false);
+      assert.isFalse(translatedError.retryable);
     });
 
     it("Sets retryable to true, if input is custom error and name is OperationTimeoutError", function () {
       const err = new Error("error message");
       err.name = "OperationTimeoutError";
-      const translatedError = Errors.translate(err) as Errors.MessagingError;
+      const translatedError = Errors.translate(err);
+      assert.instanceOf(translatedError, Errors.MessagingError);
       assert.equal(translatedError.name, "MessagingError");
       assert.equal(translatedError.code, "OperationTimeoutError");
       assert.equal(translatedError.message, err.message);
@@ -92,7 +94,8 @@ describe("Errors", function () {
     it("Sets retryable to true, if input is custom error and name is InsufficientCreditError", function () {
       const err = new Error("error message");
       err.name = "InsufficientCreditError";
-      const translatedError = Errors.translate(err) as Errors.MessagingError;
+      const translatedError = Errors.translate(err);
+      assert.instanceOf(translatedError, Errors.MessagingError);
       assert.equal(translatedError.name, "MessagingError");
       assert.equal(translatedError.code, "InsufficientCreditError");
       assert.equal(translatedError.message, err.message);
@@ -103,7 +106,8 @@ describe("Errors", function () {
     it("Does not sets retryable to true, if input is custom error and name is SendOperationFailedError", function () {
       const err = new Error("error message");
       err.name = "SendOperationFailedError";
-      const translatedError = Errors.translate(err) as Errors.MessagingError;
+      const translatedError = Errors.translate(err);
+      assert.instanceOf(translatedError, Errors.MessagingError);
       assert.equal(translatedError.name, "MessagingError");
       assert.equal(translatedError.code, "SendOperationFailedError");
       assert.equal(translatedError.message, err.message);
@@ -117,7 +121,7 @@ describe("Errors", function () {
       assert.equal(translatedError.name, "AbortError");
       assert.equal(translatedError.message, err.message);
       assert.equal(translatedError.stack, err.stack);
-      assert.isUndefined((translatedError as Errors.MessagingError).retryable);
+      assert.notInstanceOf(translatedError, Errors.MessagingError);
     });
 
     [
@@ -140,7 +144,8 @@ describe("Errors", function () {
     ].forEach(function (mapping) {
       it("translates " + mapping.from + " into " + mapping.to, function () {
         const err: any = new AMQPError(mapping.from, mapping.message);
-        const translatedError = Errors.translate(err) as Errors.MessagingError;
+        const translatedError = Errors.translate(err);
+        assert.instanceOf(translatedError, Errors.MessagingError);
         // <unknown> won't have a code since it has no matching condition
         if (translatedError.code) {
           assert.equal(translatedError.code, mapping.to);
@@ -206,7 +211,8 @@ describe("Errors", function () {
       it(
         "SystemError from node.js  with code: '" + mapping.code + "' to a MessagingError",
         function () {
-          const translatedError = Errors.translate(mapping as any) as Errors.MessagingError;
+          const translatedError = Errors.translate(mapping);
+          assert.instanceOf(translatedError, Errors.MessagingError);
           assert.equal(translatedError.name, "MessagingError");
           assert.equal(translatedError.code, mapping.code);
           if (
@@ -350,3 +356,45 @@ describe("Errors", function () {
     });
   });
 });
+
+describe("errors.ts", () => {
+  it("translate maps AMQP error with status-code: 404 in description to MessagingEntityNotFoundError", () => {
+    const err: any = {
+      name: "AmqpProtocolError",
+      condition: "amqp:not-found",
+      description: "The messaging entity blah could not be found. status-code: 404",
+    };
+    const translated = Errors.translate(err);
+    assert.instanceOf(translated, Errors.MessagingError);
+    assert.equal(translated.code, "MessagingEntityNotFoundError");
+  });
+
+  it("translate maps AMQP error with 'messaging entity could not be found' to MessagingEntityNotFoundError", () => {
+    const err: any = {
+      name: "AmqpProtocolError",
+      condition: "amqp:not-found",
+      description: "The messaging entity 'myentity' could not be found.",
+    };
+    const translated = Errors.translate(err);
+    assert.instanceOf(translated, Errors.MessagingError);
+    assert.equal(translated.code, "MessagingEntityNotFoundError");
+  });
+
+  it("translate handles already-translated MessagingError", () => {
+    const err = new Errors.MessagingError("already translated");
+    const translated = Errors.translate(err);
+    assert.strictEqual(translated, err);
+  });
+
+  it("translate handles MessageWaitTimeout condition", () => {
+    const err: any = {
+      name: "AmqpProtocolError",
+      condition: "com.microsoft:message-wait-timeout",
+      description: "No messages available",
+    };
+    const translated = Errors.translate(err);
+    assert.instanceOf(translated, Errors.MessagingError);
+    assert.equal(translated.name, "MessagingError");
+    assert.equal(translated.code, "MessageWaitTimeout");
+  });
+});