private async Task <Uri> SaveDataToBlobStorageAsync(
DataBundleRequestDto requestDto,
IEnumerable <Guid> dataAvailableNotificationGuids)
{
var testString = @$ "
<data>
<uuid>{requestDto.IdempotencyId}</uuid>
public async Task <IBundleContent?> WaitForBundleContentFromSubDomainAsync(Bundle bundle)
{
ArgumentNullException.ThrowIfNull(bundle, nameof(bundle));
var request = new DataBundleRequestDto(
Guid.NewGuid(),
bundle.ProcessId.ToString(),
bundle.ProcessId.ToString(),
new MessageTypeDto(bundle.ContentType.Value));
_logger.LogProcess("Peek", "WaitForContent", _correlationContext.Id, bundle.Recipient.ToString(), bundle.BundleId.ToString(), bundle.Origin.ToString());
var response = await _dataBundleRequestSender.SendAsync(request, (DomainOrigin)bundle.Origin).ConfigureAwait(false);
if (response == null)
{
_logger.LogProcess("Peek", "NoDomainResponse", _correlationContext.Id, bundle.Recipient.ToString(), bundle.BundleId.ToString(), bundle.Origin.ToString());
return(null);
}
if (response.IsErrorResponse)
{
_logger.LogProcess("Peek", "DomainErrorResponse", _correlationContext.Id, bundle.Recipient.ToString(), bundle.BundleId.ToString(), bundle.Origin.ToString());
_logger.LogError(
"Domain returned an error {Reason}. Correlation ID: {CorrelationId}.\nDescription: {FailureDescription}",
response.ResponseError.Reason,
_correlationContext.Id,
response.ResponseError.FailureDescription);
return(null);
}
_logger.LogProcess("Peek", "DomainResponse", _correlationContext.Id, bundle.Recipient.ToString(), bundle.BundleId.ToString(), bundle.Origin.ToString());
return(new AzureBlobBundleContent(_marketOperatorDataStorageService, response.ContentUri));
}
public async Task <Uri> AddStreamToStorageAsync(Stream stream, DataBundleRequestDto requestDto)
{
ArgumentNullException.ThrowIfNull(requestDto, nameof(requestDto));
if (stream is not {
Length : > 0
})
private async Task <DataBundleResponseDto> CreateSuccessResponseAsync(
DataBundleRequestDto requestDto,
IEnumerable <Guid> dataAvailableNotificationGuids)
{
var resourceUrl = await SaveDataToBlobStorageAsync(requestDto, dataAvailableNotificationGuids).ConfigureAwait(false);
return(requestDto.CreateResponse(new Uri(resourceUrl.AbsoluteUri)));
}
private static DataBundleResponseDto CreateFailedResponse(
DataBundleRequestDto requestDto,
DataBundleResponseErrorReason failedReason)
{
return(requestDto.CreateErrorResponse(new DataBundleResponseErrorDto(
failedReason,
failedReason.ToString())));
}
/// <summary>
/// Creates a failed <see cref="DataBundleResponseDto"/> from <see cref="DataBundleRequestDto"/>.
/// </summary>
/// <param name="request">The request to create a response from.</param>
/// <param name="errorResponse">A description of the error.</param>
/// <returns>The response to the specified request.</returns>
public static DataBundleResponseDto CreateErrorResponse(this DataBundleRequestDto request, DataBundleResponseErrorDto errorResponse)
{
ArgumentNullException.ThrowIfNull(request, nameof(request));
return(new DataBundleResponseDto(
request.RequestId,
request.IdempotencyId,
errorResponse));
}
public static Task <IReadOnlyList <Guid> > GetDataAvailableIdsAsync(this DataBundleRequestDto request, Scope scope)
{
var currentConfig = scope.GetInstance <StorageConfig>();
var currentFactory = scope.GetInstance <IStorageServiceClientFactory>();
var storageFromClient = new MessageHub.Client.Storage.StorageHandler(
new TestClientFactoryWrapper(currentFactory),
new MessageHub.Client.StorageConfig(currentConfig.AzureBlobStorageContainerName));
return(storageFromClient.GetDataAvailableNotificationIdsAsync(request));
}
public byte[] Parse(DataBundleRequestDto request)
{
ArgumentNullException.ThrowIfNull(request, nameof(request));
var message = new DataBundleRequestContract
{
RequestId = request.RequestId.ToString(),
DataAvailableNotificationReferenceId = request.DataAvailableNotificationReferenceId,
IdempotencyId = request.IdempotencyId,
MessageType = request.MessageType.Value
};
return(message.ToByteArray());
}
public async Task SendAsync_ValidInput_AddsCorrectIntegrationEvents()
{
// Arrange
var serviceBusSenderMock = new Mock <ServiceBusSender>();
var serviceBusSessionReceiverMock = new Mock <ServiceBusSessionReceiver>();
const string sbqTimeseriesReply = "sbq-TimeSeries-reply";
await using var mockedServiceBusClient = new MockedServiceBusClient(
sbqTimeseriesReply,
string.Empty,
serviceBusSenderMock.Object,
serviceBusSessionReceiverMock.Object);
var serviceBusClientFactory = new Mock <IServiceBusClientFactory>();
serviceBusClientFactory.Setup(x => x.Create()).Returns(mockedServiceBusClient);
await using var messageBusFactory = new AzureServiceBusFactory(serviceBusClientFactory.Object);
var config = new MessageHubConfig("fake_value", sbqTimeseriesReply);
// ServiceBusMessage
var target = new DataBundleResponseSender(
new ResponseBundleParser(),
messageBusFactory,
config);
var requestMock = new DataBundleRequestDto(
Guid.NewGuid(),
"A9D032EB-4AAC-44F3-BE1C-8584B8533875",
"42D509CB-1D93-430D-A2D4-7DBB9AE56771",
new MessageTypeDto("80BB9BB8-CDE8-4C77-BE76-FDC886FD75A3"));
var response = requestMock.CreateResponse(new Uri("https://test.dk/test"));
// Act
await target.SendAsync(response).ConfigureAwait(false);
// Assert
serviceBusSenderMock.Verify(
x => x.SendMessageAsync(
It.Is <ServiceBusMessage>(
message =>
message.ApplicationProperties.ContainsKey("OperationTimestamp") &&
message.ApplicationProperties.ContainsKey("OperationCorrelationId") &&
message.ApplicationProperties.ContainsKey("MessageVersion") &&
message.ApplicationProperties.ContainsKey("MessageType") &&
message.ApplicationProperties.ContainsKey("EventIdentification")),
default),
Times.Once);
}
public void CreateResponse_ReturnsResponse()
{
// arrange
var requestId = Guid.Parse("BCDFAF35-B914-488E-A8FB-C41FC377097D");
var uri = new Uri("http://localhost");
var request = new DataBundleRequestDto(
requestId,
"C141D536-170F-48A6-92FC-EA0D79D2F7E0",
"D5D400AD-CC11-409A-B757-75EB9AA8B0EA",
new MessageTypeDto("message_type"));
// act
var actual = request.CreateResponse(uri);
// assert
Assert.Equal(requestId, actual.RequestId);
Assert.Equal(uri, actual.ContentUri);
}
public async Task AddStreamToStorageAsync_StreamIsValid_ReturnsUri()
{
// arrange
var mockedStorageServiceClientFactory = new Mock <IStorageServiceClientFactory>();
var mockedBlobServiceClient = new Mock <BlobServiceClient>();
var mockedBlobContainerClient = new Mock <BlobContainerClient>();
var mockedBlobClient = new Mock <BlobClient>();
var mockedDataBundleRequestDto = new DataBundleRequestDto(
Guid.NewGuid(),
"24AEFA9F-91D5-4908-A111-157C48D7FC6D",
Guid.NewGuid().ToString(),
new MessageTypeDto("fake_value"));
var testUri = new Uri("https://test.test.dk/FileStorage/postoffice-blobstorage");
mockedBlobClient.Setup(
x => x.Uri)
.Returns(testUri);
mockedBlobContainerClient.Setup(
x => x.UploadBlobAsync(It.IsAny <string>(), It.IsAny <Stream>(), default));
mockedBlobContainerClient.Setup(
x => x.GetBlobClient(It.IsAny <string>()))
.Returns(mockedBlobClient.Object);
mockedBlobServiceClient.Setup(
x => x.GetBlobContainerClient(It.IsAny <string>()))
.Returns(mockedBlobContainerClient.Object);
mockedStorageServiceClientFactory.Setup(
x => x.Create())
.Returns(mockedBlobServiceClient.Object);
var target = new StorageHandler(mockedStorageServiceClientFactory.Object, new StorageConfig("fake_value"));
// act
await using var inputStream = new MemoryStream(new byte[] { 1, 2, 3 });
var result = await target.AddStreamToStorageAsync(inputStream, mockedDataBundleRequestDto).ConfigureAwait(false);
// assert
Assert.Equal(testUri, result);
}
public async Task <DataBundleResponseDto?> SendAsync(
DataBundleRequestDto dataBundleRequestDto,
DomainOrigin domainOrigin)
{
ArgumentNullException.ThrowIfNull(dataBundleRequestDto, nameof(dataBundleRequestDto));
var bytes = _requestBundleParser.Parse(dataBundleRequestDto);
var sessionId = dataBundleRequestDto.RequestId.ToString();
var replyQueue = GetReplyQueueName(domainOrigin);
var targetQueue = GetQueueName(domainOrigin);
var serviceBusMessage = new ServiceBusMessage(bytes)
{
SessionId = sessionId,
ReplyToSessionId = sessionId,
ReplyTo = replyQueue,
TimeToLive = _peekRequestConfig.PeekTimeout ?? _defaultTimeout
}.AddRequestDataBundleIntegrationEvents(dataBundleRequestDto.IdempotencyId);
var serviceBusClient = _messageBusFactory.GetSenderClient(targetQueue);
await serviceBusClient
.PublishMessageAsync <ServiceBusMessage>(serviceBusMessage)
.ConfigureAwait(false);
await using var receiverMessageBus = await _messageBusFactory
.GetSessionReceiverClientAsync(replyQueue, sessionId)
.ConfigureAwait(false);
var response = await receiverMessageBus
.ReceiveMessageAsync <ServiceBusMessage>(_peekRequestConfig.PeekTimeout ?? _defaultTimeout)
.ConfigureAwait(false);
if (response == null)
{
return(null);
}
return(_responseBundleParser.Parse(response.Body.ToArray()));
}
public async Task AddStreamToStorageAsync_RequestFailure_ThrowsCustomException()
{
// arrange
var mockedStorageServiceClientFactory = new Mock <IStorageServiceClientFactory>();
var mockedBlobServiceClient = new Mock <BlobServiceClient>();
var mockedBlobContainerClient = new Mock <BlobContainerClient>();
var mockedBlobClient = new Mock <BlobClient>();
var mockedDataBundleRequestDto = new DataBundleRequestDto(
Guid.NewGuid(),
"9B0A9B6C-EA5F-4DD0-817B-4D29A681984E",
Guid.NewGuid().ToString(),
new MessageTypeDto("fake_value"));
mockedBlobServiceClient.Setup(
x => x.GetBlobContainerClient(It.IsAny <string>()))
.Returns(mockedBlobContainerClient.Object);
mockedBlobContainerClient
.Setup(client => client.GetBlobClient(It.IsAny <string>()))
.Returns(mockedBlobClient.Object);
mockedBlobClient.Setup(
x => x.UploadAsync(
It.IsAny <Stream>(),
It.IsAny <bool>(),
default))
.ThrowsAsync(new RequestFailedException("test"));
mockedStorageServiceClientFactory.Setup(
x => x.Create())
.Returns(mockedBlobServiceClient.Object);
var target = new StorageHandler(mockedStorageServiceClientFactory.Object, new StorageConfig("fake_value"));
// act, assert
await using var inputStream = new MemoryStream(new byte[] { 1, 2, 3 });
await Assert.ThrowsAsync <MessageHubStorageException>(
() => target.AddStreamToStorageAsync(
inputStream,
mockedDataBundleRequestDto))
.ConfigureAwait(false);
}
private async Task <DataBundleResponseDto> CreateResponseAsync(DataBundleRequestDto requestDto)
{
var dataAvailableNotificationGuids = await _storageHandler
.GetDataAvailableNotificationIdsAsync(requestDto)
.ConfigureAwait(false);
if (dataAvailableNotificationGuids.Contains(new Guid("0ae6c542-385f-4d89-bfba-d6c451915a1b")))
{
return(CreateFailedResponse(requestDto, DataBundleResponseErrorReason.DatasetNotFound));
}
if (dataAvailableNotificationGuids.Contains(new Guid("3cfce64e-aa1d-4003-924d-69c8739e73a6")))
{
return(CreateFailedResponse(requestDto, DataBundleResponseErrorReason.DatasetNotAvailable));
}
if (dataAvailableNotificationGuids.Contains(new Guid("befdcf5a-f58d-493b-9a17-e5231609c8f6")))
{
return(CreateFailedResponse(requestDto, DataBundleResponseErrorReason.InternalError));
}
return(await CreateSuccessResponseAsync(requestDto, dataAvailableNotificationGuids).ConfigureAwait(false));
}
public async Task SendAsync_ValidInput_SendsMessage()
{
// Arrange
const string queueName = "sbq-MeteringPoints-reply";
var serviceBusSenderMock = new Mock <ServiceBusSender>();
var serviceBusSessionReceiverMock = new Mock <ServiceBusSessionReceiver>();
await using var mockedServiceBusClient = new MockedServiceBusClient(
queueName,
string.Empty,
serviceBusSenderMock.Object,
serviceBusSessionReceiverMock.Object);
var serviceBusClientFactory = new Mock <IServiceBusClientFactory>();
serviceBusClientFactory.Setup(x => x.Create()).Returns(mockedServiceBusClient);
await using var messageBusFactory = new AzureServiceBusFactory(serviceBusClientFactory.Object);
var config = new MessageHubConfig("fake_value", queueName);
var target = new DataBundleResponseSender(
new ResponseBundleParser(),
messageBusFactory,
config);
var requestMock = new DataBundleRequestDto(
Guid.NewGuid(),
"F3DE0389-AC26-4461-A11B-61077BF0CA32",
"7E9D048D-F0D8-476D-8739-AAA83284C9C6",
new MessageTypeDto("80BB9BB8-CDE8-4C77-BE76-FDC886FD75A3"));
var response = requestMock.CreateResponse(new Uri("https://test.dk/test"));
// Act
await target.SendAsync(response).ConfigureAwait(false);
// Assert
serviceBusSenderMock.Verify(x => x.SendMessageAsync(It.IsAny <ServiceBusMessage>(), default), Times.Once);
}
public void CreateErrorResponse_ReturnsResponse()
{
// arrange
var requestId = Guid.Parse("BCDFAF35-B914-488E-A8FB-C41FC377097D");
var request = new DataBundleRequestDto(
requestId,
"CBF03641-95C2-4386-A04E-892CDF1D793A",
"D5D400AD-CC11-409A-B757-75EB9AA8B0EA",
new MessageTypeDto("message_type"));
var dataBundleResponseErrorDto = new DataBundleResponseErrorDto(
DataBundleResponseErrorReason.DatasetNotFound,
"fake_description");
// act
var actual = request.CreateErrorResponse(dataBundleResponseErrorDto);
// assert
Assert.Equal(requestId, actual.RequestId);
Assert.Equal(dataBundleResponseErrorDto, actual.ResponseError);
Assert.Equal(dataBundleResponseErrorDto.Reason, actual.ResponseError !.Reason);
Assert.Equal(dataBundleResponseErrorDto.FailureDescription, actual.ResponseError.FailureDescription);
}
public async Task AddStreamToStorageAsync_StreamIsEmpty_ThrowsArgumentException()
{
// arrange
var mockedStorageServiceClientFactory = new Mock <IStorageServiceClientFactory>();
var mockedBlobServiceClient = new Mock <BlobServiceClient>();
var mockedDataBundleRequestDto = new DataBundleRequestDto(
Guid.NewGuid(),
"A6A7912F-A578-4448-A2C1-6545F4C8EA8C",
Guid.NewGuid().ToString(),
new MessageTypeDto("fake_value"));
mockedStorageServiceClientFactory.Setup(
x => x.Create())
.Returns(mockedBlobServiceClient.Object);
var target = new StorageHandler(mockedStorageServiceClientFactory.Object, new StorageConfig("fake_value"));
// act, assert
await Assert.ThrowsAsync <ArgumentException>(
() => target.AddStreamToStorageAsync(
Stream.Null,
mockedDataBundleRequestDto))
.ConfigureAwait(false);
}
