Joseph Doherty
513fa1aa16
Comment/XML-doc changes only: - add summaries to ~10k test methods, fixtures, fakes and helpers (+ <param> on theories, <returns> on async Task methods, <inheritdoc/> on interface implementations the checker can resolve) - strip ~2.6k project-tracking references (WP*, P*-*, row-NN, Task N, #NN, Component-0NN) from comments, keeping the explanatory text; reword false positives in comments only - real docs on fakes implementing BCL/library interfaces (IDisposable, ILogger, IOptionsMonitor, IAsyncLifetime) - reword the last 5 src/ false positives (CWE-1236, failures-1, year-0001, M365) Only non-comment edits: four one-line nested classes split across lines so members can carry docs. Build 0 errors / 0 warnings.
445 lines
20 KiB
C#
445 lines
20 KiB
C#
using Microsoft.EntityFrameworkCore;
|
|
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.Types.Deployment;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
|
|
using ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Repositories;
|
|
|
|
namespace ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests;
|
|
|
|
/// <summary>
|
|
/// Coverage for the Central UI deployment-status page's server-side read path —
|
|
/// <see cref="DeploymentManagerRepository.QueryDeploymentListPageAsync"/> and
|
|
/// <see cref="DeploymentManagerRepository.GetDeploymentStatusCountsAsync"/>
|
|
/// (residual R3).
|
|
///
|
|
/// <para>
|
|
/// These replace a whole-table <c>GetAllDeploymentRecords</c> read whose only
|
|
/// caller then site-scoped, sorted, counted the status tiles and sliced a page in
|
|
/// the Blazor circuit's memory. Every one of those jobs is asserted here to happen
|
|
/// in SQL instead: the filter dimensions, the total count, the deterministic
|
|
/// ordering that makes offset paging safe, and the grouped tile aggregation.
|
|
/// </para>
|
|
///
|
|
/// <para>
|
|
/// Uses the shared SQLite in-memory fixture. It enforces the
|
|
/// <c>DeploymentRecord → Instance</c> FK, which is exactly the relationship the
|
|
/// new query's inner join relies on, so the seeds are real Site/Template/Instance
|
|
/// rows.
|
|
/// </para>
|
|
/// </summary>
|
|
public class DeploymentListQueryRepositoryTests : IDisposable
|
|
{
|
|
private readonly ScadaBridgeDbContext _context;
|
|
private readonly DeploymentManagerRepository _repository;
|
|
private readonly DateTimeOffset _base = new(2026, 8, 15, 12, 0, 0, TimeSpan.Zero);
|
|
|
|
/// <summary>Initializes a new instance of the <c>DeploymentListQueryRepositoryTests</c> class.</summary>
|
|
public DeploymentListQueryRepositoryTests()
|
|
{
|
|
_context = SqliteTestHelper.CreateInMemoryContext();
|
|
_repository = new DeploymentManagerRepository(_context);
|
|
}
|
|
|
|
/// <summary>Releases the resources held by the test fixture.</summary>
|
|
public void Dispose()
|
|
{
|
|
_context.Database.CloseConnection();
|
|
_context.Dispose();
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
private async Task<int> SeedSiteAsync(string name)
|
|
{
|
|
var site = new Site(name, name);
|
|
_context.Sites.Add(site);
|
|
await _context.SaveChangesAsync();
|
|
return site.Id;
|
|
}
|
|
|
|
private async Task<int> SeedInstanceAsync(string uniqueName, int siteId)
|
|
{
|
|
var template = new Template($"T-{uniqueName}");
|
|
_context.Templates.Add(template);
|
|
await _context.SaveChangesAsync();
|
|
|
|
var instance = new Instance(uniqueName) { SiteId = siteId, TemplateId = template.Id };
|
|
_context.Instances.Add(instance);
|
|
await _context.SaveChangesAsync();
|
|
return instance.Id;
|
|
}
|
|
|
|
private async Task<DeploymentRecord> SeedRecordAsync(
|
|
string deploymentId,
|
|
int instanceId,
|
|
DeploymentStatus status,
|
|
DateTimeOffset deployedAt,
|
|
string deployedBy = "alice",
|
|
string? revisionHash = null)
|
|
{
|
|
var record = new DeploymentRecord(deploymentId, deployedBy)
|
|
{
|
|
InstanceId = instanceId,
|
|
Status = status,
|
|
DeployedAt = deployedAt,
|
|
RevisionHash = revisionHash
|
|
};
|
|
_context.DeploymentRecords.Add(record);
|
|
await _context.SaveChangesAsync();
|
|
return record;
|
|
}
|
|
|
|
// ── Paging ────────────────────────────────────────────────────────────────
|
|
|
|
/// <summary>Verifies that a page query returns the requested slice together with the total count of the whole set.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task QueryPage_ReturnsRequestedSlice_AndTheTotalCountOfTheWholeSet()
|
|
{
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var instanceId = await SeedInstanceAsync("Inst-1", siteId);
|
|
for (var i = 0; i < 25; i++)
|
|
{
|
|
await SeedRecordAsync($"dep-{i:D3}", instanceId, DeploymentStatus.Success, _base.AddMinutes(i));
|
|
}
|
|
|
|
var page2 = await _repository.QueryDeploymentListPageAsync(
|
|
new DeploymentListFilter(), pageNumber: 2, pageSize: 10);
|
|
|
|
Assert.Equal(25, page2.TotalCount);
|
|
Assert.Equal(10, page2.Rows.Count);
|
|
Assert.Equal(3, page2.PageCount(10));
|
|
|
|
// Newest first: page 2 of 10 starts at the 11th newest deployment.
|
|
Assert.Equal("dep-014", page2.Rows[0].DeploymentId);
|
|
Assert.Equal("dep-005", page2.Rows[^1].DeploymentId);
|
|
}
|
|
|
|
/// <summary>Verifies that consecutive pages neither overlap nor drop rows, even when rows share a deployed-at timestamp.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task QueryPage_PagesDoNotOverlapOrDropRows_EvenWhenDeployedAtTies()
|
|
{
|
|
// Rapid redeploys write several records on the same clock tick. Without the
|
|
// Id tie-break the sort key is unstable and offset paging repeats or drops
|
|
// rows between pages — the failure mode the ThenByDescending(Id) prevents.
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var instanceId = await SeedInstanceAsync("Inst-1", siteId);
|
|
for (var i = 0; i < 9; i++)
|
|
{
|
|
await SeedRecordAsync($"dep-{i:D3}", instanceId, DeploymentStatus.Success, _base);
|
|
}
|
|
|
|
var seen = new List<string>();
|
|
for (var page = 1; page <= 3; page++)
|
|
{
|
|
var result = await _repository.QueryDeploymentListPageAsync(
|
|
new DeploymentListFilter(), pageNumber: page, pageSize: 3);
|
|
seen.AddRange(result.Rows.Select(r => r.DeploymentId));
|
|
}
|
|
|
|
Assert.Equal(9, seen.Count);
|
|
Assert.Equal(9, seen.Distinct().Count());
|
|
}
|
|
|
|
/// <summary>Verifies that a non-positive page number is floored at page one.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task QueryPage_NonPositivePageNumber_IsFlooredAtPageOne()
|
|
{
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var instanceId = await SeedInstanceAsync("Inst-1", siteId);
|
|
await SeedRecordAsync("dep-000", instanceId, DeploymentStatus.Success, _base);
|
|
|
|
var page = await _repository.QueryDeploymentListPageAsync(
|
|
new DeploymentListFilter(), pageNumber: 0, pageSize: 10);
|
|
|
|
Assert.Single(page.Rows);
|
|
}
|
|
|
|
/// <summary>Verifies that an oversized page size is clamped to the maximum.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task QueryPage_OversizedPageSize_IsClampedToTheMaximum()
|
|
{
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var instanceId = await SeedInstanceAsync("Inst-1", siteId);
|
|
await SeedRecordAsync("dep-000", instanceId, DeploymentStatus.Success, _base);
|
|
|
|
// A caller asking for int.MaxValue rows must not be able to turn the paged
|
|
// read back into the whole-table read it replaced.
|
|
var page = await _repository.QueryDeploymentListPageAsync(
|
|
new DeploymentListFilter(), pageNumber: 1, pageSize: int.MaxValue);
|
|
|
|
Assert.Single(page.Rows);
|
|
Assert.True(DeploymentListPage.MaxPageSize > 0);
|
|
}
|
|
|
|
/// <summary>Verifies that a page past the end returns no rows but still reports the total.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task QueryPage_PastTheEnd_ReturnsNoRowsButStillReportsTheTotal()
|
|
{
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var instanceId = await SeedInstanceAsync("Inst-1", siteId);
|
|
await SeedRecordAsync("dep-000", instanceId, DeploymentStatus.Success, _base);
|
|
|
|
var page = await _repository.QueryDeploymentListPageAsync(
|
|
new DeploymentListFilter(), pageNumber: 9, pageSize: 25);
|
|
|
|
Assert.Empty(page.Rows);
|
|
Assert.Equal(1, page.TotalCount);
|
|
}
|
|
|
|
// ── Joined projection ─────────────────────────────────────────────────────
|
|
|
|
/// <summary>Verifies that the page query joins the instance so its name and site travel with each row.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task QueryPage_JoinsTheInstance_SoNameAndSiteTravelWithTheRow()
|
|
{
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var instanceId = await SeedInstanceAsync("Line3.Filler", siteId);
|
|
await SeedRecordAsync("dep-000", instanceId, DeploymentStatus.Failed, _base,
|
|
deployedBy: "bob", revisionHash: "abc123");
|
|
|
|
var row = Assert.Single(
|
|
(await _repository.QueryDeploymentListPageAsync(new DeploymentListFilter(), 1, 25)).Rows);
|
|
|
|
Assert.Equal("Line3.Filler", row.InstanceUniqueName);
|
|
Assert.Equal(siteId, row.SiteId);
|
|
Assert.Equal(instanceId, row.InstanceId);
|
|
Assert.Equal("dep-000", row.DeploymentId);
|
|
Assert.Equal(DeploymentStatus.Failed, row.Status);
|
|
Assert.Equal("bob", row.DeployedBy);
|
|
Assert.Equal("abc123", row.RevisionHash);
|
|
}
|
|
|
|
// ── Filters ───────────────────────────────────────────────────────────────
|
|
|
|
/// <summary>Verifies that the status filter is applied in the database query.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task QueryPage_StatusFilter_IsAppliedInTheDatabase()
|
|
{
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var instanceId = await SeedInstanceAsync("Inst-1", siteId);
|
|
await SeedRecordAsync("dep-ok", instanceId, DeploymentStatus.Success, _base);
|
|
await SeedRecordAsync("dep-bad", instanceId, DeploymentStatus.Failed, _base.AddMinutes(1));
|
|
|
|
var page = await _repository.QueryDeploymentListPageAsync(
|
|
new DeploymentListFilter(Status: DeploymentStatus.Failed), 1, 25);
|
|
|
|
Assert.Equal(1, page.TotalCount);
|
|
Assert.Equal("dep-bad", Assert.Single(page.Rows).DeploymentId);
|
|
}
|
|
|
|
/// <summary>Verifies that the instance filter restricts results to a single instance's history.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task QueryPage_InstanceFilter_RestrictsToOneInstanceHistory()
|
|
{
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var a = await SeedInstanceAsync("Inst-A", siteId);
|
|
var b = await SeedInstanceAsync("Inst-B", siteId);
|
|
await SeedRecordAsync("dep-a", a, DeploymentStatus.Success, _base);
|
|
await SeedRecordAsync("dep-b", b, DeploymentStatus.Success, _base);
|
|
|
|
var page = await _repository.QueryDeploymentListPageAsync(
|
|
new DeploymentListFilter(InstanceId: b), 1, 25);
|
|
|
|
Assert.Equal("dep-b", Assert.Single(page.Rows).DeploymentId);
|
|
}
|
|
|
|
/// <summary>Verifies that the search term matches across the identifiers a user can look up.</summary>
|
|
/// <param name="term">The term.</param>
|
|
/// <param name="expected">The expected.</param>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Theory]
|
|
[InlineData("Filler", "dep-a")] // instance unique name
|
|
[InlineData("dep-b", "dep-b")] // deployment id
|
|
[InlineData("carol", "dep-b")] // initiating user
|
|
[InlineData("rev-a", "dep-a")] // revision hash
|
|
public async Task QueryPage_Search_MatchesAcrossTheFindableIdentifiers(string term, string expected)
|
|
{
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var a = await SeedInstanceAsync("Line3.Filler", siteId);
|
|
var b = await SeedInstanceAsync("Line4.Capper", siteId);
|
|
await SeedRecordAsync("dep-a", a, DeploymentStatus.Success, _base, deployedBy: "alice", revisionHash: "rev-a1");
|
|
await SeedRecordAsync("dep-b", b, DeploymentStatus.Success, _base.AddMinutes(1), deployedBy: "carol", revisionHash: "rev-b1");
|
|
|
|
var page = await _repository.QueryDeploymentListPageAsync(
|
|
new DeploymentListFilter(Search: term), 1, 25);
|
|
|
|
Assert.Equal(expected, Assert.Single(page.Rows).DeploymentId);
|
|
}
|
|
|
|
/// <summary>Verifies that a whitespace-only search is treated as no constraint.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task QueryPage_WhitespaceSearch_IsTreatedAsUnconstrained()
|
|
{
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var instanceId = await SeedInstanceAsync("Inst-1", siteId);
|
|
await SeedRecordAsync("dep-000", instanceId, DeploymentStatus.Success, _base);
|
|
|
|
var page = await _repository.QueryDeploymentListPageAsync(
|
|
new DeploymentListFilter(Search: " "), 1, 25);
|
|
|
|
Assert.Equal(1, page.TotalCount);
|
|
}
|
|
|
|
/// <summary>Verifies that the site scope restricts results to the granted sites.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task QueryPage_SiteScope_RestrictsToTheGrantedSites()
|
|
{
|
|
var s1 = await SeedSiteAsync("S1");
|
|
var s2 = await SeedSiteAsync("S2");
|
|
var a = await SeedInstanceAsync("Inst-A", s1);
|
|
var b = await SeedInstanceAsync("Inst-B", s2);
|
|
await SeedRecordAsync("dep-a", a, DeploymentStatus.Success, _base);
|
|
await SeedRecordAsync("dep-b", b, DeploymentStatus.Success, _base.AddMinutes(1));
|
|
|
|
var page = await _repository.QueryDeploymentListPageAsync(
|
|
new DeploymentListFilter(SiteIdScope: new[] { s2 }), 1, 25);
|
|
|
|
Assert.Equal(1, page.TotalCount);
|
|
Assert.Equal("dep-b", Assert.Single(page.Rows).DeploymentId);
|
|
}
|
|
|
|
/// <summary>Verifies that an empty site scope is a real filter that matches nothing.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task QueryPage_EmptySiteScope_IsARealFilterThatMatchesNothing()
|
|
{
|
|
// A scoped user granted no sites must see nothing — an empty scope must NOT
|
|
// degrade into "unconstrained", which would leak every site's deployments.
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var instanceId = await SeedInstanceAsync("Inst-1", siteId);
|
|
await SeedRecordAsync("dep-000", instanceId, DeploymentStatus.Success, _base);
|
|
|
|
var page = await _repository.QueryDeploymentListPageAsync(
|
|
new DeploymentListFilter(SiteIdScope: Array.Empty<int>()), 1, 25);
|
|
|
|
Assert.Equal(0, page.TotalCount);
|
|
Assert.Empty(page.Rows);
|
|
}
|
|
|
|
/// <summary>Verifies that site scope and status filters compose correctly for the CLI query path.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task QueryPage_SiteScopeAndStatus_Compose_ForTheCliQueryPath()
|
|
{
|
|
// Register row 37: this is now the ONLY paged read of DeploymentRecords —
|
|
// the CLI/HTTP QueryDeployments command reaches it through the same filter
|
|
// the UI page uses, where it used to have a second repository method with
|
|
// instance-id-list scoping and no total. Its combination (site scope AND a
|
|
// status filter, over more rows than one page holds) is pinned here.
|
|
var s1 = await SeedSiteAsync("S1");
|
|
var s2 = await SeedSiteAsync("S2");
|
|
var a = await SeedInstanceAsync("Inst-A", s1);
|
|
var b = await SeedInstanceAsync("Inst-B", s2);
|
|
for (var i = 0; i < 4; i++)
|
|
{
|
|
await SeedRecordAsync($"dep-a{i}", a, DeploymentStatus.Failed, _base.AddMinutes(i));
|
|
await SeedRecordAsync($"dep-b{i}", b, DeploymentStatus.Failed, _base.AddMinutes(i));
|
|
}
|
|
await SeedRecordAsync("dep-a-ok", a, DeploymentStatus.Success, _base.AddHours(1));
|
|
|
|
var page = await _repository.QueryDeploymentListPageAsync(
|
|
new DeploymentListFilter(Status: DeploymentStatus.Failed, SiteIdScope: new[] { s1 }),
|
|
pageNumber: 1, pageSize: 2);
|
|
|
|
// Four in-scope failures exist; the page is bounded to two and the total
|
|
// reports the rest, so a bounded page is never mistaken for a complete one.
|
|
Assert.Equal(4, page.TotalCount);
|
|
Assert.Equal(2, page.Rows.Count);
|
|
Assert.All(page.Rows, r => Assert.Equal(s1, r.SiteId));
|
|
Assert.All(page.Rows, r => Assert.Equal(DeploymentStatus.Failed, r.Status));
|
|
}
|
|
|
|
// ── Status counts ─────────────────────────────────────────────────────────
|
|
|
|
/// <summary>Verifies that status counts group every status and report absent statuses as zero.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task StatusCounts_GroupsEveryStatus_WithAbsentOnesReportedAsZero()
|
|
{
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var instanceId = await SeedInstanceAsync("Inst-1", siteId);
|
|
await SeedRecordAsync("dep-1", instanceId, DeploymentStatus.Success, _base);
|
|
await SeedRecordAsync("dep-2", instanceId, DeploymentStatus.Success, _base.AddMinutes(1));
|
|
await SeedRecordAsync("dep-3", instanceId, DeploymentStatus.Failed, _base.AddMinutes(2));
|
|
await SeedRecordAsync("dep-4", instanceId, DeploymentStatus.InProgress, _base.AddMinutes(3));
|
|
|
|
var counts = await _repository.GetDeploymentStatusCountsAsync(new DeploymentListFilter());
|
|
|
|
Assert.Equal(0, counts.Pending);
|
|
Assert.Equal(1, counts.InProgress);
|
|
Assert.Equal(2, counts.Success);
|
|
Assert.Equal(1, counts.Failed);
|
|
Assert.Equal(4, counts.Total);
|
|
}
|
|
|
|
/// <summary>Verifies that status counts ignore the status filter so each tile keeps its own total.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task StatusCounts_IgnoreTheStatusFilter_SoEachTileKeepsItsOwnTotal()
|
|
{
|
|
// The tiles are the status BREAKDOWN of the filtered set. Honouring the
|
|
// active status filter here would zero the other three tiles the moment an
|
|
// operator clicked one.
|
|
var siteId = await SeedSiteAsync("S1");
|
|
var instanceId = await SeedInstanceAsync("Inst-1", siteId);
|
|
await SeedRecordAsync("dep-1", instanceId, DeploymentStatus.Success, _base);
|
|
await SeedRecordAsync("dep-2", instanceId, DeploymentStatus.Failed, _base.AddMinutes(1));
|
|
|
|
var counts = await _repository.GetDeploymentStatusCountsAsync(
|
|
new DeploymentListFilter(Status: DeploymentStatus.Failed));
|
|
|
|
Assert.Equal(1, counts.Success);
|
|
Assert.Equal(1, counts.Failed);
|
|
Assert.Equal(2, counts.Total);
|
|
}
|
|
|
|
/// <summary>Verifies that status counts honor every filter dimension other than status.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task StatusCounts_HonourEveryOtherFilterDimension()
|
|
{
|
|
var s1 = await SeedSiteAsync("S1");
|
|
var s2 = await SeedSiteAsync("S2");
|
|
var a = await SeedInstanceAsync("Inst-A", s1);
|
|
var b = await SeedInstanceAsync("Inst-B", s2);
|
|
await SeedRecordAsync("dep-a1", a, DeploymentStatus.Success, _base);
|
|
await SeedRecordAsync("dep-a2", a, DeploymentStatus.Failed, _base.AddMinutes(1));
|
|
await SeedRecordAsync("dep-b1", b, DeploymentStatus.Success, _base.AddMinutes(2));
|
|
|
|
var scoped = await _repository.GetDeploymentStatusCountsAsync(
|
|
new DeploymentListFilter(SiteIdScope: new[] { s1 }));
|
|
Assert.Equal(2, scoped.Total);
|
|
|
|
var searched = await _repository.GetDeploymentStatusCountsAsync(
|
|
new DeploymentListFilter(Search: "Inst-B"));
|
|
Assert.Equal(1, searched.Total);
|
|
Assert.Equal(1, searched.Success);
|
|
|
|
var byInstance = await _repository.GetDeploymentStatusCountsAsync(
|
|
new DeploymentListFilter(InstanceId: a));
|
|
Assert.Equal(2, byInstance.Total);
|
|
}
|
|
|
|
/// <summary>Verifies that status counts over an empty set are all zero.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task StatusCounts_EmptySet_IsAllZeros()
|
|
{
|
|
var counts = await _repository.GetDeploymentStatusCountsAsync(new DeploymentListFilter());
|
|
|
|
Assert.Equal(DeploymentStatusCounts.Empty, counts);
|
|
}
|
|
}
|