test: port full BasicNode Functions host E2E suite (Storage backend)

Replace the thin 2-function smoke app with a faithful port of the extension
repo's BasicNode app and xUnit E2E suite, wired to the published
durable-functions (^3.1.0) + @azure/functions (^4.11.2) so the suite is
genuinely runnable rather than blocked on an unmerged in-repo package.

App (test-app/): port all orchestrators, activities, class-based entities and
client-operation HTTP triggers verbatim (HelloCities, ActivityInputType,
Suspend/Resume, Terminate, Timeout, Rewind, IsReplaying checks, LargeOutput,
activity/entity error handling, orchestration query, purge), plus Shared/
ExceptionTypes.ts and a generic StartOrchestration starter.

Harness: generalize to mirror DurableHelpers/HttpHelpers (invokeHttpTrigger,
parseInstanceId/parseStatusQueryGetUri, waitForOrchestrationState,
getOrchestrationDetails) and add the Node localizer strings. Keep the shared
single-host lifecycle with func/Azurite preflight + clean skip.

Specs: 13 area specs ported faithfully from the xUnit tests using the Node
localizer strings. Node/Node-DTS skip traits translated (Storage backend keeps
Node-DTS tests); Node bug annotations honored (#642, #564, #608, #645, #679,
#644, and the suspend/resume/terminate-of-terminal swallow quirk).

Infra: remove the unmerged-package dependency and PR#282 gating language from
the workflow, script, eslint/prettier ignores; rewrite the README with the new
scenarios, prerequisites, run instructions and deferred follow-ups.

Verified locally: build + typecheck + eslint + prettier clean; full suite runs
green against a real func host + Azurite (13 suites, 35 passed, 10 skipped).

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

Author: YunchuWang

.github/workflows/functions-e2e-tests.yaml

@@ -2,13 +2,14 @@ name: 🧪 Functions Host E2E Tests
 
 # Gated Azure Functions host E2E suite. It launches a real `func start` host for
 # test/e2e-functions/test-app (backed by Azurite / AzureStorage) and drives the
-# app over HTTP. It exercises the in-repo `durable-functions` package added by
-# PR #282 (packages/azure-functions-durable), which is NOT on `main` yet.
+# app over HTTP, porting the extension repo's `BasicNode` app + xUnit tests.
 #
-# Every job is gated behind the `RUN_FUNCTIONS_E2E` repository variable, so this
-# workflow is a no-op until that variable is set to 'true' (do so only after
-# PR #282 has merged). Until then, existing CI stays green and this suite never
-# runs — mirroring durabletask-python PR #155.
+# The test-app depends on the PUBLISHED `durable-functions` + `@azure/functions`
+# packages, so it installs and runs without any in-repo package build. The suite
+# self-gates: each spec SKIPS cleanly when the Azure Functions Core Tools (`func`)
+# or the Azurite storage emulator are unavailable, and RUNS when both are present.
+# In CI below we install and start both, so the suite runs for real; the self-skip
+# is the safety net that keeps the job green if a prerequisite fails to come up.
 
 on:
   workflow_dispatch:
@@ -24,8 +25,6 @@ permissions:
 
 jobs:
   functions-e2e-tests:
-    # No-op until the repo variable is set after PR #282 merges.
-    if: ${{ vars.RUN_FUNCTIONS_E2E == 'true' }}
     strategy:
       fail-fast: false
       matrix:
@@ -43,14 +42,12 @@ jobs:
           node-version: ${{ matrix.node-version }}
           registry-url: "https://registry.npmjs.org"
 
+      # Root install provides jest + ts-jest used to run the spec files. The specs
+      # do not depend on the core durabletask-js packages, so no workspace build is
+      # required here.
       - name: ⚙️ Install dependencies
         run: npm ci
 
-      # Builds the workspace including packages/azure-functions-durable (PR #282).
-      # If that package is absent the test-app cannot install and the suite skips.
-      - name: 🏗️ Build workspace
-        run: npm run build
-
       - name: 🔧 Install Azurite and Azure Functions Core Tools
         run: npm install -g azurite azure-functions-core-tools@4
 
@@ -68,6 +65,8 @@ jobs:
             sleep 1
           done
 
+      # Installs the PUBLISHED durable-functions / @azure/functions packages and
+      # compiles the ported BasicNode app to dist/ (consumed by `func start`).
       - name: 📦 Install + build test-app
         working-directory: test/e2e-functions/test-app
         run: |

.prettierignore

@@ -8,6 +8,6 @@ coverage
 # don't lint proto files and output
 proto
 
-# vendored Azure Functions sample app — kept byte-for-byte identical to
-# azure-functions-durable-js (its own 4-space toolchain; see PR #282)
+# ported Azure Functions sample app — kept close to
+# azure-functions-durable-js's BasicNode (its own 4-space toolchain)
 test/e2e-functions/test-app

eslint.config.mjs

@@ -41,8 +41,8 @@ export default tseslint.config(
       "**/jest.config.js",
       "jest.functions-e2e.config.js",
       "**/src/proto/**",
-      // Vendored Azure Functions sample app kept byte-for-byte identical to
-      // azure-functions-durable-js; it has its own toolchain (see PR #282).
+      // Ported Azure Functions sample app (from azure-functions-durable-js's
+      // `BasicNode`), kept close to source and with its own 4-space toolchain.
       "test/e2e-functions/test-app/**",
     ],
   }

jest.functions-e2e.config.js

@@ -21,6 +21,7 @@ module.exports = {
     ],
   },
   globalSetup: "<rootDir>/test/e2e-functions/global-setup.ts",
+  globalTeardown: "<rootDir>/test/e2e-functions/global-teardown.ts",
   // Host cold-start (extension-bundle download + worker spin-up) dominates.
   testTimeout: 300_000,
 };

scripts/test-e2e-functions.sh

@@ -5,12 +5,13 @@
 # Azure Functions host ("func start") for test/e2e-functions/test-app, backed by
 # Azurite (the local Azure Storage emulator), and drives it over HTTP.
 #
+# The test-app depends on the PUBLISHED durable-functions / @azure/functions
+# packages, so it installs and builds without any in-repo package build.
+#
 # Prerequisites (the suite SKIPS cleanly if any are missing):
 #   - Azure Functions Core Tools ('func') v4 on PATH
 #   - Azurite reachable on 127.0.0.1:10000 (started here if the 'azurite' CLI is
 #     installed and the port is free)
-#   - packages/azure-functions-durable present (PR #282) so the test-app's local
-#     'durable-functions' dependency installs
 
 set -uo pipefail
 
@@ -42,17 +43,10 @@ if ! azurite_up; then
     fi
 fi
 
-# Build the workspace (incl. packages/azure-functions-durable from PR #282) so
-# the test-app's local 'durable-functions' dependency resolves.
-echo "Building workspace..."
-( cd "$ROOT_DIR" && npm run build )
-
-if [ -f "$ROOT_DIR/packages/azure-functions-durable/package.json" ]; then
-    echo "Installing + building test-app..."
-    ( cd "$TEST_APP_DIR" && npm install && npm run build )
-else
-    echo "packages/azure-functions-durable not found (PR #282 not merged); the suite will skip."
-fi
+# Install + build the ported BasicNode app against the published durable-functions
+# package so 'func start' has a dist/ to serve.
+echo "Installing + building test-app..."
+( cd "$TEST_APP_DIR" && npm install && npm run build )
 
 echo "Running Functions host E2E tests..."
 ( cd "$ROOT_DIR" && npm run test:e2e:functions:internal )

test/e2e-functions/README.md

@@ -1,57 +1,95 @@
 # Azure Functions host E2E tests (gated)
 
-This suite launches a **real Azure Functions host** (`func start`) for the sample
+This suite launches a **real Azure Functions host** (`func start`) for the ported
 app under [`test-app/`](./test-app), backed by **Azurite** (the local Azure
-Storage emulator) using the Durable Task **AzureStorage** provider, and drives
-the app entirely over HTTP. The Node.js worker, the Functions host, and the
-Durable extension all cooperate exactly as they would in production.
+Storage emulator) using the Durable Task **AzureStorage** provider, and drives the
+app entirely over HTTP. The Node.js worker, the Functions host, and the Durable
+extension all cooperate exactly as they would in production.
 
-It mirrors the Python suite added in
-[durabletask-python#155](https://github.com/microsoft/durabletask-python/pull/155).
+It is a faithful port of the Azure Functions host E2E suite from the
+[`azure-functions-durable-extension`](https://github.com/Azure/azure-functions-durable-extension)
+repo — the `BasicNode` app plus its xUnit test classes — adapted to Jest. Expected
+strings and Node-specific bug annotations come from that repo's
+`NodeTestLanguageLocalizer`.
 
-## ⚠️ Gated until PR #282 merges
+## Published `durable-functions` dependency
 
-The sample app depends on the in-repo `durable-functions` package
-(`packages/azure-functions-durable`) added by
-[durabletask-js#282](https://github.com/microsoft/durabletask-js/pull/282), which
-is **not on `main` yet**. This suite is deliberately split out from #282 so it
-can land independently without touching that package.
+The [`test-app`](./test-app) is wired to the **published** npm packages
+`durable-functions` (`^3.1.0`) and `@azure/functions` (`^4.11.2`), so it installs
+and builds without any in-repo package build. This is what makes the suite
+genuinely runnable.
 
-Because the package does not exist on `main`, everything here is **gated /
-skipped** so existing CI (`npm test`, lint, build) stays green:
+To run the app against an **in-repo** build of the Azure Functions durable package
+instead, change the `durable-functions` dependency in
+[`test-app/package.json`](./test-app/package.json) to a `file:` reference (e.g.
+`file:../../../packages/azure-functions-durable`) once that package exists on your
+branch, then re-run `npm install`. A note to this effect lives in that
+`package.json` (`comment_durable-functions`).
 
-- **Prerequisite detection** — the suite skips cleanly unless all of these hold
-  (see `harness.ts` + `global-setup.ts`):
+## Gating / skip model
+
+The suite **skips cleanly** (it never fails) unless everything it needs is present,
+so it is safe to leave wired into CI and to run locally without setup:
+
+- **Prerequisite detection** — `global-setup.ts` only starts the shared `func`
+  host when all of these hold (otherwise every spec skips):
   1. Azure Functions Core Tools (`func`) v4 is on `PATH`,
   2. Azurite is reachable on `127.0.0.1:10000`, and
   3. the test-app is installed and built (`test-app/node_modules` + `test-app/dist`).
-
-  On `main`, step 3 cannot be satisfied (the local `durable-functions` package is
-  absent), so the suite is a clean no-op.
-
+- **One shared host** — `global-setup.ts` starts a single `func start` host for the
+  whole run (mirroring the C# `FunctionAppFixture`) and writes its base URL to a
+  preflight file; the specs drive it over HTTP and `global-teardown.ts` stops it.
 - **Isolation** — these specs are only run by the dedicated
-  `jest.functions-e2e.config.js` via `npm run test:e2e:functions:internal`. They
-  are **not** part of the default `npm test` / workspaces test run, nor of
+  `jest.functions-e2e.config.js` via `npm run test:e2e:functions:internal`. They are
+  **not** part of the default `npm test` / workspaces test run, nor of
   `test:e2e:internal` (which is scoped to `tests/e2e`).
-- **CI** — `.github/workflows/functions-e2e-tests.yaml` gates every job behind the
-  `RUN_FUNCTIONS_E2E` repository variable. It is a no-op until that variable is
-  set to `true` (do so only after #282 has merged).
+- **CI** — `.github/workflows/functions-e2e-tests.yaml` installs `func` + Azurite,
+  installs/builds the test-app, and runs the suite on PRs that touch
+  `test/e2e-functions/**`. The self-skip is the safety net if a prerequisite fails
+  to come up.
 
 ## What it covers
 
-Faithful to the (identical) `azure-functions-durable-js` sample app:
-
-- **`hello.spec.ts`** — starts the `helloOrchestrator` (which chains three
-  `hello` activities) and asserts the output is
-  `["Hello, Tokyo", "Hello, Seattle", "Hello, Cairo"]`.
-- **`counter1.spec.ts`** — signals the `counter1` durable entity (`add`, 1) via
-  HTTP and asserts the persisted state increments (1, then 2). `reset` is not
-  wired to an HTTP route in the sample app, so it is not tested.
-
-The only additions to the sample app are a plain `/api/ping` readiness function
-(for host-readiness probing) and the dependency wiring (`durable-functions`
-points at the workspace package). The Durable function code is kept byte-for-byte
-identical to `azure-functions-durable-js`.
+One spec per area, mirroring the extension repo's test classes. Because this is the
+**Storage** backend, `[Trait("Node-DTS","Skip")]` and `[Trait("DTS","Skip")]` tests
+are **included** (those skips apply only to the DTS backend); `[Trait("Node","Skip")]`
+tests are `it.skip` with a comment citing the same reason.
+
+| Spec                          | Ported from                    | Notes                                                                                                       |
+| ----------------------------- | ------------------------------ | ----------------------------------------------------------------------------------------------------------- |
+| `hello-cities.spec.ts`        | `HelloCitiesTest`              | activity chaining → `Hello Tokyo!` etc.                                                                     |
+| `activity-input-type.spec.ts` | `ActivityInputTypeTests`       | `byte[]`/`int[]`/string/custom-class serialization                                                          |
+| `error-handling.spec.ts`      | `ErrorHandlingTests`           | rethrow/catch/retry activity & entity; skips dotnet-only FailureDetails + custom-exception-properties tests |
+| `external-event.spec.ts`      | `ExternalEventTests`           | raise to running/completed/missing (raise-to-completed error skipped per #645)                              |
+| `suspend-resume.spec.ts`      | `SuspendResumeTests`           | suspend/resume running, suspended, completed                                                                |
+| `terminate.spec.ts`           | `TerminateOrchestratorTests`   | terminate running/terminated/completed/nonexistent                                                          |
+| `timeout.spec.ts`             | `TimeoutTests`                 | `Task.any` activity-vs-timer race                                                                           |
+| `rewind.spec.ts`              | `RewindOrchestratorTests`      | fail → rewind → complete; invocation counts; rewind-only-failed                                             |
+| `is-replaying.spec.ts`        | `IsReplayingTests`             | `isReplaying` flags (ConditionalLog #564 and FanOutFanIn #679 skipped)                                      |
+| `large-output.spec.ts`        | `LargeOutputOrchestratorTests` | 65 KB via status URI + 4.5 MB via query trigger                                                             |
+| `orchestration-query.spec.ts` | `OrchestrationQueryTests`      | `GetAllInstances` / `GetRunningInstances`                                                                   |
+| `purge.spec.ts`               | `PurgeInstancesTests`          | purge by time / by entity id (purge-without-start-time #644 skipped)                                        |
+| `class-based-entity.spec.ts`  | `ClassBasedEntityTests`        | class-based entity state                                                                                    |
+
+### Node bug annotations honored
+
+- [#642](https://github.com/Azure/azure-functions-durable-js/issues/642) — entity
+  error text: inner "This entity failed"/"More information" assertions omitted.
+- [#645](https://github.com/Azure/azure-functions-durable-js/issues/645) —
+  raise-external-event to a completed instance: error assertions omitted.
+- [#564](https://github.com/Azure/azure-functions-durable-js/issues/564) —
+  `isReplaying` undefined before the first `yield`: `IsReplayingConditionalLog`
+  skipped.
+- [#679](https://github.com/Azure/azure-functions-durable-js/issues/679) —
+  `IsReplayingFanOutFanIn` skipped.
+- [#644](https://github.com/Azure/azure-functions-durable-js/issues/644) — purge
+  without a start time: those purge tests skipped.
+- Node swallows suspend/resume/terminate of a **terminal** instance and returns
+  success (`200`); the specs assert that behavior.
+
+The test-app additions over `BasicNode` are a plain `/api/ping` readiness function
+(for host-readiness probing) and the published-dependency wiring. The Durable
+function code is otherwise kept close to the source app.
 
 ## Running locally
 
@@ -66,11 +104,10 @@ azurite --silent --location /tmp/azurite --blobPort 10000 --queuePort 10001 --ta
 # 2. Install the Core Tools (if needed)
 npm install -g azure-functions-core-tools@4
 
-# 3. Build the workspace (must include packages/azure-functions-durable from #282)
+# 3. Install root dev deps (jest + ts-jest)
 npm ci
-npm run build
 
-# 4. Install + build the test-app
+# 4. Install + build the test-app (against the published durable-functions)
 cd test/e2e-functions/test-app
 npm install
 npm run build
@@ -81,11 +118,24 @@ npm run test:e2e:functions:internal
 ```
 
 Or use the convenience wrapper, which starts Azurite (if the CLI is installed),
-builds the workspace + test-app, and runs the suite:
+installs + builds the test-app, and runs the suite:
 
 ```bash
 npm run test:e2e:functions
 ```
 
 If any prerequisite is missing, the suite skips with a `[functions-e2e]` note
 instead of failing.
+
+## Follow-ups (deferred)
+
+The following extension-repo test areas are **not** ported yet. Most need extra
+infrastructure (an OTLP collector, multi-version host config, scheduled starts) or
+an orchestration that is not part of `BasicNode`:
+
+- **DistributedTracing / DistributedTracingEntities** — need an OTLP collector.
+- **Versioning / EntityVersioning** — need a multi-version host configuration.
+- **DedupeStatuses**, **GetOrchestrationHistory**, **HTTPFeature**, **Restart**,
+  **Scheduled** — not yet ported.
+- **`PurgeOnlyPurgesTerminalOrchestrations`** — needs a `HelloActivityDIFailure`
+  orchestration that is not present in `BasicNode`.

test/e2e-functions/activity-input-type.spec.ts

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+/**
+ * Ported from the extension e2e `ActivityInputTypeTests.DifferentActivityInputTypeTests`.
+ *
+ * Verifies that different input types (byte[], empty byte[], single byte, custom
+ * class, int[], string, custom-class array) serialize correctly and are received
+ * by activities without serialization errors.
+ *
+ * Gated: skips cleanly unless the shared host was started by globalSetup.
+ */
+
+import {
+  getOrchestrationDetails,
+  invokeHttpTrigger,
+  parseStatusQueryGetUri,
+  readPreflight,
+  waitForOrchestrationState,
+} from "./harness";
+
+const preflight = readPreflight();
+const describeMaybe = preflight.ok ? describe : describe.skip;
+const baseUrl = preflight.baseUrl ?? "";
+
+if (!preflight.ok) {
+  console.warn(`[functions-e2e] activity-input-type.spec skipped: ${preflight.reason}`);
+}
+
+describeMaybe("Functions host E2E — activity input types (AzureStorage)", () => {
+  it("ActivityInputTypeOrchestrator serializes every input type without errors", async () => {
+    const response = await invokeHttpTrigger(
+      baseUrl,
+      "StartOrchestration",
+      "?orchestrationName=ActivityInputTypeOrchestrator",
+    );
+    expect(response.status).toBe(202); // HttpStatusCode.Accepted
+
+    const statusQueryGetUri = parseStatusQueryGetUri(response);
+    await waitForOrchestrationState(statusQueryGetUri, "Completed", 30);
+
+    const { outputString } = await getOrchestrationDetails(statusQueryGetUri);
+
+    expect(outputString).toContain("Received byte[]: [1, 2, 3, 4, 5]");
+    expect(outputString).toContain("Received byte[]: []");
+    expect(outputString).toContain("Received byte: 42");
+    expect(outputString).toContain("Received CustomClass: {Name: Test, Age: 25, Duration: 01:00:00, Data: [1, 2, 3]}");
+    expect(outputString).toContain("Received int[]: [1, 2, 3, 4, 5]");
+    expect(outputString).toContain("Received string: Test string input");
+    expect(outputString).toContain(
+      "Received CustomClass[]: [{Name: Test1, Age: 25, Duration: 00:30:00, Data: [1, 2, 3]}, {Name: Test2, Age: 30, Duration: 00:45:00, Data: []}]",
+    );
+
+    // No serialization errors, especially for byte[] types.
+    expect(outputString).not.toContain("Error:");
+  }, 120_000);
+});

test/e2e-functions/class-based-entity.spec.ts

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+/**
+ * Ported from the extension e2e `ClassBasedEntityTests.ClassBasedEntityTest`.
+ *
+ * Runs an orchestration that sets and reads a class-based entity's state and
+ * asserts the exact returned state string.
+ *
+ * Gated: skips cleanly unless the shared host was started by globalSetup.
+ */
+
+import {
+  getOrchestrationDetails,
+  invokeHttpTrigger,
+  parseStatusQueryGetUri,
+  readPreflight,
+  waitForOrchestrationState,
+} from "./harness";
+
+const preflight = readPreflight();
+const describeMaybe = preflight.ok ? describe : describe.skip;
+const baseUrl = preflight.baseUrl ?? "";
+
+if (!preflight.ok) {
+  console.warn(`[functions-e2e] class-based-entity.spec skipped: ${preflight.reason}`);
+}
+
+describeMaybe("Functions host E2E — class-based entity (AzureStorage)", () => {
+  it("ClassBasedEntityOrchestration returns the entity state string", async () => {
+    const response = await invokeHttpTrigger(
+      baseUrl,
+      "StartOrchestration",
+      "?orchestrationName=ClassBasedEntityOrchestration",
+    );
+    expect(response.status).toBe(202); // HttpStatusCode.Accepted
+
+    const statusQueryGetUri = parseStatusQueryGetUri(response);
+    await waitForOrchestrationState(statusQueryGetUri, "Completed", 30);
+
+    const { outputString } = await getOrchestrationDetails(statusQueryGetUri);
+    expect(outputString).toBe("IConfiguration: yes, MyInjectedService: yes, BlobContainerClient: yes, Number: 42");
+  }, 120_000);
+});