feat(deploymentmanager): DeployAreaAsync bulk-deploys an area subtree through the shared DeploySiteAsync core; PreviewSubtreeDeployAsync returns confirm counts (Gitea #40)

DeploySiteAsync's body moves into a private core taking the site plus an optional area-id filter; site deploy behaviour is unchanged. The subtree is one in-memory ParentAreaId walk (cycle-safe) shared by the deploy and the preview. DeploymentService gains an ITemplateEngineRepository dependency for the area lookups.
2026-10-22 14:07:33 -04:00
parent b9751473a6
commit eb1c9ea7f9
9 changed files with 568 additions and 20 deletions
@@ -0,0 +1,409 @@
+using System.Collections.Concurrent;
+using Akka.Actor;
+using Akka.TestKit.Xunit2;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+using NSubstitute;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Deployment;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites;
+using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
+using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Services;
+using ZB.MOM.WW.ScadaBridge.Commons.Messages.Deployment;
+using ZB.MOM.WW.ScadaBridge.Commons.Types;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Flattening;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Templates;
+using ZB.MOM.WW.ScadaBridge.Communication;
+using ZB.MOM.WW.ScadaBridge.TemplateEngine.Flattening;
+
+namespace ZB.MOM.WW.ScadaBridge.DeploymentManager.Tests;
+
+/// <summary>
+/// Area-subtree bulk deployment (Gitea #40). <c>DeployAreaAsync</c> is
+/// <c>DeploySiteAsync</c> narrowed to the instances under one area and all of its
+/// descendants, so these tests pin the narrowing — descendants in, siblings and
+/// ancestors out — plus the bulk rules it must inherit unchanged (Disabled always
+/// skipped, up-to-date skipped unless forced). They also cover the cheap
+/// pre-confirm counts <c>PreviewSubtreeDeployAsync</c> returns.
+/// </summary>
+public class DeployAreaAsyncTests : TestKit
+{
+    private const int SiteId = 1;
+    private const int OtherSiteId = 2;
+
+    // Site 1:  Plant(100) ─┬─ Line1(101) ── Cell(102)
+    //                      └─ Line2(103)
+    //          Warehouse(200)
+    // Site 2:  Remote(900)
+    private const int PlantArea = 100;
+    private const int Line1Area = 101;
+    private const int CellArea = 102;
+    private const int Line2Area = 103;
+    private const int WarehouseArea = 200;
+    private const int RemoteArea = 900;
+
+    private readonly IDeploymentManagerRepository _repo = Substitute.For<IDeploymentManagerRepository>();
+    private readonly IFlatteningPipeline _pipeline = Substitute.For<IFlatteningPipeline>();
+    private readonly ISiteRepository _siteRepo = Substitute.For<ISiteRepository>();
+    private readonly ITemplateEngineRepository _templateRepo = Substitute.For<ITemplateEngineRepository>();
+    private readonly IAuditService _audit = Substitute.For<IAuditService>();
+
+    private readonly Dictionary<int, string> _deployedHashes = new();
+    private readonly Dictionary<int, DeploymentRecord> _currentRecords = new();
+    private readonly OperationLockManager _lockManager = new();
+    private List<Area> _siteAreas = new();
+
+    /// <summary>Initializes the test class with the area tree above and substituted repositories.</summary>
+    public DeployAreaAsyncTests()
+    {
+        _siteRepo.GetSiteByIdAsync(Arg.Any<int>(), Arg.Any<CancellationToken>())
+            .Returns(ci => ci.ArgAt<int>(0) is SiteId or OtherSiteId
+                ? new Site($"Site {ci.ArgAt<int>(0)}", $"site-{ci.ArgAt<int>(0)}") { Id = ci.ArgAt<int>(0) }
+                : null);
+
+        _pipeline.CreateSession().Returns(_ => new FlattenSession(new TemplateGraphWatermark()));
+
+        _repo.GetDeployedRevisionHashesAsync(Arg.Any<CancellationToken>())
+            .Returns(_ => (IReadOnlyDictionary<int, string>)new Dictionary<int, string>(_deployedHashes));
+        _repo.GetCurrentDeploymentStatusesAsync(Arg.Any<IReadOnlyCollection<int>>(), Arg.Any<CancellationToken>())
+            .Returns(ci => (IReadOnlyDictionary<int, DeploymentRecord>)ci.ArgAt<IReadOnlyCollection<int>>(0)
+                .Where(_currentRecords.ContainsKey)
+                .ToDictionary(id => id, id => _currentRecords[id]));
+
+        ArrangeAreas(
+            Area(PlantArea, SiteId, null),
+            Area(Line1Area, SiteId, PlantArea),
+            Area(CellArea, SiteId, Line1Area),
+            Area(Line2Area, SiteId, PlantArea),
+            Area(WarehouseArea, SiteId, null));
+
+        _templateRepo.GetAreaByIdAsync(RemoteArea, Arg.Any<CancellationToken>())
+            .Returns(Area(RemoteArea, OtherSiteId, null));
+    }
+
+    private static Area Area(int id, int siteId, int? parentId) =>
+        new($"Area-{id}") { Id = id, SiteId = siteId, ParentAreaId = parentId };
+
+    /// <summary>Replaces site 1's area set (by-id and by-site lookups both answer from it).</summary>
+    private void ArrangeAreas(params Area[] areas)
+    {
+        _siteAreas = areas.ToList();
+        foreach (var area in areas)
+            _templateRepo.GetAreaByIdAsync(area.Id, Arg.Any<CancellationToken>()).Returns(area);
+        _templateRepo.GetAreasBySiteIdAsync(SiteId, Arg.Any<CancellationToken>())
+            .Returns(_ => (IReadOnlyList<Area>)_siteAreas);
+    }
+
+    /// <summary>
+    /// Seeds one deployable instance per entry, in the given area (null = no area).
+    /// Instance ids are 1-based in argument order and named <c>Inst-NN</c>.
+    /// </summary>
+    private List<Instance> ArrangeInstances(params int?[] areaIds)
+    {
+        var instances = new List<Instance>();
+        for (var i = 1; i <= areaIds.Length; i++)
+        {
+            var instance = new Instance($"Inst-{i:00}")
+            {
+                Id = i,
+                SiteId = SiteId,
+                TemplateId = 10,
+                AreaId = areaIds[i - 1],
+                State = InstanceState.NotDeployed
+            };
+            instances.Add(instance);
+
+            _repo.GetInstanceByIdAsync(i, Arg.Any<CancellationToken>()).Returns(instance);
+            _repo.GetCurrentDeploymentStatusAsync(i, Arg.Any<CancellationToken>()).Returns((DeploymentRecord?)null);
+
+            var config = new FlattenedConfiguration { InstanceUniqueName = instance.UniqueName };
+            _pipeline.FlattenAndValidateAsync(
+                    i, Arg.Any<CancellationToken>(), Arg.Any<bool>(), Arg.Any<FlattenSession?>())
+                .Returns(Result<FlatteningPipelineResult>.Success(
+                    new FlatteningPipelineResult(config, $"sha256:{i}", ValidationResult.Success())));
+        }
+
+        _siteRepo.GetInstancesBySiteIdAsync(SiteId, Arg.Any<CancellationToken>()).Returns(instances);
+        return instances;
+    }
+
+    /// <summary>Makes the instance <c>Enabled</c> with a deployed snapshot whose hash the probe recomputes.</summary>
+    private void ArrangeUpToDate(Instance instance)
+    {
+        var hash = $"sha256:{instance.Id}";
+        instance.State = InstanceState.Enabled;
+
+        _deployedHashes[instance.Id] = hash;
+        var prior = new DeploymentRecord($"prior-{instance.Id}", "admin")
+        {
+            InstanceId = instance.Id,
+            Status = DeploymentStatus.Success,
+            RevisionHash = hash,
+        };
+        _currentRecords[instance.Id] = prior;
+        _repo.GetCurrentDeploymentStatusAsync(instance.Id, Arg.Any<CancellationToken>()).Returns(prior);
+        _pipeline.ComputeRevisionHashAsync(instance.Id, Arg.Any<FlattenSession?>(), Arg.Any<CancellationToken>())
+            .Returns(Result<string>.Success(hash));
+    }
+
+    private (DeploymentService Service, ConcurrentBag<string> Applied) CreateService()
+    {
+        var applied = new ConcurrentBag<string>();
+        var commActor = Sys.ActorOf(Props.Create(() => new RecordingSiteActor(applied)));
+
+        var comms = new CommunicationService(
+            Options.Create(new CommunicationOptions { DeploymentTimeout = TimeSpan.FromSeconds(30) }),
+            NullLogger<CommunicationService>.Instance);
+        comms.SetCommunicationActor(commActor);
+
+        var options = Options.Create(new DeploymentManagerOptions
+        {
+            OperationLockTimeout = TimeSpan.FromSeconds(5),
+            SiteDeploymentMaxParallelism = 3,
+            SiteDeploymentTimeoutPerInstance = TimeSpan.FromSeconds(30),
+            SiteDeploymentReconcileTimeout = TimeSpan.FromSeconds(5)
+        });
+
+        var service = new DeploymentService(
+            _repo, _siteRepo, _templateRepo, _pipeline, comms, _lockManager, _audit,
+            new DiffService(),
+            new RevisionHashService(),
+            new DeploymentStatusNotifier(NullLogger<DeploymentStatusNotifier>.Instance),
+            options,
+            Options.Create(new CommunicationOptions
+            {
+                CentralFetchBaseUrl = "https://central.test:9000",
+                PendingDeploymentTtl = TimeSpan.FromMinutes(5)
+            }),
+            NullLogger<DeploymentService>.Instance);
+        return (service, applied);
+    }
+
+    /// <summary>
+    /// The subtree is the area plus every descendant at any depth; an instance
+    /// sitting directly in the area counts, and siblings, ancestors, other root
+    /// areas and area-less instances do not.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task DeployAreaAsync_DeploysAreaAndDescendants_Only()
+    {
+        // 1:Plant 2:Line1 3:Cell 4:Line2 5:Warehouse 6:no area
+        ArrangeInstances(PlantArea, Line1Area, CellArea, Line2Area, WarehouseArea, null);
+        var (service, applied) = CreateService();
+
+        var result = await service.DeployAreaAsync(Line1Area, "admin");
+
+        Assert.True(result.IsSuccess, result.IsFailure ? result.Error : null);
+        Assert.Equal("site-1", result.Value.SiteIdentifier);
+        Assert.Equal(new[] { "Inst-02", "Inst-03" }, applied.Order().ToArray());
+        Assert.Equal(2, result.Value.SuccessCount);
+        Assert.Equal(0, result.Value.FailureCount);
+        Assert.Empty(result.Value.SkippedInstances!);
+
+        // Nothing outside the subtree was even flattened.
+        foreach (var id in new[] { 1, 4, 5, 6 })
+            await _pipeline.DidNotReceive().FlattenAndValidateAsync(
+                id, Arg.Any<CancellationToken>(), Arg.Any<bool>(), Arg.Any<FlattenSession?>());
+    }
+
+    /// <summary>A root area's subtree spans every nested level beneath it.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task DeployAreaAsync_RootArea_IncludesEveryNestedLevel()
+    {
+        ArrangeInstances(PlantArea, Line1Area, CellArea, Line2Area, WarehouseArea, null);
+        var (service, applied) = CreateService();
+
+        var result = await service.DeployAreaAsync(PlantArea, "admin");
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal(new[] { "Inst-01", "Inst-02", "Inst-03", "Inst-04" }, applied.Order().ToArray());
+    }
+
+    /// <summary>Disabled instances inside the subtree are skipped, forced or not.</summary>
+    /// <param name="force">Whether the deploy is forced.</param>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task DeployAreaAsync_DisabledInstancesAreSkipped_RegardlessOfForce(bool force)
+    {
+        var instances = ArrangeInstances(Line1Area, CellArea);
+        instances[1].State = InstanceState.Disabled;
+        var (service, applied) = CreateService();
+
+        var result = await service.DeployAreaAsync(Line1Area, "admin", force);
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal(new[] { "Inst-01" }, applied.ToArray());
+        var skipped = Assert.Single(result.Value.SkippedInstances!);
+        Assert.Equal("Inst-02", skipped.UniqueName);
+        Assert.Contains("deploy individually to re-enable", skipped.Reason);
+        Assert.Equal(InstanceState.Disabled, instances[1].State);
+    }
+
+    /// <summary>Up-to-date instances inside the subtree are skipped unless the deploy is forced.</summary>
+    /// <param name="force">Whether the deploy is forced.</param>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task DeployAreaAsync_UpToDateInstancesAreSkipped_UnlessForced(bool force)
+    {
+        var instances = ArrangeInstances(Line1Area, CellArea);
+        ArrangeUpToDate(instances[1]);
+        var (service, applied) = CreateService();
+
+        var result = await service.DeployAreaAsync(Line1Area, "admin", force);
+
+        Assert.True(result.IsSuccess);
+        if (force)
+        {
+            Assert.Equal(new[] { "Inst-01", "Inst-02" }, applied.Order().ToArray());
+            Assert.Empty(result.Value.SkippedInstances!);
+        }
+        else
+        {
+            Assert.Equal(new[] { "Inst-01" }, applied.ToArray());
+            var skipped = Assert.Single(result.Value.SkippedInstances!);
+            Assert.Equal("Inst-02", skipped.UniqueName);
+            Assert.Contains("up-to-date", skipped.Reason);
+        }
+    }
+
+    /// <summary>An unknown area is a failure result, not an empty success.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task DeployAreaAsync_UnknownArea_ReturnsFailure()
+    {
+        ArrangeInstances(Line1Area);
+        _templateRepo.GetAreaByIdAsync(4242, Arg.Any<CancellationToken>()).Returns((Area?)null);
+        var (service, applied) = CreateService();
+
+        var result = await service.DeployAreaAsync(4242, "admin");
+
+        Assert.True(result.IsFailure);
+        Assert.Contains("not found", result.Error);
+        Assert.Empty(applied);
+    }
+
+    /// <summary>An area with no instances anywhere in its subtree is an empty success.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task DeployAreaAsync_EmptySubtree_SucceedsWithEmptySummary()
+    {
+        ArrangeInstances(WarehouseArea);
+        var (service, applied) = CreateService();
+
+        var result = await service.DeployAreaAsync(Line2Area, "admin");
+
+        Assert.True(result.IsSuccess);
+        Assert.Empty(result.Value.InstanceResults);
+        Assert.Empty(applied);
+    }
+
+    /// <summary>
+    /// A corrupt parent chain (a cycle) must not hang the walk: the subtree still
+    /// resolves and the deploy completes.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task DeployAreaAsync_ParentCycle_TerminatesAndDeploysTheReachableSet()
+    {
+        ArrangeAreas(
+            Area(PlantArea, SiteId, CellArea), // Plant -> Cell -> Line1 -> Plant
+            Area(Line1Area, SiteId, PlantArea),
+            Area(CellArea, SiteId, Line1Area),
+            Area(WarehouseArea, SiteId, null));
+        ArrangeInstances(PlantArea, Line1Area, CellArea, WarehouseArea);
+        var (service, applied) = CreateService();
+
+        var result = await service.DeployAreaAsync(Line1Area, "admin")
+            .WaitAsync(TimeSpan.FromSeconds(10));
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal(new[] { "Inst-01", "Inst-02", "Inst-03" }, applied.Order().ToArray());
+    }
+
+    /// <summary>The whole-site deploy is unaffected by areas: area-less and every-area instances all go.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task DeploySiteAsync_StillDeploysEveryInstance_RegardlessOfArea()
+    {
+        ArrangeInstances(PlantArea, CellArea, WarehouseArea, null);
+        var (service, applied) = CreateService();
+
+        var result = await service.DeploySiteAsync(SiteId, "admin");
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal(new[] { "Inst-01", "Inst-02", "Inst-03", "Inst-04" }, applied.Order().ToArray());
+    }
+
+    /// <summary>The whole-site preview counts every instance and the Disabled ones among them.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task PreviewSubtreeDeployAsync_WholeSite_CountsAllAndDisabled()
+    {
+        var instances = ArrangeInstances(PlantArea, CellArea, WarehouseArea, null);
+        instances[2].State = InstanceState.Disabled;
+        var (service, _) = CreateService();
+
+        var result = await service.PreviewSubtreeDeployAsync(SiteId, null);
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal(new SubtreeDeployPreview(4, 1), result.Value);
+        // Cheap: no staleness probe, no flatten.
+        _pipeline.DidNotReceive().CreateSession();
+    }
+
+    /// <summary>The area preview counts exactly the subtree's instances.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task PreviewSubtreeDeployAsync_Area_CountsSubtreeOnly()
+    {
+        var instances = ArrangeInstances(PlantArea, Line1Area, CellArea, Line2Area, WarehouseArea);
+        instances[2].State = InstanceState.Disabled;
+        var (service, _) = CreateService();
+
+        var result = await service.PreviewSubtreeDeployAsync(SiteId, Line1Area);
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal(new SubtreeDeployPreview(2, 1), result.Value);
+    }
+
+    /// <summary>An area belonging to a different site, an unknown area, or an unknown site is a failure.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task PreviewSubtreeDeployAsync_RejectsForeignOrUnknownAreaAndUnknownSite()
+    {
+        ArrangeInstances(Line1Area);
+        _templateRepo.GetAreaByIdAsync(4242, Arg.Any<CancellationToken>()).Returns((Area?)null);
+        var (service, _) = CreateService();
+
+        Assert.True((await service.PreviewSubtreeDeployAsync(SiteId, RemoteArea)).IsFailure);
+        Assert.True((await service.PreviewSubtreeDeployAsync(SiteId, 4242)).IsFailure);
+        Assert.True((await service.PreviewSubtreeDeployAsync(77, null)).IsFailure);
+    }
+
+    /// <summary>Answers every deploy with Success, recording which instances the site was asked to apply.</summary>
+    private sealed class RecordingSiteActor : ReceiveActor
+    {
+        /// <summary>Initializes the actor with the collection that records applied instance names.</summary>
+        /// <param name="applied">The collection that receives each applied instance's unique name.</param>
+        public RecordingSiteActor(ConcurrentBag<string> applied)
+        {
+            Receive<SiteEnvelope>(env =>
+            {
+                if (env.Message is not RefreshDeploymentCommand cmd)
+                    return;
+
+                applied.Add(cmd.InstanceUniqueName);
+                Sender.Tell(new DeploymentStatusResponse(
+                    cmd.DeploymentId, cmd.InstanceUniqueName,
+                    DeploymentStatus.Success, null, DateTimeOffset.UtcNow));
+            });
+        }
+    }
+}
@@ -107,7 +107,7 @@ public class DeploySiteAsyncTests : TestKit
        });

        return new DeploymentService(
-            _repo, _siteRepo, _pipeline, comms, _lockManager, _audit,
+            _repo, _siteRepo, Substitute.For<ITemplateEngineRepository>(), _pipeline, comms, _lockManager, _audit,
            new DiffService(),
            new RevisionHashService(),
            new DeploymentStatusNotifier(NullLogger<DeploymentStatusNotifier>.Instance),
@@ -61,6 +61,7 @@ public class DeploymentServiceStalenessTests
        _service = new DeploymentService(
            _repo,
            siteRepo,
+            Substitute.For<ITemplateEngineRepository>(),
            _pipeline,
            new CommunicationService(
                Options.Create(new CommunicationOptions()),
@@ -51,7 +51,7 @@ public class DeploymentServiceTests : TestKit

        var siteRepo = CreateSiteRepoStub();
        _service = new DeploymentService(
-            _repo, siteRepo, _pipeline, _comms, _lockManager, _audit,
+            _repo, siteRepo, Substitute.For<ITemplateEngineRepository>(), _pipeline, _comms, _lockManager, _audit,
            new DiffService(),
            new RevisionHashService(),
            new DeploymentStatusNotifier(NullLogger<DeploymentStatusNotifier>.Instance),
@@ -196,7 +196,7 @@ public class DeploymentServiceTests : TestKit
        siteRepo.GetSiteByIdAsync(42, Arg.Any<CancellationToken>()).Returns((Site?)null);

        var service = new DeploymentService(
-            _repo, siteRepo, _pipeline, _comms, _lockManager, _audit,
+            _repo, siteRepo, Substitute.For<ITemplateEngineRepository>(), _pipeline, _comms, _lockManager, _audit,
            new DiffService(),
            new RevisionHashService(),
            new DeploymentStatusNotifier(NullLogger<DeploymentStatusNotifier>.Instance),
@@ -428,7 +428,7 @@ public class DeploymentServiceTests : TestKit

        var siteRepo = CreateSiteRepoStub();
        var service = new DeploymentService(
-            _repo, siteRepo, _pipeline, comms, _lockManager, _audit,
+            _repo, siteRepo, Substitute.For<ITemplateEngineRepository>(), _pipeline, comms, _lockManager, _audit,
            new DiffService(),
            new RevisionHashService(),
            new DeploymentStatusNotifier(NullLogger<DeploymentStatusNotifier>.Instance),
@@ -1243,7 +1243,7 @@ public class DeploymentServiceTests : TestKit

        var siteRepo = CreateSiteRepoStub();
        return new DeploymentService(
-            _repo, siteRepo, _pipeline, comms, _lockManager, _audit,
+            _repo, siteRepo, Substitute.For<ITemplateEngineRepository>(), _pipeline, comms, _lockManager, _audit,
            new DiffService(),
            new RevisionHashService(),
            new DeploymentStatusNotifier(NullLogger<DeploymentStatusNotifier>.Instance),
@@ -1862,7 +1862,7 @@ public class DeploymentServiceTests : TestKit

        var siteRepo = CreateSiteRepoStub();
        var service = new DeploymentService(
-            _repo, siteRepo, _pipeline, comms, _lockManager, _audit,
+            _repo, siteRepo, Substitute.For<ITemplateEngineRepository>(), _pipeline, comms, _lockManager, _audit,
            new DiffService(),
            new RevisionHashService(),
            new DeploymentStatusNotifier(NullLogger<DeploymentStatusNotifier>.Instance),
@@ -1922,7 +1922,7 @@ public class DeploymentServiceTests : TestKit
        var siteRepo = CreateSiteRepoStub();
        var deadline = TimeSpan.FromMilliseconds(300);
        var service = new DeploymentService(
-            _repo, siteRepo, _pipeline, comms, _lockManager, _audit,
+            _repo, siteRepo, Substitute.For<ITemplateEngineRepository>(), _pipeline, comms, _lockManager, _audit,
            new DiffService(),
            new RevisionHashService(),
            new DeploymentStatusNotifier(NullLogger<DeploymentStatusNotifier>.Instance),
@@ -1973,7 +1973,7 @@ public class DeploymentServiceTests : TestKit

        var siteRepo = CreateSiteRepoStub();
        var service = new DeploymentService(
-            _repo, siteRepo, _pipeline, comms, _lockManager, _audit,
+            _repo, siteRepo, Substitute.For<ITemplateEngineRepository>(), _pipeline, comms, _lockManager, _audit,
            new DiffService(),
            new RevisionHashService(),
            new DeploymentStatusNotifier(NullLogger<DeploymentStatusNotifier>.Instance),
@@ -2021,7 +2021,7 @@ public class DeploymentServiceTests : TestKit

        var siteRepo = CreateSiteRepoStub();
        var service = new DeploymentService(
-            _repo, siteRepo, _pipeline, comms, _lockManager, _audit,
+            _repo, siteRepo, Substitute.For<ITemplateEngineRepository>(), _pipeline, comms, _lockManager, _audit,
            new DiffService(),
            new RevisionHashService(),
            new DeploymentStatusNotifier(NullLogger<DeploymentStatusNotifier>.Instance),
@@ -60,7 +60,7 @@ public class DeploymentStatusNotifierTests : TestKit
            });

        _service = new DeploymentService(
-            _repo, siteRepo, _pipeline, _comms, _lockManager, _audit,
+            _repo, siteRepo, Substitute.For<ITemplateEngineRepository>(), _pipeline, _comms, _lockManager, _audit,
            new DiffService(), new RevisionHashService(), _notifier,
            options,
            // Notify-and-fetch: a non-empty CentralFetchBaseUrl lets the
@@ -73,6 +73,7 @@ public class PendingUpdatesEvaluatorTests
        _deploymentService = new DeploymentService(
            _deploymentRepo,
            _siteRepo,
+            Substitute.For<ITemplateEngineRepository>(),
            _pipeline,
            comms,
            new OperationLockManager(),
@@ -12,6 +12,7 @@ using ZB.MOM.WW.ScadaBridge.Commons.Entities.Deployment;
 using ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances;
 using ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites;
 using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
+using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
 using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Services;
 using ZB.MOM.WW.ScadaBridge.Commons.Messages.Deployment;
 using ZB.MOM.WW.ScadaBridge.Commons.Types;
@@ -206,7 +207,7 @@ public sealed class BulkDeployPoisonedContextTests : TestKit, IDisposable
            .Returns(Result<string>.Failure("indeterminate"));

        return new DeploymentService(
-            repository, siteRepository, pipeline, comms, new OperationLockManager(),
+            repository, siteRepository, Substitute.For<ITemplateEngineRepository>(), pipeline, comms, new OperationLockManager(),
            Substitute.For<IAuditService>(),
            new DiffService(),
            new RevisionHashService(),