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); }