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));
}
public ServerConnectFlow(IMqttAuthenticationProvider authenticationProvider,
IRepository <ClientSession> sessionRepository,
IRepository <ConnectionWill> willRepository,
IPublishSenderFlow senderFlow)
{
this.authenticationProvider = authenticationProvider;
this.sessionRepository = sessionRepository;
this.willRepository = willRepository;
this.senderFlow = senderFlow;
}
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 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;
}
public ClientConnectFlow(IRepository <ClientSession> sessionRepository,
IPublishSenderFlow senderFlow)
{
_sessionRepository = sessionRepository;
_senderFlow = senderFlow;
}
