Files
scadaproj/ZB.MOM.WW.Secrets/tests/ZB.MOM.WW.Secrets.Ui.Tests/Fakes/RecordingSecretStore.cs
T

133 lines
5.3 KiB
C#

using System.Collections.Concurrent;
using ZB.MOM.WW.Secrets.Abstractions;
namespace ZB.MOM.WW.Secrets.Ui.Tests.Fakes;
/// <summary>
/// A hand-written <see cref="ISecretStore"/> test double (the family does not use Moq) that keeps
/// an in-memory table of rows and records every <see cref="UpsertAsync"/> and
/// <see cref="DeleteAsync"/> call so a test can assert on the mutation trail.
/// </summary>
public sealed class RecordingSecretStore : ISecretStore
{
private readonly ConcurrentDictionary<string, StoredSecret> _rows = new();
private readonly ConcurrentQueue<StoredSecret> _upserts = new();
private readonly ConcurrentQueue<SecretName> _gets = new();
private readonly ConcurrentQueue<(SecretName Name, string? Actor)> _deletes = new();
/// <summary>Names read, in call order; never plaintext.</summary>
public IReadOnlyList<SecretName> Gets => _gets.ToArray();
/// <summary>Optional controlled read, including fixtures that deliberately ignore cancellation.</summary>
public Func<SecretName, CancellationToken, Task<StoredSecret?>>? GetOverride { get; set; }
/// <summary>Optional hook awaited before the normal recorded upsert commits.</summary>
public Func<StoredSecret, CancellationToken, Task>? UpsertOverride { get; set; }
private int _listCalls;
/// <summary>Number of metadata-list requests, including failed/retried reads.</summary>
public int ListCalls => _listCalls;
/// <summary>Optional metadata listing fault.</summary>
public Exception? ListFault { get; set; }
/// <summary>Optional controlled metadata read, including fixtures ignoring cancellation.</summary>
public Func<bool, CancellationToken, Task<IReadOnlyList<SecretMetadata>>>? ListOverride { get; set; }
/// <summary>Optional controlled delay before the normal delete commits.</summary>
public Func<SecretName, string?, CancellationToken, Task>? DeleteOverride { get; set; }
/// <summary>Rows upserted, in call order.</summary>
public IReadOnlyList<StoredSecret> Upserts => _upserts.ToArray();
/// <summary>Delete calls (name + recorded actor), in call order.</summary>
public IReadOnlyList<(SecretName Name, string? Actor)> Deletes => _deletes.ToArray();
/// <summary>When set, <see cref="UpsertAsync"/> throws this to drive the mutation-failure path.</summary>
public Exception? UpsertFault { get; set; }
/// <summary>When set, <see cref="DeleteAsync"/> throws this to drive the mutation-failure path.</summary>
public Exception? DeleteFault { get; set; }
/// <summary>Seeds a row so <see cref="GetAsync"/> and <see cref="ListAsync"/> can return it.</summary>
/// <param name="row">The row to seed.</param>
public void Seed(StoredSecret row) => _rows[row.Name.Value] = row;
/// <inheritdoc />
public Task<StoredSecret?> GetAsync(SecretName name, CancellationToken ct)
{
_gets.Enqueue(name);
return GetOverride is null
? Task.FromResult(_rows.TryGetValue(name.Value, out StoredSecret? row) ? row : null)
: GetOverride(name, ct);
}
/// <inheritdoc />
public async Task UpsertAsync(StoredSecret row, CancellationToken ct)
{
if (UpsertOverride is not null)
{
await UpsertOverride(row, ct);
}
if (UpsertFault is not null)
{
throw UpsertFault;
}
_rows[row.Name.Value] = row;
_upserts.Enqueue(row);
}
/// <inheritdoc />
public async Task<bool> DeleteAsync(SecretName name, string? actor, CancellationToken ct)
{
if (DeleteOverride is not null) await DeleteOverride(name, actor, ct);
if (DeleteFault is not null)
{
throw DeleteFault;
}
_deletes.Enqueue((name, actor));
return _rows.TryRemove(name.Value, out _);
}
/// <inheritdoc />
public Task<IReadOnlyList<SecretMetadata>> ListAsync(bool includeDeleted, CancellationToken ct)
{
Interlocked.Increment(ref _listCalls);
if (ListOverride is not null) return ListOverride(includeDeleted, ct);
if (ListFault is not null) return Task.FromException<IReadOnlyList<SecretMetadata>>(ListFault);
IReadOnlyList<SecretMetadata> projection = _rows.Values
.Where(r => includeDeleted || !r.IsDeleted)
.Select(r => new SecretMetadata
{
Name = r.Name,
Description = r.Description,
ContentType = r.ContentType,
KekId = r.KekId,
Revision = r.Revision,
IsDeleted = r.IsDeleted,
CreatedUtc = r.CreatedUtc,
UpdatedUtc = r.UpdatedUtc,
CreatedBy = r.CreatedBy,
UpdatedBy = r.UpdatedBy,
})
.ToArray();
return Task.FromResult(projection);
}
/// <inheritdoc />
public Task<IReadOnlyList<SecretManifestEntry>> GetManifestAsync(CancellationToken ct)
=> throw new NotSupportedException();
/// <inheritdoc />
public Task ApplyReplicatedAsync(StoredSecret row, CancellationToken ct)
=> throw new NotSupportedException();
/// <inheritdoc />
public Task<bool> ApplyRewrapAsync(
StoredSecret rewrappedRow, byte[] expectedCurrentWrappedDek, CancellationToken ct)
=> throw new NotSupportedException();
}