protected override void SetupMocks()
{
var seq = new MockSequence();
SessionMock.InSequence(seq).Setup(p => p.RegisterMessage("SSH_MSG_USERAUTH_FAILURE"));
SessionMock.InSequence(seq).Setup(p => p.RegisterMessage("SSH_MSG_USERAUTH_SUCCESS"));
SessionMock.InSequence(seq).Setup(p => p.RegisterMessage("SSH_MSG_USERAUTH_BANNER"));
ConnectionInfoMock.InSequence(seq).Setup(p => p.CreateNoneAuthenticationMethod())
.Returns(NoneAuthenticationMethodMock.Object);
NoneAuthenticationMethodMock.InSequence(seq).Setup(p => p.Authenticate(SessionMock.Object))
.Returns(AuthenticationResult.Failure);
ConnectionInfoMock.InSequence(seq).Setup(p => p.AuthenticationMethods)
.Returns(new List <IAuthenticationMethod>
{
PublicKeyAuthenticationMethodMock.Object,
PasswordAuthenticationMethodMock.Object
});
NoneAuthenticationMethodMock.InSequence(seq)
.Setup(p => p.AllowedAuthentications)
.Returns(new[] { "password" });
PublicKeyAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("publickey");
PasswordAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("password");
PasswordAuthenticationMethodMock.InSequence(seq).Setup(p => p.Authenticate(SessionMock.Object))
.Returns(AuthenticationResult.Failure);
// obtain name for inclusion in SshAuthenticationException
PasswordAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("password");
SessionMock.InSequence(seq).Setup(p => p.UnRegisterMessage("SSH_MSG_USERAUTH_FAILURE"));
SessionMock.InSequence(seq).Setup(p => p.UnRegisterMessage("SSH_MSG_USERAUTH_SUCCESS"));
SessionMock.InSequence(seq).Setup(p => p.UnRegisterMessage("SSH_MSG_USERAUTH_BANNER"));
}
public async Task Index_Success(int categoryId, int productsCount)
{
//Arrange
var productServiceMock = new ProductServiceMock();
var cookieProviderMock = new CookieProviderMock(categoryId);
var sessionMock = new SessionMock();
var context = new DefaultHttpContext
{
Session = sessionMock.Object
};
var controller = new ShopController(productServiceMock.Object, cookieProviderMock.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = context
}
};
//Act
var result = await controller.Index();
//Assert
var view = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ShopPageViewModel>(view.Model);
Assert.Equal(productsCount, model.Products.Count);
Assert.Equal(4, model.Categories.Count);
Assert.Equal(categoryId, model.CategoryId);
}
protected override void SetupMocks()
{
_sequence = new MockSequence();
SessionMock.InSequence(_sequence).Setup(p => p.ConnectionInfo).Returns(ConnectionInfoMock.Object);
ConnectionInfoMock.InSequence(_sequence).Setup(p => p.RetryAttempts).Returns(1);
SessionMock.Setup(p => p.SessionSemaphore).Returns(_sessionSemaphore);
SessionMock.InSequence(_sequence)
.Setup(
p =>
p.SendMessage(
It.Is <ChannelOpenMessage>(
m =>
m.LocalChannelNumber == _localChannelNumber &&
m.InitialWindowSize == _localWindowSize && m.MaximumPacketSize == _localPacketSize &&
m.Info is SessionChannelOpenInfo)));
SessionMock.InSequence(_sequence)
.Setup(p => p.WaitOnHandle(It.IsNotNull <WaitHandle>()))
.Callback <WaitHandle>(
w =>
{
SessionMock.Raise(
s => s.ChannelOpenConfirmationReceived += null,
new MessageEventArgs <ChannelOpenConfirmationMessage>(
new ChannelOpenConfirmationMessage(
_localChannelNumber,
_remoteWindowSize,
_remotePacketSize,
_remoteChannelNumber)));
w.WaitOne();
});
SessionMock.Setup(p => p.IsConnected).Returns(false);
}
public void Send_TcpServiceSendCalled_NotThrows()
{
var task = Task.Delay(1);
const ulong SendMessageId = 1234;
var mTcpService = TcpServiceMock.Create().BuildSend(returnTask: () => task);
this.RegisterMock(mTcpService);
var seqNo = 1;
var mSession = SessionMock.Create()
.BuildGenerateMessageSeqNo(confirm => Tuple.Create(SendMessageId, seqNo));
var mClientSettings = ClientSettingsMock.Create().AttachSession(() => mSession.Object);
this.RegisterMock(mClientSettings);
this.RegisterType <TcpTransport>();
// ---
var transport = this.Resolve <TcpTransport>();
transport.Send(new byte[1]);
Thread.Sleep(1000);
// --
mTcpService.Verify(service => service.Send(It.IsAny <byte[]>()), Times.Once);
}
protected override void SetupMocks()
{
var sequence = new MockSequence();
SessionMock.InSequence(sequence).Setup(p => p.IsConnected).Returns(true);
SessionMock.InSequence(sequence).Setup(p => p.TrySendMessage(It.Is <ChannelEofMessage>(c => c.LocalChannelNumber == _remoteChannelNumber))).Returns(true);
SessionMock.InSequence(sequence).Setup(p => p.IsConnected).Returns(true);
SessionMock.InSequence(sequence).Setup(p => p.TrySendMessage(It.Is <ChannelCloseMessage>(c => c.LocalChannelNumber == _remoteChannelNumber))).Returns(true);
SessionMock.InSequence(sequence).Setup(p => p.ConnectionInfo).Returns(ConnectionInfoMock.Object);
ConnectionInfoMock.InSequence(sequence).Setup(p => p.ChannelCloseTimeout).Returns(_channelCloseTimeout);
SessionMock.InSequence(sequence)
.Setup(p => p.TryWait(It.IsAny <EventWaitHandle>(), _channelCloseTimeout))
.Callback <WaitHandle, TimeSpan>((waitHandle, channelCloseTimeout) =>
{
new Thread(() =>
{
Thread.Sleep(100);
// raise ChannelCloseReceived event to set waithandle for receiving
// SSH_MSG_CHANNEL_CLOSE message from server which is waited on after
// sending the SSH_MSG_CHANNEL_CLOSE message to the server
SessionMock.Raise(s => s.ChannelCloseReceived += null,
new MessageEventArgs <ChannelCloseMessage>(new ChannelCloseMessage(_localChannelNumber)));
}).Start();
_closeTimer.Start();
try
{
waitHandle.WaitOne();
}
finally
{
_closeTimer.Stop();
}
})
.Returns(WaitResult.Success);
}
public void SendAndRecive_SimpleCall_NotThrows()
{
var sendData = new byte[] { 123, 214 };
const long SendMessageId = 1234;
var receiveData = new byte[] { 123, 214 };
const long ReciveMessageId = 12;
const long AuthKeyId = 12123123;
var mTcpTransport = TcpTransportMock.Create();
AddSendHandler(mTcpTransport, SendMessageId, sendData);
AddReceiveHandler(mTcpTransport, AuthKeyId, ReciveMessageId, receiveData);
this.RegisterMock(mTcpTransport);
var mSession = SessionMock.Create().BuildGenerateMesId(() => SendMessageId);
var mClientSettings = ClientSettingsMock.Create().AttachSession(() => mSession.Object);
this.RegisterMock(mClientSettings);
this.RegisterType <MtProtoPlainSender>();
// ---
var mtProtoPlainSender = this.Resolve <MtProtoPlainSender>();
var sendTask = mtProtoPlainSender.SendAndReceive(sendData);
// --
Assert.Equal(receiveData, sendTask.Result);
mTcpTransport.Verify(transport => transport.Send(It.IsAny <byte[]>()), Times.Once);
}
protected override void SetupMocks()
{
var sequence = new MockSequence();
SessionMock.InSequence(sequence).Setup(p => p.IsConnected).Returns(true);
SessionMock.InSequence(sequence).Setup(p => p.TrySendMessage(It.Is <ChannelCloseMessage>(c => c.LocalChannelNumber == _remoteChannelNumber))).Returns(true);
SessionMock.InSequence(sequence).Setup(p => p.ConnectionInfo).Returns(ConnectionInfoMock.Object);
ConnectionInfoMock.InSequence(sequence).Setup(p => p.ChannelCloseTimeout).Returns(_channelCloseTimeout);
SessionMock.InSequence(sequence).Setup(p => p.TryWait(It.IsAny <EventWaitHandle>(), _channelCloseTimeout)).Returns(WaitResult.TimedOut);
}
protected override void SetupMocks()
{
var seq = new MockSequence();
SessionMock.InSequence(seq).Setup(p => p.RegisterMessage("SSH_MSG_USERAUTH_FAILURE"));
SessionMock.InSequence(seq).Setup(p => p.RegisterMessage("SSH_MSG_USERAUTH_SUCCESS"));
SessionMock.InSequence(seq).Setup(p => p.RegisterMessage("SSH_MSG_USERAUTH_BANNER"));
ConnectionInfoMock.InSequence(seq).Setup(p => p.CreateNoneAuthenticationMethod())
.Returns(NoneAuthenticationMethodMock.Object);
/* 1 */
NoneAuthenticationMethodMock.InSequence(seq).Setup(p => p.Authenticate(SessionMock.Object))
.Returns(AuthenticationResult.Failure);
ConnectionInfoMock.InSequence(seq).Setup(p => p.AuthenticationMethods)
.Returns(new List <IAuthenticationMethod>
{
PasswordAuthenticationMethodMock.Object,
PublicKeyAuthenticationMethodMock.Object,
KeyboardInteractiveAuthenticationMethodMock.Object,
});
NoneAuthenticationMethodMock.InSequence(seq)
.Setup(p => p.AllowedAuthentications)
.Returns(new[] { "publickey", "password" });
/* Enumerate supported authentication methods */
PasswordAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("password");
PublicKeyAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("publickey");
KeyboardInteractiveAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("keyboard-interactive");
/* 2 */
PasswordAuthenticationMethodMock.InSequence(seq).Setup(p => p.Authenticate(SessionMock.Object))
.Returns(AuthenticationResult.PartialSuccess);
PasswordAuthenticationMethodMock.InSequence(seq).Setup(p => p.AllowedAuthentications)
.Returns(new[] { "keyboard-interactive", "publickey" });
/* Enumerate supported authentication methods */
PasswordAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("password");
PublicKeyAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("publickey");
KeyboardInteractiveAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("keyboard-interactive");
/* 3 */
PublicKeyAuthenticationMethodMock.InSequence(seq)
.Setup(p => p.Authenticate(SessionMock.Object))
.Returns(AuthenticationResult.Success);
SessionMock.InSequence(seq).Setup(p => p.UnRegisterMessage("SSH_MSG_USERAUTH_FAILURE"));
SessionMock.InSequence(seq).Setup(p => p.UnRegisterMessage("SSH_MSG_USERAUTH_SUCCESS"));
SessionMock.InSequence(seq).Setup(p => p.UnRegisterMessage("SSH_MSG_USERAUTH_BANNER"));
}
protected override void SetupMocks()
{
var sequence = new MockSequence();
SessionMock.InSequence(sequence).Setup(p => p.ConnectionInfo).Returns(ConnectionInfoMock.Object);
ConnectionInfoMock.InSequence(sequence).Setup(p => p.RetryAttempts).Returns(1);
SessionMock.Setup(p => p.SessionSemaphore).Returns(_sessionSemaphore);
SessionMock.InSequence(sequence)
.Setup(
p =>
p.SendMessage(
It.Is <ChannelOpenMessage>(
m =>
m.LocalChannelNumber == _localChannelNumber &&
m.InitialWindowSize == _localWindowSize && m.MaximumPacketSize == _localPacketSize &&
m.Info is SessionChannelOpenInfo)));
SessionMock.InSequence(sequence)
.Setup(p => p.WaitOnHandle(It.IsNotNull <WaitHandle>()))
.Callback <WaitHandle>(
w =>
{
SessionMock.Raise(
s => s.ChannelOpenConfirmationReceived += null,
new MessageEventArgs <ChannelOpenConfirmationMessage>(
new ChannelOpenConfirmationMessage(
_localChannelNumber,
_remoteWindowSize,
_remotePacketSize,
_remoteChannelNumber)));
w.WaitOne();
});
SessionMock.InSequence(sequence).Setup(p => p.IsConnected).Returns(true);
SessionMock.InSequence(sequence)
.Setup(
p => p.TrySendMessage(It.Is <ChannelEofMessage>(m => m.LocalChannelNumber == _remoteChannelNumber)))
.Returns(true);
SessionMock.InSequence(sequence).Setup(p => p.IsConnected).Returns(true);
SessionMock.InSequence(sequence)
.Setup(
p => p.TrySendMessage(It.Is <ChannelCloseMessage>(m => m.LocalChannelNumber == _remoteChannelNumber)))
.Returns(true);
SessionMock.InSequence(sequence).Setup(p => p.ConnectionInfo).Returns(ConnectionInfoMock.Object);
ConnectionInfoMock.InSequence(sequence).Setup(p => p.ChannelCloseTimeout).Returns(_channelCloseTimeout);
SessionMock.InSequence(sequence)
.Setup(p => p.TryWait(It.IsNotNull <WaitHandle>(), _channelCloseTimeout))
.Callback <WaitHandle, TimeSpan>(
(waitHandle, channelCloseTimeout) =>
{
SessionMock.Raise(
s => s.ChannelCloseReceived += null,
new MessageEventArgs <ChannelCloseMessage>(new ChannelCloseMessage(_localChannelNumber)));
waitHandle.WaitOne();
})
.Returns(WaitResult.Success);
}
private void SetupSessions()
{
this.dataStorageMock = new Mock <IDataStorage>();
this.sessionMock = new SessionMock();
this.dataStorageMock.Setup(x => x.NewSession()).Returns(() => this.sessionMock);
this.reportingMock = new Mock <IReporting>();
this.reportingSessionMock = new SessionMock();
this.reportingMock.Setup(x => x.NewSession()).Returns(() => this.reportingSessionMock);
}
protected override void SetupMocks()
{
var sequence = new MockSequence();
SessionMock.InSequence(sequence).Setup(p => p.IsConnected).Returns(true);
SessionMock.InSequence(sequence).Setup(p => p.TrySendMessage(It.Is <ChannelCloseMessage>(c => c.LocalChannelNumber == _remoteChannelNumber))).Returns(true);
SessionMock.InSequence(sequence).Setup(p => p.ConnectionInfo).Returns(ConnectionInfoMock.Object);
ConnectionInfoMock.InSequence(sequence).Setup(p => p.ChannelCloseTimeout).Returns(_channelCloseTimeout);
SessionMock.InSequence(sequence)
.Setup(p => p.TryWait(It.IsAny <EventWaitHandle>(), _channelCloseTimeout))
.Callback <WaitHandle, TimeSpan>((waitHandle, channelCloseTimeout) => _channelClosedWaitHandleSignaled = waitHandle.WaitOne(0))
.Returns(WaitResult.Success);
}
protected override void Arrange()
{
base.Arrange();
_channel = new ChannelSession(SessionMock.Object, _localChannelNumber, _localWindowSize, _localPacketSize);
_channel.Closed += (sender, args) => _channelClosedRegister.Add(args);
_channel.Exception += (sender, args) => _channelExceptionRegister.Add(args);
_channel.Open();
SessionMock.Raise(
p => p.ChannelCloseReceived += null,
new MessageEventArgs <ChannelCloseMessage>(new ChannelCloseMessage(_localChannelNumber)));
}
private static (AspNetSessionValueLayoutRenderer, HttpContext) CreateRenderer(bool throwsError = false)
{
var(renderer, httpContext) = CreateWithHttpContext();
var mockSession = new SessionMock(throwsError);
mockSession.SetString("a", "https://duckduckgo.com");
httpContext.Session = mockSession;
httpContext.Items = new Dictionary <object, object>();
var sessionFeature = new SessionFeatureMock(mockSession);
httpContext.Features.Get <ISessionFeature>().Returns(sessionFeature);
return(renderer, httpContext);
}
protected override void Arrange()
{
base.Arrange();
_channel = new ChannelStub(SessionMock.Object, _localChannelNumber, _localWindowSize, _localPacketSize);
_channel.Closed += (sender, args) => { _channelClosedRegister.Add(args); };
_channel.EndOfData += (sender, args) => _channelEndOfDataRegister.Add(args);
_channel.Exception += (sender, args) => _channelExceptionRegister.Add(args);
_channel.InitializeRemoteChannelInfo(_remoteChannelNumber, _remoteWindowSize, _remotePacketSize);
_channel.SetIsOpen(true);
SessionMock.Raise(
s => s.ChannelEofReceived += null,
new MessageEventArgs <ChannelEofMessage>(new ChannelEofMessage(_localChannelNumber)));
}
public async Task Send_SimpleCall_NotThrows()
{
const ulong SendMessageId = 1234;
var authKey = SessionMock.GenerateAuthKeyData();
ulong sessionId = 1231231;
ulong salt = 5432111;
var seqNo = 123;
var mSession = SessionMock.Create()
.BuildGenerateMessageSeqNo(confirm => Tuple.Create(SendMessageId, seqNo))
.BuildSession(sessionId, salt, authKey);
var request = new RequestPing();
var mTcpTransport = TcpTransportMock.Create();
AddSendHandler(mTcpTransport, request);
this.RegisterMock(mTcpTransport);
var mClientSettings = ClientSettingsMock.Create().AttachSession(() => mSession.Object);
this.RegisterMock(mClientSettings);
var mConfirmRecieve = ConfirmationRecieveServiceMock.Create()
.BuildWaitForConfirm(messageId =>
{
Assert.Equal(SendMessageId, messageId);
return(Task.FromResult(true));
});
this.RegisterMock(mConfirmRecieve);
this.RegisterType <MtProtoSendService>();
// ---
var mtProtoPlainSender = this.Resolve <MtProtoSendService>();
var sendResult = mtProtoPlainSender.Send(request);
await sendResult.Result.Item1;
// --
mTcpTransport.Verify(transport => transport.Send(It.IsAny <byte[]>()), Times.Once);
mConfirmRecieve.Verify(store => store.WaitForConfirm(It.IsAny <ulong>()), Times.Once);
}
protected override void SetupMocks()
{
var sequence = new MockSequence();
SessionMock.InSequence(sequence).Setup(p => p.ConnectionInfo).Returns(ConnectionInfoMock.Object);
ConnectionInfoMock.InSequence(sequence).Setup(p => p.RetryAttempts).Returns(2);
SessionMock.Setup(p => p.SessionSemaphore).Returns(_sessionSemaphore);
SessionMock.InSequence(sequence)
.Setup(
p =>
p.SendMessage(
It.Is <ChannelOpenMessage>(
m =>
m.LocalChannelNumber == _localChannelNumber &&
m.InitialWindowSize == _localWindowSize && m.MaximumPacketSize == _localPacketSize &&
m.Info is SessionChannelOpenInfo)));
SessionMock.InSequence(sequence)
.Setup(p => p.WaitOnHandle(It.IsNotNull <WaitHandle>()))
.Throws(_waitOnConfirmationException);
}
protected override void SetupMocks()
{
var sequence = new MockSequence();
SessionMock.InSequence(sequence).Setup(p => p.IsConnected).Returns(true);
SessionMock.InSequence(sequence).Setup(p => p.TrySendMessage(It.Is <ChannelCloseMessage>(c => c.LocalChannelNumber == _remoteChannelNumber))).Returns(true);
SessionMock.InSequence(sequence).Setup(p => p.ConnectionInfo).Returns(ConnectionInfoMock.Object);
ConnectionInfoMock.InSequence(sequence).Setup(p => p.ChannelCloseTimeout).Returns(_channelCloseTimeout);
SessionMock.InSequence(sequence)
.Setup(p => p.TryWait(It.IsAny <EventWaitHandle>(), _channelCloseTimeout))
.Callback <WaitHandle, TimeSpan>((waitHandle, channelCloseTimeout) =>
{
_raiseChannelCloseReceivedThread = new Thread(() =>
{
Thread.Sleep(100);
// signal that the ChannelCloseMessage was received; we use this to verify whether we've actually
// waited on the EventWaitHandle to be set; this needs to be set before we raise the ChannelCloseReceived
// to make sure the waithandle is signaled when the Dispose method completes (or else the assert that
// checks whether the handle has been signaled, will sometimes fail)
_channelClosedReceived.Set();
// raise ChannelCloseReceived event to set waithandle for receiving SSH_MSG_CHANNEL_CLOSE message
// from server which is waited on after sending the SSH_MSG_CHANNEL_CLOSE message to the server
//
// this will cause a new invocation of Close() that will block until the Close() that was invoked
// as part of Dispose() has released the lock; as such, this thread cannot be joined until that
// lock is released
//
// we're mocking the wait on the ChannelCloseMessage, but we still want
// to get the channel in the state that it would have after actually receiving
// the ChannelCloseMessage
SessionMock.Raise(s => s.ChannelCloseReceived += null, new MessageEventArgs <ChannelCloseMessage>(new ChannelCloseMessage(_localChannelNumber)));
});
_raiseChannelCloseReceivedThread.Start();
waitHandle.WaitOne();
})
.Returns(WaitResult.Success);
}
public void SendMessageOnSessionShouldNeverBeInvoked()
{
SessionMock.Verify(p => p.SendMessage(It.IsAny <Message>()), Times.Never);
}
public void Recieve_SimpleCall_NotThrows()
{
const long RequestMessageId = 1234;
var authKeyData = SessionMock.GenerateAuthKeyData();
const ulong sessionId = 123456;
const ulong salt = 654321;
uint[] rpcResponceCode = { 0xf35c6d01 };
var sendUser = new TDialog
{
ReadInboxMaxId = 132,
Peer = new TPeerUser {
UserId = 123
},
NotifySettings = new TPeerNotifySettingsEmpty(),
Draft = new TDraftMessageEmpty()
};
var mSession = SessionMock.Create().BuildSession(sessionId, salt, authKeyData);
this.RegisterMock(mSession);
var mClientSettings = ClientSettingsMock.Create().AttachSession(() => mSession.Object);
this.RegisterMock(mClientSettings);
var mTcpTransport = TcpTransportMock.Create().BuildReceieve(out var tsc);
this.RegisterMock(mTcpTransport);
var mConfrimSendService = ConfirmationSendServiceMock.Create().BuildAddForSend(messageId => Assert.Equal(RequestMessageId, messageId));
this.RegisterMock(mConfrimSendService);
var mRecieveHandler = RecieveHandlerMock.Create().BuildRecieveHandler(rpcResponceCode).BuildHandleResponce(
(code, reader) =>
{
Assert.Equal(RequestMessageId, reader.ReadInt64());
return(null);
});
this.RegisterMock(mRecieveHandler);
this.RegisterAdapterForHandler();
this.RegisterType <RecievingService>();
// ---
var rpcResult = new TRpcResult {
ReqMsgId = RequestMessageId, Result = sendUser
};
var recieveData = EncodePacket(Serializer.SerializeObject(rpcResult), RequestMessageId);
var mtProtoPlainSender = this.Resolve <RecievingService>();
mtProtoPlainSender.StartReceiving();
Thread.Sleep(500);
tsc.SetResult(recieveData);
Thread.Sleep(500);
// --
mRecieveHandler.Verify(recieveService => recieveService.HandleResponce(It.IsAny <BinaryReader>()), Times.Once);
mConfrimSendService.Verify(recieveService => recieveService.AddForSend(It.IsAny <long>()), Times.Once);
}
protected override void SetupMocks()
{
var seq = new MockSequence();
SessionMock.InSequence(seq).Setup(p => p.RegisterMessage("SSH_MSG_USERAUTH_FAILURE"));
SessionMock.InSequence(seq).Setup(p => p.RegisterMessage("SSH_MSG_USERAUTH_SUCCESS"));
SessionMock.InSequence(seq).Setup(p => p.RegisterMessage("SSH_MSG_USERAUTH_BANNER"));
ConnectionInfoMock.InSequence(seq).Setup(p => p.CreateNoneAuthenticationMethod())
.Returns(NoneAuthenticationMethodMock.Object);
/* 1 */
NoneAuthenticationMethodMock.InSequence(seq).Setup(p => p.Authenticate(SessionMock.Object))
.Returns(AuthenticationResult.Failure);
ConnectionInfoMock.InSequence(seq)
.Setup(p => p.AuthenticationMethods)
.Returns(new List <IAuthenticationMethod>
{
PublicKeyAuthenticationMethodMock.Object,
PasswordAuthenticationMethodMock.Object
});
NoneAuthenticationMethodMock.InSequence(seq)
.Setup(p => p.AllowedAuthentications)
.Returns(new[] { "password" });
/* Enumerate supported authentication methods */
PublicKeyAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("publickey");
PasswordAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("password");
/* 2 */
PasswordAuthenticationMethodMock.InSequence(seq)
.Setup(p => p.Authenticate(SessionMock.Object))
.Returns(AuthenticationResult.PartialSuccess);
PasswordAuthenticationMethodMock.InSequence(seq)
.Setup(p => p.AllowedAuthentications)
.Returns(new[] { "password" });
/* Enumerate supported authentication methods */
PublicKeyAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("publickey");
PasswordAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("password");
/* 3 */
PasswordAuthenticationMethodMock.InSequence(seq)
.Setup(p => p.Authenticate(SessionMock.Object))
.Returns(AuthenticationResult.PartialSuccess);
PasswordAuthenticationMethodMock.InSequence(seq)
.Setup(p => p.AllowedAuthentications)
.Returns(new[] { "password" });
/* Enumerate supported authentication methods */
PublicKeyAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("publickey");
PasswordAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("password");
/* 4 */
PasswordAuthenticationMethodMock.InSequence(seq)
.Setup(p => p.Authenticate(SessionMock.Object))
.Returns(AuthenticationResult.PartialSuccess);
PasswordAuthenticationMethodMock.InSequence(seq)
.Setup(p => p.AllowedAuthentications)
.Returns(new[] { "password" });
/* Enumerate supported authentication methods */
PublicKeyAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("publickey");
PasswordAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("password");
/* 5: Record partial success limit reached exception, and skip password authentication method */
PasswordAuthenticationMethodMock.InSequence(seq).Setup(p => p.Name).Returns("x_password_x");
SessionMock.InSequence(seq).Setup(p => p.UnRegisterMessage("SSH_MSG_USERAUTH_FAILURE"));
SessionMock.InSequence(seq).Setup(p => p.UnRegisterMessage("SSH_MSG_USERAUTH_SUCCESS"));
SessionMock.InSequence(seq).Setup(p => p.UnRegisterMessage("SSH_MSG_USERAUTH_BANNER"));
}
public void SendMessageOnSessionShouldBeInvokedOnceWithChannelEofMessage()
{
SessionMock.Verify(
p => p.SendMessage(It.Is <ChannelEofMessage>(e => e.LocalChannelNumber == _remoteChannelNumber)),
Times.Once);
}
protected override void SetupMocks()
{
SessionMock.Setup(p => p.SendMessage(It.Is <ChannelEofMessage>(e => e.LocalChannelNumber == _remoteChannelNumber)));
}
public void TryWaitOnSessionShouldBeInvokedOnce()
{
SessionMock.Verify(p => p.TryWait(It.IsAny <EventWaitHandle>(), _channelCloseTimeout), Times.Once);
}
public void TrySendMessageOnSessionShouldNeverBeInvokedForChannelEofMessage()
{
SessionMock.Verify(
p => p.TrySendMessage(It.Is <ChannelEofMessage>(c => c.LocalChannelNumber == _remoteChannelNumber)),
Times.Never);
}
public void TrySendMessageOnSessionShouldBeInvokedOnceForChannelCloseMessage()
{
SessionMock.Verify(
p => p.TrySendMessage(It.Is <ChannelCloseMessage>(c => c.LocalChannelNumber == _remoteChannelNumber)),
Times.Once);
}
public ReadOnlySessionTests()
{
DocumentSession = new DocumentSessionMock();
Session = new SessionMock(DocumentSession);
}
private void SetupSessions()
{
this.dataStorageMock = new Mock<IDataStorage>();
this.sessionMock = new SessionMock();
this.dataStorageMock.Setup(x => x.NewSession()).Returns(() => this.sessionMock);
this.reportingMock = new Mock<IReporting>();
this.reportingSessionMock = new SessionMock();
this.reportingMock.Setup(x => x.NewSession()).Returns(() => this.reportingSessionMock);
}
protected override void Act()
{
SessionMock.Raise(
s => s.ChannelCloseReceived += null,
new MessageEventArgs <ChannelCloseMessage>(new ChannelCloseMessage(_localChannelNumber)));
}
public void ChannelCloseMessageShouldBeSentOnce()
{
SessionMock.Verify(p => p.TrySendMessage(It.Is <ChannelCloseMessage>(m => m.LocalChannelNumber == _remoteChannelNumber)), Times.Once);
}
protected override void Act()
{
SessionMock.Raise(s => s.ChannelRequestReceived += null,
new MessageEventArgs <ChannelRequestMessage>(new ChannelRequestMessage(_localChannelNumber, _requestInfo)));
}
protected override void SetupMocks()
{
SessionMock.Setup(p => p.IsConnected).Returns(false);
}
