chore: add verification sample for PR #196

Verification sample: examples/verification/pr-196-connection-string-case-insensitive.ts

Verifies that connection string property keys are parsed case-insensitively,
matching Azure SDK conventions. Tests parsing with lowercase, uppercase,
mixed-case, and PascalCase keys, plus an end-to-end orchestration using a
lowercase connection string against the DTS emulator.

Generated by pr-verification-agent

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

Author: Copilot

examples/verification/pr-196-connection-string-case-insensitive.ts

@@ -0,0 +1,260 @@
+// Verification sample for PR #196: Fix connection string property key lookup case sensitivity
+//
+// Customer scenario: A developer configures their Durable Task Scheduler connection
+// using a connection string copied from a config file or environment variable that
+// has lowercase or mixed-case property keys (e.g., "endpoint=..." instead of
+// "Endpoint=..."). This is common when connection strings are generated by scripts,
+// stored in environment variables by deployment tools, or copied from documentation
+// that uses different casing conventions.
+//
+// Before fix: The connection string parser would throw an error like
+// "The connection string must contain an Authentication property" because keys
+// were stored and looked up case-sensitively (e.g., "authentication" != "Authentication").
+//
+// After fix: Property keys are normalized to lowercase during parsing, so connection
+// strings work regardless of key casing — matching Azure SDK conventions.
+
+import {
+  OrchestrationContext,
+  ActivityContext,
+  OrchestrationStatus,
+  TOrchestrator,
+  TActivity,
+} from "@microsoft/durabletask-js";
+import {
+  DurableTaskAzureManagedClientBuilder,
+  DurableTaskAzureManagedWorkerBuilder,
+  DurableTaskAzureManagedConnectionString,
+} from "@microsoft/durabletask-js-azuremanaged";
+
+const endpoint = process.env.ENDPOINT || "localhost:8080";
+const taskHub = process.env.TASKHUB || "default";
+
+// Step 1: Verify that connection strings with different key casings parse correctly.
+// This is the core behavior the PR fixes.
+function verifyConnectionStringParsing(): {
+  passed: boolean;
+  details: { casing: string; connectionString: string; result: string }[];
+} {
+  const testCases = [
+    {
+      casing: "all-lowercase",
+      connectionString: `endpoint=http://${endpoint};authentication=None;taskhub=${taskHub}`,
+    },
+    {
+      casing: "all-uppercase",
+      connectionString: `ENDPOINT=http://${endpoint};AUTHENTICATION=None;TASKHUB=${taskHub}`,
+    },
+    {
+      casing: "mixed-case",
+      connectionString: `endPoint=http://${endpoint};AUTHENTICATION=None;taskHub=${taskHub}`,
+    },
+    {
+      casing: "PascalCase (standard)",
+      connectionString: `Endpoint=http://${endpoint};Authentication=None;TaskHub=${taskHub}`,
+    },
+    {
+      casing: "lowercase with optional ClientID",
+      connectionString: `endpoint=http://${endpoint};authentication=None;taskhub=${taskHub};clientid=test-client-id`,
+    },
+  ];
+
+  const details: { casing: string; connectionString: string; result: string }[] = [];
+  let allPassed = true;
+
+  for (const tc of testCases) {
+    try {
+      const parsed = new DurableTaskAzureManagedConnectionString(tc.connectionString);
+      // Verify that values are correctly extracted regardless of key casing
+      const ep = parsed.getEndpoint();
+      const auth = parsed.getAuthentication();
+      const hub = parsed.getTaskHubName();
+
+      if (ep && auth && hub) {
+        details.push({ casing: tc.casing, connectionString: tc.connectionString, result: "PASS" });
+      } else {
+        details.push({
+          casing: tc.casing,
+          connectionString: tc.connectionString,
+          result: `FAIL: missing values (endpoint=${ep}, auth=${auth}, taskHub=${hub})`,
+        });
+        allPassed = false;
+      }
+    } catch (err: any) {
+      details.push({
+        casing: tc.casing,
+        connectionString: tc.connectionString,
+        result: `FAIL: ${err.message}`,
+      });
+      allPassed = false;
+    }
+  }
+
+  return { passed: allPassed, details };
+}
+
+// Step 2: Verify that a lowercase connection string can be used to actually connect
+// to the DTS emulator and run an orchestration end-to-end.
+
+// A simple order-processing orchestration that a customer might write
+const processOrder: TOrchestrator = async function* (ctx: OrchestrationContext, orderId: string): any {
+  // Validate the order
+  const isValid: boolean = yield ctx.callActivity(validateOrder, orderId);
+  if (!isValid) {
+    return { orderId, status: "rejected", reason: "validation failed" };
+  }
+
+  // Process payment
+  const paymentResult: string = yield ctx.callActivity(processPayment, orderId);
+
+  return { orderId, status: "completed", paymentResult };
+};
+
+const validateOrder: TActivity<string, boolean> = async (
+  _ctx: ActivityContext,
+  orderId: string,
+): Promise<boolean> => {
+  // Simulate order validation
+  console.log(`  [Activity] Validating order: ${orderId}`);
+  return orderId.length > 0;
+};
+
+const processPayment: TActivity<string, string> = async (
+  _ctx: ActivityContext,
+  orderId: string,
+): Promise<string> => {
+  // Simulate payment processing
+  console.log(`  [Activity] Processing payment for order: ${orderId}`);
+  return `payment-${orderId}-confirmed`;
+};
+
+async function main() {
+  console.log("=== PR #196 Verification: Connection String Case-Insensitive Keys ===\n");
+
+  // --- Part 1: Connection string parsing verification ---
+  console.log("--- Part 1: Connection string parsing with various key casings ---\n");
+  const parseResult = verifyConnectionStringParsing();
+
+  for (const detail of parseResult.details) {
+    const icon = detail.result === "PASS" ? "✅" : "❌";
+    console.log(`  ${icon} ${detail.casing}: ${detail.result}`);
+  }
+  console.log();
+
+  if (!parseResult.passed) {
+    console.log("=== VERIFICATION RESULT ===");
+    console.log(
+      JSON.stringify(
+        {
+          pr: 196,
+          scenario: "connection-string-case-insensitive-parsing",
+          passed: false,
+          parseResults: parseResult.details,
+          timestamp: new Date().toISOString(),
+        },
+        null,
+        2,
+      ),
+    );
+    process.exit(1);
+  }
+
+  // --- Part 2: End-to-end orchestration using lowercase connection string ---
+  console.log("--- Part 2: End-to-end orchestration with lowercase connection string ---\n");
+
+  // Use an all-lowercase connection string — this is the exact scenario that
+  // previously failed before the fix
+  const lowercaseConnectionString = `endpoint=http://${endpoint};authentication=None;taskhub=${taskHub}`;
+  console.log(`  Connection string: ${lowercaseConnectionString}\n`);
+
+  const client = new DurableTaskAzureManagedClientBuilder()
+    .connectionString(lowercaseConnectionString)
+    .build();
+
+  const worker = new DurableTaskAzureManagedWorkerBuilder()
+    .connectionString(lowercaseConnectionString)
+    .addOrchestrator(processOrder)
+    .addActivity(validateOrder)
+    .addActivity(processPayment)
+    .build();
+
+  await worker.start();
+  console.log("  Worker started successfully with lowercase connection string\n");
+
+  const orderId = `order-${Date.now()}`;
+  const id = await client.scheduleNewOrchestration(processOrder, { input: orderId });
+  console.log(`  Orchestration scheduled: ${id}`);
+
+  const state = await client.waitForOrchestrationCompletion(id, undefined, 30);
+
+  const expectedStatus = OrchestrationStatus.COMPLETED;
+  const actualStatus = state?.runtimeStatus;
+  const statusName = actualStatus !== undefined ? OrchestrationStatus[actualStatus] : "UNKNOWN";
+  const passed = parseResult.passed && actualStatus === expectedStatus;
+
+  let output: any = undefined;
+  try {
+    output = state?.serializedOutput ? JSON.parse(state.serializedOutput) : undefined;
+  } catch {
+    output = state?.serializedOutput;
+  }
+
+  console.log(`\n  Orchestration completed:`);
+  console.log(`    Instance ID: ${id}`);
+  console.log(`    Status: ${statusName}`);
+  console.log(`    Output: ${JSON.stringify(output)}`);
+  console.log();
+
+  console.log("=== VERIFICATION RESULT ===");
+  console.log(
+    JSON.stringify(
+      {
+        pr: 196,
+        scenario: "connection-string-case-insensitive-keys",
+        checks: [
+          {
+            name: "Parse lowercase keys",
+            expected: "PASS",
+            actual: parseResult.details.find((d) => d.casing === "all-lowercase")?.result,
+            passed: parseResult.details.find((d) => d.casing === "all-lowercase")?.result === "PASS",
+          },
+          {
+            name: "Parse uppercase keys",
+            expected: "PASS",
+            actual: parseResult.details.find((d) => d.casing === "all-uppercase")?.result,
+            passed: parseResult.details.find((d) => d.casing === "all-uppercase")?.result === "PASS",
+          },
+          {
+            name: "Parse mixed-case keys",
+            expected: "PASS",
+            actual: parseResult.details.find((d) => d.casing === "mixed-case")?.result,
+            passed: parseResult.details.find((d) => d.casing === "mixed-case")?.result === "PASS",
+          },
+          {
+            name: "E2E orchestration with lowercase connection string",
+            expected: "COMPLETED",
+            actual: statusName,
+            passed: actualStatus === expectedStatus,
+          },
+        ],
+        instanceId: id,
+        status: statusName,
+        output,
+        passed,
+        timestamp: new Date().toISOString(),
+      },
+      null,
+      2,
+    ),
+  );
+
+  await worker.stop();
+  await client.stop();
+
+  process.exit(passed ? 0 : 1);
+}
+
+main().catch((err) => {
+  console.error("Verification failed with error:", err);
+  process.exit(1);
+});