public void FilterAddIDTest()
{
LogItem message = new LogItem(category, level, msg, ids, GetException());
var qThread = new Mock<IQueued<LogItem>>(MockBehavior.Strict);
var writer = new Mock<ILogWriter>(MockBehavior.Strict);
writer
.Setup(s => s.Write(It.IsAny<LogItem>()));
writer
.Setup(s => s.GetTimeout())
.Returns(timeout);
qThread
.Setup(s => s.SetTimeout(It.IsAny<int>()));
LogCollector target = new LogCollector(qThread.Object, writer.Object);
target.FilterAddID(1);
qThread.Raise(s => s.OnReceive += null, message);
writer
.Verify(s => s.Write(It.IsAny<LogItem>()), Times.Never());
target.FilterAddID(3);
target.FilterAddID(1);
qThread.Raise(s => s.OnReceive += null, message);
writer
.Verify(s => s.Write(It.Is<LogItem>(a => a.Equals(message))), Times.Once());
}
protected void Arrange()
{
var random = new Random();
_operationTimeout = TimeSpan.FromMilliseconds(random.Next(100, 500));
_expected = new byte[random.Next(30, 50)];
_encoding = Encoding.UTF8;
random.NextBytes(_expected);
_sessionMock = new Mock<ISession>(MockBehavior.Strict);
_channelSessionMock = new Mock<IChannelSession>(MockBehavior.Strict);
var sequence = new MockSequence();
_sessionMock.InSequence(sequence).Setup(p => p.CreateChannelSession()).Returns(_channelSessionMock.Object);
_channelSessionMock.InSequence(sequence).Setup(p => p.Open());
_channelSessionMock.InSequence(sequence).Setup(p => p.SendSubsystemRequest("sftp")).Returns(true);
_channelSessionMock.InSequence(sequence).Setup(p => p.IsOpen).Returns(true);
_channelSessionMock.InSequence(sequence).Setup(p => p.SendData(It.IsAny<byte[]>())).Callback(
() =>
{
// generate response for SftpInitRequest
var versionInfoResponse = SftpVersionResponseBuilder.Create(3)
.Build();
_channelSessionMock.Raise(
c => c.DataReceived += null,
new ChannelDataEventArgs(0, versionInfoResponse));
});
_channelSessionMock.InSequence(sequence).Setup(p => p.IsOpen).Returns(true);
_channelSessionMock.InSequence(sequence).Setup(p => p.SendData(It.IsAny<byte[]>())).Callback(
() =>
{
var sftpNameResponse = CreateSftpNameResponse(1, _encoding, "ABC");
_channelSessionMock.Raise(
c => c.DataReceived += null,
new ChannelDataEventArgs(0, sftpNameResponse));
}
);
_channelSessionMock.InSequence(sequence).Setup(p => p.IsOpen).Returns(true);
_channelSessionMock.InSequence(sequence).Setup(p => p.SendData(It.IsAny<byte[]>())).Callback(
() =>
{
var sftpDataResponse = CreateSftpDataResponse(2, _expected);
_channelSessionMock.Raise(
c => c.DataReceived += null,
new ChannelDataEventArgs(0, sftpDataResponse.Take(0, 20)));
_channelSessionMock.Raise(
c => c.DataReceived += null,
new ChannelDataEventArgs(0, sftpDataResponse.Take(20, sftpDataResponse.Length - 20)));
}
);
_sftpSession = new SftpSession(_sessionMock.Object, _operationTimeout, _encoding);
_sftpSession.Connect();
}
protected void Arrange()
{
var random = new Random();
_operationTimeout = TimeSpan.FromMilliseconds(random.Next(100, 500));
_encoding = Encoding.UTF8;
_bAvail = (ulong) random.Next(0, int.MaxValue);
_sessionMock = new Mock<ISession>(MockBehavior.Strict);
_channelSessionMock = new Mock<IChannelSession>(MockBehavior.Strict);
var sequence = new MockSequence();
_sessionMock.InSequence(sequence).Setup(p => p.CreateChannelSession()).Returns(_channelSessionMock.Object);
_channelSessionMock.InSequence(sequence).Setup(p => p.Open());
_channelSessionMock.InSequence(sequence).Setup(p => p.SendSubsystemRequest("sftp")).Returns(true);
_channelSessionMock.InSequence(sequence).Setup(p => p.IsOpen).Returns(true);
_channelSessionMock.InSequence(sequence).Setup(p => p.SendData(It.IsAny<byte[]>())).Callback(
() =>
{
// generate response for SftpInitRequest
var versionInfoResponse = SftpVersionResponseBuilder.Create(3)
.AddExtension("*****@*****.**", "")
.Build();
_channelSessionMock.Raise(
c => c.DataReceived += null,
new ChannelDataEventArgs(0, versionInfoResponse));
});
_channelSessionMock.InSequence(sequence).Setup(p => p.IsOpen).Returns(true);
_channelSessionMock.InSequence(sequence).Setup(p => p.SendData(It.IsAny<byte[]>())).Callback(
() =>
{
var sftpNameResponse = CreateSftpNameResponse(1, _encoding, "ABC");
_channelSessionMock.Raise(
c => c.DataReceived += null,
new ChannelDataEventArgs(0, sftpNameResponse));
}
);
_channelSessionMock.InSequence(sequence).Setup(p => p.IsOpen).Returns(true);
_channelSessionMock.InSequence(sequence).Setup(p => p.SendData(It.IsAny<byte[]>())).Callback(
() =>
{
var statVfsReplyBuilder = StatVfsReplyBuilder.Create(2);
statVfsReplyBuilder.WithBAvail(_bAvail);
var statVfsReply = statVfsReplyBuilder.Build();
_channelSessionMock.Raise(
c => c.DataReceived += null,
new ChannelDataEventArgs(0, statVfsReply));
}
);
_sftpSession = new SftpSession(_sessionMock.Object, _operationTimeout, _encoding);
_sftpSession.Connect();
}
public void TestAmountIndexRaisesWhenPlaying()
{
var mockTimer = new Mock<ITimer>();
Piano piano = GetNewPiano(mockTimer.Object);
piano.StartPlaying();
mockTimer.Raise(mock => mock.Elapsed += null, new EventArgs());
mockTimer.Raise(mock => mock.Elapsed += null, new EventArgs());
foreach(PianoKey pianoKey in piano.AllKeys)
{
Assert.AreEqual(2, pianoKey.CurrentIndex);
}
}
private void Arrange()
{
var random = new Random();
_localChannelNumber = (uint)random.Next(0, int.MaxValue);
_localWindowSize = (uint)random.Next(0, int.MaxValue);
_localPacketSize = (uint)random.Next(0, int.MaxValue);
_remoteChannelNumber = (uint)random.Next(0, int.MaxValue);
_remoteWindowSize = (uint)random.Next(0, int.MaxValue);
_remotePacketSize = (uint)random.Next(0, int.MaxValue);
_closeTimer = new Stopwatch();
_channelClosedRegister = new List<ChannelEventArgs>();
_channelExceptionRegister = new List<ExceptionEventArgs>();
_sessionMock = new Mock<ISession>(MockBehavior.Strict);
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.WaitOnHandle(It.IsAny<EventWaitHandle>()))
.Callback<WaitHandle>(w =>
{
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
{
w.WaitOne();
}
finally
{
_closeTimer.Stop();
}
});
_channel = new ChannelStub(_sessionMock.Object, _localChannelNumber, _localWindowSize, _localPacketSize);
_channel.Closed += (sender, args) => _channelClosedRegister.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)));
}
protected void Arrange()
{
var random = new Random();
_closingRegister = new List<EventArgs>();
_exceptionRegister = new List<ExceptionEventArgs>();
_bindEndpoint = new IPEndPoint(IPAddress.Any, random.Next(IPEndPoint.MinPort, IPEndPoint.MaxPort));
_remoteEndpoint = new IPEndPoint(IPAddress.Parse("193.168.1.5"), random.Next(IPEndPoint.MinPort, IPEndPoint.MaxPort));
ForwardedPort = new ForwardedPortRemote(_bindEndpoint.Address, (uint)_bindEndpoint.Port, _remoteEndpoint.Address, (uint)_remoteEndpoint.Port);
_connectionInfoMock = new Mock<IConnectionInfo>(MockBehavior.Strict);
_sessionMock = new Mock<ISession>(MockBehavior.Strict);
_connectionInfoMock.Setup(p => p.Timeout).Returns(TimeSpan.FromSeconds(15));
_sessionMock.Setup(p => p.IsConnected).Returns(true);
_sessionMock.Setup(p => p.ConnectionInfo).Returns(_connectionInfoMock.Object);
_sessionMock.Setup(p => p.RegisterMessage("SSH_MSG_REQUEST_FAILURE"));
_sessionMock.Setup(p => p.RegisterMessage("SSH_MSG_REQUEST_SUCCESS"));
_sessionMock.Setup(p => p.RegisterMessage("SSH_MSG_CHANNEL_OPEN"));
_sessionMock.Setup(
p =>
p.SendMessage(
It.Is<GlobalRequestMessage>(
g =>
g.RequestName == GlobalRequestName.TcpIpForward &&
g.AddressToBind == ForwardedPort.BoundHost &&
g.PortToBind == ForwardedPort.BoundPort)))
.Callback(
() =>
_sessionMock.Raise(s => s.RequestSuccessReceived += null,
new MessageEventArgs<RequestSuccessMessage>(new RequestSuccessMessage())));
_sessionMock.Setup(p => p.WaitOnHandle(It.IsAny<WaitHandle>()));
_sessionMock.Setup(
p =>
p.SendMessage(
It.Is<GlobalRequestMessage>(
g =>
g.RequestName == GlobalRequestName.CancelTcpIpForward &&
g.AddressToBind == ForwardedPort.BoundHost && g.PortToBind == ForwardedPort.BoundPort)))
.Callback(
() =>
_sessionMock.Raise(s => s.RequestSuccessReceived += null,
new MessageEventArgs<RequestSuccessMessage>(new RequestSuccessMessage())));
_sessionMock.Setup(p => p.MessageListenerCompleted).Returns(new ManualResetEvent(false));
ForwardedPort.Closing += (sender, args) => _closingRegister.Add(args);
ForwardedPort.Exception += (sender, args) => _exceptionRegister.Add(args);
ForwardedPort.Session = _sessionMock.Object;
ForwardedPort.Start();
ForwardedPort.Stop();
}
public void ResetControllerGetsCalledOnTheViewWhenTheViewRaisesControllerChangedWithNeitherProgrammer()
{
var programmer1 = new Programmer("Joe");
var programmer2 = new Programmer("Bob");
var mockView = new Mock<PairTrackerView>();
mockView.Setup(v => v.ResetController());
var presenter = new PairTrackerPresenterBuilder().WithView(mockView.Object).Build();
mockView.Raise(v => v.StartButton_Clicked += null, new StartButtonClickedEventArgs(programmer1, programmer2));
mockView.Raise(v => v.Controller_Changed += null, new ControllerChangedEventArgs(Programmer.Neither));
mockView.VerifyAll();
}
public void UnlockNameEntryGetsCalledOnTheViewWhenTheViewRaisesStopButton_Clicked()
{
var programmer1 = new Programmer("Joe");
var programmer2 = new Programmer("Bob");
var mockView = new Mock<PairTrackerView>();
mockView.Setup(v => v.UnlockNameEntry());
var presenter = new PairTrackerPresenterBuilder().WithView(mockView.Object).Build();
mockView.Raise(v => v.StartButton_Clicked += null, new StartButtonClickedEventArgs(programmer1, programmer2));
mockView.Raise(v => v.StopButton_Clicked += null, new EventArgs());
mockView.VerifyAll();
}
private void Arrange()
{
var random = new Random();
_localChannelNumber = (uint)random.Next(0, int.MaxValue);
_localWindowSize = (uint)random.Next(0, int.MaxValue);
_localPacketSize = (uint)random.Next(0, int.MaxValue);
_remoteChannelNumber = (uint)random.Next(0, int.MaxValue);
_remoteWindowSize = (uint)random.Next(0, int.MaxValue);
_remotePacketSize = (uint)random.Next(0, int.MaxValue);
_channelClosedRegister = new List<ChannelEventArgs>();
_channelExceptionRegister = new List<ExceptionEventArgs>();
_sessionMock = new Mock<ISession>(MockBehavior.Strict);
_sessionMock.Setup(p => p.IsConnected).Returns(true);
_sessionMock.Setup(
p => p.TrySendMessage(It.Is<ChannelCloseMessage>(c => c.LocalChannelNumber == _remoteChannelNumber)))
.Returns(true);
_channel = new ChannelStub(_sessionMock.Object, _localChannelNumber, _localWindowSize, _localPacketSize);
_channel.Closed += (sender, args) => _channelClosedRegister.Add(args);
_channel.Exception += (sender, args) => _channelExceptionRegister.Add(args);
_channel.InitializeRemoteChannelInfo(_remoteChannelNumber, _remoteWindowSize, _remotePacketSize);
_channel.SetIsOpen(true);
_sessionMock.Raise(p => p.ChannelEofReceived += null,
new MessageEventArgs<ChannelEofMessage>(new ChannelEofMessage(_localChannelNumber)));
}
public void MealForOtherDayNotRemovedFromChildrenWhenRemovedFromRepository()
{
var dataRepositoryMock = new Mock<IDataRepository>();
var data = new MockData();
var allMeals = data.Meals();
dataRepositoryMock.Setup( x => x.GetAllMealsForDate( DateTime.Now.Date ) ).Returns(
new ReadOnlyCollection<Meal>( (from meal in allMeals
where meal.DateAndTimeOfMeal.Date == DateTime.Now.Date
select meal).ToList() ) );
dataRepositoryMock.Setup( x => x.GetAllMealsForDate( DateTime.Now.Date.AddDays( MockData.DaysToAddForFutureMeals ) ) ).Returns(
new ReadOnlyCollection<Meal>( (from meal in allMeals
where meal.DateAndTimeOfMeal.Date == DateTime.Now.Date.AddDays( MockData.DaysToAddForFutureMeals )
select meal).ToList() ) );
var mealNodeViewModel = new MealNodeViewModel( dataRepositoryMock.Object, null );
Assert.AreEqual( 3, mealNodeViewModel.Children.Count );
var removedMeal = allMeals.Find( m => m.DateAndTimeOfMeal.Date == DateTime.Today.AddDays( MockData.DaysToAddForFutureMeals ) && m.TypeOfMeal.Name == "Dinner" );
Assert.IsNotNull( removedMeal );
allMeals.Remove( removedMeal );
dataRepositoryMock.Raise( e => e.ItemDeleted += null, new RepositoryObjectEventArgs( removedMeal ) );
Assert.AreEqual( 3, mealNodeViewModel.Children.Count );
foreach (ClickableTreeNodeViewModel node in mealNodeViewModel.Children)
{
var meal = allMeals.Find( m => m.ID == (Guid)node.Parameter );
Assert.IsNotNull( meal );
Assert.AreEqual( meal.Name, node.Name );
}
}
public void MealForTodayAddedToChildrenWhenAddedToRepository()
{
var dataRepositoryMock = new Mock<IDataRepository>();
var data = new MockData();
var allMeals = data.Meals();
dataRepositoryMock.Setup( x => x.GetAllMealsForDate( DateTime.Now.Date ) ).Returns(
new ReadOnlyCollection<Meal>( (from meal in allMeals
where meal.DateAndTimeOfMeal.Date == DateTime.Now.Date
select meal).ToList() ) );
dataRepositoryMock.Setup( x => x.GetAllMealsForDate( DateTime.Now.Date.AddDays( MockData.DaysToAddForFutureMeals ) ) ).Returns(
new ReadOnlyCollection<Meal>( (from meal in allMeals
where meal.DateAndTimeOfMeal.Date == DateTime.Now.Date.AddDays( MockData.DaysToAddForFutureMeals )
select meal).ToList() ) );
var mealNodeViewModel = new MealNodeViewModel( dataRepositoryMock.Object, null );
Assert.AreEqual( 3, mealNodeViewModel.Children.Count );
var newMeal = new Meal(
Guid.NewGuid(), new MealType( Guid.NewGuid(), "Doesn't Matter", "", DateTime.Now, false ), DateTime.Now, "Test Meal", "Just a test" );
newMeal.FoodItemServings.Add( new Serving<FoodItem>( new FoodItem( Guid.NewGuid(), "test", "", 42 ), 1 ) );
allMeals.Add( newMeal );
dataRepositoryMock.Raise( e => e.ItemAdded += null, new RepositoryObjectEventArgs( newMeal ) );
Assert.AreEqual( 4, mealNodeViewModel.Children.Count );
foreach (ClickableTreeNodeViewModel node in mealNodeViewModel.Children)
{
Meal meal = allMeals.Find( m => m.ID == (Guid)node.Parameter );
Assert.IsNotNull( meal );
Assert.AreEqual( meal.Name, node.Name );
}
}
private static void SetupWindowSizeProperties(Mock<Window> windowMock)
{
Window window = windowMock.Object;
var currentSize = new Size(1024, 640);
windowMock.SetupGet(w => w.TotalPixelSize).Returns(() => currentSize);
#pragma warning disable 0618
windowMock.SetupSet(w => w.TotalPixelSize).Callback(s =>
{
currentSize = s;
windowMock.Raise(w => w.ViewportSizeChanged += null, s);
});
windowMock.SetupGet(w => w.ViewportPixelSize).Returns(() => currentSize);
bool isFullscreen = false;
var rememberSizeBeforeFullscreen = new Size();
windowMock.Setup(w => w.SetFullscreen(It.IsAny<Size>())).Callback((Size displaySize) =>
{
isFullscreen = true;
rememberSizeBeforeFullscreen = window.TotalPixelSize;
window.TotalPixelSize = displaySize;
});
windowMock.Setup(w => w.SetWindowed()).Callback(() =>
{
isFullscreen = false;
window.TotalPixelSize = rememberSizeBeforeFullscreen;
});
windowMock.SetupGet(w => w.IsFullscreen).Returns(() => isFullscreen);
}
public void NoHelloMessage()
{
var responseStream = new MemoryStream ();
var stream = new TestStream (new MemoryStream (), responseStream);
// Create mock byte server and client
var mockByteServer = new Mock<IServer<byte,byte>> ();
var byteServer = mockByteServer.Object;
var mockByteClient = new Mock<IClient<byte,byte>> ();
mockByteClient.Setup (x => x.Stream).Returns (stream);
var byteClient = mockByteClient.Object;
var server = new StreamServer (byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow ();
server.Start ();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionArgs<byte,byte> (byteClient);
mockByteServer.Raise (m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsFalse (eventArgs.Request.ShouldAllow);
Assert.IsTrue (eventArgs.Request.ShouldDeny);
Assert.AreEqual (0, responseStream.Length);
}
public void ConstructingControllerStartsTimelines()
{
var checkTimelines = new Mock<ITimer>();
var updateTimelines = new Mock<ITimer>();
var queue = new Queue<ITimer>();
queue.Enqueue(checkTimelines.Object);
queue.Enqueue(updateTimelines.Object);
SysTimer.Override = queue.Dequeue;
var timelines = new Mock<ITimelines>();
var controller = new TimelineController(timelines.Object);
controller.StartTimelines();
checkTimelines.Raise(c => c.Elapsed += null, EventArgs.Empty);
updateTimelines.Raise(u => u.Elapsed += null, EventArgs.Empty);
checkTimelines.VerifySet(c => c.Interval = 100);
checkTimelines.VerifySet(c => c.Interval = 60000);
checkTimelines.Verify(c => c.Start());
timelines.Verify(t => t.HomeTimeline());
timelines.Verify(t => t.MentionsTimeline());
updateTimelines.VerifySet(u => u.Interval = 30000);
updateTimelines.Verify(u => u.Start());
timelines.Verify(t => t.UpdateTimeStamps());
Assert.That(controller, Is.Not.Null);
}
public void Notification()
{
var context = new Mock<IContextAware>();
{
context.Setup(c => c.IsSynchronized)
.Returns(true);
}
var collector = new Mock<ICollectNotifications>();
var model = new NotificationModel(context.Object, collector.Object);
var propertyChangedWasRaised = 0;
var properties = new List<string>();
model.PropertyChanged += (s, e) =>
{
propertyChangedWasRaised++;
properties.Add(e.PropertyName);
};
var text = "a";
collector.Raise(c => c.OnNotification += null, new NotificationEventArgs(text));
Assert.AreEqual(1, propertyChangedWasRaised);
Assert.AreEqual(text, model.Notification);
Assert.That(
properties,
Is.EquivalentTo(
new List<string>
{
"Notification",
}));
}
public void CanExecuteChangesToFalseAndAnEventIsFiredWhenOneOfThePromtpsBecomesNotReady()
{
var numberOfEvents = 0;
var catalogItem = A.CatalogItemInfo().WithPath("Report 1").Build();
var prompt1 = Mock.Of<IPrompt>(p => p.ReadyForReportExecution == true);
var prompt2 = Mock.Of<IPrompt>(p => p.ReadyForReportExecution == true);
var prompt3 = new Mock<IPrompt>();
prompt3.SetupGet(p => p.ReadyForReportExecution).Returns(false);
_fakePromptsViewModelService.SetupGetPrompts(catalogItem.Path);
_promptsViewModel.ShowPromptsFor(catalogItem);
_fakePromptsViewModelService.ExecuteCallback(A.ObservableCollection(prompt1, prompt2, prompt3.Object));
Assert.IsFalse(_promptsViewModel.ExecuteReport.CanExecute(null));
_promptsViewModel.ExecuteReport.CanExecuteChanged += (s, e) => { numberOfEvents++; };
prompt3.SetupGet(p => p.ReadyForReportExecution).Returns(true);
prompt3.Raise(p => p.PropertyChanged += null, new PropertyChangedEventArgs("ReadyForReportExecution"));
Assert.AreEqual(numberOfEvents, 1);
Assert.IsTrue(_promptsViewModel.ExecuteReport.CanExecute(null));
}
public void ValidHelloMessage ()
{
var responseStream = new MemoryStream ();
var stream = new TestStream (new MemoryStream (helloMessage), responseStream);
// Create mock byte server and client
var mockByteServer = new Mock<IServer<byte,byte>> ();
var byteServer = mockByteServer.Object;
var byteClient = new TestClient (stream);
var server = new RPCServer (byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow ();
server.Start ();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionEventArgs<byte,byte> (byteClient);
mockByteServer.Raise (m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsTrue (eventArgs.Request.ShouldAllow);
Assert.IsFalse (eventArgs.Request.ShouldDeny);
server.Update ();
Assert.AreEqual (1, server.Clients.Count ());
Assert.AreEqual ("Jebediah Kerman!!!", server.Clients.First ().Name);
byte[] bytes = responseStream.ToArray ();
byte[] responseBytes = byteClient.Guid.ToByteArray ();
Assert.IsTrue (responseBytes.SequenceEqual (bytes));
}
private void Arrange()
{
var random = new Random();
_localChannelNumber = (uint)random.Next(0, int.MaxValue);
_localWindowSize = (uint)random.Next(0, int.MaxValue);
_localPacketSize = (uint)random.Next(0, int.MaxValue);
_remoteChannelNumber = (uint)random.Next(0, int.MaxValue);
_remoteWindowSize = (uint)random.Next(0, int.MaxValue);
_remotePacketSize = (uint)random.Next(0, int.MaxValue);
_channelClosedRegister = new List<ChannelEventArgs>();
_channelExceptionRegister = new List<ExceptionEventArgs>();
_initialSessionSemaphoreCount = random.Next(10, 20);
_sessionSemaphore = new SemaphoreLight(_initialSessionSemaphoreCount);
_sessionMock = new Mock<ISession>(MockBehavior.Strict);
_connectionInfoMock = new Mock<IConnectionInfo>(MockBehavior.Strict);
_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(true);
_sessionMock.InSequence(_sequence)
.Setup(
p => p.TrySendMessage(It.Is<ChannelCloseMessage>(c => c.LocalChannelNumber == _remoteChannelNumber)))
.Returns(false);
_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)));
}
public void OnStartProgress()
{
var context = new Mock<IContextAware>();
{
context.Setup(c => c.IsSynchronized)
.Returns(true);
}
var collector = new Mock<ICollectProgressReports>();
var model = new ProgressModel(context.Object, collector.Object);
var propertyChangedWasRaised = 0;
var properties = new List<string>();
model.PropertyChanged += (s, e) =>
{
propertyChangedWasRaised++;
properties.Add(e.PropertyName);
};
collector.Raise(c => c.OnStartProgress += null, EventArgs.Empty);
Assert.AreEqual(0.0, model.Progress);
Assert.AreEqual(3, propertyChangedWasRaised);
Assert.That(
properties,
Is.EquivalentTo(
new List<string>
{
"Progress",
"Description",
"HasErrors"
}));
}
public void BasicTest()
{
string goodInstance = "goodInstance";
var statePersister = new Mock<IStatePersister>();
// Creating fake data for the statePersister...
var configurationsPersisted = new List<Configuration>()
{
GetConfig(1),
GetConfig(2),
GetConfig(3)
};
Configuration firstGoodConfiguration = GetConfig(1);
Configuration secondGoodConfiguration = GetConfig(6);
firstGoodConfiguration.Instance = goodInstance;
secondGoodConfiguration.Instance = goodInstance;
configurationsPersisted.Add(firstGoodConfiguration);
configurationsPersisted.Add(secondGoodConfiguration);
statePersister.Setup(o => o.Read()).Returns(configurationsPersisted);
//Creating a fake requestmanager.
var subscriptionsRequest = new Mock<IRequestManager<ConfigurationSubscription, ConfigurationSubscriptionAnswer>>();
var updateRequest = new Mock<IRequestManager<ConfigurationUpdate, ConfigurationUpdateAnswer>>();
var allAnswerSent = new List<AnwserMessage<ConfigurationSubscriptionAnswer>>();
subscriptionsRequest.Setup(o => o.Send(It.IsAny<AnwserMessage<ConfigurationSubscriptionAnswer>>())).
Callback<AnwserMessage<ConfigurationSubscriptionAnswer>>(allAnswerSent.Add);
var toTest = new ConfigurationRequestHandler(subscriptionsRequest.Object, updateRequest.Object, statePersister.Object);
//Sending a request to the manager
var requestId = 1021;
var request = GetRequestMessage(requestId, goodInstance);
subscriptionsRequest.Raise(mock => mock.OnRequest += null, null, request);
//We check that we received what we should, one message with two elements
Assert.AreEqual(1, allAnswerSent.Count);
Assert.AreEqual(requestId, allAnswerSent.First().id);
var sentConfigurations = allAnswerSent.First().answer.result;
Assert.AreEqual(2, sentConfigurations.Count);
Assert.AreEqual(firstGoodConfiguration, sentConfigurations.First());
Assert.AreEqual(secondGoodConfiguration, sentConfigurations.Last());
//test wildcard :
var requestAll = GetRequestMessage(requestId+1, ConfigurationRequestHandler.ConfigurationInstanceWildcard);
subscriptionsRequest.Raise(mock => mock.OnRequest += null, null, requestAll);
Assert.AreEqual(configurationsPersisted.Count, allAnswerSent.Last().answer.result.Count);
}
public void TestMethodEvent()
{
var mock = new Mock<IFoo>();
string fooValue = "hello";
// Raising an event on the mock
mock.Raise(m => m.FooEvent += null, new FooEventArgs(fooValue));
}
public void ExpectCardToBePlayableAfterTurnEnded(DevelopmentCardType type)
{
var turn = new Mock<ITurn>();
var card = new DevelopmentCard(type, turn.Object);
turn.Raise(t => t.Ended += null, EventArgs.Empty);
Assert.True(card.Playable);
}
public void ReloadsAndSavesSettingsOnClosing()
{
var windowStub = new Mock<IWindow>();
var settingsMock = new Mock<ISettings>();
WindowPositionSettings.UseWith(windowStub.Object, settingsMock.Object);
windowStub.Raise(w => w.Closing += null, new CancelEventArgs());
settingsMock.Verify(settings => settings.Reload());
settingsMock.Verify(settings => settings.Save());
}
public void SetsNotMaximizedOnClosingMinimizedState()
{
var windowStub = new Mock<IWindow>();
var settingsMock = new Mock<ISettings>();
WindowPositionSettings.UseWith(windowStub.Object, settingsMock.Object);
windowStub.Setup(w => w.WindowState).Returns(WindowState.Minimized);
windowStub.Raise(w => w.Closing += null, new CancelEventArgs());
settingsMock.Verify(settings => settings.SetBoolean(MaximizedKey, false));
}
public void NewPersonalChatTest()
{
const string userName = "******";
var chatModelMock = new Mock<IChatModel>();
var modelMock = new Mock<IMainChatModel>();
modelMock.Setup(x => x.GetNewPersonalChat(userName)).Returns(chatModelMock.Object);
var viewModel = new MainPageViewModel(modelMock.Object);
modelMock.Raise(x => x.NewPersonalChat += null, new NewMessageEventArgs{UserName = userName});
modelMock.Verify(x => x.GetNewPersonalChat(userName), Times.Exactly(1), "Model method 'GetNewPersonalChat' wasn't called.");
}
public void TestMonitoringMessages()
{
var mock = new Mock<IConnector>();
mock.Setup(x => x.Connected).Returns(true);
LivenessMonitor monitor = new LivenessMonitor(mock.Object, 500, 500);
monitor.Enable();
mock.Raise(x => x.MessageReceived += null, new MessageEvent(new DummyMessage()));
Assert.IsTrue(monitor.IsUp);
Thread.Sleep(250);
mock.Raise(x => x.MessageReceived += null, new MessageEvent(new DummyMessage()));
Assert.IsTrue(monitor.IsUp);
Thread.Sleep(250);
mock.Raise(x => x.MessageReceived += null, new MessageEvent(new DummyMessage()));
Assert.IsTrue(monitor.IsUp);
Thread.Sleep(2000); // provoke timeout
Assert.IsFalse(monitor.IsUp);
}
public void RefreshUsersTest()
{
const string userName = "******";
var modelMock = new Mock<IMainChatModel>();
var viewModel = new MainPageViewModel(modelMock.Object);
Assert.AreEqual(0, viewModel.Users.Count, "Incorrect initial users count.");
modelMock.Raise(x => x.RefreshUsers += null, new RefreshUsersEventArgs{Users = new[] {userName}});
Assert.AreEqual(1, viewModel.Users.Count, "Incorrect initial users count.");
Assert.AreEqual(userName, viewModel.Users.First());
}
public void Connection_Complete_Join_Config_Channels()
{
var mock = new Mock<IIrcClientAdapter>();
var client = new ChatClient(_config, mock.Object);
mock.Raise(m => m.ConnectionComplete += null, new EventArgs());
foreach (var channel in _config.Channels)
mock.Verify(m => m.JoinChannel(channel));
}
private void Arrange()
{
var random = new Random();
_localChannelNumber = (uint) random.Next(0, int.MaxValue);
_localWindowSize = (uint) random.Next(2000, 3000);
_localPacketSize = (uint) random.Next(1000, 2000);
_initialSessionSemaphoreCount = random.Next(10, 20);
_sessionSemaphore = new SemaphoreLight(_initialSessionSemaphoreCount);
_channelClosedRegister = new List<ChannelEventArgs>();
_channelExceptionRegister = new List<ExceptionEventArgs>();
_actualException = null;
_failureReasonCode = (uint)random.Next(0, int.MaxValue);
_failureDescription = random.Next().ToString(CultureInfo.InvariantCulture);
_failureLanguage = random.Next().ToString(CultureInfo.InvariantCulture);
_sessionMock = new Mock<ISession>(MockBehavior.Strict);
_connectionInfoMock = new Mock<IConnectionInfo>(MockBehavior.Strict);
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.ChannelOpenFailureReceived += null,
new MessageEventArgs<ChannelOpenFailureMessage>(
new ChannelOpenFailureMessage(
_localChannelNumber,
_failureDescription,
_failureReasonCode,
_failureLanguage
)));
w.WaitOne();
});
_sessionMock.InSequence(sequence).Setup(p => p.ConnectionInfo).Returns(_connectionInfoMock.Object);
_connectionInfoMock.InSequence(sequence).Setup(p => p.RetryAttempts).Returns(1);
_channel = new ChannelSession(_sessionMock.Object, _localChannelNumber, _localWindowSize, _localPacketSize);
_channel.Closed += (sender, args) => _channelClosedRegister.Add(args);
_channel.Exception += (sender, args) => _channelExceptionRegister.Add(args);
}
public void OnNameUpdate()
{
var project = new Mock<IProject>();
var facade = new ProjectFacadeForScripts(new ProjectFacade(project.Object));
bool eventRaised = false;
facade.OnNameChanged += (s, e) => { eventRaised = true; };
project.Raise(p => p.OnNameChanged += null, new ValueChangedEventArgs<string>("newName"));
Assert.IsTrue(eventRaised);
}
private void TestVmFiresEvent(Action <IGitStashWrapper> eventExpression, EventArgs args, string PropertyName)
{
var wrapper = new Mock <IGitStashWrapper>();
var page = new Mock <ITeamExplorerBase>();
RecommendedActionsViewModel vm = new RecommendedActionsViewModel(wrapper.Object, page.Object);
AutoResetEvent waitHandle = new AutoResetEvent(false);
bool eventWasDispatched = false;
vm.PropertyChanged += (s, a) =>
{
if (a.PropertyName == PropertyName)
{
eventWasDispatched = true;
}
if (eventWasDispatched)
{
waitHandle.Set();
}
};
wrapper.Raise(eventExpression, args);
waitHandle.WaitOne(5000);
Assert.IsTrue(eventWasDispatched);
}
public void TryUpdateModelIsCalled_WhenItemIsFound()
{
// Arrange
var viewMock = new Mock <IEditCategoriesView>();
viewMock.Setup(v => v.ModelState).Returns(new ModelStateDictionary());
Guid categoryId = Guid.NewGuid();
var categoryServiceMock = new Mock <ICategoryService>();
categoryServiceMock.Setup(c => c.GetById(categoryId)).Returns(new Category()
{
Id = categoryId
});
EditCategoriesPresenter editCategoriesPresenter = new EditCategoriesPresenter
(viewMock.Object, categoryServiceMock.Object);
// Act
viewMock.Raise(v => v.OnUpdateItem += null, new IdEventArgs(categoryId));
// Assert
viewMock.Verify(v => v.TryUpdateModel(It.IsAny <Category>()), Times.Once());
}
public void CreateThreadPresenter_ThreadsRepositoryShouldTransferTo500_IfSomethingGoesWrong()
{
var view = new Mock <ICreateThreadView>();
view.SetupAllProperties();
var forumData = new Mock <IForumData>();
var threadsRepository = new Mock <IThreadsRepository>();
var section = new Section()
{
Name = "TestSection"
};
forumData.Setup(s => s.SectionsRepository.GetSectionByName(It.IsAny <string>())).Returns(section);
forumData.Setup(f => f.ThreadsRepository).Returns(threadsRepository.Object);
threadsRepository.Setup(t => t.CreateThread(It.IsAny <Thread>())).Throws(new Exception());
var presenter = new CreateThreadPresenter(view.Object, forumData.Object);
var testContent = "TestContent Should be at least 50 characters long!!!";
Assert.Throws <HttpException>(() => view.Raise(v => v.Create += null, new ThreadEventArgs("TestTitle", testContent, "TestSection", 1)));
}
public void GetWebRequestDesignerViewModel_SetHeaders_StringWithOneVariables_PreviewInputsCountIsOne()
{
var properties = new Dictionary <string, Mock <ModelProperty> >();
var propertyCollection = new Mock <ModelPropertyCollection>();
var headers = new Mock <ModelProperty>();
headers.SetupProperty(p => p.ComputedValue, ""); // start "tracking" sets/gets to this property
properties.Add("Headers", headers);
propertyCollection.Protected().Setup <ModelProperty>("Find", "Headers", true).Returns(headers.Object);
var modelItemMock = new Mock <ModelItem>();
modelItemMock.Setup(s => s.Properties).Returns(propertyCollection.Object);
var sut = new GetWebRequestWithTimeoutDesignerViewModel(modelItemMock.Object);
headers.Object.ComputedValue = "ContentType=[[contenttype]]";
modelItemMock.Raise(mi => mi.PropertyChanged += null, new PropertyChangedEventArgs("Headers"));
Assert.IsTrue(sut.PreviewViewModel.Inputs.Count == 1);
Assert.AreEqual(sut.PreviewViewModel.InputsVisibility, Visibility.Visible);
}
public void AddModelError_WhenItemIsNotFound()
{
// Arrange
var viewMock = new Mock <ICategoriesAdminView>();
viewMock.Setup(v => v.ModelState).Returns(new ModelStateDictionary());
string errorKey = string.Empty;
int categoryId = 1;
string expectedError = String.Format("Item with id {0} was not found", categoryId);
var categoryServiceMock = new Mock <ICategoryService>();
categoryServiceMock.Setup(c => c.GetById(categoryId)).Returns <Category>(null);
CategoriesAdminPresenter editCategoriesPresenter = new CategoriesAdminPresenter
(viewMock.Object, categoryServiceMock.Object);
// Act
viewMock.Raise(v => v.OnCategoryEdit += null, new CategoryAdminEventArgs(categoryId, null));
// Assert
Assert.AreEqual(1, viewMock.Object.ModelState[errorKey].Errors.Count);
StringAssert.AreEqualIgnoringCase(expectedError, viewMock.Object.ModelState[errorKey].Errors[0].ErrorMessage);
}
public void ThreadEditPresenter_EditThreadShouldThrowIfDbSectionsFail()
{
var view = new Mock <IThreadEditView>();
view.SetupAllProperties();
var forumData = new Mock <IForumData>();
var threadsRepository = new Mock <IThreadsRepository>();
var thread = new Thread()
{
Id = 1, IsVisible = true
};
forumData.Setup(f => f.ThreadsRepository).Returns(threadsRepository.Object);
forumData.Setup(f => f.ThreadsRepository.GetThreadById(It.IsAny <int>())).Returns(thread);
forumData.Setup(f => f.SectionsRepository).Throws(new Exception());
var presenter = new ThreadEditPresenter(view.Object, forumData.Object);
var testContent = "TestContent Should be at least 50 characters long!!";
Assert.Throws <HttpException>(() => view.Raise(v => v.EditThread += null, new ThreadEditEventArgs("TestTitle", testContent, "TestSection", 1)));
}
public void TestViewMyCheckout_ShouldCallCartFinishOrder(string name, string address, string phoneNumber)
{
var mockedView = new Mock <ICheckoutView>();
mockedView.Setup(v => v.Model).Returns(new CheckoutViewModel());
var mockedUserService = new Mock <IUserService>();
var mockedAuthenticationProvider = new Mock <IAuthenticationProvider>();
var mockedViewModelFactory = new Mock <IViewModelFactory>();
var mockedCart = new Mock <IShoppingCart>();
var checkoutPresenter = new CheckoutPresenter(mockedView.Object,
mockedAuthenticationProvider.Object,
mockedUserService.Object,
mockedViewModelFactory.Object,
mockedCart.Object);
var args = new CheckoutEventArgs(name, address, phoneNumber);
mockedView.Raise(v => v.MyCheckout += null, args);
mockedCart.Verify(c => c.FinishOrder(name, address, phoneNumber), Times.Once);
}
public async Task PendingInvocationsAreTerminatedWithExceptionWhenConnectionClosesDueToError()
{
var mockConnection = new Mock <IConnection>();
mockConnection.SetupGet(p => p.Features).Returns(new FeatureCollection());
mockConnection
.Setup(m => m.DisposeAsync())
.Returns(Task.FromResult <object>(null));
var hubConnection = new HubConnection(mockConnection.Object, Mock.Of <IHubProtocol>(), new LoggerFactory());
await hubConnection.StartAsync();
var invokeTask = hubConnection.InvokeAsync <int>("testMethod");
var exception = new InvalidOperationException();
mockConnection.Raise(m => m.Closed += null, exception);
var actualException = await Assert.ThrowsAsync <InvalidOperationException>(async() => await invokeTask);
Assert.Equal(exception, actualException);
}
public void CallInsertCategory_WhenCorrectParametersArePassed()
{
// Arrange
var viewMock = new Mock <ICategoriesView>();
viewMock.Setup(v => v.ModelState).Returns(new ModelStateDictionary());
string categoryName = "Category 1";
string categoryDescription = "Description 1";
string categoryImage = "Image 1";
var categoryServiceMock = new Mock <ICategoryService>();
CategoriesPresenter categoriesPresenter = new CategoriesPresenter(viewMock.Object,
categoryServiceMock.Object);
// Act
viewMock.Raise(v => v.OnInsertItem += null,
new CategoryInsertEventArgs(categoryName, categoryDescription, categoryImage));
// Assert
categoryServiceMock.Verify(c => c.InsertCategory(It.IsAny <Category>()), Times.Once());
}
public void View_AddCommentCallsCommentServiceCreateCommentWithCorrectUserID()
{
string anyString = "2";
int anyInt = 2;
var mockedGuid = Guid.Parse("E56F7468-AC9B-454C-A73E-E687DFC925B1");
var mockedGuidString = "E56F7468-AC9B-454C-A73E-E687DFC925B1";
var mockedView = new Mock <IVenueDetailsView>();
var mockedVenueService = new Mock <IVenueService>();
var mockedCommentService = new Mock <ICommentService>();
var mockedRatingService = new Mock <IRatingService>();
var mockedModel = new Mock <VenueDetailsViewModel>();
mockedView.Setup(x => x.Model).Returns(mockedModel.Object);
mockedCommentService.Setup(x => x.CreateComment(new Guid(), anyInt, anyString)).Verifiable();
var presenter = new VenueDetailsPresenter(mockedView.Object, mockedVenueService.Object, mockedCommentService.Object, mockedRatingService.Object);
mockedView.Raise(x => x.AddComment += null, new AddCommentEventArgs(mockedGuidString, anyString, anyString));
mockedCommentService.Verify(x => x.CreateComment(It.Is <Guid>(y => y == mockedGuid), anyInt, anyString), Times.Once);
}
public void View_UpdateRatingCallsAddRatingServiceAddRatingWithCorrecRating()
{
string anyString = "2";
int anyInt = 2;
var mockedGuid = Guid.Parse("E56F7468-AC9B-454C-A73E-E687DFC925B1");
var mockedGuidString = "E56F7468-AC9B-454C-A73E-E687DFC925B1";
var mockedView = new Mock <IVenueDetailsView>();
var mockedVenueService = new Mock <IVenueService>();
var mockedCommentService = new Mock <ICommentService>();
var mockedRatingService = new Mock <IRatingService>();
var mockedModel = new Mock <VenueDetailsViewModel>();
mockedView.Setup(x => x.Model).Returns(mockedModel.Object);
mockedRatingService.Setup(x => x.AddRating(new Guid(), anyInt, anyInt)).Verifiable();
var presenter = new VenueDetailsPresenter(mockedView.Object, mockedVenueService.Object, mockedCommentService.Object, mockedRatingService.Object);
mockedView.Raise(x => x.UpdateRating += null, new UpdateRatingEventArgs(mockedGuidString, anyString, anyString));
mockedRatingService.Verify(x => x.AddRating(mockedGuid, anyInt, It.Is <int>(y => y == anyInt)), Times.Once);
}
public void TestCase_HeaterIsDelayedPaused_AfterStarted_StatusCheckWithWiteBoxTest()
{
bool IsOn = false;
TestController.EActivityChanged += (sender, e) =>
{
TestStatus = e.Status;
IsOn = e.TurnOn;
};
TestController.Start();
TestController.DelayedPause();
MockedDelayControllerPause.Verify(obj => obj.SetTime(new HeaterParameters().DurationDelayPause));
MockedDelayControllerPause.Verify(obj => obj.Start());
MockedDelayControllerPause.Raise(obj => obj.Elapsed += null, new EventArgs() as ElapsedEventArgs);
Assert.AreEqual(HeaterStatus.ControllerState.ControllerIsPaused, TestStatus.ActualControllerState);
Assert.AreEqual(HeaterStatus.OperationState.RegularOperation, TestStatus.ActualOperationState);
Assert.IsFalse(IsOn);
}
public void SetLeagueTablesToViewModel_WhenOnGetLeaguesIsRaised()
{
var viewMock = new Mock <ILeaguesView>();
var leagueServiceMock = new Mock <ILeagueService>();
IEnumerable <League> leagues = new List <League>()
{
new League()
};
leagueServiceMock.Setup(x => x.GetAlLeagues()).Returns(leagues);
LeaguesViewModel model = new LeaguesViewModel();
viewMock.Setup(x => x.Model).Returns(model);
LeaguePresenter presenter = new LeaguePresenter(viewMock.Object, leagueServiceMock.Object);
viewMock.Raise(x => x.OnGetLeagues += null, new IdEventArgs(8));
Assert.AreEqual(leagues, viewMock.Object.Model.Leagues);
}
public void HotspotPropertyChanged_SpanProperty_RaisesPropertyChangedForLineAndColumn()
{
var eventHandler = new Mock <PropertyChangedEventHandler>();
var issueViz = new Mock <IAnalysisIssueVisualization>();
var testSubject = CreateTestSubject(issueViz.Object);
testSubject.PropertyChanged += eventHandler.Object;
eventHandler.VerifyNoOtherCalls();
issueViz.Raise(x => x.PropertyChanged += null, new PropertyChangedEventArgs(nameof(IAnalysisIssueVisualization.Span)));
eventHandler.Verify(x => x(testSubject,
It.Is((PropertyChangedEventArgs args) => args.PropertyName == nameof(IHotspotViewModel.Line))),
Times.Once);
eventHandler.Verify(x => x(testSubject,
It.Is((PropertyChangedEventArgs args) => args.PropertyName == nameof(IHotspotViewModel.Column))),
Times.Once);
eventHandler.VerifyNoOtherCalls();
}
public void EditVocabularyPresenter_SaveTerm_Does_Not_Save_If_Term_Invalid()
{
// Arrange
var mockView = new Mock <IEditVocabularyView>();
var editModel = new EditVocabularyModel {
Term = new Term {
TermId = Constants.TERM_UpdateTermId
}
};
mockView.Setup(v => v.Model).Returns(editModel);
EditVocabularyPresenter presenter = CreatePresenter(mockView, true);
Mock <ObjectValidator> mockValidator = MockHelper.EnableInvalidMockValidator(presenter.Validator, editModel.Term);
// Act
mockView.Raise(v => v.SaveTerm += null, EventArgs.Empty);
// Assert
Mock.Get(presenter.TermController).Verify(r => r.UpdateTerm(It.IsAny <Term>()), Times.Never());
}
public void WhenUnsubscribe_MessageSubscribersNotCalled()
{
// Arrange
Mock <IConnectionManager> manager = new Mock <IConnectionManager>();
Realtime.Channel target = new Realtime.Channel("test", "client", manager.Object);
Message[] receivedMessage = null;
Action <Message[]> action = (m) => receivedMessage = m;
target.Subscribe("test", action);
// Act
target.Unsubscribe("test", action);
Message[] targetMessages = new Message[] { new Message("test", null), new Message("test2", null) };
manager.Raise(c => c.MessageReceived += null, new ProtocolMessage(ProtocolMessage.MessageAction.Message, "test")
{
Messages = targetMessages
});
// Assert
Assert.Null(receivedMessage);
}
public void EditVocabularyPresenter_SaveTerm_Validates_Term()
{
// Arrange
var mockView = new Mock <IEditVocabularyView>();
var editModel = new EditVocabularyModel {
Term = new Term {
TermId = Constants.TERM_UpdateTermId
}
};
mockView.Setup(v => v.Model).Returns(editModel);
EditVocabularyPresenter presenter = CreatePresenter(mockView, true);
Mock <ObjectValidator> mockValidator = MockHelper.EnableValidMockValidator(presenter.Validator, editModel.Term);
// Act
mockView.Raise(v => v.SaveTerm += null, EventArgs.Empty);
// Assert
mockValidator.Verify(v => v.ValidateObject(It.IsAny <Term>()));
}
public void Interception_OfAnyMessage_FailsWithException()
{
Mock <IDialog> dialogStub = new Mock <IDialog>();
Mock <IMessageFilter> messageFilterStub = new Mock <IMessageFilter>();
Mock <IMessage> messageStub = new Mock <IMessage>();
Mock <IDialogProvider> dialogProviderStub = new Mock <IDialogProvider>();
messageFilterStub.Setup(x => x.Intercept(It.IsAny <IMessage>())).Returns(true);
using (MessageInterceptor <IMessage> messageInterceptor = new MessageInterceptor <IMessage>(dialogStub.Object,
messageFilterStub.Object,
(MessageReceivedEventArgs <IMessage> e) =>
{
throw new InvalidOperationException();
}))
{
Assert.ThrowsException <InvalidOperationException>(() =>
{
dialogStub.Raise(x => x.MessageDispatching += null, new MessageDispatchingEventArgs(messageStub.Object,
dialogProviderStub.Object));
});
}
}
public void TestViewMyCheckout_ShouldSetViewModelIsCheckoutSuccessfullToTrue(string name, string address, string phoneNumber)
{
var mockedView = new Mock <ICheckoutView>();
mockedView.Setup(v => v.Model).Returns(new CheckoutViewModel());
var mockedUserService = new Mock <IUserService>();
var mockedAuthenticationProvider = new Mock <IAuthenticationProvider>();
var mockedViewModelFactory = new Mock <IViewModelFactory>();
var mockedCart = new Mock <IShoppingCart>();
var checkoutPresenter = new CheckoutPresenter(mockedView.Object,
mockedAuthenticationProvider.Object,
mockedUserService.Object,
mockedViewModelFactory.Object,
mockedCart.Object);
var args = new CheckoutEventArgs(name, address, phoneNumber);
mockedView.Raise(v => v.MyCheckout += null, args);
Assert.IsTrue(mockedView.Object.Model.IsCheckoutSuccessful);
}
public async Task WaitBlockersAsync_AddAndRelease2BlockersBeforeWaiting_NoWaiting()
{
// ARRANGE
using var animationBlockerService = new AnimationBlockerService();
var blockerMock1 = new Mock <ICommandBlocker>();
var blocker1 = blockerMock1.Object;
var blockerMock2 = new Mock <ICommandBlocker>();
var blocker2 = blockerMock1.Object;
animationBlockerService.AddBlocker(blocker1);
animationBlockerService.AddBlocker(blocker2);
blockerMock1.Raise(x => x.Released += null, EventArgs.Empty);
blockerMock2.Raise(x => x.Released += null, EventArgs.Empty);
// ACT
await animationBlockerService.WaitBlockersAsync().ConfigureAwait(false);
// ASSERT
Assert.Pass();
}
public void AddAllCountriesToViewModel_WhenOnGetAllCountriesEventIsRaised()
{
var footballPlayerServiceMock = new Mock <IFootballPlayerService>();
var countryServiceMock = new Mock <ICountryService>();
var teamServiceMock = new Mock <ITeamService>();
var viewMock = new Mock <IManageFootballPlayersView>();
viewMock.Setup(v => v.Model).Returns(new ManageFootballPlayersViewModel());
IEnumerable <Country> countries = new List <Country>();
countryServiceMock.Setup(x => x.GetAllCountries()).Returns(countries);
ManageFootballPlayersPresenter scoresPresenter = new ManageFootballPlayersPresenter(
viewMock.Object,
footballPlayerServiceMock.Object,
countryServiceMock.Object,
teamServiceMock.Object);
viewMock.Raise(x => x.OnGetAllCoutries += null, EventArgs.Empty);
CollectionAssert.AreEquivalent(countries, viewMock.Object.Model.Countries);
}
public void AddPicturePathToViewModel_WhenOnGetPicturePathEventIsRaised(string testPicturePath)
{
// Arrange
var searchViewMock = new Mock <ISearchView>();
searchViewMock.SetupGet(view => view.Model).Returns(new SearchViewModel());
var advertServiceMock = new Mock <IAdvertServices>();
var pictureServiceMock = new Mock <IPictureServices>();
pictureServiceMock.Setup(p => p.GetFirstPicturesNameByAdvertId(It.IsAny <int>())).Returns(testPicturePath);
var searcherPresenter = new SearcherPresenter(searchViewMock.Object, advertServiceMock.Object, pictureServiceMock.Object);
var getPictureEvetnArgs = new GetPicturePathEventArgs(3);
// Act
searchViewMock.Raise(v => v.OnGetPicturePath += null, getPictureEvetnArgs);
// Assert
CollectionAssert.AreEquivalent(testPicturePath, searchViewMock.Object.Model.PicturePath);
}
public void ReplacementSelectionOverwritesAdjustmentOnParseAfterRecoverSelectionsOnNextParse()
{
var selectionServiceMock = TestSelectionServiceMock();
var parseManagerMock = new Mock <IParseManager>();
var selectionRecoverer = new SelectionRecoverer(selectionServiceMock.Object, parseManagerMock.Object);
var selectionOffset = new Selection(0, 2, 4, 5);
var selectionReplacement = new Selection(22, 2, 44, 5);
selectionRecoverer.SaveSelections(_testModuleSelections
.Select(qualifiedSelection => qualifiedSelection.QualifiedName).Take(1));
selectionRecoverer.AdjustSavedSelection(_testModuleSelections[0].QualifiedName, selectionOffset);
selectionRecoverer.ReplaceSavedSelection(_testModuleSelections[0].QualifiedName, selectionReplacement);
selectionRecoverer.RecoverSavedSelectionsOnNextParse();
var stateEventArgs = new ParserStateEventArgs(_stateExpectedToTriggerTheRecovery, ParserState.Pending,
CancellationToken.None);
parseManagerMock.Raise(m => m.StateChanged += null, stateEventArgs);
selectionServiceMock.Verify(
m => m.TrySetSelection(_testModuleSelections[0].QualifiedName, selectionReplacement), Times.Once);
}
public void AppendGetUserToViewModel_WhenOnViewGetUserIsRaised()
{
var viewMock = new Mock <IUserView>();
var userService = new Mock <IUserService>();
var trollPhotoService = new Mock <ITrollPhotoService>();
string id = "id";
User user = new User()
{
Id = id
};
userService.Setup(x => x.GetUserById(It.IsAny <string>())).Returns(user);
UserViewModel model = new UserViewModel();
viewMock.Setup(x => x.Model).Returns(model);
UserPresenter presenter = new UserPresenter(viewMock.Object, userService.Object, trollPhotoService.Object);
viewMock.Raise(x => x.GetUser += null, new UserIdEventArgs(id));
Assert.AreSame(user, viewMock.Object.Model.User);
}
public void WeakEventManager_AddWeakEventListener_Custom_FiresEvent()
{
var source = new Mock <INotifyPropertyChanged>();
var invocations = 0;
var wem = new WeakEventManager();
wem.AddWeakEventListener <INotifyPropertyChanged, PropertyChangedEventArgs>(
source.Object,
nameof(INotifyPropertyChanged.PropertyChanged),
(s, a) =>
{
s.ShouldBe(source.Object);
invocations++;
}
);
source.Raise(x => x.PropertyChanged += null, new PropertyChangedEventArgs("Foo"));
invocations.ShouldBe(1);
}
public void GameFinishedFired()
{
var field = new Mock <IAsteroidField>();
var ship = new Mock <ISpaceShip>();
var container = new Container();
container.RegisterType <Flight>();
container.RegisterInstance(field.Object);
container.RegisterInstance(ship.Object);
container.RegisterInstance(new Mock <IShipController>().Object);
var flight = container.Resolve <Flight>();
flight.StartNewFlight();
bool gameFinishedFired = false;
flight.GameFinished += () => { gameFinishedFired = true; };
ship.SetupGet(s => s.Hp).Returns(0);
ship.Raise(s => s.HpChanged += null);
Assert.AreEqual(true, gameFinishedFired);
}
public void SetViewModelTitleCorrectly()
{
//Arrange
var mockedView = new Mock <IPageView>();
mockedView.Setup(v => v.Model).Returns(new PageViewModel());
var mockedPageService = new Mock <IPageService>();
var mockedConverter = new Mock <IMarkupConverter>();
var pagePresenterUnderTest = new PagePresenter(mockedView.Object, mockedPageService.Object, mockedConverter.Object);
string expectedTitle = "page title";
var page = new SotnWiki.Models.Page()
{
Title = expectedTitle
};
mockedPageService.Setup(x => x.GetPageByTitle(It.IsAny <string>())).Returns(page);
//Act
mockedView.Raise(v => v.OnPageGetContent += null, new PageEventArgs(""));
//Assert
Assert.AreEqual(expectedTitle, mockedView.Object.Model.Title);
}
public void OneRecordExpire()
{
var name = "scooby.doo.local";
var recordType = 1;
var ttl = 1;
var timer = new Mock <ITimer>();
var serviceCache = new ServiceCache(timer.Object);
var packet = CreatePacket(new[] { new Tuple <string, int, int>(name, recordType, ttl) });
var verified = false;
serviceCache.AddPacket(packet);
serviceCache.RequestUpdate += (x) =>
{
Assert.AreEqual(x.Length, 1);
Assert.AreEqual(x[0].Item1, name);
Assert.AreEqual(x[0].Item2, recordType);
verified = true;
};
Thread.Sleep(1000);
timer.Raise(x => x.Fired += null);
Assert.IsTrue(verified);
}
public void Test_ConsumerFrameCreatedChanged()
{
var mockOscListener = new Mock <IOscListener>();
var oscEventHub = new CasparCGOscEventsHub(mockOscListener.Object);
var expectedframesCreated = 200;
var expectedAvailableFrames = 999999999;
var expectedPortId = 9;
ConsumerFrameCreatedEventArgs args = null;
oscEventHub.ConsumerFrameCreatedChanged += (s, e) =>
{
args = e;
};
mockOscListener.Raise(f => f.OscMessageReceived += null, this, new OscMessageEventArgs(new OscMessage($"/channel/1/output/port/{expectedPortId}/frame", expectedframesCreated, expectedAvailableFrames)));
Assert.NotNull(args);
Assert.Equal(1, args.ChannelId);
Assert.Equal(args.PortId, (uint)expectedPortId);
Assert.Equal(args.FramesCreated, expectedframesCreated);
Assert.Equal(args.AvailableFrames, expectedAvailableFrames);
}
public void TestOfFiringACreatedEvent()
{
var sendingFileMoq = new Mock <ISendingFile>();
var fileSenderMoq = new Mock <IFileSender>();
fileSenderMoq.Setup(s => s.Send("a\\b")).Verifiable();
var folderWatcherMoq = new Mock <IFileWatcher>();
var manipulatorMoq = new Mock <IFileManipulator>();
var loggerMoq = new Mock <ILog>();
FileHandler fileHandler =
new FileHandler("doesn't matter", "doesn't matter again", folderWatcherMoq.Object, manipulatorMoq.Object, fileSenderMoq.Object, loggerMoq.Object);
fileHandler.Enable();
folderWatcherMoq.Raise((m => m.Created += null), new FileSystemEventArgs(WatcherChangeTypes.All, "a", "b"));
fileSenderMoq.Verify(s => s.Send("a\\b"), Times.Once);
}
