public async Task when_sending_disconnect_and_client_session_has_persistent_state_then_disconnects_and_preserves_session()
{
var connectionProvider = new Mock <IConnectionProvider> ();
var sessionRepository = new Mock <IRepository <ClientSession> >();
var willRepository = new Mock <IRepository <ConnectionWill> > ();
var flow = new DisconnectFlow(connectionProvider.Object, sessionRepository.Object, willRepository.Object);
var clientId = Guid.NewGuid().ToString();
var channel = new Mock <IMqttChannel <IPacket> > ();
var disconnect = new Disconnect();
var session = new ClientSession
{
ClientId = clientId,
Clean = false
};
connectionProvider
.Setup(p => p.GetConnection(It.Is <string> (c => c == clientId)))
.Returns(channel.Object);
sessionRepository.Setup(r => r.Get(It.IsAny <Expression <Func <ClientSession, bool> > >())).Returns(session);
await flow.ExecuteAsync(clientId, disconnect, channel.Object)
.ConfigureAwait(continueOnCapturedContext: false);
willRepository.Verify(r => r.Delete(It.IsAny <Expression <Func <ConnectionWill, bool> > > ()));
sessionRepository.Verify(r => r.Delete(It.Is <ClientSession>(s => s == session)), Times.Never);
}
public async Task when_sending_disconnect_and_client_session_has_persistent_state_then_disconnects_and_preserves_session()
{
Mock <IConnectionProvider> connectionProvider = new Mock <IConnectionProvider>();
Mock <IRepository <ClientSession> > sessionRepository = new Mock <IRepository <ClientSession> >();
Mock <IRepository <ConnectionWill> > willRepository = new Mock <IRepository <ConnectionWill> >();
DisconnectFlow flow = new DisconnectFlow(connectionProvider.Object, sessionRepository.Object, willRepository.Object);
string clientId = Guid.NewGuid().ToString();
Mock <IMqttChannel <IPacket> > channel = new Mock <IMqttChannel <IPacket> >();
Disconnect disconnect = new Disconnect();
ClientSession session = new ClientSession(clientId, clean: false);
connectionProvider
.Setup(p => p.GetConnection(It.Is <string>(c => c == clientId)))
.Returns(channel.Object);
sessionRepository.Setup(r => r.Read(It.IsAny <string>())).Returns(session);
await flow.ExecuteAsync(clientId, disconnect, channel.Object);
willRepository.Verify(r => r.Delete(It.IsAny <string>()));
sessionRepository.Verify(r => r.Delete(It.Is <string>(s => s == session.Id)), Times.Never);
}
public async Task when_sending_disconnect_and_client_session_has_clean_state_then_disconnects_and_delete_will_and_session()
{
var connectionProvider = new Mock <IConnectionProvider> ();
var sessionRepository = new Mock <IRepository <ClientSession> >();
var willRepository = new Mock <IRepository <ConnectionWill> > ();
var flow = new DisconnectFlow(connectionProvider.Object, sessionRepository.Object, willRepository.Object);
var clientId = Guid.NewGuid().ToString();
var channel = new Mock <IMqttChannel <IPacket> > ();
var disconnect = new Disconnect();
var session = new ClientSession(clientId, clean: true);
connectionProvider
.Setup(p => p.GetConnection(It.Is <string> (c => c == clientId)))
.Returns(channel.Object);
sessionRepository.Setup(r => r.Read(It.IsAny <string>())).Returns(session);
await flow.ExecuteAsync(clientId, disconnect, channel.Object)
.ConfigureAwait(continueOnCapturedContext: false);
willRepository.Verify(r => r.Delete(It.IsAny <string> ()));
sessionRepository.Verify(r => r.Delete(It.Is <string>(s => s == session.Id)));
}
public void when_getting_explicit_server_flow_from_type_then_succeeds()
{
IMqttAuthenticationProvider authenticationProvider = Mock.Of <IMqttAuthenticationProvider>(p => p.Authenticate(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()) == true);
ServerProtocolFlowProvider flowProvider = new ServerProtocolFlowProvider(authenticationProvider, Mock.Of <IConnectionProvider>(), Mock.Of <IMqttTopicEvaluator>(),
Mock.Of <IRepositoryProvider>(), Mock.Of <IPacketIdProvider>(), Mock.Of <ISubject <MqttUndeliveredMessage> >(), new MqttConfiguration());
ServerConnectFlow connectFlow = flowProvider.GetFlow <ServerConnectFlow>();
PublishSenderFlow senderFlow = flowProvider.GetFlow <PublishSenderFlow>();
ServerPublishReceiverFlow receiverFlow = flowProvider.GetFlow <ServerPublishReceiverFlow>();
ServerSubscribeFlow subscribeFlow = flowProvider.GetFlow <ServerSubscribeFlow>();
ServerUnsubscribeFlow unsubscribeFlow = flowProvider.GetFlow <ServerUnsubscribeFlow>();
DisconnectFlow disconnectFlow = flowProvider.GetFlow <DisconnectFlow>();
Assert.NotNull(connectFlow);
Assert.NotNull(senderFlow);
Assert.NotNull(receiverFlow);
Assert.NotNull(subscribeFlow);
Assert.NotNull(unsubscribeFlow);
Assert.NotNull(disconnectFlow);
}
