Add dependency version validation pipeline

.github/workflows/dep-version-validation.yml

@@ -0,0 +1,182 @@
+# ================================================================================================
+# Dependency Version Validation Pipeline
+# ================================================================================================
+# Validates that changes to dependency versions (Directory.Packages.props) do not break
+# the DurableTask Framework (DTFx) NuGet packages at build or runtime.
+#
+# The DTFx Core and Emulator packages are consumed downstream by:
+#   - azure-functions-durable-extension (WebJobs extension)
+#   - AAPT-DTMB (DTS data plane)
+#
+# This pipeline:
+#   1. Packs DurableTask.Core and DurableTask.Emulator from source into a local feed
+#   2. Builds a standalone console app that runs a HelloCities orchestration
+#      using the Emulator backend
+#   3. Validates orchestration output and loaded assembly versions
+# ================================================================================================
+
+name: Dependency Version Validation
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'Directory.Packages.props'
+      - 'tools/DurableTask.props'
+      - 'Test/SmokeTests/**'
+  pull_request:
+    paths:
+      - 'Directory.Packages.props'
+      - 'tools/DurableTask.props'
+      - 'Test/SmokeTests/**'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  dep-validation-smoke-test:
+    name: 'Emulator Orchestration Smoke Test (NuGet Packages)'
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      # ---- Checkout & SDK Setup ----
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup .NET 8.0 SDK
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '8.0.x'
+
+      # ---- Parse DTFx Versions ----
+      - name: Parse DTFx package versions
+        id: version
+        run: |
+          set -e
+
+          # Use MSBuild to resolve the evaluated PackageVersion/Version
+          # so imports, conditions, and prerelease labels are handled correctly.
+          get_msbuild_version() {
+            local project_file="$1"
+            local version
+
+            version=$(dotnet msbuild "$project_file" -nologo -getProperty:PackageVersion 2>/dev/null | tail -n 1 | tr -d '\r')
+            if [ -z "$version" ]; then
+              version=$(dotnet msbuild "$project_file" -nologo -getProperty:Version 2>/dev/null | tail -n 1 | tr -d '\r')
+            fi
+
+            if [ -z "$version" ]; then
+              echo "Failed to resolve version for $project_file" >&2
+              exit 1
+            fi
+
+            echo "$version"
+          }
+
+          CORE_VERSION=$(get_msbuild_version "src/DurableTask.Core/DurableTask.Core.csproj")
+          echo "Core version: ${CORE_VERSION}"
+          echo "core_version=${CORE_VERSION}" >> "$GITHUB_OUTPUT"
+
+          EMULATOR_VERSION=$(get_msbuild_version "src/DurableTask.Emulator/DurableTask.Emulator.csproj")
+          echo "Emulator version: ${EMULATOR_VERSION}"
+          echo "emulator_version=${EMULATOR_VERSION}" >> "$GITHUB_OUTPUT"
+
+      # ---- Pack DTFx Packages from Source ----
+      - name: Pack DTFx packages from source
+        run: |
+          set -e
+          LOCAL_PACKAGES="Test/SmokeTests/EmulatorSmokeTest/local-packages"
+          mkdir -p "$LOCAL_PACKAGES"
+
+          # Build Core first (Emulator depends on it)
+          echo "Building DurableTask.Core..."
+          dotnet build src/DurableTask.Core/DurableTask.Core.csproj -c Release
+
+          echo "Building DurableTask.Emulator..."
+          dotnet build src/DurableTask.Emulator/DurableTask.Emulator.csproj -c Release
+
+          # Pack from build output
+          echo "Packing DurableTask.Core..."
+          dotnet pack src/DurableTask.Core/DurableTask.Core.csproj -c Release --no-build --output "$LOCAL_PACKAGES"
+
+          echo "Packing DurableTask.Emulator..."
+          dotnet pack src/DurableTask.Emulator/DurableTask.Emulator.csproj -c Release --no-build --output "$LOCAL_PACKAGES"
+
+          echo "Local packages:"
+          ls -la "$LOCAL_PACKAGES"
+
+      # ---- Verify Packed Packages ----
+      - name: Verify packed packages
+        env:
+          CORE_VERSION: ${{ steps.version.outputs.core_version }}
+          EMULATOR_VERSION: ${{ steps.version.outputs.emulator_version }}
+        run: |
+          set -e
+          LOCAL_PACKAGES="Test/SmokeTests/EmulatorSmokeTest/local-packages"
+
+          CORE_PKG="Microsoft.Azure.DurableTask.Core.${CORE_VERSION}.nupkg"
+          if [ ! -f "$LOCAL_PACKAGES/$CORE_PKG" ]; then
+            echo "FAIL: Missing Core package: $CORE_PKG"
+            echo "Available packages:"
+            ls -1 "$LOCAL_PACKAGES"
+            exit 1
+          fi
+          echo "  OK: $CORE_PKG"
+
+          EMULATOR_PKG="Microsoft.Azure.DurableTask.Emulator.${EMULATOR_VERSION}.nupkg"
+          if [ ! -f "$LOCAL_PACKAGES/$EMULATOR_PKG" ]; then
+            echo "FAIL: Missing Emulator package: $EMULATOR_PKG"
+            echo "Available packages:"
+            ls -1 "$LOCAL_PACKAGES"
+            exit 1
+          fi
+          echo "  OK: $EMULATOR_PKG"
+          echo "PASS: DTFx packages verified."
+
+      # ---- Build Smoke Test App ----
+      - name: Build smoke test app
+        env:
+          CORE_VERSION: ${{ steps.version.outputs.core_version }}
+          EMULATOR_VERSION: ${{ steps.version.outputs.emulator_version }}
+        run: |
+          set -e
+          cd Test/SmokeTests/EmulatorSmokeTest
+          dotnet build EmulatorSmokeTest.csproj -c Release \
+            -p:SmokeTestCoreVersion=$CORE_VERSION \
+            -p:SmokeTestEmulatorVersion=$EMULATOR_VERSION \
+            -v normal
+
+      # ---- Verify DTFx packages resolved from local-packages ----
+      - name: Verify DTFx packages from local source
+        run: |
+          set -e
+          echo "Verifying DTFx packages were restored from local-packages..."
+          ASSETS_FILE="Test/SmokeTests/EmulatorSmokeTest/obj/project.assets.json"
+          for pkg in "Microsoft.Azure.DurableTask.Core" "Microsoft.Azure.DurableTask.Emulator"; do
+            if grep -qi "$pkg" "$ASSETS_FILE"; then
+              echo "  OK: $pkg found in project.assets.json"
+            else
+              echo "  FAIL: $pkg NOT found"
+              exit 1
+            fi
+          done
+          echo "PASS: DTFx packages verified in build output."
+
+      # ---- Run Smoke Test ----
+      - name: Run smoke test
+        env:
+          CORE_VERSION: ${{ steps.version.outputs.core_version }}
+          EMULATOR_VERSION: ${{ steps.version.outputs.emulator_version }}
+        run: |
+          set -e
+          echo "Running Emulator Smoke Test..."
+          dotnet run --project Test/SmokeTests/EmulatorSmokeTest/EmulatorSmokeTest.csproj \
+            -c Release \
+            --no-build \
+            -p:SmokeTestCoreVersion=$CORE_VERSION \
+            -p:SmokeTestEmulatorVersion=$EMULATOR_VERSION
+
+          echo "Smoke test completed successfully."

Test/SmokeTests/EmulatorSmokeTest/.gitignore

@@ -0,0 +1 @@
+local-packages/*.nupkg

Test/SmokeTests/EmulatorSmokeTest/EmulatorSmokeTest.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>false</IsTestProject>
+    <ManagePackageVersionsCentrally>false</ManagePackageVersionsCentrally>
+    <!-- Default versions for standalone restore (e.g. Dependency Submission workflow).
+         These are overridden by -p:SmokeTestCoreVersion / -p:SmokeTestEmulatorVersion in the CI pipeline. -->
+    <SmokeTestCoreVersion Condition="'$(SmokeTestCoreVersion)' == ''">3.7.1</SmokeTestCoreVersion>
+    <SmokeTestEmulatorVersion Condition="'$(SmokeTestEmulatorVersion)' == ''">2.6.0</SmokeTestEmulatorVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!--
+      DTFx packages under test (from local-packages feed).
+      Core and Emulator use different version schemes, so they have separate properties.
+      Injected via -p:SmokeTestCoreVersion=... -p:SmokeTestEmulatorVersion=... at build time.
+    -->
+    <PackageReference Include="Microsoft.Azure.DurableTask.Core" Version="$(SmokeTestCoreVersion)" />
+    <PackageReference Include="Microsoft.Azure.DurableTask.Emulator" Version="$(SmokeTestEmulatorVersion)" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.1" />
+  </ItemGroup>
+
+</Project>

Test/SmokeTests/EmulatorSmokeTest/NuGet.config

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <clear />
+    <add key="local-packages" value="./local-packages" />
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
+  </packageSources>
+
+  <!--
+    Package source mapping ensures that the DTFx packages under test are ONLY
+    resolved from the local-packages feed during CI builds. When local-packages
+    is empty (standalone restore), NuGet will fall through to nuget.org since
+    both sources map the patterns.
+  -->
+  <packageSourceMapping>
+    <packageSource key="local-packages">
+      <package pattern="Microsoft.Azure.DurableTask.Core" />
+      <package pattern="Microsoft.Azure.DurableTask.Emulator" />
+    </packageSource>
+    <packageSource key="nuget.org">
+      <package pattern="*" />
+      <package pattern="Microsoft.Azure.DurableTask.Core" />
+      <package pattern="Microsoft.Azure.DurableTask.Emulator" />
+    </packageSource>
+  </packageSourceMapping>
+</configuration>

Test/SmokeTests/EmulatorSmokeTest/Program.cs

@@ -0,0 +1,111 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Reflection;
+using DurableTask.Core;
+using DurableTask.Emulator;
+using Microsoft.Extensions.Logging;
+
+Console.WriteLine("=== DurableTask Emulator Smoke Test ===");
+Console.WriteLine();
+
+using ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
+{
+    builder.AddConsole();
+    builder.SetMinimumLevel(LogLevel.Warning);
+});
+
+// Create the in-memory orchestration service
+var orchestrationService = new LocalOrchestrationService();
+
+// Start the worker with our orchestration and activities
+var worker = new TaskHubWorker(orchestrationService, loggerFactory);
+await worker
+    .AddTaskOrchestrations(typeof(HelloCitiesOrchestration))
+    .AddTaskActivities(typeof(SayHelloActivity))
+    .StartAsync();
+
+// Create a client and start the orchestration
+var client = new TaskHubClient(orchestrationService, loggerFactory: loggerFactory);
+OrchestrationInstance instance = await client.CreateOrchestrationInstanceAsync(
+    typeof(HelloCitiesOrchestration), input: null);
+
+Console.WriteLine($"Started orchestration: {instance.InstanceId}");
+
+// Wait for completion
+OrchestrationState result = await client.WaitForOrchestrationAsync(
+    instance, TimeSpan.FromSeconds(30), CancellationToken.None);
+
+Console.WriteLine($"Orchestration status: {result.OrchestrationStatus}");
+Console.WriteLine($"Orchestration output: {result.Output}");
+
+await worker.StopAsync(true);
+
+// Print loaded DTFx assembly versions (after usage to ensure all assemblies are loaded)
+Console.WriteLine();
+Console.WriteLine("Loaded DTFx assembly versions:");
+foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+{
+    string? name = asm.GetName().Name;
+    if (name != null && name.StartsWith("DurableTask.", StringComparison.OrdinalIgnoreCase))
+    {
+        string? infoVersion = asm
+            .GetCustomAttribute<AssemblyInformationalVersionAttribute>()
+            ?.InformationalVersion;
+        if (infoVersion != null && infoVersion.Contains('+'))
+        {
+            infoVersion = infoVersion[..infoVersion.IndexOf('+')];
+        }
+        Console.WriteLine($"  {name} = {infoVersion ?? asm.GetName().Version?.ToString() ?? "unknown"}");
+    }
+}
+
+// Validate result
+if (result.OrchestrationStatus != OrchestrationStatus.Completed)
+{
+    Console.WriteLine("FAIL: Orchestration did not complete successfully.");
+    return 1;
+}
+
+if (result.Output == null ||
+    !result.Output.Contains("Hello, Tokyo!") ||
+    !result.Output.Contains("Hello, London!") ||
+    !result.Output.Contains("Hello, Seattle!"))
+{
+    Console.WriteLine("FAIL: Orchestration output did not contain expected greetings.");
+    return 1;
+}
+
+Console.WriteLine();
+Console.WriteLine("PASS: HelloCities orchestration completed with expected output.");
+return 0;
+
+// ---- Orchestration ----
+
+/// <summary>
+/// A simple function chaining orchestration that calls SayHello for three cities.
+/// </summary>
+public class HelloCitiesOrchestration : TaskOrchestration<string, object>
+{
+    public override async Task<string> RunTask(OrchestrationContext context, object input)
+    {
+        string result = "";
+        result += await context.ScheduleTask<string>(typeof(SayHelloActivity), "Tokyo") + " ";
+        result += await context.ScheduleTask<string>(typeof(SayHelloActivity), "London") + " ";
+        result += await context.ScheduleTask<string>(typeof(SayHelloActivity), "Seattle");
+        return result;
+    }
+}
+
+// ---- Activity ----
+
+/// <summary>
+/// A simple activity that returns a greeting for the given city name.
+/// </summary>
+public class SayHelloActivity : TaskActivity<string, string>
+{
+    protected override string Execute(TaskContext context, string cityName)
+    {
+        return $"Hello, {cityName}!";
+    }
+}