protected override async Task ProcessPublishAsync(Publish publish, string clientId)
{
if (publish.Retain)
{
var existingRetainedMessage = retainedRepository.Get(r => r.Topic == publish.Topic);
if (existingRetainedMessage != null)
{
retainedRepository.Delete(existingRetainedMessage);
}
if (publish.Payload.Length > 0)
{
var retainedMessage = new RetainedMessage {
Topic = publish.Topic,
QualityOfService = publish.QualityOfService,
Payload = publish.Payload
};
retainedRepository.Create(retainedMessage);
}
}
await DispatchAsync(publish, clientId)
.ConfigureAwait(continueOnCapturedContext: false);
}
public async Task when_sending_publish_with_retain_then_retain_message_is_replaced()
{
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 = new Mock <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 topic = "foo/bar";
var sessions = new List <ClientSession> {
new ClientSession {
ClientId = Guid.NewGuid().ToString(), Clean = false
}
};
var existingRetainedMessage = new RetainedMessage();
retainedRepository.Setup(r => r.Get(It.IsAny <Expression <Func <RetainedMessage, bool> > >())).Returns(existingRetainedMessage);
sessionRepository.Setup(r => r.GetAll(It.IsAny <Expression <Func <ClientSession, bool> > > ())).Returns(sessions.AsQueryable());
var qos = MqttQualityOfService.AtMostOnce;
var payload = "Publish Flow Test";
var publish = new Publish(topic, qos, retain: true, duplicated: false);
publish.Payload = Encoding.UTF8.GetBytes(payload);
var receiver = new Subject <IPacket> ();
var channel = new Mock <IMqttChannel <IPacket> > ();
channel.Setup(c => c.ReceiverStream).Returns(receiver);
var flow = new ServerPublishReceiverFlow(topicEvaluator.Object, connectionProvider.Object, publishSenderFlow.Object,
retainedRepository.Object, sessionRepository.Object, willRepository.Object, packetIdProvider, undeliveredMessagesListener, configuration);
await flow.ExecuteAsync(clientId, publish, channel.Object)
.ConfigureAwait(continueOnCapturedContext: false);
retainedRepository.Verify(r => r.Delete(It.Is <RetainedMessage> (m => m == existingRetainedMessage)));
retainedRepository.Verify(r => r.Create(It.Is <RetainedMessage> (m => m.Topic == topic && m.QualityOfService == qos && m.Payload.ToList().SequenceEqual(publish.Payload))));
channel.Verify(c => c.SendAsync(It.IsAny <IPacket> ()), Times.Never);
}
protected override async Task ProcessPublishAsync(Publish publish, string clientId)
{
if (publish.Retain)
{
RetainedMessage existingRetainedMessage = retainedRepository.Read(publish.Topic);
if (existingRetainedMessage != null)
{
retainedRepository.Delete(existingRetainedMessage.Id);
}
if (publish.Payload != null && publish.Payload.Length > 0)
{
RetainedMessage retainedMessage = new RetainedMessage(publish.Topic,
publish.QualityOfService,
publish.Payload);
retainedRepository.Create(retainedMessage);
}
}
await DispatchAsync(publish, clientId);
}
