public async Task Validate_BundleId_ValidatesProperty(string value, bool isValid)
{
// Arrange
const string propertyName = nameof(PeekMasterDataCommand.BundleId);
var target = new PeekMasterDataCommandRuleSet();
var command = new PeekMasterDataCommand(
ValidRecipient,
value);
// Act
var result = await target.ValidateAsync(command).ConfigureAwait(false);
// Assert
if (isValid)
{
Assert.True(result.IsValid);
Assert.DoesNotContain(propertyName, result.Errors.Select(x => x.PropertyName));
}
else
{
Assert.False(result.IsValid);
Assert.Contains(propertyName, result.Errors.Select(x => x.PropertyName));
}
}
public async Task PeekMasterDataCommandHandle_WithoutData_ReturnsNullStream()
{
// Arrange
var request = new PeekMasterDataCommand("fake_value", Guid.NewGuid().ToString());
var warehouseDomainServiceMock = new Mock <IMarketOperatorDataDomainService>();
warehouseDomainServiceMock
.Setup(x =>
x.GetNextUnacknowledgedMasterDataAsync(
It.Is <LegacyActorId>(r =>
string.Equals(r.Value, request.MarketOperator, StringComparison.OrdinalIgnoreCase)),
It.Is <Uuid>(r => BundleIdCheck(r, request))))
.ReturnsAsync((Bundle?)null);
var target = new PeekHandler(
warehouseDomainServiceMock.Object,
new Mock <ILogger>().Object,
new Mock <ICorrelationContext>().Object);
// Act
var(hasContent, _, stream, _) = await target.Handle(request, CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.False(hasContent);
Assert.Equal(0, stream.Length);
await stream.DisposeAsync().ConfigureAwait(false);
}
public async Task PeekMasterDataCommand_SingleNotificationMultiplePeek_ReturnsData()
{
// Arrange
var recipientGln = new MockedGln();
var bundleId = Guid.NewGuid().ToString();
await AddMeteringPointsNotificationAsync(recipientGln).ConfigureAwait(false);
await using var host = await MarketOperatorIntegrationTestHost
.InitializeAsync()
.ConfigureAwait(false);
await using var scope = host.BeginScope();
var mediator = scope.GetInstance <IMediator>();
var peekCommand = new PeekMasterDataCommand(recipientGln, bundleId);
// Act
var responseA = await mediator.Send(peekCommand).ConfigureAwait(false);
var responseB = await mediator.Send(peekCommand).ConfigureAwait(false);
// Assert
Assert.NotNull(responseA);
Assert.True(responseA.HasContent);
Assert.NotNull(responseB);
Assert.True(responseB.HasContent);
}
public async Task PeekMasterDataCommand_InvalidCommand_ThrowsException()
{
// Arrange
await using var host = await MarketOperatorIntegrationTestHost
.InitializeAsync()
.ConfigureAwait(false);
await using var scope = host.BeginScope();
var mediator = scope.GetInstance <IMediator>();
var peekCommand = new PeekMasterDataCommand(" ", " ");
// Act + Assert
await Assert.ThrowsAsync <ValidationException>(() => mediator.Send(peekCommand)).ConfigureAwait(false);
}
public async Task PeekMasterDataCommandHandle_WithData_ReturnsDataStream()
{
// Arrange
var bundleId = Guid.NewGuid().ToString();
var request = new PeekMasterDataCommand("fake_value", bundleId);
var bundleContentMock = new Mock <IBundleContent>();
bundleContentMock
.Setup(x => x.OpenAsync())
.ReturnsAsync(() => new MemoryStream(new byte[] { 1, 2, 3 }));
var bundle = new Bundle(
new Uuid(bundleId),
new LegacyActorId(new GlobalLocationNumber("fake_value")),
DomainOrigin.MarketRoles,
new ContentType("fake_value"),
Array.Empty <Uuid>(),
bundleContentMock.Object,
Enumerable.Empty <string>());
var warehouseDomainServiceMock = new Mock <IMarketOperatorDataDomainService>();
warehouseDomainServiceMock
.Setup(x =>
x.GetNextUnacknowledgedMasterDataAsync(
It.Is <LegacyActorId>(r =>
string.Equals(r.Value, request.MarketOperator, StringComparison.OrdinalIgnoreCase)),
It.Is <Uuid>(r => BundleIdCheck(r, request))))
.ReturnsAsync(bundle);
var target = new PeekHandler(
warehouseDomainServiceMock.Object,
new Mock <ILogger>().Object,
new Mock <ICorrelationContext>().Object);
// Act
var(hasContent, bid, stream, _) = await target.Handle(request, CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.True(hasContent);
Assert.Equal(bundleId, bid);
Assert.Equal(1, stream.ReadByte());
Assert.Equal(2, stream.ReadByte());
Assert.Equal(3, stream.ReadByte());
await stream.DisposeAsync().ConfigureAwait(false);
}
public Task <HttpResponseData> RunAsync(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "peek/masterdata")]
HttpRequestData request)
{
return(request.ProcessAsync(async() =>
{
var command = new PeekMasterDataCommand(_operatorIdentity.ActorId, _bundleIdProvider.TryGetBundleId(request));
var(hasContent, bundleId, stream, documentTypes) = await _mediator.Send(command).ConfigureAwait(false);
var response = hasContent
? request.CreateResponse(stream, MediaTypeNames.Application.Xml)
: request.CreateResponse(HttpStatusCode.NoContent);
response.Headers.Add(Constants.BundleIdHeaderName, bundleId);
if (_featureFlags.IsFeatureActive(Feature.SendMessageTypeHeader))
{
response.Headers.Add(Constants.MessageTypeName, string.Join(",", documentTypes));
}
return response;
}));
}
public async Task PeekMasterDataCommand_AllNotificationsCanBundle_ReturnsBundle()
{
// Arrange
var recipientGln = new MockedGln();
var expectedGuidA = await AddBundlingNotificationAsync(recipientGln, "MeteringPoints", true).ConfigureAwait(false);
var expectedGuidB = await AddBundlingNotificationAsync(recipientGln, "MeteringPoints", true).ConfigureAwait(false);
var expectedGuidC = await AddBundlingNotificationAsync(recipientGln, "MeteringPoints", true).ConfigureAwait(false);
var bundleId = Guid.NewGuid().ToString();
await using var host = await MarketOperatorIntegrationTestHost
.InitializeAsync()
.ConfigureAwait(false);
await using var scope = host.BeginScope();
var mediator = scope.GetInstance <IMediator>();
var peekCommand = new PeekMasterDataCommand(recipientGln, bundleId);
// Act
var response = await mediator.Send(peekCommand).ConfigureAwait(false);
// Assert
Assert.NotNull(response);
Assert.True(response.HasContent);
var bundleContents = await response.Data.ReadAsDataBundleRequestAsync().ConfigureAwait(false);
var dataAvailableNotificationIds = await bundleContents.GetDataAvailableIdsAsync(scope).ConfigureAwait(false);
Assert.Equal(3, dataAvailableNotificationIds.Count);
Assert.Contains(expectedGuidA, dataAvailableNotificationIds);
Assert.Contains(expectedGuidB, dataAvailableNotificationIds);
Assert.Contains(expectedGuidC, dataAvailableNotificationIds);
}
public Task <PeekResponse> Handle(PeekMasterDataCommand request, CancellationToken cancellationToken)
{
return(HandleAsync(request, _marketOperatorDataDomainService.GetNextUnacknowledgedMasterDataAsync));
}
