{
+ ["LogLevel"] = logLevel
+ };
+ }
+
+ ///
+ /// Writes the install directory to the Windows Registry under
+ /// HKLM\SOFTWARE\Werkr\{ProductType} so that the application
+ /// can discover its configuration via the registry configuration provider.
+ ///
+ private static void WriteRegistrySettings( Session session, string installDir ) {
+ try {
+ string productName = GetSessionProperty( session, "ProductName", deferred: true );
+ string subKey = productName.Contains( "Agent" ) ? "Agent" : "Server";
+ string registryPath = $@"SOFTWARE\Werkr\{subKey}";
+
+ using RegistryKey key = Microsoft.Win32.Registry.LocalMachine.CreateSubKey( registryPath );
+ key.SetValue( "InstallDirectory", installDir );
+ key.SetValue( "ConfigPath", Path.Combine( installDir, "appsettings.json" ) );
+ session.Log( $"Registry settings written to HKLM\\{registryPath}" );
+ } catch (Exception e) {
+ // Non-fatal — don't fail the install over registry writes
+ session.Log( $"Warning: Could not write registry settings. Error: {e.Message}" );
+ }
+ }
+
+ #endregion Private Methods
+}
diff --git a/src/Installer/Msi/CustomActions/Werkr.Installer.Msi.CustomActions.csproj b/src/Installer/Msi/CustomActions/Werkr.Installer.Msi.CustomActions.csproj
new file mode 100644
index 0000000..ae52c1e
--- /dev/null
+++ b/src/Installer/Msi/CustomActions/Werkr.Installer.Msi.CustomActions.csproj
@@ -0,0 +1,42 @@
+
+
+
+ Werkr.Installer.Msi.CustomActions
+ net481
+ latest
+ enable
+ embedded
+ Library
+ true
+ true
+ true
+
+ false
+
+ $(NoWarn);NU1701
+
+
+
+
+
+
+
+ $(RuntimeIdentifier)
+ $(Platform)
+
+
+ win-x64
+ x64
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Installer/Msi/CustomActions/packages.lock.json b/src/Installer/Msi/CustomActions/packages.lock.json
new file mode 100644
index 0000000..9d0c1f5
--- /dev/null
+++ b/src/Installer/Msi/CustomActions/packages.lock.json
@@ -0,0 +1,107 @@
+{
+ "version": 1,
+ "dependencies": {
+ ".NETFramework,Version=v4.8.1": {
+ "System.Text.Json": {
+ "type": "Direct",
+ "requested": "[10.0.5, )",
+ "resolved": "10.0.5",
+ "contentHash": "vW2zhkWziyfhoSXNf42mTWyilw+vfwBGOsODDsHSFtOIY6LCgfRVUyaAilLEL4Kc1fzhaxcep5pS0VWYPSDW0w==",
+ "dependencies": {
+ "Microsoft.Bcl.AsyncInterfaces": "10.0.5",
+ "System.Buffers": "4.6.1",
+ "System.IO.Pipelines": "10.0.5",
+ "System.Memory": "4.6.3",
+ "System.Runtime.CompilerServices.Unsafe": "6.1.2",
+ "System.Text.Encodings.Web": "10.0.5",
+ "System.Threading.Tasks.Extensions": "4.6.3",
+ "System.ValueTuple": "4.6.1"
+ }
+ },
+ "WixToolset.Dtf.CustomAction": {
+ "type": "Direct",
+ "requested": "[6.0.2, )",
+ "resolved": "6.0.2",
+ "contentHash": "VJRjIOzIkfolXw+kUWenyx2YQT/gagpr6Cs0XnvLPz7xl6pp/v+lQdwWh+wBu2P6apkg4yH1XI1WmXrTCjlD9g==",
+ "dependencies": {
+ "WixToolset.Dtf.WindowsInstaller": "6.0.2"
+ }
+ },
+ "WixToolset.Dtf.WindowsInstaller": {
+ "type": "Direct",
+ "requested": "[6.0.2, )",
+ "resolved": "6.0.2",
+ "contentHash": "Tnc1EIjE5A7nvEcnUQLEgf1F1sXWzd3L4/n1/PXMnlt7dzaTEvR2OTiFgHD6Y+Tq9qZzAQZelcoS0Ps9bCLufw=="
+ },
+ "Microsoft.Bcl.AsyncInterfaces": {
+ "type": "Transitive",
+ "resolved": "10.0.5",
+ "contentHash": "hQB3Hq1LlF0NkGVNyZIvwIQIY3LM7Cw1oYjNiTvdNqmzzipVAWEK1c5sj2H5aFX0udnjgPLxSYKq2fupueS8ow==",
+ "dependencies": {
+ "System.Threading.Tasks.Extensions": "4.6.3"
+ }
+ },
+ "System.Buffers": {
+ "type": "Transitive",
+ "resolved": "4.6.1",
+ "contentHash": "N8GXpmiLMtljq7gwvyS+1QvKT/W2J8sNAvx+HVg4NGmsG/H+2k/y9QI23auLJRterrzCiDH+IWAw4V/GPwsMlw=="
+ },
+ "System.IO.Pipelines": {
+ "type": "Transitive",
+ "resolved": "10.0.5",
+ "contentHash": "8/ZHN/j2y1t+7McdCf1wXku2/c7wtrGLz3WQabIoPuLAn3bHDWT6YOJYreJq8sCMPSo6c8iVYXUdLlFGX5PEqw==",
+ "dependencies": {
+ "System.Buffers": "4.6.1",
+ "System.Memory": "4.6.3",
+ "System.Threading.Tasks.Extensions": "4.6.3"
+ }
+ },
+ "System.Memory": {
+ "type": "Transitive",
+ "resolved": "4.6.3",
+ "contentHash": "qdcDOgnFZY40+Q9876JUHnlHu7bosOHX8XISRoH94fwk6hgaeQGSgfZd8srWRZNt5bV9ZW2TljcegDNxsf+96A==",
+ "dependencies": {
+ "System.Buffers": "4.6.1",
+ "System.Numerics.Vectors": "4.6.1",
+ "System.Runtime.CompilerServices.Unsafe": "6.1.2"
+ }
+ },
+ "System.Numerics.Vectors": {
+ "type": "Transitive",
+ "resolved": "4.6.1",
+ "contentHash": "sQxefTnhagrhoq2ReR0D/6K0zJcr9Hrd6kikeXsA1I8kOCboTavcUC4r7TSfpKFeE163uMuxZcyfO1mGO3EN8Q=="
+ },
+ "System.Runtime.CompilerServices.Unsafe": {
+ "type": "Transitive",
+ "resolved": "6.1.2",
+ "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw=="
+ },
+ "System.Text.Encodings.Web": {
+ "type": "Transitive",
+ "resolved": "10.0.5",
+ "contentHash": "opvD/nKTzGKA7GVntZ9L823kN6IxgHQfuxY+VI9gv8VE1Y7CSKoi/QS1EYDQiA63MqtZsD7X6zkISd2ZQJohTQ==",
+ "dependencies": {
+ "System.Buffers": "4.6.1",
+ "System.Memory": "4.6.3",
+ "System.Runtime.CompilerServices.Unsafe": "6.1.2"
+ }
+ },
+ "System.Threading.Tasks.Extensions": {
+ "type": "Transitive",
+ "resolved": "4.6.3",
+ "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==",
+ "dependencies": {
+ "System.Runtime.CompilerServices.Unsafe": "6.1.2"
+ }
+ },
+ "System.ValueTuple": {
+ "type": "Transitive",
+ "resolved": "4.6.1",
+ "contentHash": "+RJT4qaekpZ7DDLhf+LTjq+E48jieKiY9ulJ+BoxKmZblIJfIJT8Ufcaa/clQqnYvWs8jugfGSMu8ylS0caG0w=="
+ },
+ "werkr.common.configuration": {
+ "type": "Project"
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Installer/Msi/Server/Package.en-us.wxl b/src/Installer/Msi/Server/Package.en-us.wxl
new file mode 100644
index 0000000..da20f1a
--- /dev/null
+++ b/src/Installer/Msi/Server/Package.en-us.wxl
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/src/Installer/Msi/Server/Server.wixproj b/src/Installer/Msi/Server/Server.wixproj
new file mode 100644
index 0000000..b9e0a89
--- /dev/null
+++ b/src/Installer/Msi/Server/Server.wixproj
@@ -0,0 +1,64 @@
+
+
+ 0.0.0.1
+ Werkr.$(MSBuildProjectName).$(BuildVersion).$(RuntimeIdentifier)
+ true
+ $(RuntimeIdentifier)
+ $(Platform)
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ..\..\..\Werkr.Server\bin\$(Configuration)\net10.0
+ ..\..\..\Werkr.Server\bin\$(Configuration)\net10.0\$(RuntimeIdentifier)
+ ..\CustomActions\bin\$(Configuration)\net481\$(RuntimeIdentifier)
+
+
+ ..\..\..\Werkr.Server\bin\$(Configuration)
+ ..\..\..\Werkr.Server\bin\$(Configuration)\net10.0
+ ..\CustomActions\bin\$(Configuration)\net481
+
+
+ ..\..\..\Werkr.Server\wwwroot
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Version=$(BuildVersion);ServiceDirPath=$(ServiceDirPath)
+
+
+
+ $(NoWarn);NU1701;MSB3246;WIX1076;WIX1098
+
+
+
diff --git a/src/Installer/Msi/Server/Server.wxs b/src/Installer/Msi/Server/Server.wxs
new file mode 100644
index 0000000..943fe3e
--- /dev/null
+++ b/src/Installer/Msi/Server/Server.wxs
@@ -0,0 +1,365 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Installer/Msi/Server/images/WerkrMsiBanner.bmp b/src/Installer/Msi/Server/images/WerkrMsiBanner.bmp
new file mode 100644
index 0000000..211348c
Binary files /dev/null and b/src/Installer/Msi/Server/images/WerkrMsiBanner.bmp differ
diff --git a/src/Installer/Msi/Server/images/WerkrServerMsiDialog.bmp b/src/Installer/Msi/Server/images/WerkrServerMsiDialog.bmp
new file mode 100644
index 0000000..512f0be
Binary files /dev/null and b/src/Installer/Msi/Server/images/WerkrServerMsiDialog.bmp differ
diff --git a/src/Installer/Msi/Server/packages.lock.json b/src/Installer/Msi/Server/packages.lock.json
new file mode 100644
index 0000000..f432b8b
--- /dev/null
+++ b/src/Installer/Msi/Server/packages.lock.json
@@ -0,0 +1,19 @@
+{
+ "version": 2,
+ "dependencies": {
+ "native,Version=v0.0": {
+ "WixToolset.UI.wixext": {
+ "type": "Direct",
+ "requested": "[6.0.2, )",
+ "resolved": "6.0.2",
+ "contentHash": "1Hq+Kp4WTb9TLRLRpv/iGod6MnNadz1ZrmY1USS6SL/WVxFuiBvQVGGLXrcdQld9J7oVWCZ8k9eMFtaYJOJ5AQ=="
+ },
+ "WixToolset.Util.wixext": {
+ "type": "Direct",
+ "requested": "[6.0.2, )",
+ "resolved": "6.0.2",
+ "contentHash": "plP64ub/0KjNbtLeaeiibVCPkKfr439WTKZmTwVSoQ4fznLHBZLsE0+wcyk6dA5cQuQsD5hlmnVGTKgPioiusQ=="
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Installer/Pkg/agent/distribution.xml b/src/Installer/Pkg/agent/distribution.xml
new file mode 100644
index 0000000..c4975c0
--- /dev/null
+++ b/src/Installer/Pkg/agent/distribution.xml
@@ -0,0 +1,29 @@
+
+
+ Werkr Agent
+ app.werkr
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ app.werkr.agent.pkg
+
diff --git a/src/Installer/Pkg/agent/launchd/app.werkr.agent.plist b/src/Installer/Pkg/agent/launchd/app.werkr.agent.plist
new file mode 100644
index 0000000..e6cbfad
--- /dev/null
+++ b/src/Installer/Pkg/agent/launchd/app.werkr.agent.plist
@@ -0,0 +1,46 @@
+
+
+
+
+ Label
+ app.werkr.agent
+
+ ProgramArguments
+
+ /Library/Werkr/Agent/Werkr.Agent
+
+
+ WorkingDirectory
+ /Library/Werkr/Agent
+
+ RunAtLoad
+
+
+ KeepAlive
+
+ SuccessfulExit
+
+
+
+ ThrottleInterval
+ 10
+
+ EnvironmentVariables
+
+ DOTNET_ENVIRONMENT
+ Production
+ WERKR_CONFIG_PATH
+ /etc/werkr
+ WERKR_DATA_DIR
+ /var/lib/werkr
+ WERKR_LOG_DIR
+ /var/log/werkr
+
+
+ StandardOutPath
+ /var/log/werkr/werkr-agent.stdout.log
+
+ StandardErrorPath
+ /var/log/werkr/werkr-agent.stderr.log
+
+
diff --git a/src/Installer/Pkg/agent/scripts/postinstall b/src/Installer/Pkg/agent/scripts/postinstall
new file mode 100644
index 0000000..61f66d7
--- /dev/null
+++ b/src/Installer/Pkg/agent/scripts/postinstall
@@ -0,0 +1,38 @@
+#!/bin/bash
+set -e
+
+INSTALL_DIR="/Library/Werkr/Agent"
+CONFIG_DIR="/etc/werkr"
+DATA_DIR="/var/lib/werkr"
+LOG_DIR="/var/log/werkr"
+PLIST_NAME="app.werkr.agent"
+PLIST_SRC="${INSTALL_DIR}/launchd/${PLIST_NAME}.plist"
+PLIST_DST="/Library/LaunchDaemons/${PLIST_NAME}.plist"
+
+# Create directories
+mkdir -p "${CONFIG_DIR}"
+mkdir -p "${DATA_DIR}"
+mkdir -p "${LOG_DIR}"
+
+# Create default config if it doesn't exist
+if [ ! -f "${CONFIG_DIR}/appsettings.json" ]; then
+ echo '{}' > "${CONFIG_DIR}/appsettings.json"
+ chmod 640 "${CONFIG_DIR}/appsettings.json"
+fi
+
+# Create modules directory
+mkdir -p "${INSTALL_DIR}/modules"
+
+# Set permissions on install directory
+chmod -R 755 "${INSTALL_DIR}"
+chmod +x "${INSTALL_DIR}/Werkr.Agent"
+
+# Install launchd plist
+cp "${PLIST_SRC}" "${PLIST_DST}"
+chmod 644 "${PLIST_DST}"
+chown root:wheel "${PLIST_DST}"
+
+# Load the service (will start due to RunAtLoad=true)
+launchctl load "${PLIST_DST}" 2>/dev/null || true
+
+exit 0
diff --git a/src/Installer/Pkg/agent/scripts/preinstall b/src/Installer/Pkg/agent/scripts/preinstall
new file mode 100644
index 0000000..b0c6999
--- /dev/null
+++ b/src/Installer/Pkg/agent/scripts/preinstall
@@ -0,0 +1,11 @@
+#!/bin/bash
+set -e
+
+PLIST_DST="/Library/LaunchDaemons/app.werkr.agent.plist"
+
+# Stop and unload existing service if upgrading
+if [ -f "${PLIST_DST}" ]; then
+ launchctl unload "${PLIST_DST}" 2>/dev/null || true
+fi
+
+exit 0
diff --git a/src/Installer/Pkg/build-pkg.ps1 b/src/Installer/Pkg/build-pkg.ps1
new file mode 100644
index 0000000..012aad9
--- /dev/null
+++ b/src/Installer/Pkg/build-pkg.ps1
@@ -0,0 +1,207 @@
+#Requires -Version 7.2
+<#
+ .SYNOPSIS
+ Build a macOS .pkg installer from pre-published Werkr binaries and
+ static template files.
+
+ .DESCRIPTION
+ Standalone .pkg build script that reads static launchd plists, installer
+ scripts, and distribution.xml from src/Installer/Pkg/, stages published
+ binaries into the /Library/Werkr/ layout, and produces a product .pkg
+ via pkgbuild + productbuild.
+
+ This script can be invoked directly or called from publish.ps1.
+
+ .EXAMPLE
+ ./src/Installer/Pkg/build-pkg.ps1 -ProductType Agent -BinaryPath ./Publish/Agent -Version 1.0.0 -Architecture arm64
+
+ .EXAMPLE
+ ./src/Installer/Pkg/build-pkg.ps1 -ProductType ServerBundle -BinaryPath ./Publish/ServerBundle -Version 1.0.0 -Architecture x64 -OutputPath ./Publish
+#>
+[CmdletBinding()]
+param (
+ [Parameter(Mandatory)]
+ [ValidateSet('Agent', 'ServerBundle')]
+ [string]$ProductType,
+
+ [Parameter(Mandatory)]
+ [string]$BinaryPath,
+
+ [Parameter(Mandatory)]
+ [string]$Version,
+
+ [Parameter(Mandatory)]
+ [ValidateSet('x64', 'arm64')]
+ [string]$Architecture,
+
+ [Parameter(Mandatory = $false)]
+ [string]$OutputPath = '.',
+
+ [Parameter(Mandatory = $false)]
+ [string]$EditionName
+)
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version Latest
+
+# Resolve paths
+[string]$ScriptRoot = $PSScriptRoot
+[string]$BinaryPath = (Resolve-Path $BinaryPath).Path
+[string]$OutputPath = (Resolve-Path $OutputPath).Path
+
+# Product-specific configuration
+[string]$TemplateDir = switch ($ProductType) {
+ 'ServerBundle' { Join-Path $ScriptRoot 'server' }
+ 'Agent' { Join-Path $ScriptRoot 'agent' }
+}
+[string]$PackageIdentifier = switch ($ProductType) {
+ 'ServerBundle' { 'app.werkr.server' }
+ 'Agent' { 'app.werkr.agent' }
+}
+[string]$InstallSubDir = switch ($ProductType) {
+ 'ServerBundle' { 'Server' }
+ 'Agent' { 'Agent' }
+}
+
+# Default edition name for the .pkg filename
+if (-not $EditionName) {
+ [string]$ArchLabel = switch ($Architecture) {
+ 'arm64' { 'osx-arm64' }
+ 'x64' { 'osx-x64' }
+ }
+ $EditionName = "werkr-$($InstallSubDir.ToLower())-${Version}-${ArchLabel}"
+}
+
+Write-Host "Building .pkg: $EditionName"
+Write-Host " Product: $ProductType"
+Write-Host " Version: $Version"
+Write-Host " Architecture: $Architecture"
+Write-Host " Binaries: $BinaryPath"
+Write-Host " Templates: $TemplateDir"
+Write-Host " Output: $OutputPath"
+
+# Validate inputs
+if (-not (Test-Path $BinaryPath)) {
+ throw "Binary path does not exist: $BinaryPath"
+}
+if (-not (Test-Path $TemplateDir)) {
+ throw "Template directory does not exist: $TemplateDir"
+}
+
+# Check for pkgbuild and productbuild (require Xcode Command Line Tools)
+foreach ($tool in @('pkgbuild', 'productbuild')) {
+ $cmd = Get-Command $tool -ErrorAction SilentlyContinue
+ if (-not $cmd) {
+ throw "$tool is not installed. Install Xcode Command Line Tools: xcode-select --install"
+ }
+}
+
+# Create staging directory
+[string]$StagingDir = Join-Path ([System.IO.Path]::GetTempPath()) "werkr-pkg-$EditionName"
+if (Test-Path $StagingDir) { Remove-Item $StagingDir -Recurse -Force }
+
+# Temp directory for intermediate component .pkg
+[string]$ComponentDir = Join-Path ([System.IO.Path]::GetTempPath()) "werkr-pkg-component-$EditionName"
+if (Test-Path $ComponentDir) { Remove-Item $ComponentDir -Recurse -Force }
+$null = New-Item -ItemType Directory -Force -Path $ComponentDir
+
+try {
+ # ---- Stage payload into install layout ----
+ # Payload root mirrors the macOS filesystem — pkgbuild --install-location /
+ # places these files at their absolute paths on the target system.
+ [string]$InstallDir = Join-Path $StagingDir 'Library' 'Werkr' $InstallSubDir
+ $null = New-Item -ItemType Directory -Force -Path $InstallDir
+
+ # Copy published binaries
+ Copy-Item -Path (Join-Path $BinaryPath '*') -Destination $InstallDir -Recurse -Force
+
+ # Copy launchd plists into payload (postinstall copies them to /Library/LaunchDaemons/)
+ [string]$LaunchdSrc = Join-Path $TemplateDir 'launchd'
+ [string]$LaunchdDst = Join-Path $InstallDir 'launchd'
+ $null = New-Item -ItemType Directory -Force -Path $LaunchdDst
+ Copy-Item -Path (Join-Path $LaunchdSrc '*.plist') -Destination $LaunchdDst -Force
+
+ # Copy uninstall script into payload
+ [string]$UninstallScript = switch ($ProductType) {
+ 'ServerBundle' { Join-Path $ScriptRoot 'uninstall-werkr-server.sh' }
+ 'Agent' { Join-Path $ScriptRoot 'uninstall-werkr-agent.sh' }
+ }
+ if (Test-Path $UninstallScript) {
+ Copy-Item -Path $UninstallScript -Destination $InstallDir -Force
+ }
+
+ # Agent gets a modules directory
+ if ($ProductType -eq 'Agent') {
+ $null = New-Item -ItemType Directory -Force -Path (Join-Path $InstallDir 'modules')
+ }
+
+ # ---- Prepare scripts directory ----
+ [string]$ScriptsDir = Join-Path $TemplateDir 'scripts'
+ if (-not (Test-Path $ScriptsDir)) {
+ throw "Scripts directory does not exist: $ScriptsDir"
+ }
+
+ # ---- Prepare distribution.xml with version substitution ----
+ [string]$DistSrc = Join-Path $TemplateDir 'distribution.xml'
+ if (-not (Test-Path $DistSrc)) {
+ throw "distribution.xml does not exist: $DistSrc"
+ }
+ [string]$DistContent = (Get-Content -Path $DistSrc -Raw) -replace '{{VERSION}}', $Version
+ [string]$DistDst = Join-Path $ComponentDir 'distribution.xml'
+ Set-Content -Path $DistDst -Value $DistContent -NoNewline
+
+ # ---- Prepare resources directory ----
+ [string]$ResourcesDir = Join-Path $ScriptRoot 'resources'
+
+ # ---- Build component package with pkgbuild ----
+ [string]$ComponentPkg = Join-Path $ComponentDir "$PackageIdentifier.pkg"
+
+ [string[]]$PkgBuildArgs = @(
+ '--root', $StagingDir,
+ '--identifier', $PackageIdentifier,
+ '--version', $Version,
+ '--install-location', '/',
+ '--scripts', $ScriptsDir,
+ $ComponentPkg
+ )
+
+ Write-Host "Running: pkgbuild $($PkgBuildArgs -join ' ')"
+ & pkgbuild @PkgBuildArgs
+ if ($LASTEXITCODE -ne 0) {
+ throw "pkgbuild failed (exit $LASTEXITCODE)"
+ }
+
+ # ---- Build product package with productbuild ----
+ [string]$ProductPkg = Join-Path $OutputPath "$EditionName.pkg"
+
+ [string[]]$ProductBuildArgs = @(
+ '--distribution', $DistDst,
+ '--package-path', $ComponentDir
+ )
+
+ # Add resources if directory exists and has content
+ if ((Test-Path $ResourcesDir) -and (Get-ChildItem -Path $ResourcesDir | Measure-Object).Count -gt 0) {
+ $ProductBuildArgs += @('--resources', $ResourcesDir)
+ }
+
+ $ProductBuildArgs += $ProductPkg
+
+ Write-Host "Running: productbuild $($ProductBuildArgs -join ' ')"
+ & productbuild @ProductBuildArgs
+ if ($LASTEXITCODE -ne 0) {
+ throw "productbuild failed (exit $LASTEXITCODE)"
+ }
+
+ Write-Host "Successfully built: $ProductPkg" -ForegroundColor Green
+
+ # Show package info
+ & pkgutil --payload-files $ComponentPkg | Select-Object -First 20
+ Write-Host ' ...' -ForegroundColor DarkGray
+}
+finally {
+ # Cleanup staging and component directories
+ foreach ($dir in @($StagingDir, $ComponentDir)) {
+ if (Test-Path $dir) {
+ Remove-Item -Path $dir -Recurse -Force -ErrorAction SilentlyContinue
+ }
+ }
+}
diff --git a/src/Installer/Pkg/resources/license.html b/src/Installer/Pkg/resources/license.html
new file mode 100644
index 0000000..3b43b6c
--- /dev/null
+++ b/src/Installer/Pkg/resources/license.html
@@ -0,0 +1,29 @@
+
+
+
+
+MIT License
+Copyright © 2023 Darkgrey Development
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+
diff --git a/src/Installer/Pkg/server/distribution.xml b/src/Installer/Pkg/server/distribution.xml
new file mode 100644
index 0000000..268952e
--- /dev/null
+++ b/src/Installer/Pkg/server/distribution.xml
@@ -0,0 +1,29 @@
+
+
+ Werkr Server
+ app.werkr
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ app.werkr.server.pkg
+
diff --git a/src/Installer/Pkg/server/launchd/app.werkr.api.plist b/src/Installer/Pkg/server/launchd/app.werkr.api.plist
new file mode 100644
index 0000000..cac167c
--- /dev/null
+++ b/src/Installer/Pkg/server/launchd/app.werkr.api.plist
@@ -0,0 +1,46 @@
+
+
+
+
+ Label
+ app.werkr.api
+
+ ProgramArguments
+
+ /Library/Werkr/Server/Werkr.Api
+
+
+ WorkingDirectory
+ /Library/Werkr/Server
+
+ RunAtLoad
+
+
+ KeepAlive
+
+ SuccessfulExit
+
+
+
+ ThrottleInterval
+ 10
+
+ EnvironmentVariables
+
+ DOTNET_ENVIRONMENT
+ Production
+ WERKR_CONFIG_PATH
+ /etc/werkr
+ WERKR_DATA_DIR
+ /var/lib/werkr
+ WERKR_LOG_DIR
+ /var/log/werkr
+
+
+ StandardOutPath
+ /var/log/werkr/werkr-api.stdout.log
+
+ StandardErrorPath
+ /var/log/werkr/werkr-api.stderr.log
+
+
diff --git a/src/Installer/Pkg/server/launchd/app.werkr.server.plist b/src/Installer/Pkg/server/launchd/app.werkr.server.plist
new file mode 100644
index 0000000..d95cedd
--- /dev/null
+++ b/src/Installer/Pkg/server/launchd/app.werkr.server.plist
@@ -0,0 +1,46 @@
+
+
+
+
+ Label
+ app.werkr.server
+
+ ProgramArguments
+
+ /Library/Werkr/Server/Werkr.Server
+
+
+ WorkingDirectory
+ /Library/Werkr/Server
+
+ RunAtLoad
+
+
+ KeepAlive
+
+ SuccessfulExit
+
+
+
+ ThrottleInterval
+ 10
+
+ EnvironmentVariables
+
+ DOTNET_ENVIRONMENT
+ Production
+ WERKR_CONFIG_PATH
+ /etc/werkr
+ WERKR_DATA_DIR
+ /var/lib/werkr
+ WERKR_LOG_DIR
+ /var/log/werkr
+
+
+ StandardOutPath
+ /var/log/werkr/werkr-server.stdout.log
+
+ StandardErrorPath
+ /var/log/werkr/werkr-server.stderr.log
+
+
diff --git a/src/Installer/Pkg/server/scripts/postinstall b/src/Installer/Pkg/server/scripts/postinstall
new file mode 100644
index 0000000..111211e
--- /dev/null
+++ b/src/Installer/Pkg/server/scripts/postinstall
@@ -0,0 +1,37 @@
+#!/bin/bash
+set -e
+
+INSTALL_DIR="/Library/Werkr/Server"
+CONFIG_DIR="/etc/werkr"
+DATA_DIR="/var/lib/werkr"
+LOG_DIR="/var/log/werkr"
+
+# Create directories
+mkdir -p "${CONFIG_DIR}"
+mkdir -p "${DATA_DIR}"
+mkdir -p "${LOG_DIR}"
+
+# Create default config if it doesn't exist
+if [ ! -f "${CONFIG_DIR}/appsettings.json" ]; then
+ echo '{}' > "${CONFIG_DIR}/appsettings.json"
+ chmod 640 "${CONFIG_DIR}/appsettings.json"
+fi
+
+# Set permissions on install directory
+chmod -R 755 "${INSTALL_DIR}"
+chmod +x "${INSTALL_DIR}/Werkr.Server"
+chmod +x "${INSTALL_DIR}/Werkr.Api"
+
+# Install launchd plists and load services
+for PLIST_NAME in "app.werkr.server" "app.werkr.api"; do
+ PLIST_SRC="${INSTALL_DIR}/launchd/${PLIST_NAME}.plist"
+ PLIST_DST="/Library/LaunchDaemons/${PLIST_NAME}.plist"
+
+ cp "${PLIST_SRC}" "${PLIST_DST}"
+ chmod 644 "${PLIST_DST}"
+ chown root:wheel "${PLIST_DST}"
+
+ launchctl load "${PLIST_DST}" 2>/dev/null || true
+done
+
+exit 0
diff --git a/src/Installer/Pkg/server/scripts/preinstall b/src/Installer/Pkg/server/scripts/preinstall
new file mode 100644
index 0000000..11a5d82
--- /dev/null
+++ b/src/Installer/Pkg/server/scripts/preinstall
@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+# Stop and unload existing services if upgrading
+for PLIST_DST in \
+ "/Library/LaunchDaemons/app.werkr.server.plist" \
+ "/Library/LaunchDaemons/app.werkr.api.plist"; do
+ if [ -f "${PLIST_DST}" ]; then
+ launchctl unload "${PLIST_DST}" 2>/dev/null || true
+ fi
+done
+
+exit 0
diff --git a/src/Installer/Pkg/uninstall-werkr-agent.sh b/src/Installer/Pkg/uninstall-werkr-agent.sh
new file mode 100644
index 0000000..bf7e7cb
--- /dev/null
+++ b/src/Installer/Pkg/uninstall-werkr-agent.sh
@@ -0,0 +1,50 @@
+#!/bin/bash
+set -e
+
+# Require root privileges — avoid using sudo within the script
+if [ "$EUID" -ne 0 ]; then
+ echo "This script must be run as root." >&2
+ exit 1
+fi
+
+# Parse arguments for non-interactive mode and data removal
+NON_INTERACTIVE=0
+PURGE_DATA=0
+for arg in "$@"; do
+ case "$arg" in
+ --non-interactive) NON_INTERACTIVE=1 ;;
+ --purge-data|--remove-data) PURGE_DATA=1 ;;
+ esac
+done
+
+echo "Uninstalling Werkr Agent..."
+
+# Stop and unload service
+PLIST="/Library/LaunchDaemons/app.werkr.agent.plist"
+if [ -f "$PLIST" ]; then
+ launchctl unload "$PLIST" 2>/dev/null || true
+ rm -f "$PLIST"
+fi
+
+# Remove application files
+rm -rf /Library/Werkr/Agent
+
+# Optionally remove data
+if [ "$NON_INTERACTIVE" -eq 1 ]; then
+ if [ "$PURGE_DATA" -eq 1 ]; then
+ rm -rf /etc/werkr /var/lib/werkr /var/log/werkr
+ else
+ echo "Non-interactive mode: leaving configuration, data, and logs in place."
+ fi
+else
+ read -p "Remove configuration, data, and logs? [y/N] " -n 1 -r
+ echo
+ if [[ $REPLY =~ ^[Yy]$ ]]; then
+ rm -rf /etc/werkr /var/lib/werkr /var/log/werkr
+ fi
+fi
+
+# Forget the package receipt
+pkgutil --forget app.werkr.agent 2>/dev/null || true
+
+echo "Werkr Agent uninstalled."
diff --git a/src/Installer/Pkg/uninstall-werkr-server.sh b/src/Installer/Pkg/uninstall-werkr-server.sh
new file mode 100644
index 0000000..e12197a
--- /dev/null
+++ b/src/Installer/Pkg/uninstall-werkr-server.sh
@@ -0,0 +1,31 @@
+#!/bin/bash
+set -e
+
+echo "Uninstalling Werkr Server..."
+
+# Stop and unload services
+for PLIST in \
+ "/Library/LaunchDaemons/app.werkr.server.plist" \
+ "/Library/LaunchDaemons/app.werkr.api.plist"; do
+ if [ -f "$PLIST" ]; then
+ sudo launchctl unload "$PLIST" 2>/dev/null || true
+ sudo rm -f "$PLIST"
+ fi
+done
+
+# Remove application files
+sudo rm -rf /Library/Werkr/Server
+
+# Optionally remove data (prompt user)
+read -p "Remove configuration, data, and logs? [y/N] " -n 1 -r
+echo
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+ sudo rm -rf /etc/werkr
+ sudo rm -rf /var/lib/werkr
+ sudo rm -rf /var/log/werkr
+fi
+
+# Forget the package receipt
+sudo pkgutil --forget app.werkr.server 2>/dev/null || true
+
+echo "Werkr Server uninstalled."
diff --git a/src/Test/Werkr.Tests.Agent/AssemblyAttributes.cs b/src/Test/Werkr.Tests.Agent/AssemblyAttributes.cs
new file mode 100644
index 0000000..99be6a5
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/AssemblyAttributes.cs
@@ -0,0 +1 @@
+[assembly: Parallelize( Workers = 0, Scope = ExecutionScope.ClassLevel )]
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/AllowAllPathValidator.cs b/src/Test/Werkr.Tests.Agent/Helpers/AllowAllPathValidator.cs
new file mode 100644
index 0000000..b80b900
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/AllowAllPathValidator.cs
@@ -0,0 +1,25 @@
+using Werkr.Core.Security;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// Fake that permits every path.
+/// Used by handler unit tests where path security is not under test.
+///
+internal sealed class AllowAllPathValidator : IPathAllowlistValidator {
+
+ ///
+ /// Validates the specified path. This implementation is a no-op and always succeeds.
+ ///
+ public void ValidatePath( string path ) { }
+
+ ///
+ /// Validates multiple paths. This implementation is a no-op and always succeeds.
+ ///
+ public void ValidatePaths( params string[] paths ) { }
+
+ ///
+ /// Determines whether the given path is allowed. This implementation always returns .
+ ///
+ public bool IsPathAllowed( string path ) => true;
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/AllowPrefixValidator.cs b/src/Test/Werkr.Tests.Agent/Helpers/AllowPrefixValidator.cs
new file mode 100644
index 0000000..947ef9a
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/AllowPrefixValidator.cs
@@ -0,0 +1,62 @@
+using Werkr.Core.Security;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// Fake that only permits paths
+/// under specified prefixes. Used for testing allowlist enforcement
+/// in tests.
+///
+///
+/// Initializes a new instance of the
+/// class with the specified set of allowed directory prefixes.
+///
+internal sealed class AllowPrefixValidator( params string[] allowedPrefixes ) : IPathAllowlistValidator {
+
+ ///
+ /// The set of directory prefixes that are considered allowed.
+ ///
+ private readonly string[] _allowedPrefixes = allowedPrefixes;
+
+ ///
+ /// Validates the specified path against the configured prefixes.
+ /// Throws an when the path
+ /// is outside every allowed prefix.
+ ///
+ public void ValidatePath( string path ) {
+ if (!IsPathAllowed( path )) {
+ throw new UnauthorizedAccessException(
+ $"Path '{path}' is outside the configured allowlist." );
+ }
+ }
+
+ ///
+ /// Validates each of the specified paths against the configured
+ /// prefixes. Throws an on the
+ /// first path that is not allowed.
+ ///
+ public void ValidatePaths( params string[] paths ) {
+ foreach (string path in paths) {
+ ValidatePath( path );
+ }
+ }
+
+ ///
+ /// Determines whether the given path is allowed by checking if its
+ /// fully-qualified form starts with any of the configured prefixes
+ /// (case-insensitive comparison).
+ ///
+ public bool IsPathAllowed( string path ) {
+ string fullPath = Path.GetFullPath( path );
+ foreach (string prefix in _allowedPrefixes) {
+ string normalizedPrefix = Path.GetFullPath( prefix );
+ if (fullPath.StartsWith(
+ normalizedPrefix,
+ StringComparison.OrdinalIgnoreCase
+ )) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/DenyAllPathValidator.cs b/src/Test/Werkr.Tests.Agent/Helpers/DenyAllPathValidator.cs
new file mode 100644
index 0000000..6c493d5
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/DenyAllPathValidator.cs
@@ -0,0 +1,30 @@
+using Werkr.Core.Security;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// Fake that denies every path.
+/// Used to test that handlers properly propagate allowlist rejections.
+///
+internal sealed class DenyAllPathValidator : IPathAllowlistValidator {
+
+ ///
+ /// Always throws an regardless of the supplied path.
+ ///
+ public void ValidatePath( string path ) =>
+ throw new UnauthorizedAccessException( $"Path '{path}' is outside the configured allowlist." );
+
+ ///
+ /// Validates multiple paths. Throws an on the first path.
+ ///
+ public void ValidatePaths( params string[] paths ) {
+ foreach (string path in paths) {
+ ValidatePath( path );
+ }
+ }
+
+ ///
+ /// Determines whether the given path is allowed. This implementation always returns .
+ ///
+ public bool IsPathAllowed( string path ) => false;
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/FailHandler.cs b/src/Test/Werkr.Tests.Agent/Helpers/FailHandler.cs
new file mode 100644
index 0000000..4ad3f75
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/FailHandler.cs
@@ -0,0 +1,40 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// Fake action handler that always fails (returns Success = false, no throw).
+///
+///
+/// Initializes a new instance of the class with an optional action name.
+///
+internal sealed class FailHandler( string action = "FailAction" ) : IActionHandler {
+
+ ///
+ /// Gets the action name that this handler is registered under.
+ ///
+ public string Action { get; } = action;
+
+ ///
+ /// Executes the handler by writing an error output and returning a failure result.
+ ///
+ public async Task ExecuteAsync(
+ JsonElement parameters,
+ ChannelWriter output,
+ string? inputVariableValue = null,
+ CancellationToken cancellationToken = default
+ ) {
+ await output.WriteAsync(
+ OperatorOutput.Create(
+ LogLevel.Error,
+ "Action failed"
+ ),
+ cancellationToken
+ );
+ return new ActionOperatorResult( Success: false );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/MockHttpMessageHandler.cs b/src/Test/Werkr.Tests.Agent/Helpers/MockHttpMessageHandler.cs
new file mode 100644
index 0000000..346de48
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/MockHttpMessageHandler.cs
@@ -0,0 +1,49 @@
+using System.Net;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// A test that returns a configurable response.
+/// Used by network handler tests to avoid real HTTP traffic.
+///
+///
+/// Creates a handler that invokes the provided delegate for every request.
+///
+internal sealed class MockHttpMessageHandler(
+ Func> handler
+ ) : HttpMessageHandler {
+
+ private readonly Func> _handler = handler;
+
+ ///
+ /// Creates a handler that always returns the specified response.
+ ///
+ public MockHttpMessageHandler( HttpResponseMessage response )
+ : this( ( _, _ ) => Task.FromResult( response ) ) { }
+
+ ///
+ /// Creates a handler that returns 200 OK with the specified string body.
+ ///
+ public static MockHttpMessageHandler Ok( string body = "" ) =>
+ new( new HttpResponseMessage( HttpStatusCode.OK ) {
+ Content = new StringContent( body ),
+ } );
+
+ ///
+ /// Creates a handler that returns the specified status code with the specified body.
+ ///
+ public static MockHttpMessageHandler WithStatus(
+ HttpStatusCode statusCode,
+ string body = ""
+ ) =>
+ new( new HttpResponseMessage( statusCode ) {
+ Content = new StringContent( body ),
+ } );
+
+ ///
+ protected override Task SendAsync(
+ HttpRequestMessage request,
+ CancellationToken cancellationToken
+ ) =>
+ _handler( request, cancellationToken );
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/MockServerStreamWriter.cs b/src/Test/Werkr.Tests.Agent/Helpers/MockServerStreamWriter.cs
new file mode 100644
index 0000000..36efa63
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/MockServerStreamWriter.cs
@@ -0,0 +1,36 @@
+using Grpc.Core;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// Mock that collects written messages for assertion.
+///
+internal sealed class MockServerStreamWriter : IServerStreamWriter {
+ ///
+ /// Backing store for all messages written through
+ /// or
+ /// .
+ ///
+ private readonly List _messages = [];
+
+ ///
+ /// Gets the ordered list of messages that have been written to this stream writer.
+ ///
+ public IReadOnlyList Messages => _messages;
+
+ ///
+ public WriteOptions? WriteOptions { get; set; }
+
+ ///
+ public Task WriteAsync( T message ) {
+ _messages.Add( message );
+ return Task.CompletedTask;
+ }
+
+ ///
+ public Task WriteAsync( T message, CancellationToken cancellationToken ) {
+ cancellationToken.ThrowIfCancellationRequested( );
+ _messages.Add( message );
+ return Task.CompletedTask;
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/SlowHandler.cs b/src/Test/Werkr.Tests.Agent/Helpers/SlowHandler.cs
new file mode 100644
index 0000000..2a2f794
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/SlowHandler.cs
@@ -0,0 +1,48 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// Fake action handler that delays forever (until cancelled).
+/// Used for timeout and cancellation tests.
+///
+///
+/// Initializes a new instance of the class with an optional action name.
+///
+internal sealed class SlowHandler( string action = "SlowAction" ) : IActionHandler {
+
+ ///
+ /// Gets the action name that this handler is registered under.
+ ///
+ public string Action { get; } = action;
+
+ ///
+ /// Executes the handler by writing a start message and then blocking
+ /// indefinitely. The method will only return if the
+ /// is cancelled.
+ ///
+ public async Task ExecuteAsync(
+ JsonElement parameters,
+ ChannelWriter output,
+ string? inputVariableValue = null,
+ CancellationToken cancellationToken = default
+ ) {
+ await output.WriteAsync(
+ OperatorOutput.Create(
+ LogLevel.Information,
+ "Starting slow action..."
+ ),
+ cancellationToken
+ );
+ // Wait indefinitely until cancelled
+ await Task.Delay(
+ Timeout.Infinite,
+ cancellationToken
+ );
+ return new ActionOperatorResult( Success: true );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/SuccessHandler.cs b/src/Test/Werkr.Tests.Agent/Helpers/SuccessHandler.cs
new file mode 100644
index 0000000..ce80f04
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/SuccessHandler.cs
@@ -0,0 +1,40 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// Fake action handler that always succeeds. Used by .
+///
+///
+/// Initializes a new instance of the class with an optional action name.
+///
+internal sealed class SuccessHandler( string action = "TestAction" ) : IActionHandler {
+
+ ///
+ /// Gets the action name that this handler is registered under.
+ ///
+ public string Action { get; } = action;
+
+ ///
+ /// Executes the handler by writing a success output and returning a successful result.
+ ///
+ public async Task ExecuteAsync(
+ JsonElement parameters,
+ ChannelWriter output,
+ string? inputVariableValue = null,
+ CancellationToken cancellationToken = default
+ ) {
+ await output.WriteAsync(
+ OperatorOutput.Create(
+ LogLevel.Information,
+ "Success"
+ ),
+ cancellationToken
+ );
+ return new ActionOperatorResult( Success: true );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/TestActionDescriptor.cs b/src/Test/Werkr.Tests.Agent/Helpers/TestActionDescriptor.cs
new file mode 100644
index 0000000..d61e788
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/TestActionDescriptor.cs
@@ -0,0 +1,49 @@
+using System.Text.Json;
+using Werkr.Common.Models.Actions;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// Helper for building instances in tests
+/// with type-safe parameter serialization.
+///
+internal static class TestActionDescriptor {
+
+ ///
+ /// Shared configured with camelCase property naming.
+ ///
+ private static readonly JsonSerializerOptions s_options = new( ) {
+ PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+ };
+
+ ///
+ /// Serializes an object to a using camelCase naming.
+ /// Shared by all handler tests to avoid creating per-call serializer options.
+ ///
+ public static JsonElement Serialize( T value ) =>
+ JsonSerializer.SerializeToElement(
+ value,
+ s_options
+ );
+
+ ///
+ /// Creates an with serialized parameters.
+ ///
+ public static ActionDescriptor Create(
+ string action,
+ T parameters
+ ) =>
+ new( ) {
+ Action = action,
+ Parameters = Serialize( parameters ),
+ };
+
+ ///
+ /// Creates an with an empty JSON object parameter.
+ ///
+ public static ActionDescriptor Create( string action ) =>
+ new( ) {
+ Action = action,
+ Parameters = JsonSerializer.SerializeToElement( new { } ),
+ };
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/TestFilePathResolver.cs b/src/Test/Werkr.Tests.Agent/Helpers/TestFilePathResolver.cs
new file mode 100644
index 0000000..140539a
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/TestFilePathResolver.cs
@@ -0,0 +1,19 @@
+using Werkr.Agent.Security;
+using Werkr.Core.Security;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// Provides pre-built instances for tests:
+/// (backed by ) and
+/// (backed by ).
+///
+internal static class TestFilePathResolver {
+
+ /// Gets a resolver that allows all paths.
+ public static IFilePathResolver AllowAll { get; } = new FilePathResolver( new AllowAllPathValidator( ) );
+
+ /// Gets a resolver that denies all paths.
+ public static IFilePathResolver DenyAll { get; } = new FilePathResolver( new DenyAllPathValidator( ) );
+
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/TestHttpClientFactory.cs b/src/Test/Werkr.Tests.Agent/Helpers/TestHttpClientFactory.cs
new file mode 100644
index 0000000..dfa413d
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/TestHttpClientFactory.cs
@@ -0,0 +1,14 @@
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// A test that returns an
+/// backed by a .
+///
+/// Creates a factory backed by the specified mock handler.
+internal sealed class TestHttpClientFactory( MockHttpMessageHandler handler ) : IHttpClientFactory {
+
+ private readonly MockHttpMessageHandler _handler = handler;
+
+ ///
+ public HttpClient CreateClient( string name ) => new( _handler );
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/TestSecretStore.cs b/src/Test/Werkr.Tests.Agent/Helpers/TestSecretStore.cs
new file mode 100644
index 0000000..42cb6bb
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/TestSecretStore.cs
@@ -0,0 +1,30 @@
+using Werkr.Core.Security;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// A test backed by a simple in-memory dictionary.
+///
+internal sealed class TestSecretStore : ISecretStore {
+
+ private readonly Dictionary _secrets = new( StringComparer.OrdinalIgnoreCase );
+
+ /// Sets a secret value in the in-memory store.
+ public void Set( string key, string value ) => _secrets[key] = value;
+
+ ///
+ public Task GetSecretAsync( string key ) =>
+ Task.FromResult( _secrets.TryGetValue( key, out string? value ) ? value : null );
+
+ ///
+ public Task SetSecretAsync( string key, string value ) {
+ _secrets[key] = value;
+ return Task.CompletedTask;
+ }
+
+ ///
+ public Task DeleteSecretAsync( string key ) {
+ _ = _secrets.Remove( key );
+ return Task.CompletedTask;
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/TestServerCallContext.cs b/src/Test/Werkr.Tests.Agent/Helpers/TestServerCallContext.cs
new file mode 100644
index 0000000..cfc97db
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/TestServerCallContext.cs
@@ -0,0 +1,88 @@
+using Grpc.Core;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// Minimal stub for unit-testing gRPC interceptors.
+///
+internal sealed class TestServerCallContext : ServerCallContext {
+ ///
+ /// The request metadata headers supplied during construction.
+ ///
+ private readonly Metadata _requestHeaders;
+ ///
+ /// The cancellation token supplied during construction.
+ ///
+ private readonly CancellationToken _cancellationToken;
+ ///
+ /// Mutable user-state dictionary exposed to both the production code
+ /// (via the base class) and to tests
+ /// (via ).
+ ///
+ private readonly Dictionary _userState = [];
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ private TestServerCallContext(
+ Metadata requestHeaders,
+ CancellationToken cancellationToken
+ ) {
+ _requestHeaders = requestHeaders;
+ _cancellationToken = cancellationToken;
+ }
+
+ ///
+ /// Creates a new with optional request headers and cancellation token.
+ ///
+ public static TestServerCallContext Create(
+ Metadata? requestHeaders = null,
+ CancellationToken cancellationToken = default ) {
+ return new TestServerCallContext(
+ requestHeaders ?? [],
+ cancellationToken
+ );
+ }
+
+ ///
+ protected override string MethodCore => "/test/Method";
+ ///
+ protected override string HostCore => "localhost";
+ ///
+ protected override string PeerCore => "ipv4:127.0.0.1:12345";
+ ///
+ protected override DateTime DeadlineCore => DateTime.MaxValue;
+ ///
+ protected override Metadata RequestHeadersCore => _requestHeaders;
+ ///
+ protected override CancellationToken CancellationTokenCore => _cancellationToken;
+ ///
+ protected override Metadata ResponseTrailersCore => [];
+ ///
+ protected override Status StatusCore { get; set; }
+ ///
+ protected override WriteOptions? WriteOptionsCore { get; set; }
+ ///
+ protected override AuthContext AuthContextCore => new( string.Empty, [] );
+
+ /// Exposes the user-state dictionary that interceptors write to.
+ public IDictionary ExposedUserState => _userState;
+
+ ///
+ protected override IDictionary UserStateCore => _userState;
+
+ ///
+ ///
+ /// Always thrown; propagation tokens are not supported in tests.
+ ///
+ protected override ContextPropagationToken CreatePropagationTokenCore(
+ ContextPropagationOptions? options
+ ) {
+ throw new NotImplementedException( );
+ }
+
+ ///
+ protected override Task WriteResponseHeadersAsyncCore( Metadata responseHeaders ) {
+ return Task.CompletedTask;
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/TestUrlValidator.cs b/src/Test/Werkr.Tests.Agent/Helpers/TestUrlValidator.cs
new file mode 100644
index 0000000..b5bab6f
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/TestUrlValidator.cs
@@ -0,0 +1,33 @@
+using Werkr.Core.Security;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// Provides pre-built instances for unit tests.
+///
+internal static class TestUrlValidator {
+
+ ///
+ /// A validator that allows all URLs, returning a parsed
+ /// without any network-actions gate, allowlist, or SSRF checks.
+ ///
+ public static IUrlValidator AllowAll { get; } = new AllowAllUrlValidator( );
+
+ ///
+ /// A validator that rejects all URLs with .
+ ///
+ public static IUrlValidator DenyAll { get; } = new DenyAllUrlValidator( );
+
+ private sealed class AllowAllUrlValidator : IUrlValidator {
+ public Uri ValidateUrl( string url ) {
+ return !Uri.TryCreate( url, UriKind.Absolute, out Uri? uri )
+ ? throw new UnauthorizedAccessException( $"Invalid URL: '{url}'" )
+ : uri;
+ }
+ }
+
+ private sealed class DenyAllUrlValidator : IUrlValidator {
+ public Uri ValidateUrl( string url ) =>
+ throw new UnauthorizedAccessException( $"URL validation denied (test): '{url}'" );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Helpers/ThrowHandler.cs b/src/Test/Werkr.Tests.Agent/Helpers/ThrowHandler.cs
new file mode 100644
index 0000000..8caf1d1
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Helpers/ThrowHandler.cs
@@ -0,0 +1,32 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+
+namespace Werkr.Tests.Agent.Helpers;
+
+///
+/// Fake action handler that always throws an exception.
+///
+///
+/// Initializes a new instance of the class with an optional action name.
+///
+internal sealed class ThrowHandler( string action = "ThrowAction" ) : IActionHandler {
+
+ ///
+ /// Gets the action name that this handler is registered under.
+ ///
+ public string Action { get; } = action;
+
+ ///
+ /// Always throws an to simulate an unexpected handler failure.
+ ///
+ public Task ExecuteAsync(
+ JsonElement parameters,
+ ChannelWriter output,
+ string? inputVariableValue = null,
+ CancellationToken cancellationToken = default
+ ) {
+ throw new InvalidOperationException( "Simulated handler failure." );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Interceptors/BearerTokenInterceptorTests.cs b/src/Test/Werkr.Tests.Agent/Interceptors/BearerTokenInterceptorTests.cs
new file mode 100644
index 0000000..ce0d6f5
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Interceptors/BearerTokenInterceptorTests.cs
@@ -0,0 +1,396 @@
+using Grpc.Core;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Interceptors;
+using Werkr.Common.Models;
+using Werkr.Core.Cryptography;
+using Werkr.Core.Cryptography.KeyInfo;
+using Werkr.Data;
+using Werkr.Data.Entities.Registration;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Interceptors;
+
+///
+/// Unit tests for the gRPC server interceptor.
+/// Verifies that valid bearer tokens with a matching connection-id header allow requests
+/// through, while missing, invalid, or revoked credentials produce
+/// with . Also confirms side-effects such as storing
+/// the in user state and updating the
+/// timestamp. Uses an in-memory SQLite database
+/// for the .
+///
+[TestClass]
+public class BearerTokenInterceptorTests {
+ ///
+ /// In-memory SQLite connection kept open for the lifetime of each test.
+ ///
+ private SqliteConnection _connection = null!;
+ ///
+ /// DI service provider holding the scoped registrations.
+ ///
+ private ServiceProvider _serviceProvider = null!;
+ ///
+ /// The interceptor instance under test.
+ ///
+ private BearerTokenInterceptor _interceptor = null!;
+
+ /// Raw API key value that matches the stored hash.
+ private string _rawToken = null!;
+ ///
+ /// The identifier of the pre-seeded row.
+ ///
+ private Guid _connectionId;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Initializes an in-memory SQLite database, seeds a connected
+ /// with a hashed bearer token, and creates the under test.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _connection = new SqliteConnection( "DataSource=:memory:" );
+ _connection.Open( );
+
+ ServiceCollection services = new( );
+ _ = services.AddDbContext(
+ b => b.UseSqlite( _connection ),
+ ServiceLifetime.Scoped
+ );
+ _ = services.AddScoped( sp => sp.GetRequiredService( ) );
+
+ _serviceProvider = services.BuildServiceProvider( );
+
+ // Ensure schema is created
+ using IServiceScope initScope = _serviceProvider.CreateScope( );
+ WerkrDbContext initDb = initScope.ServiceProvider.GetRequiredService( );
+ _ = initDb.Database.EnsureCreated( );
+
+ // Seed a valid agent-side connection (IsServer = false)
+ _rawToken = Convert.ToBase64String( EncryptionProvider.GenerateRandomBytes( 32 ) );
+ string tokenHash = EncryptionProvider.HashSHA512String( _rawToken );
+ RSAKeyPair keys = EncryptionProvider.GenerateRSAKeyPair( );
+
+ RegisteredConnection conn = new( ) {
+ ConnectionName = "TestAgent",
+ RemoteUrl = "https://localhost:5000",
+ LocalPublicKey = keys.PublicKey,
+ LocalPrivateKey = keys.PrivateKey,
+ RemotePublicKey = keys.PublicKey,
+ OutboundApiKey = "outbound",
+ InboundApiKeyHash = tokenHash,
+ SharedKey = EncryptionProvider.GenerateRandomBytes( 32 ),
+ IsServer = false,
+ Status = ConnectionStatus.Connected,
+ };
+
+ _ = initDb.RegisteredConnections.Add( conn );
+ _ = initDb.SaveChanges( );
+ _connectionId = conn.Id;
+
+ _interceptor = new BearerTokenInterceptor(
+ _serviceProvider.GetRequiredService( ),
+ NullLogger.Instance
+ );
+ }
+
+ ///
+ /// Disposes the DI service provider and the SQLite connection.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ _serviceProvider.Dispose( );
+ _connection.Dispose( );
+ }
+
+ ///
+ /// Verifies that a request with a valid bearer token and connection-id invokes the continuation delegate,
+ /// allowing the request to proceed.
+ ///
+ [TestMethod]
+ public async Task ValidToken_InvokesContinuation( ) {
+ Metadata headers = CreateValidHeaders( );
+ TestServerCallContext ctx = TestServerCallContext.Create(
+ headers,
+ TestContext.CancellationToken
+ );
+ bool continuationCalled = false;
+
+ _ = await _interceptor.UnaryServerHandler(
+ "request",
+ ctx,
+ ( req, context ) => {
+ continuationCalled = true;
+ return Task.FromResult( "response" );
+ }
+ );
+
+ Assert.IsTrue( continuationCalled );
+ }
+
+ ///
+ /// Verifies that after a valid authentication the interceptor stores the resolved
+ /// in the call context's user state under the
+ /// "Connection" key, and that the stored connection matches the expected identifier.
+ ///
+ [TestMethod]
+ public async Task ValidToken_StoresConnectionInUserState( ) {
+ Metadata headers = CreateValidHeaders( );
+ TestServerCallContext ctx = TestServerCallContext.Create(
+ headers,
+ TestContext.CancellationToken
+ );
+
+ _ = await _interceptor.UnaryServerHandler(
+ "request",
+ ctx,
+ ( req, context ) => Task.FromResult( "response" )
+ );
+
+ Assert.IsTrue( ctx.ExposedUserState.ContainsKey( "Connection" ) );
+ RegisteredConnection resolved = (RegisteredConnection)ctx.ExposedUserState["Connection"];
+ Assert.AreEqual(
+ _connectionId,
+ resolved.Id
+ );
+ }
+
+ ///
+ /// Verifies that a request missing the "authorization" header throws an with
+ /// .
+ ///
+ [TestMethod]
+ public async Task MissingAuthHeader_ThrowsUnauthenticated( ) {
+ Metadata headers = new( ) {
+ { "x-werkr-connection-id", _connectionId.ToString( ) },
+ };
+ TestServerCallContext ctx = TestServerCallContext.Create(
+ headers,
+ TestContext.CancellationToken
+ );
+
+ RpcException ex = await Assert.ThrowsExactlyAsync( async ( ) =>
+ await _interceptor.UnaryServerHandler(
+ "request",
+ ctx,
+ ( r, c ) => Task.FromResult( "ok" )
+ )
+ );
+
+ Assert.AreEqual(
+ StatusCode.Unauthenticated,
+ ex.StatusCode
+ );
+ }
+
+ ///
+ /// Verifies that a request missing the "x-werkr-connection-id" header throws an with
+ /// .
+ ///
+ [TestMethod]
+ public async Task MissingConnectionIdHeader_ThrowsUnauthenticated( ) {
+ Metadata headers = new( ) {
+ { "authorization", $"Bearer {_rawToken}" },
+ };
+ TestServerCallContext ctx = TestServerCallContext.Create(
+ headers,
+ TestContext.CancellationToken
+ );
+
+ RpcException ex = await Assert.ThrowsExactlyAsync( async ( ) =>
+ await _interceptor.UnaryServerHandler(
+ "request",
+ ctx,
+ ( r, c ) => Task.FromResult( "ok" )
+ )
+ );
+
+ Assert.AreEqual(
+ StatusCode.Unauthenticated,
+ ex.StatusCode
+ );
+ }
+
+ ///
+ /// Verifies that supplying an incorrect bearer token (one whose hash does not match the stored
+ /// ) throws an with
+ /// .
+ ///
+ [TestMethod]
+ public async Task InvalidToken_ThrowsUnauthenticated( ) {
+ Metadata headers = new( ) {
+ { "authorization", "Bearer wrong-token" },
+ { "x-werkr-connection-id", _connectionId.ToString( ) },
+ };
+ TestServerCallContext ctx = TestServerCallContext.Create(
+ headers,
+ TestContext.CancellationToken
+ );
+
+ RpcException ex = await Assert.ThrowsExactlyAsync( async ( ) =>
+ await _interceptor.UnaryServerHandler(
+ "request",
+ ctx,
+ ( r, c ) => Task.FromResult( "ok" )
+ )
+ );
+
+ Assert.AreEqual(
+ StatusCode.Unauthenticated,
+ ex.StatusCode
+ );
+ }
+
+ ///
+ /// Verifies that a valid token paired with a revoked (status set to
+ /// ) throws an with
+ /// .
+ ///
+ [TestMethod]
+ public async Task RevokedConnection_ThrowsUnauthenticated( ) {
+ // Revoke the connection
+ using IServiceScope scope = _serviceProvider.CreateScope( );
+ WerkrDbContext db = scope.ServiceProvider.GetRequiredService( );
+ RegisteredConnection? conn = await db.RegisteredConnections.FindAsync(
+ [ _connectionId ], TestContext.CancellationToken );
+ conn!.Status = ConnectionStatus.Revoked;
+ _ = await db.SaveChangesAsync( TestContext.CancellationToken );
+
+ Metadata headers = CreateValidHeaders( );
+ TestServerCallContext ctx = TestServerCallContext.Create(
+ headers,
+ TestContext.CancellationToken
+ );
+
+ RpcException ex = await Assert.ThrowsExactlyAsync( async ( ) =>
+ await _interceptor.UnaryServerHandler(
+ "request",
+ ctx,
+ ( r, c ) => Task.FromResult( "ok" )
+ )
+ );
+
+ Assert.AreEqual(
+ StatusCode.Unauthenticated,
+ ex.StatusCode
+ );
+ }
+
+ ///
+ /// Verifies that referencing a connection identifier that does not exist
+ /// in the database throws an with
+ /// .
+ ///
+ [TestMethod]
+ public async Task NonExistentConnection_ThrowsUnauthenticated( ) {
+ Metadata headers = new( ) {
+ { "authorization", $"Bearer {_rawToken}" },
+ { "x-werkr-connection-id", Guid.NewGuid( ).ToString( ) },
+ };
+ TestServerCallContext ctx = TestServerCallContext.Create(
+ headers,
+ TestContext.CancellationToken
+ );
+
+ RpcException ex = await Assert.ThrowsExactlyAsync( async ( ) =>
+ await _interceptor.UnaryServerHandler(
+ "request",
+ ctx,
+ ( r, c ) => Task.FromResult( "ok" )
+ )
+ );
+
+ Assert.AreEqual(
+ StatusCode.Unauthenticated,
+ ex.StatusCode
+ );
+ }
+
+ ///
+ /// Verifies that a successful authentication updates the
+ /// timestamp on the
+ /// row to a recent UTC time.
+ ///
+ [TestMethod]
+ public async Task ValidToken_UpdatesLastSeen( ) {
+ Metadata headers = CreateValidHeaders( );
+ TestServerCallContext ctx = TestServerCallContext.Create(
+ headers,
+ TestContext.CancellationToken
+ );
+
+ _ = await _interceptor.UnaryServerHandler(
+ "request",
+ ctx,
+ ( r, c ) => Task.FromResult( "ok" )
+ );
+
+ // Verify LastSeen was set
+ using IServiceScope scope = _serviceProvider.CreateScope( );
+ WerkrDbContext db = scope.ServiceProvider.GetRequiredService( );
+ RegisteredConnection? conn = await db.RegisteredConnections.FindAsync(
+ [ _connectionId ],
+ TestContext.CancellationToken
+ );
+ Assert.IsNotNull( conn!.LastSeen );
+ Assert.IsGreaterThanOrEqualTo(
+ DateTime.UtcNow.AddSeconds( -5 ),
+ conn.LastSeen.Value
+ );
+ }
+
+ ///
+ /// Verifies that a valid request containing an "x-werkr-call-id" header
+ /// stores the call identifier in the user-state dictionary under the
+ /// "CallId" key.
+ ///
+ [TestMethod]
+ public async Task CallId_StoredInUserState( ) {
+ Guid callId = Guid.NewGuid( );
+ Metadata headers = new( ) {
+ { "authorization", $"Bearer {_rawToken}" },
+ { "x-werkr-connection-id", _connectionId.ToString( ) },
+ { "x-werkr-call-id", callId.ToString( ) },
+ };
+ TestServerCallContext ctx = TestServerCallContext.Create(
+ headers,
+ TestContext.CancellationToken
+ );
+
+ _ = await _interceptor.UnaryServerHandler(
+ "request",
+ ctx,
+ ( r, c ) => Task.FromResult( "ok" )
+ );
+
+ Assert.IsTrue( ctx.ExposedUserState.ContainsKey( "CallId" ) );
+ Assert.AreEqual(
+ callId.ToString( ),
+ ctx.ExposedUserState["CallId"]
+ );
+ }
+
+ ///
+ /// Creates a collection containing the minimum
+ /// valid authorization and connection-id headers needed for a successful
+ /// interceptor pass-through.
+ ///
+ private Metadata CreateValidHeaders( ) {
+ return [
+ new Metadata.Entry(
+ "authorization",
+ $"Bearer {_rawToken}"
+ ),
+ new Metadata.Entry(
+ "x-werkr-connection-id",
+ _connectionId.ToString( )
+ ),
+ ];
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/ActionOperatorTests.cs b/src/Test/Werkr.Tests.Agent/Operators/ActionOperatorTests.cs
new file mode 100644
index 0000000..6b2b3b1
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/ActionOperatorTests.cs
@@ -0,0 +1,403 @@
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+using Werkr.Agent.Operators;
+using Werkr.Common.Models;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators;
+
+///
+/// Unit tests for the class, which dispatches
+/// requests to registered
+/// implementations. Covers constructor validation
+/// (duplicates, missing expected actions), successful and failed handler
+/// dispatch, timeout enforcement, cancellation propagation, case-insensitive
+/// action-name matching, and null-timeout behavior.
+///
+[TestClass]
+public class ActionOperatorTests {
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates an
+ /// with the given timeout. Defaults to a one-hour timeout when none
+ /// is supplied.
+ ///
+ private static TestOptionsMonitor DefaultOptions( TimeSpan? timeout = null ) {
+ ActionOperatorConfiguration config = new( ) {
+ DefaultTimeout = timeout ?? TimeSpan.FromHours( 1 ),
+ };
+ return new TestOptionsMonitor( config );
+ }
+
+ ///
+ /// Factory that constructs an with the given
+ /// handlers, options, and optional expected-action names for validation.
+ ///
+ private static ActionOperator CreateOperator(
+ IActionHandler[] handlers,
+ IOptionsMonitor? options = null,
+ IEnumerable? expectedActions = null ) {
+ return new ActionOperator(
+ handlers,
+ options ?? DefaultOptions( ),
+ NullLogger.Instance,
+ expectedActions ?? [] );
+ }
+
+ // ──────── Construction / Validation ────────
+
+ ///
+ /// Verifies that constructing an with
+ /// uniquely-named handlers succeeds without throwing.
+ ///
+ [TestMethod]
+ public void Constructor_ValidHandlers_Succeeds( ) {
+ IActionHandler[] handlers = [new SuccessHandler( "A" ), new SuccessHandler( "B" )];
+
+ ActionOperator op = CreateOperator( handlers );
+
+ Assert.IsNotNull( op );
+ }
+
+ ///
+ /// Verifies that registering two handlers with the same action name
+ /// throws an during construction.
+ ///
+ [TestMethod]
+ public void Constructor_DuplicateHandlers_ThrowsInvalidOperation( ) {
+ IActionHandler[] handlers = [new SuccessHandler( "A" ), new SuccessHandler( "A" )];
+
+ _ = Assert.ThrowsExactly(
+ ( ) => CreateOperator( handlers ) );
+ }
+
+ ///
+ /// Verifies that if an expected-actions list contains names not covered
+ /// by the registered handlers,
+ /// an is thrown.
+ ///
+ [TestMethod]
+ public void Constructor_MissingExpectedActions_ThrowsInvalidOperation( ) {
+ IActionHandler[] handlers = [new SuccessHandler( "A" )];
+
+ _ = Assert.ThrowsExactly(
+ ( ) => new ActionOperator(
+ handlers,
+ DefaultOptions( ),
+ NullLogger.Instance,
+ expectedActions: ["A", "B", "C"] ) );
+ }
+
+ ///
+ /// Verifies that passing an empty expected-actions list skips the
+ /// validation check and allows the operator to be constructed
+ /// successfully.
+ ///
+ [TestMethod]
+ public void Constructor_EmptyExpectedActions_SkipsValidation( ) {
+ IActionHandler[] handlers = [new SuccessHandler( "OnlyOne" )];
+
+ // Should not throw even though only 1 handler and no DefaultExpectedActions
+ ActionOperator op = CreateOperator( handlers, expectedActions: [] );
+
+ Assert.IsNotNull( op );
+ }
+
+ ///
+ /// Verifies that passing for the expected-actions
+ /// parameter causes the operator to use a default list, which triggers
+ /// an when handlers are
+ /// insufficient.
+ ///
+ [TestMethod]
+ public void Constructor_NullExpectedActions_UsesDefaultList( ) {
+ // With null expectedActions, it uses DefaultExpectedActions which requires 19 handlers
+ IActionHandler[] handlers = [new SuccessHandler( "A" )];
+
+ _ = Assert.ThrowsExactly(
+ ( ) => new ActionOperator(
+ handlers,
+ DefaultOptions( ),
+ NullLogger.Instance,
+ expectedActions: null ) );
+ }
+
+ // ──────── Execute — Success ────────
+
+ ///
+ /// Verifies that dispatching to a returns
+ /// a successful and produces at least
+ /// one output message.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Execute_SuccessHandler_ReturnsSuccess( ) {
+ SuccessHandler handler = new( "TestAction" );
+ ActionOperator op = CreateOperator( [handler] );
+
+ ActionDescriptor descriptor = TestActionDescriptor.Create( "TestAction" );
+ OperatorExecution execution = op.Execute(
+ descriptor,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ List outputs = [];
+ await foreach (OperatorOutput output in execution.Output.WithCancellation( TestContext.CancellationToken )) {
+ outputs.Add( output );
+ }
+
+ IOperatorResult result = await execution.Result;
+
+ Assert.IsTrue( result is ActionOperatorResult { Success: true } );
+ Assert.IsNotEmpty( outputs );
+ }
+
+ // ──────── Execute — Failure ────────
+
+ ///
+ /// Verifies that dispatching to a returns
+ /// an with
+ /// equal to
+ /// .
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Execute_FailHandler_ReturnsFailure( ) {
+ FailHandler handler = new( "FailAction" );
+ ActionOperator op = CreateOperator( [handler] );
+
+ ActionDescriptor descriptor = TestActionDescriptor.Create( "FailAction" );
+ OperatorExecution execution = op.Execute(
+ descriptor,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ await foreach (OperatorOutput _ in execution.Output.WithCancellation( TestContext.CancellationToken )) { }
+
+ IOperatorResult result = await execution.Result;
+
+ Assert.IsTrue( result is ActionOperatorResult { Success: false } );
+ }
+
+ // ──────── Execute — Exception ────────
+
+ ///
+ /// Verifies that dispatching to a catches
+ /// the exception and returns a failure result with the exception
+ /// preserved in .
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Execute_ThrowHandler_ReturnsFailureWithException( ) {
+ ThrowHandler handler = new( "ThrowAction" );
+ ActionOperator op = CreateOperator( [handler] );
+
+ ActionDescriptor descriptor = TestActionDescriptor.Create( "ThrowAction" );
+ OperatorExecution execution = op.Execute(
+ descriptor,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ await foreach (OperatorOutput _ in execution.Output.WithCancellation( TestContext.CancellationToken )) { }
+
+ IOperatorResult result = await execution.Result;
+
+ Assert.IsTrue( result is ActionOperatorResult { Success: false } );
+ ActionOperatorResult actionResult = (ActionOperatorResult) result;
+ Assert.IsNotNull( actionResult.Exception );
+ _ = Assert.IsInstanceOfType( actionResult.Exception );
+ }
+
+ // ──────── Execute — Unknown Action ────────
+
+ ///
+ /// Verifies that requesting an action for which no handler is registered
+ /// returns a failure result and emits an error output mentioning
+ /// "No handler registered".
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Execute_UnknownAction_ReturnsFailure( ) {
+ SuccessHandler handler = new( "KnownAction" );
+ ActionOperator op = CreateOperator( [handler] );
+
+ ActionDescriptor descriptor = TestActionDescriptor.Create( "UnknownAction" );
+ OperatorExecution execution = op.Execute(
+ descriptor,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ List outputs = [];
+ await foreach (OperatorOutput output in execution.Output.WithCancellation( TestContext.CancellationToken )) {
+ outputs.Add( output );
+ }
+
+ IOperatorResult result = await execution.Result;
+
+ Assert.IsTrue( result is ActionOperatorResult { Success: false } );
+ Assert.Contains(
+ o => o.LogLevel == "Error" && o.Message.Contains( "No handler registered" ),
+ outputs,
+ "Expected error message about missing handler."
+ );
+ }
+
+ // ──────── Execute — Timeout ────────
+
+ ///
+ /// Verifies that a handler exceeding the configured default timeout is
+ /// cancelled and a failure result containing a "timed out" warning
+ /// is produced.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Execute_Timeout_ReturnsFailure( ) {
+ SlowHandler handler = new( "SlowAction" );
+ ActionOperator op = CreateOperator(
+ [handler],
+ options: DefaultOptions( timeout: TimeSpan.FromMilliseconds( 200 ) ) );
+
+ ActionDescriptor descriptor = TestActionDescriptor.Create( "SlowAction" );
+ OperatorExecution execution = op.Execute(
+ descriptor,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ List outputs = [];
+ await foreach (OperatorOutput output in execution.Output.WithCancellation( TestContext.CancellationToken )) {
+ outputs.Add( output );
+ }
+
+ IOperatorResult result = await execution.Result;
+
+ Assert.IsTrue( result is ActionOperatorResult { Success: false } );
+ Assert.Contains(
+ o => o.LogLevel == "Warning" && o.Message.Contains( "timed out" ),
+ outputs,
+ "Expected timeout warning in output."
+ );
+ }
+
+ // ──────── Execute — Cancellation ────────
+
+ ///
+ /// Verifies that externally cancelling the token passed to
+ /// stops the slow handler and
+ /// returns a failure result.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Execute_Cancellation_ReturnsFailure( ) {
+ SlowHandler handler = new( "SlowAction" );
+ ActionOperator op = CreateOperator(
+ [handler],
+ options: DefaultOptions( timeout: null ) );
+
+ using CancellationTokenSource cts = new( TimeSpan.FromMilliseconds( 200 ) );
+
+ ActionDescriptor descriptor = TestActionDescriptor.Create( "SlowAction" );
+ OperatorExecution execution = op.Execute(
+ descriptor,
+ cancellationToken: cts.Token
+ );
+
+ List outputs = [];
+ try {
+ await foreach (OperatorOutput output in execution.Output.WithCancellation( cts.Token )) {
+ outputs.Add( output );
+ }
+ } catch (OperationCanceledException) {
+ // Expected
+ }
+
+ IOperatorResult result = await execution.Result;
+
+ Assert.IsTrue( result is ActionOperatorResult { Success: false } );
+ }
+
+ // ──────── Execute — Case-insensitive dispatch ────────
+
+ ///
+ /// Verifies that action-name dispatch is case-insensitive - a handler
+ /// registered as "TestAction" can be invoked with "testaction".
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Execute_CaseInsensitiveActionName_DispatchesCorrectly( ) {
+ SuccessHandler handler = new( "TestAction" );
+ ActionOperator op = CreateOperator( [handler] );
+
+ // Use different casing than registered
+ ActionDescriptor descriptor = TestActionDescriptor.Create( "testaction" );
+ OperatorExecution execution = op.Execute(
+ descriptor,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ await foreach (OperatorOutput _ in execution.Output.WithCancellation( TestContext.CancellationToken )) { }
+
+ IOperatorResult result = await execution.Result;
+
+ Assert.IsTrue( result is ActionOperatorResult { Success: true } );
+ }
+
+ // ──────── Execute — Null timeout means no timeout ────────
+
+ ///
+ /// Verifies that setting the default timeout to
+ /// means no timeout is applied, and a quick handler completes
+ /// successfully.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Execute_NullTimeout_NoTimeoutApplied( ) {
+ SuccessHandler handler = new( "TestAction" );
+ ActionOperator op = CreateOperator(
+ [handler],
+ options: DefaultOptions( timeout: null ) );
+
+ ActionDescriptor descriptor = TestActionDescriptor.Create( "TestAction" );
+ OperatorExecution execution = op.Execute(
+ descriptor,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ await foreach (OperatorOutput _ in execution.Output.WithCancellation( TestContext.CancellationToken )) { }
+
+ IOperatorResult result = await execution.Result;
+
+ Assert.IsTrue( result is ActionOperatorResult { Success: true } );
+ }
+
+ ///
+ /// Simple implementation for tests.
+ ///
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ private sealed class TestOptionsMonitor( T currentValue ) : IOptionsMonitor {
+
+ ///
+ /// Gets the current options value.
+ ///
+ public T CurrentValue { get; } = currentValue;
+
+ ///
+ /// Returns the current value regardless of the supplied .
+ ///
+ public T Get( string? name ) => CurrentValue;
+
+ ///
+ /// No-op change listener registration. Returns .
+ ///
+ public IDisposable? OnChange( Action listener ) => null;
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/ClearContentHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/ClearContentHandlerTests.cs
new file mode 100644
index 0000000..3d9e25b
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/ClearContentHandlerTests.cs
@@ -0,0 +1,157 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates that the handler truncates an existing file to zero bytes,
+/// returns failure when the target file does not exist, and succeeds
+/// when the file is already empty.
+///
+[TestClass]
+public class ClearContentHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private ClearContentHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new ClearContentHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that clearing a file with existing content succeeds and leaves the file empty.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ClearContent_Succeeds( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "file.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "hello world",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new ClearContentParameters { Path = path } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual(
+ string.Empty,
+ await File.ReadAllTextAsync(
+ path,
+ TestContext.CancellationToken
+ )
+ );
+ }
+
+ ///
+ /// Verifies that attempting to clear a non-existent file returns a failure result
+ /// with a in the exception property.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ClearContent_FileNotFound_ReturnsFailure( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "missing.txt"
+ );
+
+ JsonElement parameters = Serialize( new ClearContentParameters { Path = path } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ ///
+ /// Verifies that clearing an already-empty file still returns a success result.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ClearContent_AlreadyEmpty_StillSucceeds( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "empty.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ string.Empty,
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new ClearContentParameters { Path = path } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/CompressArchiveHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/CompressArchiveHandlerTests.cs
new file mode 100644
index 0000000..1b61d33
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/CompressArchiveHandlerTests.cs
@@ -0,0 +1,264 @@
+using System.IO.Compression;
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates Zip and TarGz compression, overwrite behavior, and edge cases.
+///
+[TestClass]
+public class CompressArchiveHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private CompressArchiveHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new CompressArchiveHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that compressing a single file into a Zip archive succeeds.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CompressArchive_SingleFile_Zip_Succeeds( ) {
+ string sourceFile = Path.Combine( _tempDir, "data.txt" );
+ await File.WriteAllTextAsync( sourceFile, "hello world", TestContext.CancellationToken );
+ string destFile = Path.Combine( _tempDir, "archive.zip" );
+
+ JsonElement parameters = Serialize( new CompressArchiveParameters {
+ Source = sourceFile,
+ Destination = destFile,
+ Format = ArchiveFormat.Zip
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( File.Exists( destFile ) );
+
+ // Verify archive contains the file
+ using ZipArchive archive = ZipFile.OpenRead( destFile );
+ Assert.HasCount( 1, archive.Entries );
+ Assert.AreEqual( "data.txt", archive.Entries[0].Name );
+ }
+
+ ///
+ /// Verifies that compressing a directory into a Zip archive includes all files.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CompressArchive_Directory_Zip_IncludesAllFiles( ) {
+ string sourceDir = Path.Combine( _tempDir, "src" );
+ _ = Directory.CreateDirectory( sourceDir );
+ await File.WriteAllTextAsync( Path.Combine( sourceDir, "a.txt" ), "a", TestContext.CancellationToken );
+ await File.WriteAllTextAsync( Path.Combine( sourceDir, "b.txt" ), "b", TestContext.CancellationToken );
+ string subDir = Path.Combine( sourceDir, "sub" );
+ _ = Directory.CreateDirectory( subDir );
+ await File.WriteAllTextAsync( Path.Combine( subDir, "c.txt" ), "c", TestContext.CancellationToken );
+
+ string destFile = Path.Combine( _tempDir, "archive.zip" );
+
+ JsonElement parameters = Serialize( new CompressArchiveParameters {
+ Source = sourceDir,
+ Destination = destFile,
+ Format = ArchiveFormat.Zip
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ using ZipArchive archive = ZipFile.OpenRead( destFile );
+ Assert.HasCount( 3, archive.Entries );
+ }
+
+ ///
+ /// Verifies that compressing to TarGz format succeeds and produces a valid file.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CompressArchive_SingleFile_TarGz_Succeeds( ) {
+ string sourceFile = Path.Combine( _tempDir, "data.txt" );
+ await File.WriteAllTextAsync( sourceFile, "hello world", TestContext.CancellationToken );
+ string destFile = Path.Combine( _tempDir, "archive.tar.gz" );
+
+ JsonElement parameters = Serialize( new CompressArchiveParameters {
+ Source = sourceFile,
+ Destination = destFile,
+ Format = ArchiveFormat.TarGz
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( File.Exists( destFile ) );
+ Assert.IsGreaterThan( 0L, new FileInfo( destFile ).Length );
+ }
+
+ ///
+ /// Verifies that existing archives are not overwritten when Overwrite is false.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CompressArchive_ExistingArchive_NoOverwrite_Fails( ) {
+ string sourceFile = Path.Combine( _tempDir, "data.txt" );
+ await File.WriteAllTextAsync( sourceFile, "hello", TestContext.CancellationToken );
+ string destFile = Path.Combine( _tempDir, "archive.zip" );
+ await File.WriteAllTextAsync( destFile, "existing", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new CompressArchiveParameters {
+ Source = sourceFile,
+ Destination = destFile,
+ Format = ArchiveFormat.Zip,
+ Overwrite = false
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ ///
+ /// Verifies that Overwrite=true replaces an existing archive.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CompressArchive_ExistingArchive_Overwrite_Succeeds( ) {
+ string sourceFile = Path.Combine( _tempDir, "data.txt" );
+ await File.WriteAllTextAsync( sourceFile, "hello", TestContext.CancellationToken );
+ string destFile = Path.Combine( _tempDir, "archive.zip" );
+ await File.WriteAllTextAsync( destFile, "existing", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new CompressArchiveParameters {
+ Source = sourceFile,
+ Destination = destFile,
+ Format = ArchiveFormat.Zip,
+ Overwrite = true
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that Format.Auto is rejected for compression.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CompressArchive_AutoFormat_ReturnsFailure( ) {
+ string sourceFile = Path.Combine( _tempDir, "data.txt" );
+ await File.WriteAllTextAsync( sourceFile, "hello", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new CompressArchiveParameters {
+ Source = sourceFile,
+ Destination = Path.Combine( _tempDir, "archive.zip" ),
+ Format = ArchiveFormat.Auto
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that a denied source path returns failure with UnauthorizedAccessException.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CompressArchive_DeniedPath_ReturnsFailure( ) {
+ CompressArchiveHandler denied = new(
+ TestFilePathResolver.DenyAll,
+ NullLogger.Instance
+ );
+
+ JsonElement parameters = Serialize( new CompressArchiveParameters {
+ Source = "/some/path",
+ Destination = "/some/dest.zip"
+ } );
+ ActionOperatorResult result = await denied.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/CopyFileHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/CopyFileHandlerTests.cs
new file mode 100644
index 0000000..c7de1ad
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/CopyFileHandlerTests.cs
@@ -0,0 +1,295 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates single-file copy, wildcard-based multi-file copy, recursive
+/// directory copy, handling of no-match wildcards, same-source-and-destination
+/// guard, and denial by path-allowlist validation.
+///
+[TestClass]
+public class CopyFileHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private CopyFileHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler backed by
+ /// , and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new CopyFileHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that copying a single file to a new destination succeeds
+ /// and the destination file contains the same content as the source.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CopySingleFile_Succeeds( ) {
+ string src = Path.Combine(
+ _tempDir,
+ "source.txt"
+ );
+ string dest = Path.Combine(
+ _tempDir,
+ "dest.txt"
+ );
+ await File.WriteAllTextAsync(
+ src,
+ "hello",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new CopyFileParameters { Source = src, Destination = dest } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( File.Exists( dest ) );
+ Assert.AreEqual(
+ "hello",
+ await File.ReadAllTextAsync(
+ dest,
+ TestContext.CancellationToken
+ )
+ );
+ }
+
+ ///
+ /// Verifies that a wildcard source pattern copies all matching files into the specified destination directory.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CopyWildcard_CopiesMatchingFiles( ) {
+ string src1 = Path.Combine(
+ _tempDir,
+ "a.txt"
+ );
+ string src2 = Path.Combine(
+ _tempDir,
+ "b.txt"
+ );
+ string destDir = Path.Combine(
+ _tempDir,
+ "out"
+ );
+ _ = Directory.CreateDirectory( destDir );
+ await File.WriteAllTextAsync(
+ src1,
+ "a",
+ TestContext.CancellationToken
+ );
+ await File.WriteAllTextAsync(
+ src2,
+ "b",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new CopyFileParameters {
+ Source = Path.Combine( _tempDir, "*.txt" ),
+ Destination = destDir
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( File.Exists( Path.Combine( destDir, "a.txt" ) ) );
+ Assert.IsTrue( File.Exists( Path.Combine( destDir, "b.txt" ) ) );
+ }
+
+ ///
+ /// Verifies that copying a directory with the Recursive flag copies
+ /// the entire directory tree, including sub-directories and their files.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CopyDirectory_Recursive( ) {
+ string srcDir = Path.Combine(
+ _tempDir,
+ "srcDir"
+ );
+ string subDir = Path.Combine(
+ srcDir,
+ "sub"
+ );
+ _ = Directory.CreateDirectory( subDir );
+ await File.WriteAllTextAsync(
+ Path.Combine( srcDir, "root.txt" ),
+ "root",
+ TestContext.CancellationToken
+ );
+ await File.WriteAllTextAsync(
+ Path.Combine( subDir, "child.txt" ),
+ "child",
+ TestContext.CancellationToken
+ );
+
+ string destDir = Path.Combine(
+ _tempDir,
+ "destDir"
+ );
+
+ JsonElement parameters = Serialize( new CopyFileParameters {
+ Source = srcDir,
+ Destination = destDir,
+ Recursive = true
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( File.Exists( Path.Combine( destDir, "root.txt" ) ) );
+ Assert.IsTrue( File.Exists( Path.Combine( destDir, "sub", "child.txt" ) ) );
+ }
+
+ ///
+ /// Verifies that a wildcard source that matches zero files returns a failure result.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CopyNoMatch_ReturnsFailure( ) {
+ string dest = Path.Combine(
+ _tempDir,
+ "out"
+ );
+ JsonElement parameters = Serialize( new CopyFileParameters {
+ Source = Path.Combine( _tempDir, "*.xyz" ),
+ Destination = dest
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that specifying the same path as both source and destination
+ /// returns a failure result with a non-null exception.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CopySameSourceAndDest_ThrowsArgument( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "file.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "data",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new CopyFileParameters { Source = path, Destination = path } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ }
+
+ ///
+ /// Verifies that when the resolver
+ /// is used, the handler returns a failure result with an
+ /// .
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CopyDenied_ReturnsFailureWithUnauthorized( ) {
+ CopyFileHandler deniedHandler = new(
+ TestFilePathResolver.DenyAll,
+ NullLogger.Instance
+ );
+ string src = Path.Combine(
+ _tempDir,
+ "s.txt"
+ );
+ string dest = Path.Combine(
+ _tempDir,
+ "d.txt"
+ );
+ await File.WriteAllTextAsync(
+ src,
+ "data",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new CopyFileParameters { Source = src, Destination = dest } );
+ ActionOperatorResult result = await deniedHandler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/CreateDirectoryHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/CreateDirectoryHandlerTests.cs
new file mode 100644
index 0000000..0d00ff2
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/CreateDirectoryHandlerTests.cs
@@ -0,0 +1,170 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates successful creation, idempotent creation when the directory
+/// already exists, nested directory creation, and failure when a file
+/// occupies the target path.
+///
+[TestClass]
+public class CreateDirectoryHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private CreateDirectoryHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new CreateDirectoryHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that creating a new directory at a valid path succeeds and the directory exists afterward.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CreateDirectory_Succeeds( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "newDir"
+ );
+
+ JsonElement parameters = Serialize( new CreateDirectoryParameters { Path = path } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( Directory.Exists( path ) );
+ }
+
+ ///
+ /// Verifies that creating a directory that already exists is idempotent and still succeeds.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CreateDirectory_AlreadyExists_StillSucceeds( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "existingDir"
+ );
+ _ = Directory.CreateDirectory( path );
+
+ JsonElement parameters = Serialize( new CreateDirectoryParameters { Path = path } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that a nested multi-level directory path is created in its entirety.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CreateDirectory_NestedPath_CreatesAll( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "a",
+ "b",
+ "c"
+ );
+
+ JsonElement parameters = Serialize( new CreateDirectoryParameters { Path = path } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( Directory.Exists( path ) );
+ }
+
+ ///
+ /// Verifies that if a regular file already exists at the target path,
+ /// the handler returns a failure result with a non-null exception.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CreateDirectory_FileExistsAtPath_ReturnsFailure( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "conflicting"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "data",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new CreateDirectoryParameters { Path = path } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/CreateFileHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/CreateFileHandlerTests.cs
new file mode 100644
index 0000000..7b84ea0
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/CreateFileHandlerTests.cs
@@ -0,0 +1,239 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates creation of empty files, files with content, parent-directory
+/// auto-creation, overwrite guards, and failure when parent directories
+/// do not exist and auto-creation is disabled.
+///
+[TestClass]
+public class CreateFileHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private CreateFileHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new CreateFileHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that creating a new file with no content produces a zero-length file.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CreateEmptyFile_Succeeds( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "new.txt"
+ );
+
+ JsonElement parameters = Serialize( new CreateFileParameters { Path = path } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( File.Exists( path ) );
+ Assert.AreEqual( 0, new FileInfo( path ).Length );
+ }
+
+ ///
+ /// Verifies that a new file is created with the specified text content.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CreateFileWithContent_Succeeds( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "content.txt"
+ );
+
+ JsonElement parameters = Serialize( new CreateFileParameters { Path = path, Content = "hello world" } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual(
+ "hello world",
+ await File.ReadAllTextAsync(
+ path,
+ TestContext.CancellationToken
+ )
+ );
+ }
+
+ ///
+ /// Verifies that the handler creates missing parent directories when CreateParentDirectories is enabled.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CreateFileCreatesParentDirectories( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "sub",
+ "deep",
+ "file.txt"
+ );
+
+ JsonElement parameters = Serialize( new CreateFileParameters { Path = path, CreateParentDirectories = true } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( File.Exists( path ) );
+ }
+
+ ///
+ /// Verifies that attempting to create a file that already exists without
+ /// the Overwrite flag returns a failure result.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CreateFile_ExistsNoOverwrite_ReturnsFailure( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "existing.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "data",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new CreateFileParameters { Path = path, Overwrite = false } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that creating a file with the Overwrite flag when the file
+ /// already exists replaces the old content with the new content.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CreateFile_ExistsWithOverwrite_Succeeds( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "existing.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "old",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize(
+ new CreateFileParameters { Path = path, Content = "new", Overwrite = true }
+ );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual(
+ "new",
+ await File.ReadAllTextAsync(
+ path,
+ TestContext.CancellationToken
+ )
+ );
+ }
+
+ ///
+ /// Verifies that when the parent directory does not exist and
+ /// CreateParentDirectories is , the handler
+ /// returns a failure result with a non-null exception.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task CreateFile_NoParentNoCreate_ReturnsFailure( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "missing-parent",
+ "file.txt"
+ );
+
+ JsonElement parameters = Serialize(
+ new CreateFileParameters { Path = path, CreateParentDirectories = false }
+ );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/DelayHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/DelayHandlerTests.cs
new file mode 100644
index 0000000..23e111a
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/DelayHandlerTests.cs
@@ -0,0 +1,160 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Time.Testing;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates delay execution, cancellation behavior, and reason output.
+///
+[TestClass]
+public class DelayHandlerTests {
+
+ ///
+ /// The handler instance under test.
+ ///
+ private DelayHandler _handler = null!;
+ ///
+ /// Fake time provider for deterministic delay testing.
+ ///
+ private FakeTimeProvider _timeProvider = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates the handler with a fake time provider and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _timeProvider = new FakeTimeProvider( );
+ _handler = new DelayHandler(
+ NullLogger.Instance,
+ _timeProvider
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that a delay of zero seconds completes immediately.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Delay_ZeroSeconds_CompletesImmediately( ) {
+ JsonElement parameters = Serialize( new DelayParameters { Seconds = 0 } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that advancing the fake clock completes a non-zero delay.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Delay_PositiveSeconds_CompletesAfterAdvance( ) {
+ JsonElement parameters = Serialize( new DelayParameters { Seconds = 10 } );
+
+ Task task = _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ _timeProvider.Advance( TimeSpan.FromSeconds( 10 ) );
+
+ ActionOperatorResult result = await task;
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that a reason message appears in the output channel.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Delay_WithReason_WritesReasonToOutput( ) {
+ JsonElement parameters = Serialize( new DelayParameters { Seconds = 0, Reason = "waiting for deploy" } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ _channel.Writer.Complete( );
+ List messages = [ ];
+ await foreach (OperatorOutput msg in _channel.Reader.ReadAllAsync( TestContext.CancellationToken )) {
+ messages.Add( msg );
+ }
+
+ Assert.IsTrue(
+ messages.Exists( m => m.Message.Contains( "waiting for deploy" ) ),
+ "Expected reason text in output."
+ );
+ }
+
+ ///
+ /// Verifies that cancellation during a delay propagates as OperationCanceledException.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Delay_Cancelled_ThrowsOperationCanceled( ) {
+ JsonElement parameters = Serialize( new DelayParameters { Seconds = 300 } );
+ using CancellationTokenSource cts = new( );
+
+ Task task = _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: cts.Token
+ );
+
+ await cts.CancelAsync( );
+
+ _ = await Assert.ThrowsExactlyAsync( ( ) => task );
+ }
+
+ ///
+ /// Verifies that a negative Seconds value produces a failure result.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Delay_NegativeSeconds_ReturnsFailure( ) {
+ JsonElement parameters = Serialize( new DelayParameters { Seconds = -1 } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/DeleteFileHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/DeleteFileHandlerTests.cs
new file mode 100644
index 0000000..1843dc6
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/DeleteFileHandlerTests.cs
@@ -0,0 +1,179 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates deletion of a single file, recursive directory deletion,
+/// failure when the target does not exist, and forced removal of
+/// read-only files.
+///
+[TestClass]
+public class DeleteFileHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private DeleteFileHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new DeleteFileHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that deleting an existing file succeeds and the file no longer exists.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DeleteFile_Succeeds( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "file.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "data",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new DeleteFileParameters { Path = path } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsFalse( File.Exists( path ) );
+ }
+
+ ///
+ /// Verifies that deleting a directory with the Recursive flag
+ /// removes the directory and all of its contents.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DeleteDirectory_Recursive( ) {
+ string dir = Path.Combine(
+ _tempDir,
+ "subdir"
+ );
+ _ = Directory.CreateDirectory( dir );
+ await File.WriteAllTextAsync(
+ Path.Combine( dir, "file.txt" ),
+ "data",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new DeleteFileParameters { Path = dir, Recursive = true } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsFalse( Directory.Exists( dir ) );
+ }
+
+ ///
+ /// Verifies that attempting to delete a path that does not exist returns a failure result.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DeleteNonExistent_ReturnsFailure( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "missing.txt"
+ );
+
+ JsonElement parameters = Serialize( new DeleteFileParameters { Path = path } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that deleting a read-only file with the Force flag succeeds and the file is removed.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DeleteReadOnly_ForceRemoves( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "readonly.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "data",
+ TestContext.CancellationToken
+ );
+ File.SetAttributes( path, FileAttributes.ReadOnly );
+
+ JsonElement parameters = Serialize( new DeleteFileParameters { Path = path, Force = true } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsFalse( File.Exists( path ) );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/DownloadFileHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/DownloadFileHandlerTests.cs
new file mode 100644
index 0000000..ab62b4e
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/DownloadFileHandlerTests.cs
@@ -0,0 +1,240 @@
+using System.Net;
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Uses to avoid real HTTP traffic.
+///
+[TestClass]
+public class DownloadFileHandlerTests {
+
+ /// Temporary directory for download destination tests.
+ private string _tempDir = null!;
+ /// Unbounded channel for capturing messages.
+ private Channel _channel = null!;
+
+ /// Gets or sets the MSTest test context.
+ public TestContext TestContext { get; set; } = null!;
+
+ /// Sets up the temp directory and output channel.
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine( Path.GetTempPath( ), $"werkr-test-{Guid.NewGuid( )}" );
+ _ = Directory.CreateDirectory( _tempDir );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ /// Cleans up the temp directory.
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete( _tempDir, recursive: true );
+ }
+ }
+
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ private static DownloadFileHandler CreateHandler(
+ MockHttpMessageHandler mockHttp,
+ bool allowUrls = true,
+ bool allowFiles = true
+ ) =>
+ new(
+ allowUrls ? TestUrlValidator.AllowAll : TestUrlValidator.DenyAll,
+ new TestHttpClientFactory( mockHttp ),
+ allowFiles ? TestFilePathResolver.AllowAll : TestFilePathResolver.DenyAll,
+ NullLogger.Instance
+ );
+
+ /// Verifies a successful download writes content to the destination file.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DownloadFile_Success_WritesFile( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( "file-content" );
+ DownloadFileHandler handler = CreateHandler( mock );
+
+ string dest = Path.Combine( _tempDir, "downloaded.txt" );
+ JsonElement parameters = Serialize( new DownloadFileParameters {
+ Url = "https://example.com/file.txt",
+ Destination = dest,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( File.Exists( dest ) );
+ string content = await File.ReadAllTextAsync( dest, TestContext.CancellationToken );
+ Assert.AreEqual( "file-content", content );
+ }
+
+ /// Verifies the output variable contains download metadata.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DownloadFile_OutputVariable_ContainsMetadata( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( "data" );
+ DownloadFileHandler handler = CreateHandler( mock );
+
+ string dest = Path.Combine( _tempDir, "meta.txt" );
+ JsonElement parameters = Serialize( new DownloadFileParameters {
+ Url = "https://example.com/file.txt",
+ Destination = dest,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsNotNull( result.OutputVariableValue );
+
+ using JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue );
+ Assert.AreEqual( dest, doc.RootElement.GetProperty( "path" ).GetString( ) );
+ Assert.IsGreaterThan( 0L, doc.RootElement.GetProperty( "size" ).GetInt64( ) );
+ }
+
+ /// Verifies that existing files are not overwritten when Overwrite is false.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DownloadFile_ExistingFile_NoOverwrite_Fails( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( "new-content" );
+ DownloadFileHandler handler = CreateHandler( mock );
+
+ string dest = Path.Combine( _tempDir, "existing.txt" );
+ await File.WriteAllTextAsync( dest, "original", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new DownloadFileParameters {
+ Url = "https://example.com/file.txt",
+ Destination = dest,
+ Overwrite = false,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ string content = await File.ReadAllTextAsync( dest, TestContext.CancellationToken );
+ Assert.AreEqual( "original", content );
+ }
+
+ /// Verifies that existing files are overwritten when Overwrite is true.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DownloadFile_ExistingFile_Overwrite_Succeeds( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( "new-content" );
+ DownloadFileHandler handler = CreateHandler( mock );
+
+ string dest = Path.Combine( _tempDir, "existing.txt" );
+ await File.WriteAllTextAsync( dest, "original", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new DownloadFileParameters {
+ Url = "https://example.com/file.txt",
+ Destination = dest,
+ Overwrite = true,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ string content = await File.ReadAllTextAsync( dest, TestContext.CancellationToken );
+ Assert.AreEqual( "new-content", content );
+ }
+
+ /// Verifies that a denied URL causes failure.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DownloadFile_DeniedUrl_Fails( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( );
+ DownloadFileHandler handler = CreateHandler( mock, allowUrls: false );
+
+ string dest = Path.Combine( _tempDir, "denied.txt" );
+ JsonElement parameters = Serialize( new DownloadFileParameters {
+ Url = "https://example.com/file.txt",
+ Destination = dest,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ /// Verifies that a denied destination path causes failure.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DownloadFile_DeniedDestination_Fails( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( "data" );
+ DownloadFileHandler handler = CreateHandler( mock, allowFiles: false );
+
+ JsonElement parameters = Serialize( new DownloadFileParameters {
+ Url = "https://example.com/file.txt",
+ Destination = "/denied/file.txt",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ /// Verifies that server errors cause failure.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DownloadFile_ServerError_Fails( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.WithStatus( HttpStatusCode.InternalServerError );
+ DownloadFileHandler handler = CreateHandler( mock );
+
+ string dest = Path.Combine( _tempDir, "error.txt" );
+ JsonElement parameters = Serialize( new DownloadFileParameters {
+ Url = "https://example.com/file.txt",
+ Destination = dest,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsFalse( File.Exists( dest ) );
+ }
+
+ /// Verifies the Action property returns the correct name.
+ [TestMethod]
+ public void DownloadFile_ActionProperty_IsCorrect( ) {
+ DownloadFileHandler handler = CreateHandler( MockHttpMessageHandler.Ok( ) );
+ Assert.AreEqual( "DownloadFile", handler.Action );
+ }
+
+ /// Verifies intermediate directories are created.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DownloadFile_CreatesIntermediateDirectories( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( "nested" );
+ DownloadFileHandler handler = CreateHandler( mock );
+
+ string dest = Path.Combine( _tempDir, "sub", "dir", "file.txt" );
+ JsonElement parameters = Serialize( new DownloadFileParameters {
+ Url = "https://example.com/file.txt",
+ Destination = dest,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( File.Exists( dest ) );
+ string content = await File.ReadAllTextAsync( dest, TestContext.CancellationToken );
+ Assert.AreEqual( "nested", content );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/ExpandArchiveHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/ExpandArchiveHandlerTests.cs
new file mode 100644
index 0000000..3294d89
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/ExpandArchiveHandlerTests.cs
@@ -0,0 +1,299 @@
+using System.IO.Compression;
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates Zip and TarGz extraction, auto-detection, overwrite, and zip-slip protection.
+///
+[TestClass]
+public class ExpandArchiveHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private ExpandArchiveHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new ExpandArchiveHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ /// Creates a test Zip archive at the specified path with the given entries.
+ private static void CreateTestZip( string archivePath, params (string EntryName, string Content)[] entries ) {
+ using FileStream fs = new( archivePath, FileMode.Create, FileAccess.Write, FileShare.None );
+ using ZipArchive archive = new( fs, ZipArchiveMode.Create );
+ foreach ((string entryName, string content) in entries) {
+ ZipArchiveEntry entry = archive.CreateEntry( entryName );
+ using StreamWriter writer = new( entry.Open( ) );
+ writer.Write( content );
+ }
+ }
+
+ ///
+ /// Verifies that extracting a Zip archive succeeds and files are on disk.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ExpandArchive_Zip_ExtractsFiles( ) {
+ string archivePath = Path.Combine( _tempDir, "test.zip" );
+ CreateTestZip( archivePath, ("hello.txt", "world"), ("sub/nested.txt", "nested") );
+ string destDir = Path.Combine( _tempDir, "output" );
+
+ JsonElement parameters = Serialize( new ExpandArchiveParameters {
+ Source = archivePath,
+ Destination = destDir,
+ Format = ArchiveFormat.Zip
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( File.Exists( Path.Combine( destDir, "hello.txt" ) ) );
+ Assert.IsTrue( File.Exists( Path.Combine( destDir, "sub", "nested.txt" ) ) );
+ Assert.AreEqual( "world", await File.ReadAllTextAsync(
+ Path.Combine( destDir, "hello.txt" ), TestContext.CancellationToken ) );
+ }
+
+ ///
+ /// Verifies that auto-detection correctly identifies a .zip file.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ExpandArchive_AutoDetect_Zip_Succeeds( ) {
+ string archivePath = Path.Combine( _tempDir, "test.zip" );
+ CreateTestZip( archivePath, ("file.txt", "content") );
+ string destDir = Path.Combine( _tempDir, "output" );
+
+ JsonElement parameters = Serialize( new ExpandArchiveParameters {
+ Source = archivePath,
+ Destination = destDir
+ // Format defaults to Auto
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( File.Exists( Path.Combine( destDir, "file.txt" ) ) );
+ }
+
+ ///
+ /// Verifies that extraction fails when a file already exists and Overwrite is false.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ExpandArchive_ExistingFile_NoOverwrite_Fails( ) {
+ string archivePath = Path.Combine( _tempDir, "test.zip" );
+ CreateTestZip( archivePath, ("file.txt", "new content") );
+ string destDir = Path.Combine( _tempDir, "output" );
+ _ = Directory.CreateDirectory( destDir );
+ await File.WriteAllTextAsync(
+ Path.Combine( destDir, "file.txt" ), "old content", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new ExpandArchiveParameters {
+ Source = archivePath,
+ Destination = destDir,
+ Overwrite = false
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ ///
+ /// Verifies that Overwrite=true replaces existing files during extraction.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ExpandArchive_ExistingFile_Overwrite_Succeeds( ) {
+ string archivePath = Path.Combine( _tempDir, "test.zip" );
+ CreateTestZip( archivePath, ("file.txt", "new content") );
+ string destDir = Path.Combine( _tempDir, "output" );
+ _ = Directory.CreateDirectory( destDir );
+ await File.WriteAllTextAsync(
+ Path.Combine( destDir, "file.txt" ), "old content", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new ExpandArchiveParameters {
+ Source = archivePath,
+ Destination = destDir,
+ Overwrite = true
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ string content = await File.ReadAllTextAsync(
+ Path.Combine( destDir, "file.txt" ), TestContext.CancellationToken );
+ Assert.AreEqual( "new content", content );
+ }
+
+ ///
+ /// Verifies that a zip-slip attack vector (entry with ../) is rejected.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ExpandArchive_ZipSlip_Rejected( ) {
+ // Create a malicious zip with a path traversal entry
+ string archivePath = Path.Combine( _tempDir, "malicious.zip" );
+ using (FileStream fs = new( archivePath, FileMode.Create, FileAccess.Write, FileShare.None )) {
+ using ZipArchive archive = new( fs, ZipArchiveMode.Create );
+ ZipArchiveEntry entry = archive.CreateEntry( "../../../evil.txt" );
+ using StreamWriter writer = new( entry.Open( ) );
+ writer.Write( "evil content" );
+ }
+
+ string destDir = Path.Combine( _tempDir, "output" );
+
+ JsonElement parameters = Serialize( new ExpandArchiveParameters {
+ Source = archivePath,
+ Destination = destDir
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ Assert.Contains( "zip-slip", result.Exception!.Message );
+ }
+
+ ///
+ /// Verifies that an unrecognized extension with Auto format returns failure.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ExpandArchive_UnrecognizedExtension_Auto_Fails( ) {
+ string archivePath = Path.Combine( _tempDir, "test.xyz" );
+ await File.WriteAllTextAsync( archivePath, "not an archive", TestContext.CancellationToken );
+ string destDir = Path.Combine( _tempDir, "output" );
+
+ JsonElement parameters = Serialize( new ExpandArchiveParameters {
+ Source = archivePath,
+ Destination = destDir
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that a missing archive file returns failure.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ExpandArchive_MissingArchive_ReturnsFailure( ) {
+ string missingPath = Path.Combine( _tempDir, "missing.zip" );
+ string destDir = Path.Combine( _tempDir, "output" );
+
+ JsonElement parameters = Serialize( new ExpandArchiveParameters {
+ Source = missingPath,
+ Destination = destDir
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ ///
+ /// Verifies that a denied path returns failure with UnauthorizedAccessException.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ExpandArchive_DeniedPath_ReturnsFailure( ) {
+ ExpandArchiveHandler denied = new(
+ TestFilePathResolver.DenyAll,
+ NullLogger.Instance
+ );
+
+ JsonElement parameters = Serialize( new ExpandArchiveParameters {
+ Source = "/some/archive.zip",
+ Destination = "/some/dest"
+ } );
+ ActionOperatorResult result = await denied.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/FindReplaceHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/FindReplaceHandlerTests.cs
new file mode 100644
index 0000000..4777c4b
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/FindReplaceHandlerTests.cs
@@ -0,0 +1,257 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates plain text replace, regex replace, case sensitivity, and edge cases.
+///
+[TestClass]
+public class FindReplaceHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private FindReplaceHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new FindReplaceHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that a plain text case-sensitive replacement works correctly.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task FindReplace_PlainText_ReplacesAll( ) {
+ string filePath = Path.Combine( _tempDir, "test.txt" );
+ await File.WriteAllTextAsync( filePath, "hello world hello", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new FindReplaceParameters {
+ Path = filePath,
+ Find = "hello",
+ Replace = "bye"
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ string content = await File.ReadAllTextAsync( filePath, TestContext.CancellationToken );
+ Assert.AreEqual( "bye world bye", content );
+ }
+
+ ///
+ /// Verifies that case-insensitive plain text replacement works.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task FindReplace_CaseInsensitive_ReplacesAll( ) {
+ string filePath = Path.Combine( _tempDir, "test.txt" );
+ await File.WriteAllTextAsync( filePath, "Hello HELLO hello", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new FindReplaceParameters {
+ Path = filePath,
+ Find = "hello",
+ Replace = "bye",
+ CaseSensitive = false
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ string content = await File.ReadAllTextAsync( filePath, TestContext.CancellationToken );
+ Assert.AreEqual( "bye bye bye", content );
+ }
+
+ ///
+ /// Verifies that regex replacement with capture groups works.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task FindReplace_Regex_ReplacesWithGroups( ) {
+ string filePath = Path.Combine( _tempDir, "test.txt" );
+ await File.WriteAllTextAsync( filePath, "version=1.2.3", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new FindReplaceParameters {
+ Path = filePath,
+ Find = @"version=(\d+\.\d+\.\d+)",
+ Replace = "version=9.9.9",
+ IsRegex = true
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ string content = await File.ReadAllTextAsync( filePath, TestContext.CancellationToken );
+ Assert.AreEqual( "version=9.9.9", content );
+ }
+
+ ///
+ /// Verifies that no matches produces a success with 0 replacements.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task FindReplace_NoMatches_SucceedsWithZeroReplacements( ) {
+ string filePath = Path.Combine( _tempDir, "test.txt" );
+ await File.WriteAllTextAsync( filePath, "hello world", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new FindReplaceParameters {
+ Path = filePath,
+ Find = "missing",
+ Replace = "found"
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ _channel.Writer.Complete( );
+ List messages = [ ];
+ await foreach (OperatorOutput msg in _channel.Reader.ReadAllAsync( TestContext.CancellationToken )) {
+ messages.Add( msg );
+ }
+
+ Assert.IsTrue(
+ messages.Exists( m => m.Message.Contains( "0 replacement(s)" ) ),
+ "Expected zero replacements in output."
+ );
+ }
+
+ ///
+ /// Verifies that an invalid regex returns failure.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task FindReplace_InvalidRegex_ReturnsFailure( ) {
+ string filePath = Path.Combine( _tempDir, "test.txt" );
+ await File.WriteAllTextAsync( filePath, "content", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new FindReplaceParameters {
+ Path = filePath,
+ Find = "[invalid",
+ Replace = "x",
+ IsRegex = true
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ }
+
+ ///
+ /// Verifies that a non-existent file returns failure.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task FindReplace_FileNotFound_ReturnsFailure( ) {
+ string missingPath = Path.Combine( _tempDir, "missing.txt" );
+
+ JsonElement parameters = Serialize( new FindReplaceParameters {
+ Path = missingPath,
+ Find = "a",
+ Replace = "b"
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ ///
+ /// Verifies that a denied path returns failure with UnauthorizedAccessException.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task FindReplace_DeniedPath_ReturnsFailure( ) {
+ FindReplaceHandler denied = new(
+ TestFilePathResolver.DenyAll,
+ NullLogger.Instance
+ );
+
+ JsonElement parameters = Serialize( new FindReplaceParameters {
+ Path = "/some/path",
+ Find = "a",
+ Replace = "b"
+ } );
+ ActionOperatorResult result = await denied.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/GetFileInfoHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/GetFileInfoHandlerTests.cs
new file mode 100644
index 0000000..f02a3b4
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/GetFileInfoHandlerTests.cs
@@ -0,0 +1,183 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates returning metadata for files, directories, and non-existent paths.
+///
+[TestClass]
+public class GetFileInfoHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private GetFileInfoHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new GetFileInfoHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that file metadata is returned correctly for an existing file.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task GetFileInfo_ExistingFile_ReturnsMetadata( ) {
+ string filePath = Path.Combine( _tempDir, "test.txt" );
+ await File.WriteAllTextAsync( filePath, "hello world", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new GetFileInfoParameters { Path = filePath } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ _channel.Writer.Complete( );
+ List messages = [ ];
+ await foreach (OperatorOutput msg in _channel.Reader.ReadAllAsync( TestContext.CancellationToken )) {
+ messages.Add( msg );
+ }
+
+ Assert.HasCount( 1, messages );
+ JsonDocument doc = JsonDocument.Parse( messages[0].Message );
+ Assert.IsTrue( doc.RootElement.GetProperty( "exists" ).GetBoolean( ) );
+ Assert.IsFalse( doc.RootElement.GetProperty( "isDirectory" ).GetBoolean( ) );
+ Assert.IsGreaterThan( 0L, doc.RootElement.GetProperty( "size" ).GetInt64( ) );
+ }
+
+ ///
+ /// Verifies that directory metadata is returned correctly for an existing directory.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task GetFileInfo_ExistingDirectory_ReturnsMetadata( ) {
+ string dirPath = Path.Combine( _tempDir, "subdir" );
+ _ = Directory.CreateDirectory( dirPath );
+
+ JsonElement parameters = Serialize( new GetFileInfoParameters { Path = dirPath } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ _channel.Writer.Complete( );
+ List messages = [ ];
+ await foreach (OperatorOutput msg in _channel.Reader.ReadAllAsync( TestContext.CancellationToken )) {
+ messages.Add( msg );
+ }
+
+ Assert.HasCount( 1, messages );
+ JsonDocument doc = JsonDocument.Parse( messages[0].Message );
+ Assert.IsTrue( doc.RootElement.GetProperty( "exists" ).GetBoolean( ) );
+ Assert.IsTrue( doc.RootElement.GetProperty( "isDirectory" ).GetBoolean( ) );
+ }
+
+ ///
+ /// Verifies that a non-existent path returns exists=false and action succeeds.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task GetFileInfo_NonExistentPath_ReturnsNotFound( ) {
+ string missingPath = Path.Combine( _tempDir, "does-not-exist.txt" );
+
+ JsonElement parameters = Serialize( new GetFileInfoParameters { Path = missingPath } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ _channel.Writer.Complete( );
+ List messages = [ ];
+ await foreach (OperatorOutput msg in _channel.Reader.ReadAllAsync( TestContext.CancellationToken )) {
+ messages.Add( msg );
+ }
+
+ Assert.HasCount( 1, messages );
+ JsonDocument doc = JsonDocument.Parse( messages[0].Message );
+ Assert.IsFalse( doc.RootElement.GetProperty( "exists" ).GetBoolean( ) );
+ }
+
+ ///
+ /// Verifies that a denied path returns failure with UnauthorizedAccessException.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task GetFileInfo_DeniedPath_ReturnsFailure( ) {
+ GetFileInfoHandler denied = new(
+ TestFilePathResolver.DenyAll,
+ NullLogger.Instance
+ );
+
+ JsonElement parameters = Serialize( new GetFileInfoParameters { Path = "/some/path" } );
+ ActionOperatorResult result = await denied.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/HttpRequestHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/HttpRequestHandlerTests.cs
new file mode 100644
index 0000000..ed72120
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/HttpRequestHandlerTests.cs
@@ -0,0 +1,260 @@
+using System.Net;
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Configuration;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Uses to avoid real HTTP traffic.
+///
+[TestClass]
+public class HttpRequestHandlerTests {
+
+ /// Temporary directory for file output tests.
+ private string _tempDir = null!;
+ /// Unbounded channel for capturing messages.
+ private Channel _channel = null!;
+
+ /// Gets or sets the MSTest test context.
+ public TestContext TestContext { get; set; } = null!;
+
+ /// Sets up the temp directory and output channel.
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine( Path.GetTempPath( ), $"werkr-test-{Guid.NewGuid( )}" );
+ _ = Directory.CreateDirectory( _tempDir );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ /// Cleans up the temp directory.
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete( _tempDir, recursive: true );
+ }
+ }
+
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ private static HttpRequestHandler CreateHandler(
+ MockHttpMessageHandler mockHttp,
+ bool allowUrls = true,
+ bool allowFiles = true
+ ) =>
+ new(
+ allowUrls ? TestUrlValidator.AllowAll : TestUrlValidator.DenyAll,
+ new TestHttpClientFactory( mockHttp ),
+ allowFiles ? TestFilePathResolver.AllowAll : TestFilePathResolver.DenyAll,
+ Options.Create( new WorkflowVariableOptions( ) ),
+ NullLogger.Instance
+ );
+
+ /// Verifies a simple GET request returns the response body.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task HttpRequest_Get_ReturnsBody( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( "hello" );
+ HttpRequestHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new HttpRequestParameters { Url = "https://example.com/api" } );
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsNotNull( result.OutputVariableValue );
+
+ using JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue );
+ Assert.AreEqual( 200, doc.RootElement.GetProperty( "statusCode" ).GetInt32( ) );
+ Assert.AreEqual( "hello", doc.RootElement.GetProperty( "body" ).GetString( ) );
+ }
+
+ /// Verifies POST sends the parameter body.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task HttpRequest_PostWithBody_SendsBody( ) {
+ string? capturedBody = null;
+ MockHttpMessageHandler mock = new( async ( req, _ ) => {
+ capturedBody = await req.Content!.ReadAsStringAsync( CancellationToken.None );
+ return new HttpResponseMessage( HttpStatusCode.OK ) {
+ Content = new StringContent( "ok" ),
+ };
+ } );
+ HttpRequestHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new HttpRequestParameters {
+ Url = "https://example.com/api",
+ Method = "POST",
+ Body = "{\"key\":\"value\"}",
+ ContentType = "application/json",
+ } );
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "{\"key\":\"value\"}", capturedBody );
+ }
+
+ /// Verifies input variable is used as body when Body parameter is null.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task HttpRequest_PostWithInputVariable_UsesVariableAsBody( ) {
+ string? capturedBody = null;
+ MockHttpMessageHandler mock = new( async ( req, _ ) => {
+ capturedBody = await req.Content!.ReadAsStringAsync( CancellationToken.None );
+ return new HttpResponseMessage( HttpStatusCode.OK ) {
+ Content = new StringContent( "ok" ),
+ };
+ } );
+ HttpRequestHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new HttpRequestParameters {
+ Url = "https://example.com/api",
+ Method = "POST",
+ } );
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: "from-variable",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "from-variable", capturedBody );
+ }
+
+ /// Verifies that Body parameter takes precedence over input variable.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task HttpRequest_BodyParamPrecedence_OverInputVariable( ) {
+ string? capturedBody = null;
+ MockHttpMessageHandler mock = new( async ( req, _ ) => {
+ capturedBody = await req.Content!.ReadAsStringAsync( CancellationToken.None );
+ return new HttpResponseMessage( HttpStatusCode.OK ) {
+ Content = new StringContent( "ok" ),
+ };
+ } );
+ HttpRequestHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new HttpRequestParameters {
+ Url = "https://example.com/api",
+ Method = "POST",
+ Body = "param-body",
+ } );
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: "variable-body",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "param-body", capturedBody );
+ }
+
+ /// Verifies that unexpected status codes cause failure.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task HttpRequest_UnexpectedStatusCode_Fails( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.WithStatus( HttpStatusCode.NotFound, "not found" );
+ HttpRequestHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new HttpRequestParameters {
+ Url = "https://example.com/api",
+ ExpectedStatusCodes = [200],
+ } );
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ }
+
+ /// Verifies that custom expected status codes are accepted.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task HttpRequest_CustomExpectedStatusCode_Accepted( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.WithStatus( HttpStatusCode.Created );
+ HttpRequestHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new HttpRequestParameters {
+ Url = "https://example.com/api",
+ ExpectedStatusCodes = [201],
+ } );
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ /// Verifies response body is written to OutputFilePath.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task HttpRequest_OutputFilePath_WritesToFile( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( "file-content" );
+ HttpRequestHandler handler = CreateHandler( mock );
+
+ string outPath = Path.Combine( _tempDir, "response.txt" );
+ JsonElement parameters = Serialize( new HttpRequestParameters {
+ Url = "https://example.com/api",
+ OutputFilePath = outPath,
+ } );
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsTrue( File.Exists( outPath ) );
+ string content = await File.ReadAllTextAsync( outPath, TestContext.CancellationToken );
+ Assert.AreEqual( "file-content", content );
+ }
+
+ /// Verifies that a denied URL causes failure.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task HttpRequest_DeniedUrl_Fails( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( );
+ HttpRequestHandler handler = CreateHandler( mock, allowUrls: false );
+
+ JsonElement parameters = Serialize( new HttpRequestParameters { Url = "https://example.com/api" } );
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ /// Verifies that custom headers are sent with the request.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task HttpRequest_CustomHeaders_Sent( ) {
+ string? authHeader = null;
+ MockHttpMessageHandler mock = new( ( req, _ ) => {
+ authHeader = req.Headers.Authorization?.ToString( );
+ return Task.FromResult( new HttpResponseMessage( HttpStatusCode.OK ) {
+ Content = new StringContent( "ok" ),
+ } );
+ } );
+ HttpRequestHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new HttpRequestParameters {
+ Url = "https://example.com/api",
+ Headers = new Dictionary { ["Authorization"] = "Bearer test-token" },
+ } );
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "Bearer test-token", authHeader );
+ }
+
+ /// Verifies the Action property returns the correct name.
+ [TestMethod]
+ public void HttpRequest_ActionProperty_IsCorrect( ) {
+ HttpRequestHandler handler = CreateHandler( MockHttpMessageHandler.Ok( ) );
+ Assert.AreEqual( "HttpRequest", handler.Action );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/ListDirectoryHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/ListDirectoryHandlerTests.cs
new file mode 100644
index 0000000..77c2f89
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/ListDirectoryHandlerTests.cs
@@ -0,0 +1,256 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates directory enumeration with pattern matching, type filtering, sorting, and recursion.
+///
+[TestClass]
+public class ListDirectoryHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private ListDirectoryHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new ListDirectoryHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Collects all messages from the output channel after completing the writer.
+ ///
+ private async Task> CollectOutputAsync( ) {
+ _channel.Writer.Complete( );
+ List messages = [ ];
+ await foreach (OperatorOutput msg in _channel.Reader.ReadAllAsync( TestContext.CancellationToken )) {
+ messages.Add( msg );
+ }
+ return messages;
+ }
+
+ ///
+ /// Verifies that listing files only returns files, not directories.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ListDirectory_FilesOnly_ReturnsFiles( ) {
+ await File.WriteAllTextAsync( Path.Combine( _tempDir, "a.txt" ), "content", TestContext.CancellationToken );
+ await File.WriteAllTextAsync( Path.Combine( _tempDir, "b.txt" ), "content", TestContext.CancellationToken );
+ _ = Directory.CreateDirectory( Path.Combine( _tempDir, "sub" ) );
+
+ JsonElement parameters = Serialize( new ListDirectoryParameters {
+ Path = _tempDir,
+ Type = PathType.File
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ List messages = await CollectOutputAsync( );
+ // Second message is the JSON array
+ string[] files = JsonSerializer.Deserialize( messages[1].Message )!;
+ Assert.HasCount( 2, files );
+ }
+
+ ///
+ /// Verifies that listing directories only returns directories, not files.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ListDirectory_DirectoriesOnly_ReturnsDirectories( ) {
+ await File.WriteAllTextAsync( Path.Combine( _tempDir, "a.txt" ), "content", TestContext.CancellationToken );
+ _ = Directory.CreateDirectory( Path.Combine( _tempDir, "sub1" ) );
+ _ = Directory.CreateDirectory( Path.Combine( _tempDir, "sub2" ) );
+
+ JsonElement parameters = Serialize( new ListDirectoryParameters {
+ Path = _tempDir,
+ Type = PathType.Directory
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ List messages = await CollectOutputAsync( );
+ string[] dirs = JsonSerializer.Deserialize( messages[1].Message )!;
+ Assert.HasCount( 2, dirs );
+ }
+
+ ///
+ /// Verifies that a glob pattern filters entries correctly.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ListDirectory_PatternFilter_ReturnsMatching( ) {
+ await File.WriteAllTextAsync( Path.Combine( _tempDir, "data.csv" ), "a", TestContext.CancellationToken );
+ await File.WriteAllTextAsync( Path.Combine( _tempDir, "notes.txt" ), "b", TestContext.CancellationToken );
+ await File.WriteAllTextAsync( Path.Combine( _tempDir, "report.csv" ), "c", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new ListDirectoryParameters {
+ Path = _tempDir,
+ Pattern = "*.csv"
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ List messages = await CollectOutputAsync( );
+ string[] files = JsonSerializer.Deserialize( messages[1].Message )!;
+ Assert.HasCount( 2, files );
+ }
+
+ ///
+ /// Verifies that recursive enumeration includes entries from subdirectories.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ListDirectory_Recursive_IncludesSubdirectories( ) {
+ string subDir = Path.Combine( _tempDir, "sub" );
+ _ = Directory.CreateDirectory( subDir );
+ await File.WriteAllTextAsync( Path.Combine( _tempDir, "top.txt" ), "a", TestContext.CancellationToken );
+ await File.WriteAllTextAsync( Path.Combine( subDir, "nested.txt" ), "b", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new ListDirectoryParameters {
+ Path = _tempDir,
+ Recursive = true
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ List messages = await CollectOutputAsync( );
+ string[] files = JsonSerializer.Deserialize( messages[1].Message )!;
+ Assert.HasCount( 2, files );
+ }
+
+ ///
+ /// Verifies that listing an empty directory succeeds with an empty JSON array.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ListDirectory_EmptyDirectory_ReturnsEmptyArray( ) {
+ JsonElement parameters = Serialize( new ListDirectoryParameters { Path = _tempDir } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ List messages = await CollectOutputAsync( );
+ string[] files = JsonSerializer.Deserialize( messages[1].Message )!;
+ Assert.IsEmpty( files );
+ }
+
+ ///
+ /// Verifies that listing a non-existent directory returns failure.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ListDirectory_NonExistentDirectory_ReturnsFailure( ) {
+ string missing = Path.Combine( _tempDir, "does-not-exist" );
+
+ JsonElement parameters = Serialize( new ListDirectoryParameters { Path = missing } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ ///
+ /// Verifies that a denied path returns failure with UnauthorizedAccessException.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ListDirectory_DeniedPath_ReturnsFailure( ) {
+ ListDirectoryHandler denied = new(
+ TestFilePathResolver.DenyAll,
+ NullLogger.Instance
+ );
+
+ JsonElement parameters = Serialize( new ListDirectoryParameters { Path = "/some/path" } );
+ ActionOperatorResult result = await denied.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/MoveFileHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/MoveFileHandlerTests.cs
new file mode 100644
index 0000000..aa892dd
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/MoveFileHandlerTests.cs
@@ -0,0 +1,195 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates moving a single file, moving an entire directory, handling of
+/// no-match wildcards, and the same-source-and-destination guard.
+///
+[TestClass]
+public class MoveFileHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private MoveFileHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new MoveFileHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that moving a single file to a new destination succeeds,
+ /// removes the source, and creates the destination with the original content.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task MoveSingleFile_Succeeds( ) {
+ string src = Path.Combine(
+ _tempDir,
+ "source.txt"
+ );
+ string dest = Path.Combine(
+ _tempDir,
+ "dest.txt"
+ );
+ await File.WriteAllTextAsync(
+ src,
+ "hello",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new MoveFileParameters { Source = src, Destination = dest } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsFalse( File.Exists( src ) );
+ Assert.IsTrue( File.Exists( dest ) );
+ Assert.AreEqual(
+ "hello",
+ await File.ReadAllTextAsync(
+ dest,
+ TestContext.CancellationToken
+ )
+ );
+ }
+
+ ///
+ /// Verifies that moving an entire directory to a new location succeeds,
+ /// removing the source directory and placing all contents at the destination.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task MoveDirectory_Succeeds( ) {
+ string srcDir = Path.Combine(
+ _tempDir,
+ "srcDir"
+ );
+ _ = Directory.CreateDirectory( srcDir );
+ await File.WriteAllTextAsync(
+ Path.Combine( srcDir, "file.txt" ),
+ "data",
+ TestContext.CancellationToken
+ );
+
+ string destDir = Path.Combine(
+ _tempDir,
+ "destDir"
+ );
+
+ JsonElement parameters = Serialize( new MoveFileParameters { Source = srcDir, Destination = destDir } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsFalse( Directory.Exists( srcDir ) );
+ Assert.IsTrue( File.Exists( Path.Combine( destDir, "file.txt" ) ) );
+ }
+
+ ///
+ /// Verifies that a wildcard source that matches zero files returns a failure result.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task MoveNoMatch_ReturnsFailure( ) {
+ JsonElement parameters = Serialize( new MoveFileParameters {
+ Source = Path.Combine( _tempDir, "*.xyz" ),
+ Destination = Path.Combine( _tempDir, "out" )
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that specifying the same path as both source and destination
+ /// returns a failure result with a non-null exception.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task MoveSameSourceAndDest_ThrowsArgument( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "file.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "data",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new MoveFileParameters { Source = path, Destination = path } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/ReadContentHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/ReadContentHandlerTests.cs
new file mode 100644
index 0000000..58cdc99
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/ReadContentHandlerTests.cs
@@ -0,0 +1,188 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates reading file content, truncation via MaxBytes, encoding, and edge cases.
+///
+[TestClass]
+public class ReadContentHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private ReadContentHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new ReadContentHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that reading a UTF-8 file returns its full content.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ReadContent_Utf8File_ReturnsContent( ) {
+ string filePath = Path.Combine( _tempDir, "test.txt" );
+ await File.WriteAllTextAsync( filePath, "hello world", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new ReadContentParameters { Path = filePath } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ _channel.Writer.Complete( );
+ List messages = [ ];
+ await foreach (OperatorOutput msg in _channel.Reader.ReadAllAsync( TestContext.CancellationToken )) {
+ messages.Add( msg );
+ }
+
+ Assert.HasCount( 1, messages );
+ Assert.AreEqual( "hello world", messages[0].Message );
+ }
+
+ ///
+ /// Verifies that MaxBytes truncates the output content.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ReadContent_MaxBytes_TruncatesContent( ) {
+ string filePath = Path.Combine( _tempDir, "test.txt" );
+ await File.WriteAllTextAsync( filePath, "abcdefghijklmnop", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new ReadContentParameters { Path = filePath, MaxBytes = 5 } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+
+ _channel.Writer.Complete( );
+ List messages = [ ];
+ await foreach (OperatorOutput msg in _channel.Reader.ReadAllAsync( TestContext.CancellationToken )) {
+ messages.Add( msg );
+ }
+
+ Assert.HasCount( 1, messages );
+ Assert.AreEqual( "abcde", messages[0].Message );
+ }
+
+ ///
+ /// Verifies that reading a non-existent file returns failure.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ReadContent_FileNotFound_ReturnsFailure( ) {
+ string missingPath = Path.Combine( _tempDir, "missing.txt" );
+
+ JsonElement parameters = Serialize( new ReadContentParameters { Path = missingPath } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ ///
+ /// Verifies that reading an empty file succeeds with empty content.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ReadContent_EmptyFile_ReturnsEmptyContent( ) {
+ string filePath = Path.Combine( _tempDir, "empty.txt" );
+ await File.WriteAllTextAsync( filePath, string.Empty, TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new ReadContentParameters { Path = filePath } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that a denied path returns failure with UnauthorizedAccessException.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task ReadContent_DeniedPath_ReturnsFailure( ) {
+ ReadContentHandler denied = new(
+ TestFilePathResolver.DenyAll,
+ NullLogger.Instance
+ );
+
+ JsonElement parameters = Serialize( new ReadContentParameters { Path = "/some/path" } );
+ ActionOperatorResult result = await denied.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/RenameFileHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/RenameFileHandlerTests.cs
new file mode 100644
index 0000000..39d2ccd
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/RenameFileHandlerTests.cs
@@ -0,0 +1,235 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates renaming a file, renaming a directory, failure when the source
+/// does not exist, overwrite-guarded rename when the destination already exists,
+/// and overwrite-enabled rename that replaces the existing destination.
+///
+[TestClass]
+public class RenameFileHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private RenameFileHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new RenameFileHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that renaming a file to a new name succeeds, removes the old
+ /// file, and creates the file under the new name in the same directory.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task RenameFile_Succeeds( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "old.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "data",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new RenameFileParameters { Path = path, NewName = "new.txt" } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsFalse( File.Exists( path ) );
+ Assert.IsTrue( File.Exists( Path.Combine( _tempDir, "new.txt" ) ) );
+ }
+
+ ///
+ /// Verifies that renaming a directory succeeds, removes the old directory,
+ /// and creates the directory under the new name.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task RenameDirectory_Succeeds( ) {
+ string dir = Path.Combine(
+ _tempDir,
+ "oldDir"
+ );
+ _ = Directory.CreateDirectory( dir );
+
+ JsonElement parameters = Serialize( new RenameFileParameters { Path = dir, NewName = "newDir" } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsFalse( Directory.Exists( dir ) );
+ Assert.IsTrue( Directory.Exists( Path.Combine( _tempDir, "newDir" ) ) );
+ }
+
+ ///
+ /// Verifies that renaming a non-existent source returns a failure result with a non-null exception.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task RenameNonExistent_ReturnsFailure( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "missing.txt"
+ );
+
+ JsonElement parameters = Serialize( new RenameFileParameters { Path = path, NewName = "new.txt" } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ }
+
+ ///
+ /// Verifies that when the destination name already exists and
+ /// Overwrite is , the handler returns
+ /// a failure result.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task RenameFile_DestinationExists_OverwriteFalse_ReturnsFailure( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "old.txt"
+ );
+ string existing = Path.Combine(
+ _tempDir,
+ "new.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "data",
+ TestContext.CancellationToken
+ );
+ await File.WriteAllTextAsync(
+ existing,
+ "existing",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize(
+ new RenameFileParameters { Path = path, NewName = "new.txt", Overwrite = false }
+ );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that when the destination name already exists and
+ /// Overwrite is , the handler succeeds and
+ /// the destination contains the content from the original source file.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task RenameFile_DestinationExists_OverwriteTrue_Succeeds( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "old.txt"
+ );
+ string existing = Path.Combine(
+ _tempDir,
+ "new.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "newdata",
+ TestContext.CancellationToken
+ );
+ await File.WriteAllTextAsync(
+ existing,
+ "existing",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize(
+ new RenameFileParameters { Path = path, NewName = "new.txt", Overwrite = true }
+ );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual(
+ "newdata",
+ await File.ReadAllTextAsync(
+ Path.Combine( _tempDir, "new.txt" ),
+ TestContext.CancellationToken
+ )
+ );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/SendEmailHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/SendEmailHandlerTests.cs
new file mode 100644
index 0000000..bff2c94
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/SendEmailHandlerTests.cs
@@ -0,0 +1,179 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// These tests focus on configuration gating, parameter validation, and credential
+/// loading. Actual SMTP delivery is not tested here (requires a real SMTP server).
+///
+[TestClass]
+public class SendEmailHandlerTests {
+
+ /// Unbounded channel for capturing messages.
+ private Channel _channel = null!;
+
+ /// Gets or sets the MSTest test context.
+ public TestContext TestContext { get; set; } = null!;
+
+ /// Sets up the output channel.
+ [TestInitialize]
+ public void TestInit( ) {
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ private static SendEmailHandler CreateHandler(
+ bool enableNetwork = true,
+ TestSecretStore? secretStore = null
+ ) {
+ ActionOperatorConfiguration config = new( ) {
+ EnableNetworkActions = enableNetwork,
+ };
+ return new SendEmailHandler(
+ new TestOptionsMonitor( config ),
+ secretStore ?? new TestSecretStore( ),
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ }
+
+ /// Verifies the handler rejects when EnableNetworkActions is false.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task SendEmail_NetworkDisabled_Fails( ) {
+ SendEmailHandler handler = CreateHandler( enableNetwork: false );
+
+ JsonElement parameters = Serialize( new SendEmailParameters {
+ SmtpHost = "smtp.example.com",
+ From = "sender@example.com",
+ To = ["recipient@example.com"],
+ Subject = "Test",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ /// Verifies the handler rejects when there are zero recipients.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task SendEmail_NoRecipients_Fails( ) {
+ SendEmailHandler handler = CreateHandler( );
+
+ JsonElement parameters = Serialize( new SendEmailParameters {
+ SmtpHost = "smtp.example.com",
+ From = "sender@example.com",
+ To = [],
+ Subject = "Test",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ /// Verifies the handler fails when a credential is specified but missing from the store.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task SendEmail_MissingCredential_Fails( ) {
+ // When EnableNetworkActions is true but we try to connect to a non-existent SMTP server,
+ // the handler will fail at the SMTP connect step. However, we can test the credential
+ // lookup path by verifying the error message when a credential name is given but not found.
+ // Since we can't mock MailKit's SmtpClient easily, we accept the connection failure.
+ SendEmailHandler handler = CreateHandler( );
+
+ JsonElement parameters = Serialize( new SendEmailParameters {
+ SmtpHost = "127.0.0.1",
+ Port = 0, // invalid port to fail fast
+ From = "sender@example.com",
+ To = ["recipient@example.com"],
+ Subject = "Test",
+ CredentialName = "missing-cred",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ }
+
+ /// Verifies the handler fails when an attachment file does not exist.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task SendEmail_MissingAttachment_Fails( ) {
+ SendEmailHandler handler = CreateHandler( );
+
+ JsonElement parameters = Serialize( new SendEmailParameters {
+ SmtpHost = "127.0.0.1",
+ Port = 0,
+ From = "sender@example.com",
+ To = ["recipient@example.com"],
+ Subject = "Test",
+ Attachments = ["/nonexistent/file.txt"],
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ }
+
+ /// Verifies the Action property returns the correct name.
+ [TestMethod]
+ public void SendEmail_ActionProperty_IsCorrect( ) {
+ SendEmailHandler handler = CreateHandler( );
+ Assert.AreEqual( "SendEmail", handler.Action );
+ }
+
+ /// Verifies body falls back to input variable when Body parameter is null.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task SendEmail_BodyFromVariable_UsedWhenBodyNull( ) {
+ // This test validates up to the SMTP connect step which will fail.
+ // The key assertion is that the handler does not reject due to missing body.
+ SendEmailHandler handler = CreateHandler( );
+
+ JsonElement parameters = Serialize( new SendEmailParameters {
+ SmtpHost = "127.0.0.1",
+ Port = 0,
+ From = "sender@example.com",
+ To = ["recipient@example.com"],
+ Subject = "Test",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: "body from variable",
+ cancellationToken: TestContext.CancellationToken );
+
+ // Will fail at SMTP connect — that's expected.
+ // The test passes as long as no ArgumentException is thrown for missing body.
+ Assert.IsFalse( result.Success );
+ Assert.IsNotInstanceOfType( result.Exception );
+ }
+
+ /// Local stub.
+ private sealed class TestOptionsMonitor( T currentValue ) : IOptionsMonitor {
+ public T CurrentValue { get; } = currentValue;
+ public T Get( string? name ) => CurrentValue;
+ public IDisposable? OnChange( Action listener ) => null;
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/SendWebhookHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/SendWebhookHandlerTests.cs
new file mode 100644
index 0000000..ce20d0b
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/SendWebhookHandlerTests.cs
@@ -0,0 +1,226 @@
+using System.Net;
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Uses to avoid real HTTP traffic.
+///
+[TestClass]
+public class SendWebhookHandlerTests {
+
+ /// Unbounded channel for capturing messages.
+ private Channel _channel = null!;
+
+ /// Gets or sets the MSTest test context.
+ public TestContext TestContext { get; set; } = null!;
+
+ /// Sets up the output channel.
+ [TestInitialize]
+ public void TestInit( ) {
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ private static SendWebhookHandler CreateHandler(
+ MockHttpMessageHandler mockHttp,
+ bool allowUrls = true
+ ) =>
+ new(
+ allowUrls ? TestUrlValidator.AllowAll : TestUrlValidator.DenyAll,
+ new TestHttpClientFactory( mockHttp ),
+ NullLogger.Instance
+ );
+
+ /// Verifies a basic webhook POST is sent with payload from parameter.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task SendWebhook_PayloadFromParameter_SendsPost( ) {
+ string? capturedBody = null;
+ string? capturedContentType = null;
+ MockHttpMessageHandler mock = new( async ( req, _ ) => {
+ capturedBody = await req.Content!.ReadAsStringAsync( CancellationToken.None );
+ capturedContentType = req.Content.Headers.ContentType?.MediaType;
+ return new HttpResponseMessage( HttpStatusCode.OK ) {
+ Content = new StringContent( "{\"ok\":true}" ),
+ };
+ } );
+ SendWebhookHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new SendWebhookParameters {
+ Url = "https://example.com/webhook",
+ Payload = "{\"event\":\"test\"}",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "{\"event\":\"test\"}", capturedBody );
+ Assert.AreEqual( "application/json", capturedContentType );
+ }
+
+ /// Verifies input variable value is used as payload when Payload is null.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task SendWebhook_PayloadFromVariable_SendsPost( ) {
+ string? capturedBody = null;
+ MockHttpMessageHandler mock = new( async ( req, _ ) => {
+ capturedBody = await req.Content!.ReadAsStringAsync( CancellationToken.None );
+ return new HttpResponseMessage( HttpStatusCode.OK ) {
+ Content = new StringContent( "ok" ),
+ };
+ } );
+ SendWebhookHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new SendWebhookParameters {
+ Url = "https://example.com/webhook",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: "{\"from\":\"variable\"}",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "{\"from\":\"variable\"}", capturedBody );
+ }
+
+ /// Verifies Payload parameter takes precedence over input variable.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task SendWebhook_PayloadPrecedence_OverVariable( ) {
+ string? capturedBody = null;
+ MockHttpMessageHandler mock = new( async ( req, _ ) => {
+ capturedBody = await req.Content!.ReadAsStringAsync( CancellationToken.None );
+ return new HttpResponseMessage( HttpStatusCode.OK ) {
+ Content = new StringContent( "ok" ),
+ };
+ } );
+ SendWebhookHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new SendWebhookParameters {
+ Url = "https://example.com/webhook",
+ Payload = "{\"from\":\"param\"}",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: "{\"from\":\"variable\"}",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "{\"from\":\"param\"}", capturedBody );
+ }
+
+ /// Verifies default empty body when no payload or variable.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task SendWebhook_NoPayloadNoVariable_SendsEmptyObject( ) {
+ string? capturedBody = null;
+ MockHttpMessageHandler mock = new( async ( req, _ ) => {
+ capturedBody = await req.Content!.ReadAsStringAsync( CancellationToken.None );
+ return new HttpResponseMessage( HttpStatusCode.OK ) {
+ Content = new StringContent( "ok" ),
+ };
+ } );
+ SendWebhookHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new SendWebhookParameters {
+ Url = "https://example.com/webhook",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "{}", capturedBody );
+ }
+
+ /// Verifies output variable contains statusCode and responseBody.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task SendWebhook_OutputVariable_ContainsMetadata( ) {
+ MockHttpMessageHandler mock = new( new HttpResponseMessage( HttpStatusCode.Accepted ) {
+ Content = new StringContent( "{\"id\":42}" ),
+ } );
+ SendWebhookHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new SendWebhookParameters {
+ Url = "https://example.com/webhook",
+ Payload = "{}",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsNotNull( result.OutputVariableValue );
+
+ using JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue );
+ Assert.AreEqual( 202, doc.RootElement.GetProperty( "statusCode" ).GetInt32( ) );
+ Assert.AreEqual( "{\"id\":42}", doc.RootElement.GetProperty( "responseBody" ).GetString( ) );
+ Assert.IsGreaterThanOrEqualTo( 0L, doc.RootElement.GetProperty( "elapsedMs" ).GetInt64( ) );
+ }
+
+ /// Verifies that custom headers are sent with the webhook request.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task SendWebhook_CustomHeaders_Sent( ) {
+ string? customHeader = null;
+ MockHttpMessageHandler mock = new( ( req, _ ) => {
+ customHeader = req.Headers.TryGetValues( "X-Custom", out IEnumerable? vals )
+ ? string.Join( ",", vals )
+ : null;
+ return Task.FromResult( new HttpResponseMessage( HttpStatusCode.OK ) {
+ Content = new StringContent( "ok" ),
+ } );
+ } );
+ SendWebhookHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new SendWebhookParameters {
+ Url = "https://example.com/webhook",
+ Payload = "{}",
+ Headers = new Dictionary { ["X-Custom"] = "test-value" },
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "test-value", customHeader );
+ }
+
+ /// Verifies denied URL causes failure.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task SendWebhook_DeniedUrl_Fails( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( );
+ SendWebhookHandler handler = CreateHandler( mock, allowUrls: false );
+
+ JsonElement parameters = Serialize( new SendWebhookParameters {
+ Url = "https://example.com/webhook",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ /// Verifies the Action property returns the correct name.
+ [TestMethod]
+ public void SendWebhook_ActionProperty_IsCorrect( ) {
+ SendWebhookHandler handler = CreateHandler( MockHttpMessageHandler.Ok( ) );
+ Assert.AreEqual( "SendWebhook", handler.Action );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/StartProcessHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/StartProcessHandlerTests.cs
new file mode 100644
index 0000000..514856d
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/StartProcessHandlerTests.cs
@@ -0,0 +1,242 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates launching processes with echo commands (cross-platform),
+/// handling of non-zero exit codes, fire-and-forget mode, bare-executable
+/// path-validation bypass, timeout-based process termination, and
+/// standard-output capture.
+///
+[TestClass]
+public class StartProcessHandlerTests {
+
+ ///
+ /// The handler instance under test.
+ ///
+ private StartProcessHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates the handler backed by and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _handler = new StartProcessHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that starting a simple echo command (platform-appropriate)
+ /// with WaitForExit returns a successful result.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task StartProcess_EchoCommand_Succeeds( ) {
+ string fileName;
+ string arguments;
+ if (OperatingSystem.IsWindows( )) {
+ fileName = "cmd.exe";
+ arguments = "/c echo hello";
+ } else {
+ fileName = "/bin/sh";
+ arguments = "-c \"echo hello\"";
+ }
+
+ JsonElement parameters = Serialize( new StartProcessParameters {
+ FileName = fileName,
+ Arguments = arguments,
+ WaitForExit = true
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that a process exiting with a non-zero exit code returns
+ /// a failure result.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task StartProcess_NonZeroExit_ReturnsFailure( ) {
+ string fileName;
+ string arguments;
+ if (OperatingSystem.IsWindows( )) {
+ fileName = "cmd.exe";
+ arguments = "/c exit 1";
+ } else {
+ fileName = "/bin/sh";
+ arguments = "-c \"exit 1\"";
+ }
+
+ JsonElement parameters = Serialize( new StartProcessParameters {
+ FileName = fileName,
+ Arguments = arguments,
+ WaitForExit = true
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that when WaitForExit is the handler
+ /// returns immediately with a success result (fire-and-forget mode).
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task StartProcess_FireAndForget_ReturnsImmediately( ) {
+ string fileName;
+ string arguments;
+ if (OperatingSystem.IsWindows( )) {
+ fileName = "cmd.exe";
+ arguments = "/c echo fire-and-forget";
+ } else {
+ fileName = "/bin/sh";
+ arguments = "-c \"echo fire-and-forget\"";
+ }
+
+ JsonElement parameters = Serialize( new StartProcessParameters {
+ FileName = fileName,
+ Arguments = arguments,
+ WaitForExit = false
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that launching a bare executable name (without a directory
+ /// component) skips path-allowlist validation and still succeeds.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task StartProcess_BareExecutable_SkipsPathValidation( ) {
+ // "dotnet" is a bare executable name — should not trigger path validation
+ JsonElement parameters = Serialize( new StartProcessParameters {
+ FileName = "dotnet",
+ Arguments = "--version",
+ WaitForExit = true
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that when the process exceeds the TimeoutMs value
+ /// it is killed and the handler returns a failure result.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task StartProcess_Timeout_KillsProcess( ) {
+ string fileName;
+ string arguments;
+ if (OperatingSystem.IsWindows( )) {
+ fileName = "cmd.exe";
+ arguments = "/c ping -n 300 127.0.0.1";
+ } else {
+ fileName = "/bin/sh";
+ arguments = "-c \"sleep 300\"";
+ }
+
+ JsonElement parameters = Serialize( new StartProcessParameters {
+ FileName = fileName,
+ Arguments = arguments,
+ WaitForExit = true,
+ TimeoutMs = 500
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that the handler captures the process's standard output and
+ /// writes it through the channel, where it
+ /// can be found by searching for the expected text.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task StartProcess_CapturesOutput( ) {
+ string fileName;
+ string arguments;
+ if (OperatingSystem.IsWindows( )) {
+ fileName = "cmd.exe";
+ arguments = "/c echo test-output";
+ } else {
+ fileName = "/bin/sh";
+ arguments = "-c \"echo test-output\"";
+ }
+
+ JsonElement parameters = Serialize( new StartProcessParameters {
+ FileName = fileName,
+ Arguments = arguments,
+ WaitForExit = true
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+ Assert.IsTrue( result.Success );
+ _channel.Writer.Complete( );
+ List outputs = [];
+ await foreach (OperatorOutput output in _channel.Reader.ReadAllAsync( TestContext.CancellationToken )) {
+ outputs.Add( output );
+ }
+
+ Assert.Contains(
+ o => o.Message.Contains( "test-output" ),
+ outputs,
+ "Expected output containing 'test-output'."
+ );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/StopProcessHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/StopProcessHandlerTests.cs
new file mode 100644
index 0000000..6a39ff3
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/StopProcessHandlerTests.cs
@@ -0,0 +1,134 @@
+using System.Diagnostics;
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates failure when the target process name does not exist,
+/// successful forceful kill of a running process by PID,
+/// and failure when an invalid PID is supplied.
+///
+[TestClass]
+public class StopProcessHandlerTests {
+
+ ///
+ /// The handler instance under test.
+ ///
+ private StopProcessHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates the handler and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _handler = new StopProcessHandler( NullLogger.Instance );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that stopping a process by a name that does not exist returns a failure result.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task StopProcess_NonexistentName_ReturnsFailure( ) {
+ JsonElement parameters = Serialize( new StopProcessParameters {
+ ProcessName = $"werkr-test-nonexistent-{Guid.NewGuid()}"
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that stopping a running process by its PID with
+ /// Force enabled succeeds, and the process exits within a
+ /// reasonable timeframe. Launches a long-running subprocess that
+ /// is killed by the handler.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task StopProcess_ByPid_StopsProcess( ) {
+ // Start a long-running process we can kill
+ ProcessStartInfo startInfo = OperatingSystem.IsWindows( )
+ ? new ProcessStartInfo( "cmd.exe", "/c ping -n 300 127.0.0.1" ) {
+ CreateNoWindow = true,
+ UseShellExecute = false
+ }
+ : new ProcessStartInfo( "/bin/sh", "-c \"sleep 300\"" ) {
+ CreateNoWindow = true,
+ UseShellExecute = false
+ };
+ using Process process = Process.Start( startInfo )!;
+ int pid = process.Id;
+
+ try {
+ JsonElement parameters = Serialize( new StopProcessParameters {
+ ProcessName = process.ProcessName,
+ ProcessId = pid,
+ Force = true
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ // Give a moment for the process to actually exit
+ _ = process.WaitForExit( 5_000 );
+ Assert.IsTrue( process.HasExited );
+ } finally {
+ if (!process.HasExited) {
+ process.Kill( entireProcessTree: true );
+ }
+ }
+ }
+
+ ///
+ /// Verifies that supplying an invalid (non-existent) PID returns a failure result with a non-null exception.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task StopProcess_InvalidPid_ReturnsFailure( ) {
+ JsonElement parameters = Serialize( new StopProcessParameters {
+ ProcessName = "unused",
+ ProcessId = int.MaxValue,
+ Force = true
+ } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/TestConnectionHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/TestConnectionHandlerTests.cs
new file mode 100644
index 0000000..69d5d60
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/TestConnectionHandlerTests.cs
@@ -0,0 +1,206 @@
+using System.Net;
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Tests TCP and HTTP connectivity checking with mock infrastructure.
+///
+[TestClass]
+public class TestConnectionHandlerTests {
+
+ /// Unbounded channel for capturing messages.
+ private Channel _channel = null!;
+
+ /// Gets or sets the MSTest test context.
+ public TestContext TestContext { get; set; } = null!;
+
+ /// Sets up the output channel.
+ [TestInitialize]
+ public void TestInit( ) {
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ private static TestConnectionHandler CreateHandler(
+ MockHttpMessageHandler mockHttp,
+ bool allowUrls = true
+ ) =>
+ new(
+ allowUrls ? TestUrlValidator.AllowAll : TestUrlValidator.DenyAll,
+ new TestHttpClientFactory( mockHttp ),
+ NullLogger.Instance
+ );
+
+ /// Verifies HTTP mode returns reachable when server responds with 200.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task TestConnection_Http_Reachable( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( );
+ TestConnectionHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new TestConnectionParameters {
+ Host = "example.com",
+ Port = 80,
+ Protocol = ConnectionProtocol.Http,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsNotNull( result.OutputVariableValue );
+
+ using JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue );
+ Assert.IsTrue( doc.RootElement.GetProperty( "reachable" ).GetBoolean( ) );
+ Assert.AreEqual( 200, doc.RootElement.GetProperty( "statusCode" ).GetInt32( ) );
+ }
+
+ /// Verifies HTTPS mode returns reachable with status code.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task TestConnection_Https_Reachable( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( );
+ TestConnectionHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new TestConnectionParameters {
+ Host = "example.com",
+ Port = 443,
+ Protocol = ConnectionProtocol.Https,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ using JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.IsTrue( doc.RootElement.GetProperty( "reachable" ).GetBoolean( ) );
+ }
+
+ /// Verifies HTTP mode with expected status code mismatch sets reachable=false.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task TestConnection_Http_ExpectedStatusMismatch_NotReachable( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.WithStatus( HttpStatusCode.NotFound );
+ TestConnectionHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new TestConnectionParameters {
+ Host = "example.com",
+ Port = 80,
+ Protocol = ConnectionProtocol.Http,
+ ExpectedStatusCode = 200,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success ); // action itself succeeds
+ using JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.IsFalse( doc.RootElement.GetProperty( "reachable" ).GetBoolean( ) );
+ Assert.AreEqual( 404, doc.RootElement.GetProperty( "statusCode" ).GetInt32( ) );
+ }
+
+ /// Verifies HTTP mode with matching expected status code sets reachable=true.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task TestConnection_Http_ExpectedStatusMatch_Reachable( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.WithStatus( HttpStatusCode.NotFound );
+ TestConnectionHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new TestConnectionParameters {
+ Host = "example.com",
+ Port = 80,
+ Protocol = ConnectionProtocol.Http,
+ ExpectedStatusCode = 404,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ using JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.IsTrue( doc.RootElement.GetProperty( "reachable" ).GetBoolean( ) );
+ }
+
+ /// Verifies that HTTP mode captures connection errors.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task TestConnection_Http_ConnectionError_NotReachable( ) {
+ MockHttpMessageHandler mock = new( ( _, _ ) =>
+ throw new HttpRequestException( "Connection refused" ) );
+ TestConnectionHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new TestConnectionParameters {
+ Host = "example.com",
+ Port = 80,
+ Protocol = ConnectionProtocol.Http,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success ); // action itself succeeds
+ using JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.IsFalse( doc.RootElement.GetProperty( "reachable" ).GetBoolean( ) );
+ Assert.IsNotNull( doc.RootElement.GetProperty( "error" ).GetString( ) );
+ }
+
+ /// Verifies denied URL causes action failure.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task TestConnection_DeniedUrl_Fails( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( );
+ TestConnectionHandler handler = CreateHandler( mock, allowUrls: false );
+
+ JsonElement parameters = Serialize( new TestConnectionParameters {
+ Host = "example.com",
+ Port = 80,
+ Protocol = ConnectionProtocol.Http,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ /// Verifies the output contains timing information.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task TestConnection_OutputContainsElapsedMs( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( );
+ TestConnectionHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new TestConnectionParameters {
+ Host = "example.com",
+ Port = 443,
+ Protocol = ConnectionProtocol.Https,
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ using JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.IsTrue( doc.RootElement.TryGetProperty( "elapsedMs", out JsonElement elapsed ) );
+ Assert.IsGreaterThanOrEqualTo( 0L, elapsed.GetInt64( ) );
+ }
+
+ /// Verifies the Action property returns the correct name.
+ [TestMethod]
+ public void TestConnection_ActionProperty_IsCorrect( ) {
+ TestConnectionHandler handler = CreateHandler( MockHttpMessageHandler.Ok( ) );
+ Assert.AreEqual( "TestConnection", handler.Action );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/TestExistsHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/TestExistsHandlerTests.cs
new file mode 100644
index 0000000..4f9676b
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/TestExistsHandlerTests.cs
@@ -0,0 +1,237 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates existence checks for files, directories, and the "any" type,
+/// as well as non-existence scenarios and type mismatches (e.g., asking for
+/// a file when a directory exists at the path).
+///
+[TestClass]
+public class TestExistsHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// The handler instance under test.
+ ///
+ private TestExistsHandler _handler = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory, the handler, and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _handler = new TestExistsHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that checking an existing file with returns success.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task FileExists_ReturnsSuccess( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "file.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "data",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new TestExistsParameters { Path = path, Type = PathType.File } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that checking a missing file with returns failure.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task FileNotExists_ReturnsFailure( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "missing.txt"
+ );
+
+ JsonElement parameters = Serialize( new TestExistsParameters { Path = path, Type = PathType.File } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that checking an existing directory with returns success.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DirectoryExists_ReturnsSuccess( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "subdir"
+ );
+ _ = Directory.CreateDirectory( path );
+
+ JsonElement parameters = Serialize( new TestExistsParameters { Path = path, Type = PathType.Directory } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that checking a missing directory with returns failure.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DirectoryNotExists_ReturnsFailure( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "missing-dir"
+ );
+
+ JsonElement parameters = Serialize( new TestExistsParameters { Path = path, Type = PathType.Directory } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that checking an existing file with returns success.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task AnyType_FileExists_ReturnsSuccess( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "file.txt"
+ );
+ await File.WriteAllTextAsync(
+ path,
+ "data",
+ TestContext.CancellationToken
+ );
+
+ JsonElement parameters = Serialize( new TestExistsParameters { Path = path, Type = PathType.Any } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that checking an existing directory with returns success.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task AnyType_DirectoryExists_ReturnsSuccess( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "dir"
+ );
+ _ = Directory.CreateDirectory( path );
+
+ JsonElement parameters = Serialize( new TestExistsParameters { Path = path, Type = PathType.Any } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that checking a directory path with
+ /// returns failure, because the path exists as a directory rather than
+ /// a file.
+ ///
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task FileType_OnDirectory_ReturnsFailure( ) {
+ string path = Path.Combine(
+ _tempDir,
+ "dir"
+ );
+ _ = Directory.CreateDirectory( path );
+
+ JsonElement parameters = Serialize( new TestExistsParameters { Path = path, Type = PathType.File } );
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/TransformJsonHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/TransformJsonHandlerTests.cs
new file mode 100644
index 0000000..6299e71
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/TransformJsonHandlerTests.cs
@@ -0,0 +1,727 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates dual-mode input (file vs. variable), JSON Pointer path navigation,
+/// and all four operation types: Extract, Set, Delete, Merge.
+///
+[TestClass]
+public class TransformJsonHandlerTests {
+
+ /// Handler under test.
+ private TransformJsonHandler _handler = null!;
+ /// Captures messages.
+ private Channel _channel = null!;
+ /// Temp directory for file I/O tests.
+ private string _tempDir = null!;
+
+ /// MSTest context.
+ public TestContext TestContext { get; set; } = null!;
+
+ /// Creates handler, channel, and temp directory for each test.
+ [TestInitialize]
+ public void TestInit( ) {
+ _handler = new TransformJsonHandler(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance
+ );
+ _channel = Channel.CreateUnbounded( );
+ _tempDir = Path.Combine( Path.GetTempPath( ), $"werkr-test-transformjson-{Guid.NewGuid( ):N}" );
+ _ = Directory.CreateDirectory( _tempDir );
+ }
+
+ /// Removes the temp directory after each test.
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete( _tempDir, recursive: true );
+ }
+ }
+
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ // ══════════════════════════════════════════════════════════════════════════════
+ // ── Input Resolution ─────────────────────────────────────────────────────────
+ // ══════════════════════════════════════════════════════════════════════════════
+
+ /// Variable input is used when no InputPath is set.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task TransformJson_VariableInput_Succeeds( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/name" }],
+ } );
+ string input = """{"name":"Alice","age":30}""";
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: input,
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "\"Alice\"", result.OutputVariableValue );
+ }
+
+ /// File input takes precedence over variable input.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task TransformJson_FileInputTakesPrecedence( ) {
+ string filePath = Path.Combine( _tempDir, "input.json" );
+ await File.WriteAllTextAsync( filePath, """{"source":"file"}""", CancellationToken.None );
+
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ InputPath = filePath,
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/source" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"source":"variable"}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "\"file\"", result.OutputVariableValue );
+ }
+
+ /// Fails with descriptive error when neither input source is available.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task TransformJson_NoInput_Fails( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/x" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer,
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ Assert.Contains( "neither", result.Exception.Message );
+ }
+
+ /// Fails with descriptive error when input is not valid JSON.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task TransformJson_InvalidJsonInput_Fails( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/x" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: "not-json{{{",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ Assert.Contains( "not valid JSON", result.Exception.Message );
+ }
+
+ /// Fails when InputPath file does not exist.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task TransformJson_InputFileNotFound_Fails( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ InputPath = Path.Combine( _tempDir, "nope.json" ),
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/x" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer,
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ Assert.Contains( "not found", result.Exception.Message );
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════════
+ // ── Extract ──────────────────────────────────────────────────────────────────
+ // ══════════════════════════════════════════════════════════════════════════════
+
+ /// Extract a top-level string property.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Extract_TopLevelProperty( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/name" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"name":"Bob","age":25}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "\"Bob\"", result.OutputVariableValue );
+ }
+
+ /// Extract a nested property using JSON Pointer.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Extract_NestedProperty( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/address/city" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer,
+ inputVariableValue: """{"address":{"city":"Seattle","state":"WA"}}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "\"Seattle\"", result.OutputVariableValue );
+ }
+
+ /// Extract an array element by index.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Extract_ArrayElement( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/items/1" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"items":["a","b","c"]}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "\"b\"", result.OutputVariableValue );
+ }
+
+ /// Extract a non-existent path returns null.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Extract_NonExistentPath_ReturnsNull( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/missing" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"name":"Alice"}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "null", result.OutputVariableValue );
+ }
+
+ /// Extract root (empty pointer) returns the full document.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Extract_RootPointer_ReturnsFullDocument( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "" }],
+ } );
+ string input = """{"x":1}""";
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: input,
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsNotNull( result.OutputVariableValue );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue );
+ Assert.AreEqual( 1, doc.RootElement.GetProperty( "x" ).GetInt32( ) );
+ }
+
+ /// Extract using $. convenience syntax.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Extract_DollarDotSyntax( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "$.name" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"name":"Charlie"}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "\"Charlie\"", result.OutputVariableValue );
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════════
+ // ── Set ──────────────────────────────────────────────────────────────────────
+ // ══════════════════════════════════════════════════════════════════════════════
+
+ /// Set an existing property to a new value.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Set_ExistingProperty( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Set, Path = "/name", Value = "\"Eve\"" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"name":"Alice"}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.AreEqual( "Eve", doc.RootElement.GetProperty( "name" ).GetString( ) );
+ }
+
+ /// Set a new property on an existing object.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Set_NewProperty( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Set, Path = "/email", Value = "\"a@b.com\"" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"name":"Alice"}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.AreEqual( "a@b.com", doc.RootElement.GetProperty( "email" ).GetString( ) );
+ Assert.AreEqual( "Alice", doc.RootElement.GetProperty( "name" ).GetString( ) );
+ }
+
+ /// Set creates intermediate objects for nested paths.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Set_CreatesIntermediateObjects( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Set, Path = "/address/city", Value = "\"Portland\"" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.AreEqual( "Portland", doc.RootElement.GetProperty( "address" ).GetProperty( "city" ).GetString( ) );
+ }
+
+ /// Set array element by index.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Set_ArrayElement( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Set, Path = "/items/1", Value = "\"replaced\"" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"items":["a","b","c"]}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.AreEqual( "replaced", doc.RootElement.GetProperty( "items" )[1].GetString( ) );
+ }
+
+ /// Set fails when Value is null.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Set_NullValue_Fails( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Set, Path = "/x" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ Assert.Contains( "Value is required", result.Exception.Message );
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════════
+ // ── Delete ───────────────────────────────────────────────────────────────────
+ // ══════════════════════════════════════════════════════════════════════════════
+
+ /// Delete removes an existing property.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Delete_ExistingProperty( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Delete, Path = "/age" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"name":"Alice","age":30}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.AreEqual( "Alice", doc.RootElement.GetProperty( "name" ).GetString( ) );
+ Assert.IsFalse( doc.RootElement.TryGetProperty( "age", out _ ) );
+ }
+
+ /// Delete a non-existent path succeeds silently.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Delete_NonExistentPath_SilentSuccess( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Delete, Path = "/missing" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"name":"Alice"}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.AreEqual( "Alice", doc.RootElement.GetProperty( "name" ).GetString( ) );
+ }
+
+ /// Delete a nested property.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Delete_NestedProperty( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Delete, Path = "/address/city" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer,
+ inputVariableValue: """{"address":{"city":"Seattle","state":"WA"}}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ JsonElement addr = doc.RootElement.GetProperty( "address" );
+ Assert.IsFalse( addr.TryGetProperty( "city", out _ ) );
+ Assert.AreEqual( "WA", addr.GetProperty( "state" ).GetString( ) );
+ }
+
+ /// Delete an array element by index.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Delete_ArrayElement( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Delete, Path = "/items/1" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"items":["a","b","c"]}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ JsonElement items = doc.RootElement.GetProperty( "items" );
+ Assert.AreEqual( 2, items.GetArrayLength( ) );
+ Assert.AreEqual( "a", items[0].GetString( ) );
+ Assert.AreEqual( "c", items[1].GetString( ) );
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════════
+ // ── Merge ────────────────────────────────────────────────────────────────────
+ // ══════════════════════════════════════════════════════════════════════════════
+
+ /// Merge into root object adds/overrides properties.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Merge_IntoRoot( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation {
+ Type = JsonTransformType.Merge, Path = "",
+ Value = """{"age":31,"email":"a@b.com"}"""
+ }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"name":"Alice","age":30}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.AreEqual( "Alice", doc.RootElement.GetProperty( "name" ).GetString( ) );
+ Assert.AreEqual( 31, doc.RootElement.GetProperty( "age" ).GetInt32( ) );
+ Assert.AreEqual( "a@b.com", doc.RootElement.GetProperty( "email" ).GetString( ) );
+ }
+
+ /// Merge into a nested object.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Merge_IntoNestedObject( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation {
+ Type = JsonTransformType.Merge, Path = "/address",
+ Value = """{"zip":"98101"}"""
+ }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer,
+ inputVariableValue: """{"address":{"city":"Seattle"}}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ JsonElement addr = doc.RootElement.GetProperty( "address" );
+ Assert.AreEqual( "Seattle", addr.GetProperty( "city" ).GetString( ) );
+ Assert.AreEqual( "98101", addr.GetProperty( "zip" ).GetString( ) );
+ }
+
+ /// Merge into a non-object target fails.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Merge_NonObjectTarget_Fails( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation {
+ Type = JsonTransformType.Merge, Path = "/name",
+ Value = """{"x":1}"""
+ }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"name":"Alice"}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ Assert.Contains( "not a JSON object", result.Exception.Message );
+ }
+
+ /// Merge with null Value fails.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Merge_NullValue_Fails( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation {
+ Type = JsonTransformType.Merge, Path = ""
+ }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ Assert.Contains( "Value is required", result.Exception.Message );
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════════
+ // ── Operation Sequencing ─────────────────────────────────────────────────────
+ // ══════════════════════════════════════════════════════════════════════════════
+
+ /// Multiple operations applied in order: extract → set.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task OperationSequencing_ExtractThenSet( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [
+ new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/settings" },
+ new JsonTransformOperation { Type = JsonTransformType.Set, Path = "/theme", Value = "\"dark\"" },
+ ],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer,
+ inputVariableValue: """{"settings":{"theme":"light","lang":"en"}}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.AreEqual( "dark", doc.RootElement.GetProperty( "theme" ).GetString( ) );
+ Assert.AreEqual( "en", doc.RootElement.GetProperty( "lang" ).GetString( ) );
+ }
+
+ /// Set then delete in sequence.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task OperationSequencing_SetThenDelete( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [
+ new JsonTransformOperation { Type = JsonTransformType.Set, Path = "/temp", Value = "true" },
+ new JsonTransformOperation { Type = JsonTransformType.Delete, Path = "/old" },
+ ],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"old":"data","keep":"me"}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.IsTrue( doc.RootElement.GetProperty( "temp" ).GetBoolean( ) );
+ Assert.AreEqual( "me", doc.RootElement.GetProperty( "keep" ).GetString( ) );
+ Assert.IsFalse( doc.RootElement.TryGetProperty( "old", out _ ) );
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════════
+ // ── Output ───────────────────────────────────────────────────────────────────
+ // ══════════════════════════════════════════════════════════════════════════════
+
+ /// OutputPath writes file AND populates OutputVariableValue.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task OutputPath_WritesFileAndVariable( ) {
+ string outputFile = Path.Combine( _tempDir, "out.json" );
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ OutputPath = outputFile,
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Set, Path = "/x", Value = "42" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsNotNull( result.OutputVariableValue );
+
+ // Verify file was written
+ Assert.IsTrue( File.Exists( outputFile ) );
+ string fileContent = await File.ReadAllTextAsync( outputFile, CancellationToken.None );
+ JsonDocument fileParsed = JsonDocument.Parse( fileContent );
+ Assert.AreEqual( 42, fileParsed.RootElement.GetProperty( "x" ).GetInt32( ) );
+
+ // Verify variable matches
+ JsonDocument varParsed = JsonDocument.Parse( result.OutputVariableValue );
+ Assert.AreEqual( 42, varParsed.RootElement.GetProperty( "x" ).GetInt32( ) );
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════════
+ // ── Path Validation ──────────────────────────────────────────────────────────
+ // ══════════════════════════════════════════════════════════════════════════════
+
+ /// Denied InputPath fails via IFilePathResolver.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DeniedInputPath_Fails( ) {
+ TransformJsonHandler deniedHandler = new(
+ TestFilePathResolver.DenyAll,
+ NullLogger.Instance );
+
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ InputPath = "/some/path.json",
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/x" }],
+ } );
+
+ ActionOperatorResult result = await deniedHandler.ExecuteAsync(
+ parameters, _channel.Writer,
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ /// Denied OutputPath fails via IFilePathResolver.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task DeniedOutputPath_Fails( ) {
+ TransformJsonHandler deniedHandler = new(
+ TestFilePathResolver.DenyAll,
+ NullLogger.Instance );
+
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ OutputPath = "/some/output.json",
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Set, Path = "/x", Value = "1" }],
+ } );
+
+ ActionOperatorResult result = await deniedHandler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ // ══════════════════════════════════════════════════════════════════════════════
+ // ── JSON Pointer Edge Cases ──────────────────────────────────────────────────
+ // ══════════════════════════════════════════════════════════════════════════════
+
+ /// Tilde escaping: ~0 → ~ and ~1 → /.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Pointer_TildeEscaping( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/a~1b" }],
+ } );
+
+ // The property name is literally "a/b"
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"a/b":"found"}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "\"found\"", result.OutputVariableValue );
+ }
+
+ /// ~0 unescapes to ~.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Pointer_Tilde0Escaping( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "/a~0b" }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{"a~b":"found"}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "\"found\"", result.OutputVariableValue );
+ }
+
+ /// Empty operations array fails.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task EmptyOperations_Fails( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: """{}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ Assert.IsNotNull( result.Exception );
+ Assert.Contains( "at least one operation", result.Exception.Message );
+ }
+
+ /// $ alone references root.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Pointer_DollarAlone_ReferencesRoot( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation { Type = JsonTransformType.Extract, Path = "$" }],
+ } );
+ string input = """{"x":1}""";
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer, inputVariableValue: input,
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ Assert.AreEqual( 1, doc.RootElement.GetProperty( "x" ).GetInt32( ) );
+ }
+
+ /// Deep merge recursively merges nested objects.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task Merge_DeepRecursive( ) {
+ JsonElement parameters = Serialize( new TransformJsonParameters {
+ Operations = [new JsonTransformOperation {
+ Type = JsonTransformType.Merge, Path = "",
+ Value = """{"a":{"y":2}}"""
+ }],
+ } );
+
+ ActionOperatorResult result = await _handler.ExecuteAsync(
+ parameters, _channel.Writer,
+ inputVariableValue: """{"a":{"x":1}}""",
+ cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue! );
+ JsonElement a = doc.RootElement.GetProperty( "a" );
+ Assert.AreEqual( 1, a.GetProperty( "x" ).GetInt32( ) );
+ Assert.AreEqual( 2, a.GetProperty( "y" ).GetInt32( ) );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/UploadFileHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/UploadFileHandlerTests.cs
new file mode 100644
index 0000000..3011623
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/UploadFileHandlerTests.cs
@@ -0,0 +1,210 @@
+using System.Net;
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Uses to avoid real HTTP traffic.
+///
+[TestClass]
+public class UploadFileHandlerTests {
+
+ /// Temporary directory for source file tests.
+ private string _tempDir = null!;
+ /// Unbounded channel for capturing messages.
+ private Channel _channel = null!;
+
+ /// Gets or sets the MSTest test context.
+ public TestContext TestContext { get; set; } = null!;
+
+ /// Sets up the temp directory and output channel.
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine( Path.GetTempPath( ), $"werkr-test-{Guid.NewGuid( )}" );
+ _ = Directory.CreateDirectory( _tempDir );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ /// Cleans up the temp directory.
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete( _tempDir, recursive: true );
+ }
+ }
+
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ private static UploadFileHandler CreateHandler(
+ MockHttpMessageHandler mockHttp,
+ bool allowUrls = true,
+ bool allowFiles = true
+ ) =>
+ new(
+ allowUrls ? TestUrlValidator.AllowAll : TestUrlValidator.DenyAll,
+ new TestHttpClientFactory( mockHttp ),
+ allowFiles ? TestFilePathResolver.AllowAll : TestFilePathResolver.DenyAll,
+ NullLogger.Instance
+ );
+
+ /// Verifies a file upload sends multipart form data.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task UploadFile_Success_SendsMultipart( ) {
+ string? capturedContentType = null;
+ MockHttpMessageHandler mock = new( ( req, _ ) => {
+ capturedContentType = req.Content?.Headers.ContentType?.MediaType;
+ return Task.FromResult( new HttpResponseMessage( HttpStatusCode.OK ) {
+ Content = new StringContent( "{\"uploaded\":true}" ),
+ } );
+ } );
+ UploadFileHandler handler = CreateHandler( mock );
+
+ string srcFile = Path.Combine( _tempDir, "upload.txt" );
+ await File.WriteAllTextAsync( srcFile, "upload-content", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new UploadFileParameters {
+ FilePath = srcFile,
+ Url = "https://example.com/upload",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "multipart/form-data", capturedContentType );
+ }
+
+ /// Verifies output variable contains status code and metadata.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task UploadFile_OutputVariable_ContainsMetadata( ) {
+ MockHttpMessageHandler mock = new( new HttpResponseMessage( HttpStatusCode.Created ) {
+ Content = new StringContent( "{\"id\":99}" ),
+ } );
+ UploadFileHandler handler = CreateHandler( mock );
+
+ string srcFile = Path.Combine( _tempDir, "data.bin" );
+ await File.WriteAllTextAsync( srcFile, "binary-data", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new UploadFileParameters {
+ FilePath = srcFile,
+ Url = "https://example.com/upload",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.IsNotNull( result.OutputVariableValue );
+
+ using JsonDocument doc = JsonDocument.Parse( result.OutputVariableValue );
+ Assert.AreEqual( 201, doc.RootElement.GetProperty( "statusCode" ).GetInt32( ) );
+ Assert.AreEqual( "data.bin", doc.RootElement.GetProperty( "fileName" ).GetString( ) );
+ Assert.IsGreaterThan( 0L, doc.RootElement.GetProperty( "fileSize" ).GetInt64( ) );
+ }
+
+ /// Verifies that a missing source file causes failure.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task UploadFile_MissingFile_Fails( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( );
+ UploadFileHandler handler = CreateHandler( mock );
+
+ JsonElement parameters = Serialize( new UploadFileParameters {
+ FilePath = Path.Combine( _tempDir, "nonexistent.txt" ),
+ Url = "https://example.com/upload",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ /// Verifies that a denied URL causes failure.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task UploadFile_DeniedUrl_Fails( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( );
+ UploadFileHandler handler = CreateHandler( mock, allowUrls: false );
+
+ string srcFile = Path.Combine( _tempDir, "file.txt" );
+ await File.WriteAllTextAsync( srcFile, "data", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new UploadFileParameters {
+ FilePath = srcFile,
+ Url = "https://example.com/upload",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ /// Verifies that a denied file path causes failure.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task UploadFile_DeniedFilePath_Fails( ) {
+ MockHttpMessageHandler mock = MockHttpMessageHandler.Ok( );
+ UploadFileHandler handler = CreateHandler( mock, allowFiles: false );
+
+ JsonElement parameters = Serialize( new UploadFileParameters {
+ FilePath = "/denied/file.txt",
+ Url = "https://example.com/upload",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ /// Verifies the custom HTTP method is used.
+ [TestMethod]
+ [Timeout( 10_000, CooperativeCancellation = true )]
+ public async Task UploadFile_CustomMethod_Used( ) {
+ string? capturedMethod = null;
+ MockHttpMessageHandler mock = new( ( req, _ ) => {
+ capturedMethod = req.Method.Method;
+ return Task.FromResult( new HttpResponseMessage( HttpStatusCode.OK ) {
+ Content = new StringContent( "ok" ),
+ } );
+ } );
+ UploadFileHandler handler = CreateHandler( mock );
+
+ string srcFile = Path.Combine( _tempDir, "file.txt" );
+ await File.WriteAllTextAsync( srcFile, "data", TestContext.CancellationToken );
+
+ JsonElement parameters = Serialize( new UploadFileParameters {
+ FilePath = srcFile,
+ Url = "https://example.com/upload",
+ Method = "PUT",
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters, _channel.Writer, cancellationToken: TestContext.CancellationToken );
+
+ Assert.IsTrue( result.Success );
+ Assert.AreEqual( "PUT", capturedMethod );
+ }
+
+ /// Verifies the Action property returns the correct name.
+ [TestMethod]
+ public void UploadFile_ActionProperty_IsCorrect( ) {
+ UploadFileHandler handler = CreateHandler( MockHttpMessageHandler.Ok( ) );
+ Assert.AreEqual( "UploadFile", handler.Action );
+ }
+}
diff --git a/src/Test/Werkr.Tests.Agent/Operators/Actions/WatchFileHandlerTests.cs b/src/Test/Werkr.Tests.Agent/Operators/Actions/WatchFileHandlerTests.cs
new file mode 100644
index 0000000..a4bebe8
--- /dev/null
+++ b/src/Test/Werkr.Tests.Agent/Operators/Actions/WatchFileHandlerTests.cs
@@ -0,0 +1,356 @@
+using System.Text.Json;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging.Abstractions;
+using Werkr.Agent.Operators.Actions;
+using Werkr.Common.Models;
+using Werkr.Common.Models.Actions;
+using Werkr.Core.Communication;
+using Werkr.Core.Operators;
+using Werkr.Tests.Agent.Helpers;
+
+namespace Werkr.Tests.Agent.Operators.Actions;
+
+///
+/// Unit tests for the action handler.
+/// Validates FSW-mode detection, polling-mode detection, stability checks,
+/// timeout behavior, and cancellation.
+///
+[TestClass]
+public class WatchFileHandlerTests {
+
+ ///
+ /// Temporary directory created for each test and cleaned up afterward.
+ ///
+ private string _tempDir = null!;
+ ///
+ /// Unbounded channel used to capture messages.
+ ///
+ private Channel _channel = null!;
+
+ ///
+ /// Gets or sets the MSTest for the current test run.
+ ///
+ public TestContext TestContext { get; set; } = null!;
+
+ ///
+ /// Creates a unique temporary directory and an unbounded output channel.
+ ///
+ [TestInitialize]
+ public void TestInit( ) {
+ _tempDir = Path.Combine(
+ Path.GetTempPath( ),
+ $"werkr-test-{Guid.NewGuid( )}"
+ );
+ _ = Directory.CreateDirectory( _tempDir );
+ _channel = Channel.CreateUnbounded( );
+ }
+
+ ///
+ /// Deletes the temporary directory and all its contents.
+ ///
+ [TestCleanup]
+ public void TestCleanup( ) {
+ if (Directory.Exists( _tempDir )) {
+ Directory.Delete(
+ _tempDir,
+ recursive: true
+ );
+ }
+ }
+
+ ///
+ /// Serializes a value to a using the shared test serializer.
+ ///
+ private static JsonElement Serialize( T value ) =>
+ TestActionDescriptor.Serialize( value );
+
+ ///
+ /// Verifies that a pre-existing matching file is detected immediately in FSW mode.
+ ///
+ [TestMethod]
+ [Timeout( 30_000, CooperativeCancellation = true )]
+ public async Task WatchFile_PreExistingFile_FswMode_Succeeds( ) {
+ // Create file before starting the watch
+ string filePath = Path.Combine( _tempDir, "data.csv" );
+ await File.WriteAllTextAsync( filePath, "content", TestContext.CancellationToken );
+
+ WatchFileHandler handler = new(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance,
+ TimeProvider.System
+ );
+
+ JsonElement parameters = Serialize( new WatchFileParameters {
+ Directory = _tempDir,
+ Pattern = "*.csv",
+ StabilitySeconds = 1,
+ TimeoutSeconds = 10,
+ PollIntervalMs = 100
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that a file created after watch starts is detected in FSW mode.
+ ///
+ [TestMethod]
+ [Timeout( 30_000, CooperativeCancellation = true )]
+ public async Task WatchFile_NewFile_FswMode_Succeeds( ) {
+ WatchFileHandler handler = new(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance,
+ TimeProvider.System
+ );
+
+ JsonElement parameters = Serialize( new WatchFileParameters {
+ Directory = _tempDir,
+ Pattern = "*.csv",
+ StabilitySeconds = 1,
+ TimeoutSeconds = 10,
+ PollIntervalMs = 100
+ } );
+
+ // Start watching, then create the file shortly after
+ Task watchTask = handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ await Task.Delay( 200, TestContext.CancellationToken );
+ string filePath = Path.Combine( _tempDir, "report.csv" );
+ await File.WriteAllTextAsync( filePath, "content", TestContext.CancellationToken );
+
+ ActionOperatorResult result = await watchTask;
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that polling mode detects a pre-existing file.
+ ///
+ [TestMethod]
+ [Timeout( 30_000, CooperativeCancellation = true )]
+ public async Task WatchFile_PreExistingFile_PollingMode_Succeeds( ) {
+ string filePath = Path.Combine( _tempDir, "data.csv" );
+ await File.WriteAllTextAsync( filePath, "content", TestContext.CancellationToken );
+
+ WatchFileHandler handler = new(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance,
+ TimeProvider.System
+ );
+
+ JsonElement parameters = Serialize( new WatchFileParameters {
+ Directory = _tempDir,
+ Pattern = "*.csv",
+ StabilitySeconds = 1,
+ TimeoutSeconds = 10,
+ PollIntervalMs = 100,
+ UsePolling = true
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that FailOnTimeout returns failure when no file appears.
+ ///
+ [TestMethod]
+ [Timeout( 30_000, CooperativeCancellation = true )]
+ public async Task WatchFile_Timeout_FailOnTimeout_ReturnsFailure( ) {
+ WatchFileHandler handler = new(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance,
+ TimeProvider.System
+ );
+
+ JsonElement parameters = Serialize( new WatchFileParameters {
+ Directory = _tempDir,
+ Pattern = "*.csv",
+ StabilitySeconds = 1,
+ TimeoutSeconds = 2,
+ PollIntervalMs = 100,
+ UsePolling = true,
+ Mode = WatchFileMode.FailOnTimeout
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ _ = Assert.IsInstanceOfType( result.Exception );
+ }
+
+ ///
+ /// Verifies that ExitQuietly returns success when no file appears within timeout.
+ ///
+ [TestMethod]
+ [Timeout( 30_000, CooperativeCancellation = true )]
+ public async Task WatchFile_Timeout_ExitQuietly_ReturnsSuccess( ) {
+ WatchFileHandler handler = new(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance,
+ TimeProvider.System
+ );
+
+ JsonElement parameters = Serialize( new WatchFileParameters {
+ Directory = _tempDir,
+ Pattern = "*.csv",
+ StabilitySeconds = 1,
+ TimeoutSeconds = 2,
+ PollIntervalMs = 100,
+ UsePolling = true,
+ Mode = WatchFileMode.ExitQuietly
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsTrue( result.Success );
+ }
+
+ ///
+ /// Verifies that a non-matching pattern does not trigger detection.
+ ///
+ [TestMethod]
+ [Timeout( 30_000, CooperativeCancellation = true )]
+ public async Task WatchFile_NonMatchingPattern_TimesOut( ) {
+ string filePath = Path.Combine( _tempDir, "data.txt" );
+ await File.WriteAllTextAsync( filePath, "content", TestContext.CancellationToken );
+
+ WatchFileHandler handler = new(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance,
+ TimeProvider.System
+ );
+
+ JsonElement parameters = Serialize( new WatchFileParameters {
+ Directory = _tempDir,
+ Pattern = "*.csv", // won't match .txt file
+ StabilitySeconds = 1,
+ TimeoutSeconds = 2,
+ PollIntervalMs = 100,
+ UsePolling = true,
+ Mode = WatchFileMode.FailOnTimeout
+ } );
+
+ ActionOperatorResult result = await handler.ExecuteAsync(
+ parameters,
+ _channel.Writer,
+ cancellationToken: TestContext.CancellationToken
+ );
+
+ Assert.IsFalse( result.Success );
+ }
+
+ ///
+ /// Verifies that cancellation during a watch propagates as OperationCanceledException.
+ ///
+ [TestMethod]
+ [Timeout( 30_000, CooperativeCancellation = true )]
+ public async Task WatchFile_Cancelled_ThrowsOperationCanceled( ) {
+ WatchFileHandler handler = new(
+ TestFilePathResolver.AllowAll,
+ NullLogger.Instance,
+ TimeProvider.System
+ );
+
+ JsonElement parameters = Serialize( new WatchFileParameters {
+ Directory = _tempDir,
+ Pattern = "*.csv",
+ StabilitySeconds = 1,
+ TimeoutSeconds = 300,
+ PollIntervalMs = 100,
+ UsePolling = true
+ } );
+
+ using CancellationTokenSource cts = new( );
+
+ Task