async Task HandlePublishReleaseAsync(string clientId, PublishRelease publishRelease, IMqttChannel <IPacket> channel)
{
RemovePendingAcknowledgement(clientId, publishRelease.PacketId, MqttPacketType.PublishReceived);
await SendAckAsync(clientId, new PublishComplete (publishRelease.PacketId), channel)
.ConfigureAwait(continueOnCapturedContext: false);
}
public async Task when_writing_publish_release_packet_then_succeeds(string jsonPath, string packetPath)
{
jsonPath = Path.Combine(Environment.CurrentDirectory, jsonPath);
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
byte[] expectedPacket = Packet.ReadAllBytes(packetPath);
FlowPacketFormatter <PublishRelease> formatter = new FlowPacketFormatter <PublishRelease>(MqttPacketType.PublishRelease, id => new PublishRelease(id));
PublishRelease publishRelease = Packet.ReadPacket <PublishRelease>(jsonPath);
byte[] result = await formatter.FormatAsync(publishRelease);
expectedPacket.Should().BeEquivalentTo(result);
}
public override async Task ExecuteAsync(string clientId, IPacket input, IMqttChannel <IPacket> channel)
{
if (input.Type == MqttPacketType.Publish)
{
Publish publish = input as Publish;
await HandlePublishAsync(clientId, publish, channel);
}
else if (input.Type == MqttPacketType.PublishRelease)
{
PublishRelease publishRelease = input as PublishRelease;
await HandlePublishReleaseAsync(clientId, publishRelease, channel);
}
}
async Task SendPendingAcknowledgementsAsync(ClientSession session, IMqttChannel <IPacket> channel)
{
foreach (PendingAcknowledgement pendingAcknowledgement in session.GetPendingAcknowledgements())
{
IFlowPacket ack = default;
if (pendingAcknowledgement.Type == MqttPacketType.PublishReceived)
{
ack = new PublishReceived(pendingAcknowledgement.PacketId);
}
else if (pendingAcknowledgement.Type == MqttPacketType.PublishRelease)
{
ack = new PublishRelease(pendingAcknowledgement.PacketId);
}
await _senderFlow.SendAckAsync(session.Id, ack, channel);
}
}
async Task SendPendingAcknowledgementsAsync(ClientSession session, IMqttChannel <IPacket> channel)
{
foreach (var pendingAcknowledgement in session.GetPendingAcknowledgements())
{
var ack = default(IFlowPacket);
if (pendingAcknowledgement.Type == MqttPacketType.PublishReceived)
{
ack = new PublishReceived(pendingAcknowledgement.PacketId);
}
else if (pendingAcknowledgement.Type == MqttPacketType.PublishRelease)
{
ack = new PublishRelease(pendingAcknowledgement.PacketId);
}
await senderFlow.SendAckAsync(session.ClientId, ack, channel, PendingMessageStatus.PendingToAcknowledge)
.ConfigureAwait(continueOnCapturedContext: false);
}
}
public async Task when_sending_publish_release_then_publish_complete_is_sent()
{
var clientId = Guid.NewGuid().ToString();
var configuration = Mock.Of <MqttConfiguration> ();
var topicEvaluator = new Mock <IMqttTopicEvaluator> ();
var connectionProvider = new Mock <IConnectionProvider> ();
var publishSenderFlow = new Mock <IPublishSenderFlow> ();
var retainedRepository = Mock.Of <IRepository <RetainedMessage> > ();
var sessionRepository = new Mock <IRepository <ClientSession> > ();
var willRepository = new Mock <IRepository <ConnectionWill> >();
sessionRepository.Setup(r => r.Get(It.IsAny <Expression <Func <ClientSession, bool> > > ()))
.Returns(new ClientSession {
ClientId = clientId,
PendingMessages = new List <PendingMessage> {
new PendingMessage()
}
});
var packetIdProvider = Mock.Of <IPacketIdProvider> ();
var undeliveredMessagesListener = new Subject <MqttUndeliveredMessage> ();
var flow = new ServerPublishReceiverFlow(topicEvaluator.Object, connectionProvider.Object, publishSenderFlow.Object,
retainedRepository, sessionRepository.Object, willRepository.Object, packetIdProvider, undeliveredMessagesListener, configuration);
var packetId = (ushort)new Random().Next(0, ushort.MaxValue);
var publishRelease = new PublishRelease(packetId);
var channel = new Mock <IMqttChannel <IPacket> > ();
channel.Setup(c => c.IsConnected).Returns(true);
await flow.ExecuteAsync(clientId, publishRelease, channel.Object)
.ConfigureAwait(continueOnCapturedContext: false);
channel.Verify(c => c.SendAsync(It.Is <IPacket> (p => p is PublishComplete && (p as PublishComplete).PacketId == packetId)));
}
async Task HandlePublishReleaseAsync(string clientId, PublishRelease publishRelease, IMqttChannel <IPacket> channel)
{
RemovePendingAcknowledgement(clientId, publishRelease.PacketId, MqttPacketType.PublishReceived);
await SendAckAsync(clientId, new PublishComplete( publishRelease.PacketId ), channel);
}
