internal MqttConnectedClient(IMqttChannel <IPacket> packetChannel,
IProtocolFlowProvider flowProvider,
IRepositoryProvider repositoryProvider,
IPacketIdProvider packetIdProvider,
MqttConfiguration configuration)
: base(packetChannel, flowProvider, repositoryProvider, packetIdProvider, configuration)
{
}
public async Task when_subscribing_topic_with_retain_message_then_retained_is_sent()
{
MqttConfiguration configuration = new MqttConfiguration {
MaximumQualityOfService = MqttQualityOfService.AtLeastOnce
};
Mock <IMqttTopicEvaluator> topicEvaluator = new Mock <IMqttTopicEvaluator>();
Mock <IRepository <ClientSession> > sessionRepository = new Mock <IRepository <ClientSession> >();
IPacketIdProvider packetIdProvider = Mock.Of <IPacketIdProvider>();
Mock <IRepository <RetainedMessage> > retainedMessageRepository = new Mock <IRepository <RetainedMessage> >();
Mock <IPublishSenderFlow> senderFlow = new Mock <IPublishSenderFlow>();
string clientId = Guid.NewGuid().ToString();
ClientSession session = new ClientSession(clientId, clean: false);
sessionRepository.Setup(r => r.Read(It.IsAny <string>())).Returns(session);
MqttQualityOfService fooQoS = MqttQualityOfService.AtLeastOnce;
string fooTopic = "test/foo/#";
Subscription fooSubscription = new Subscription(fooTopic, fooQoS);
string retainedTopic = "test/foo/bar";
MqttQualityOfService retainedQoS = MqttQualityOfService.ExactlyOnce;
byte[] retainedPayload = Encoding.UTF8.GetBytes("Retained Message Test");
List <RetainedMessage> retainedMessages = new List <RetainedMessage> {
new RetainedMessage(retainedTopic, retainedQoS, retainedPayload)
};
topicEvaluator.Setup(e => e.IsValidTopicFilter(It.IsAny <string>())).Returns(true);
topicEvaluator.Setup(e => e.Matches(It.IsAny <string>(), It.IsAny <string>())).Returns(true);
retainedMessageRepository.Setup(r => r.ReadAll()).Returns(retainedMessages.AsQueryable());
ushort packetId = (ushort)new Random().Next(0, ushort.MaxValue);
Subscribe subscribe = new Subscribe(packetId, fooSubscription);
Mock <IMqttChannel <IPacket> > channel = new Mock <IMqttChannel <IPacket> >();
Mock <IConnectionProvider> connectionProvider = new Mock <IConnectionProvider>();
connectionProvider
.Setup(p => p.GetConnection(It.Is <string>(c => c == clientId)))
.Returns(channel.Object);
ServerSubscribeFlow flow = new ServerSubscribeFlow(topicEvaluator.Object,
sessionRepository.Object, retainedMessageRepository.Object,
packetIdProvider, senderFlow.Object, configuration);
await flow.ExecuteAsync(clientId, subscribe, channel.Object);
senderFlow.Verify(f => f.SendPublishAsync(It.Is <string>(s => s == clientId),
It.Is <Publish>(p => p.Topic == retainedTopic &&
p.QualityOfService == fooQoS &&
p.Payload.ToList().SequenceEqual(retainedPayload) &&
p.PacketId.HasValue &&
p.Retain),
It.Is <IMqttChannel <IPacket> >(c => c == channel.Object),
It.Is <PendingMessageStatus>(x => x == PendingMessageStatus.PendingToSend)));
}
public async Task when_subscribing_new_topics_then_subscriptions_are_created_and_ack_is_sent()
{
MqttConfiguration configuration = new MqttConfiguration {
MaximumQualityOfService = MqttQualityOfService.AtLeastOnce
};
Mock <IMqttTopicEvaluator> topicEvaluator = new Mock <IMqttTopicEvaluator>();
Mock <IRepository <ClientSession> > sessionRepository = new Mock <IRepository <ClientSession> >();
IPacketIdProvider packetIdProvider = Mock.Of <IPacketIdProvider>();
IRepository <RetainedMessage> retainedMessageRepository = Mock.Of <IRepository <RetainedMessage> >();
IPublishSenderFlow senderFlow = Mock.Of <IPublishSenderFlow>();
string clientId = Guid.NewGuid().ToString();
ClientSession session = new ClientSession(clientId, clean: false);
topicEvaluator.Setup(e => e.IsValidTopicFilter(It.IsAny <string>())).Returns(true);
sessionRepository.Setup(r => r.Read(It.IsAny <string>())).Returns(session);
MqttQualityOfService fooQoS = MqttQualityOfService.AtLeastOnce;
string fooTopic = "test/foo/1";
Subscription fooSubscription = new Subscription(fooTopic, fooQoS);
MqttQualityOfService barQoS = MqttQualityOfService.AtMostOnce;
string barTopic = "test/bar/1";
Subscription barSubscription = new Subscription(barTopic, barQoS);
ushort packetId = (ushort)new Random().Next(0, ushort.MaxValue);
Subscribe subscribe = new Subscribe(packetId, fooSubscription, barSubscription);
Mock <IMqttChannel <IPacket> > channel = new Mock <IMqttChannel <IPacket> >();
IPacket response = default;
channel.Setup(c => c.SendAsync(It.IsAny <IPacket>()))
.Callback <IPacket>(p => response = p)
.Returns(Task.Delay(0));
Mock <IConnectionProvider> connectionProvider = new Mock <IConnectionProvider>();
connectionProvider
.Setup(p => p.GetConnection(It.Is <string>(c => c == clientId)))
.Returns(channel.Object);
ServerSubscribeFlow flow = new ServerSubscribeFlow(topicEvaluator.Object, sessionRepository.Object,
retainedMessageRepository, packetIdProvider, senderFlow, configuration);
await flow.ExecuteAsync(clientId, subscribe, channel.Object);
sessionRepository.Verify(r => r.Update(It.Is <ClientSession>(s => s.Id == clientId && s.Subscriptions.Count == 2 &&
s.Subscriptions.All(x => x.TopicFilter == fooTopic || x.TopicFilter == barTopic))));
Assert.NotNull(response);
SubscribeAck subscribeAck = response as SubscribeAck;
Assert.NotNull(subscribeAck);
packetId.Should().Be(subscribeAck.PacketId);
2.Should().Be(subscribeAck.ReturnCodes.Count());
Assert.True(subscribeAck.ReturnCodes.Any(c => c == SubscribeReturnCode.MaximumQoS0));
Assert.True(subscribeAck.ReturnCodes.Any(c => c == SubscribeReturnCode.MaximumQoS1));
}
internal MqttClientImpl(IPacketChannelFactory channelFactory,
IProtocolFlowProvider flowProvider,
IRepositoryProvider repositoryProvider,
IPacketIdProvider packetIdProvider,
MqttConfiguration configuration)
{
receiver = new Subject <MqttApplicationMessage>();
this.channelFactory = channelFactory;
this.flowProvider = flowProvider;
sessionRepository = repositoryProvider.GetRepository <ClientSession>();
this.packetIdProvider = packetIdProvider;
this.configuration = configuration;
clientSender = TaskRunner.Get();
}
public ServerSubscribeFlow(IMqttTopicEvaluator topicEvaluator,
IRepository <ClientSession> sessionRepository,
IRepository <RetainedMessage> retainedRepository,
IPacketIdProvider packetIdProvider,
IPublishSenderFlow senderFlow,
MqttConfiguration configuration)
{
_topicEvaluator = topicEvaluator;
_sessionRepository = sessionRepository;
_retainedRepository = retainedRepository;
_packetIdProvider = packetIdProvider;
_senderFlow = senderFlow;
_configuration = configuration;
}
public ServerProtocolFlowProvider(IMqttAuthenticationProvider authenticationProvider,
IConnectionProvider connectionProvider,
IMqttTopicEvaluator topicEvaluator,
IRepositoryProvider repositoryProvider,
IPacketIdProvider packetIdProvider,
ISubject <MqttUndeliveredMessage> undeliveredMessagesListener,
MqttConfiguration configuration)
: base(topicEvaluator, repositoryProvider, configuration)
{
_authenticationProvider = authenticationProvider;
_connectionProvider = connectionProvider;
_packetIdProvider = packetIdProvider;
_undeliveredMessagesListener = undeliveredMessagesListener;
}
public ServerPublishReceiverFlow(IMqttTopicEvaluator topicEvaluator,
IConnectionProvider connectionProvider,
IPublishSenderFlow senderFlow,
IRepository <RetainedMessage> retainedRepository,
IRepository <ClientSession> sessionRepository,
IRepository <ConnectionWill> willRepository,
IPacketIdProvider packetIdProvider,
ISubject <MqttUndeliveredMessage> undeliveredMessagesListener,
MqttConfiguration configuration)
: base(topicEvaluator, retainedRepository, sessionRepository, configuration)
{
_connectionProvider = connectionProvider;
_senderFlow = senderFlow;
_willRepository = willRepository;
_packetIdProvider = packetIdProvider;
_undeliveredMessagesListener = undeliveredMessagesListener;
}
internal MqttClientImpl(IMqttChannel <IPacket> packetChannel,
IProtocolFlowProvider flowProvider,
IRepositoryProvider repositoryProvider,
IPacketIdProvider packetIdProvider,
MqttConfiguration configuration)
{
receiver = new ReplaySubject <MqttApplicationMessage> (window: TimeSpan.FromSeconds(configuration.WaitTimeoutSecs));
sender = new ReplaySubject <IPacket> (window: TimeSpan.FromSeconds(configuration.WaitTimeoutSecs));
this.packetChannel = packetChannel;
this.flowProvider = flowProvider;
sessionRepository = repositoryProvider.GetRepository <ClientSession> ();
this.packetIdProvider = packetIdProvider;
this.configuration = configuration;
clientSender = TaskRunner.Get();
packetListener = new ClientPacketListener(packetChannel, flowProvider, configuration);
packetListener.Listen();
ObservePackets();
}
