public async Task SendAsync_ValidInputForDomain_SendsMessage(DomainOrigin domainOrigin, string queueName)
{
// Arrange
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 target = new DequeueNotificationSender(messageBusFactory, _testConfig);
var dataAvailable = new DequeueNotificationDto(
"fake_value",
new ActorIdDto(Guid.NewGuid()));
// Act
await target.SendAsync("fake_value", dataAvailable, domainOrigin).ConfigureAwait(false);
// Assert
serviceBusSenderMock.Verify(x => x.SendMessageAsync(It.IsAny <ServiceBusMessage>(), default), Times.Once);
}
private static DataAvailableNotificationDto CreateDto(DomainOrigin origin, string messageType, string recipient)
{
return(new DataAvailableNotificationDto(
Guid.NewGuid(),
new GlobalLocationNumberDto(string.IsNullOrWhiteSpace(recipient) ? GlnHelper.CreateRandomGln() : recipient),
new MessageTypeDto(string.IsNullOrWhiteSpace(messageType) ? "timeseries" : messageType),
origin,
true,
1));
}
public void Map_ContentType_ReturnsWeight(DomainOrigin domainOrigin, int expectedWeight)
{
// arrange
var target = new WeightCalculatorDomainService();
// act
var actual = target.CalculateMaxWeight(domainOrigin);
// assert
Assert.Equal(new Weight(expectedWeight), actual);
}
public Bundle(
Uuid bundleId,
ActorId recipient,
DomainOrigin origin,
ContentType contentType,
IEnumerable <Uuid> notificationIds,
IEnumerable <string> documentTypes)
{
BundleId = bundleId;
Origin = origin;
ContentType = contentType;
Recipient = recipient;
NotificationIds = notificationIds;
DocumentTypes = documentTypes;
ProcessId = new ProcessId(bundleId, recipient);
}
public Weight CalculateMaxWeight(DomainOrigin domainOrigin)
{
switch (domainOrigin)
{
case DomainOrigin.Aggregations:
case DomainOrigin.TimeSeries:
case DomainOrigin.MeteringPoints:
case DomainOrigin.MarketRoles:
case DomainOrigin.Charges:
return(new Weight(50 * 1024));
case DomainOrigin.Unknown:
throw new InvalidOperationException($"Mapping of enum {nameof(DomainOrigin)}.{nameof(DomainOrigin.Unknown)} to type {nameof(Weight)} is undefined.");
default:
throw new ArgumentOutOfRangeException(nameof(domainOrigin), domainOrigin, null);
}
}
public DataAvailableNotification(
Uuid notificationId,
ActorId recipient,
ContentType contentType,
DomainOrigin origin,
SupportsBundling supportsBundling,
Weight weight,
SequenceNumber sequenceNumber,
DocumentType documentType)
{
NotificationId = notificationId;
Recipient = recipient;
ContentType = contentType;
Origin = origin;
SupportsBundling = supportsBundling;
Weight = weight;
SequenceNumber = sequenceNumber;
DocumentType = documentType;
}
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()));
}
private static IEnumerable <DataAvailableNotification> CreateInfinite(
ActorId recipient,
long initialSequenceNumber,
DomainOrigin domainOrigin = DomainOrigin.Charges,
string contentType = "default_content_type",
bool supportsBundling = true,
int weight = 1)
{
while (true)
{
yield return(new DataAvailableNotification(
new Uuid(Guid.NewGuid()),
recipient,
new ContentType(contentType),
domainOrigin,
new SupportsBundling(supportsBundling),
new Weight(weight),
new SequenceNumber(initialSequenceNumber++),
new DocumentType("RSM??")));
}
}
private string GetQueueName(DomainOrigin domainOrigin)
{
switch (domainOrigin)
{
case DomainOrigin.Charges:
return(_peekRequestConfig.ChargesQueue);
case DomainOrigin.TimeSeries:
return(_peekRequestConfig.TimeSeriesQueue);
case DomainOrigin.Aggregations:
return(_peekRequestConfig.AggregationsQueue);
case DomainOrigin.MarketRoles:
return(_peekRequestConfig.MarketRolesQueue);
case DomainOrigin.MeteringPoints:
return(_peekRequestConfig.MeteringPointsQueue);
default:
throw new ArgumentOutOfRangeException(nameof(domainOrigin), domainOrigin, null);
}
}
public static DataAvailableNotificationDto CreateOriginDto(DomainOrigin origin, string messageType, string recipient)
{
var dto = CreateDto(origin, messageType, recipient);
return(dto);
}
private static DataAvailableNotificationDto CreateDto(DomainOrigin origin, string messageType, string recipient)
{
var msgDto = DataAvailableNotificationFactory.CreateOriginDto(origin, messageType, recipient);
return(msgDto);
}
public Task SendAsync(string correlationId, DequeueNotificationDto dequeueNotificationDto, DomainOrigin domainOrigin)
{
ArgumentNullException.ThrowIfNull(dequeueNotificationDto, nameof(dequeueNotificationDto));
var queueName = GetQueueName(domainOrigin);
var serviceBusSender = _messageBusFactory.GetSenderClient(queueName);
#pragma warning disable CS0618
var marketOperator = dequeueNotificationDto.MarketOperator is LegacyActorIdDto legacyActorIdDto
#pragma warning restore CS0618
? legacyActorIdDto.LegacyValue
: dequeueNotificationDto.MarketOperator.Value.ToString();
var contract = new DequeueContract
{
DataAvailableNotificationReferenceId = dequeueNotificationDto.DataAvailableNotificationReferenceId,
MarketOperator = marketOperator
};
var dequeueMessage = new ServiceBusMessage(new BinaryData(contract.ToByteArray()))
.AddDequeueIntegrationEvents(correlationId);
return(serviceBusSender.PublishMessageAsync <ServiceBusMessage>(dequeueMessage));
}
