137 lines
5.5 KiB
C#
137 lines
5.5 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 delay before a read, without replacing the store's normal row behavior.</summary>
|
|
public Func<SecretName, CancellationToken, Task>? BeforeGetAsync { 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 async Task<StoredSecret?> GetAsync(SecretName name, CancellationToken ct)
|
|
{
|
|
_gets.Enqueue(name);
|
|
if (BeforeGetAsync is not null) await BeforeGetAsync(name, ct);
|
|
return GetOverride is null
|
|
? (_rows.TryGetValue(name.Value, out StoredSecret? row) ? row : null)
|
|
: await 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();
|
|
}
|