public void PutsDashboardsIntoListViewWhenTheyAreLoaded() { var dashboards = new[] { new JiraDashboard("Dashboard 1000", 1000), new JiraDashboard("Dashboard 2000", 2000) }; _presenter.Initialize(_view); _view.JiraUrl = "http://somejira.atlassian.net"; _jira.GetDashboardsAsync(Arg.Any <Uri>(), Arg.Any <JiraCredentials>()) .Returns(Task.FromResult(dashboards.AsEnumerable())); // _view.LoadDashboardsButtonClicked += Raise.Event(); // _view.Received().DashboardItems = Arg.Do <IDashboardDisplayItem[]>( a => Assert.That(a, Is.EquivalentTo(dashboards))); }
public void UsesCredentialsFromPreferencesWhenLoadingDashboard() { var credentials = Substitute.For <JiraCredentials>(); _preferences.GetPreferences() .Returns(new Preferences { LoginCookies = credentials }); _presenter.Initialize(_view); _view.JiraUrl = "http://somejira.atlassian.net"; // _view.LoadDashboardsButtonClicked += Raise.Event(); // _jira.Received().GetDashboardsAsync(Arg.Any <Uri>(), credentials); }
public void SavesNoCredentialsInPreferencesIfTheyAreCleared() { _presenter.Initialize(_view); _view.JiraUrl = "http://somejira.atlassian.net"; _view.SelectedDashboardItem = new JiraDashboard("", 1); _childPresenter.When(c => c.Initialize(_childView, Arg.Any <IJiraLoginParent>())) .Do(c => c.Arg <IJiraLoginParent>().ClearJiraCredentials()); // _view.JiraLoginButtonClicked += Raise.Event(); _view.SaveButtonClicked += Raise.Event(); // _preferences.Received() .SetPreferences(Arg.Is <Preferences>( p => p.LoginCookies.Count == 0 && p.LoginUsername == null)); }
public void Should_be_executed_when_the_message_handler_complete_message() { // Arrange var model = Substitute.For <IModel>(); model.IsOpen.Returns(true); var msgHandler = Substitute.For <IMessageHandler>(); var consumer = new BurrowConsumerForTest(model, msgHandler, Substitute.For <IRabbitWatcher>(), true, 3) { ConsumerTag = "ConsumerTag" }; // Action msgHandler.HandlingComplete += Raise.Event <MessageHandlingEvent>(BurrowConsumerForTest.ADeliverEventArgs); Assert.IsTrue(consumer.WaitHandler.WaitOne(5000), "Test wait timeout"); // Assert model.Received().BasicAck(Arg.Any <ulong>(), false); consumer.Dispose(); }
public async Task ClosingTextViewDisposesFile() { var textView = CreateTextView(); var target = new PullRequestSessionManager( CreatePullRequestService(), CreateSessionService(), CreateConnectionManager(), CreateModelServiceFactory(), CreateTeamExplorerContext(CreateRepositoryModel())); var file = (PullRequestSessionLiveFile)await target.GetLiveFile(FilePath, textView, textView.TextBuffer); var compositeDisposable = file.ToDispose as CompositeDisposable; Assert.That(compositeDisposable, Is.Not.Null); Assert.That(compositeDisposable.IsDisposed, Is.False); textView.Closed += Raise.Event(); Assert.That(compositeDisposable.IsDisposed, Is.True); }
public void NetworkInterfacesAdded_ShouldBeRaised_WhenNewInterfaceAdded() { // Arrange var wasRaised = false; _interfaces.Interfaces().Returns(new INetworkInterface[] { new TestNetworkInterface("n1") }); var subject = new ObservableNetworkInterfaces(_interfaces); subject.NetworkInterfacesAdded += (s, e) => wasRaised = true; _interfaces.NetworkAddressChanged += Raise.Event(); _interfaces.Interfaces() .Returns(new INetworkInterface[] { new TestNetworkInterface("n1"), new TestNetworkInterface("n2") }); wasRaised = false; // Act _interfaces.NetworkAddressChanged += Raise.Event(); // Assert wasRaised.Should().BeTrue(); }
public void WhenPasteIsRequestedSelectedActionIsInvoked() { var fakeAction = Substitute.For <IActionViewModel>(); SystemUnderTest.SelectedAction = fakeAction; var fakeElement = Substitute.For <IClipboardDataControlPackage>(); SystemUnderTest.SelectedElement = fakeElement; var fakeMediator = Container.Resolve <IClipboardUserInterfaceInteractionMediator>(); fakeMediator.PastePerformed += Raise.Event <EventHandler <PastePerformedEventArgument> >(new object()); fakeAction .Received() .Action .PerformAsync(Arg.Any <IClipboardDataPackage>()); }
ValueTarget_Is_Not_Updated_On_Localizer_CultureTracker_CultureChanged_When_ValueTarget_Has_Been_Unloaded() { var msgId = "msgID"; var text = "text"; var oldText = "old text"; _valueTarget.Text = oldText; var @params = new object[] { "foo", 42 }; var target = new GettextExtension(msgId, @params); GettextExtension.Localizer = Substitute.For <ILocalizer>(); target.ProvideValue(_serviceProvider); _valueTarget.RaiseEvent(new RoutedEventArgs(FrameworkElement.UnloadedEvent)); GettextExtension.Localizer.Catalog.GetString(Arg.Is(msgId), Arg.Is(@params)).Returns(text); GettextExtension.Localizer.CultureTracker.CultureChanged += Raise.Event <EventHandler <CultureEventArgs> >(new CultureEventArgs(new CultureInfo("en-US"))); Assert.Equal(oldText, _valueTarget.Text); }
private async Task <TestResult> StartStop(Context context, bool processingQueueEmpty = true, bool newBestSuggestedBlock = false, int stepDelayMultiplier = 100) { AutoResetEvent processedEvent = new AutoResetEvent(false); context.BlockTree.SuggestBlock(Arg.Any <Block>(), Arg.Any <bool>()) .Returns(AddBlockResult.Added) .AndDoes(c => { processedEvent.Set(); }); context.AuRaBlockProducer.Start(); await processedEvent.WaitOneAsync(context.StepDelay *stepDelayMultiplier, CancellationToken.None); context.BlockTree.ClearReceivedCalls(); try { await Task.Delay(context.StepDelay); if (processingQueueEmpty) { context.BlockProcessingQueue.ProcessingQueueEmpty += Raise.Event(); } if (newBestSuggestedBlock) { context.BlockTree.NewBestSuggestedBlock += Raise.EventWith(new BlockEventArgs(Build.A.Block.TestObject)); context.BlockTree.ClearReceivedCalls(); } await processedEvent.WaitOneAsync(context.StepDelay *stepDelayMultiplier, CancellationToken.None); } finally { await context.AuRaBlockProducer.StopAsync(); } return(new TestResult(q => context.BlockTree.Received(q).SuggestBlock(Arg.Any <Block>(), Arg.Any <bool>()))); }
public void CanRaiseEvents() { var calculator = Mock.Of <ICalculator>(); calculator.InsertBehavior(0, new EventBehavior()); var raised = false; EventHandler handler = (sender, args) => raised = true; calculator.PoweringUp += handler; calculator.PoweringUp += Raise.Event(); Assert.True(raised); raised = false; calculator.PoweringUp -= handler; calculator.PoweringUp -= handler; calculator.PoweringUp += Raise(); Assert.False(raised); var property = ""; calculator.PropertyChanged += (sender, args) => property = args.PropertyName; calculator.PropertyChanged += Raise <PropertyChangedEventHandler>(new PropertyChangedEventArgs("Mode")); Assert.Equal("Mode", property); var progress = 0; calculator.Progress += (_, i) => progress = i; calculator.Progress += Raise(10); Assert.Equal(10, progress); }
public void PublishAsync_Where_A_Single_Publication_Configuration_Which_Results_In_A_Successfull_Publication() { var _busConfigurationBuilder = new BusConfigurationBuilder(); _busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri); _busConfigurationBuilder .RegisterPublication <MyEvent>( TestingConfiguration.ExchangeName, typeof(MyEvent).Name); var _busConfirguration = _busConfigurationBuilder.Build(); var _connectionManager = Substitute.For <IConnectionManager>(); var _connection = Substitute.For <IConnection>(); var _channel = Substitute.For <IModel>(); var _context = Substitute.For <IBusContext>(); var _waitHandle = new AutoResetEvent(false); _connectionManager.Connection.Returns(_connection); _connection.CreateModel().Returns(_channel); _channel.NextPublishSeqNo.Returns(1UL); _channel .When(channel => channel.BasicPublish(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IBasicProperties>(), Arg.Any <byte[]>())) .Do(callInfo => _waitHandle.Set()); var _SUT = new Connected( _busConfirguration, _connectionManager, _context); var _theEvent = new MyEvent(Guid.NewGuid(), null, "Some detail", 1); var _publicationResult = _SUT.PublishAsync(_theEvent); _waitHandle.WaitOne(); // Allow publication to complete _channel.BasicAcks += Raise.Event <BasicAckEventHandler>(_channel, new BasicAckEventArgs { Multiple = true, DeliveryTag = 10 }); _publicationResult.Wait(); Assert.AreEqual(PMCG.Messaging.PublicationResultStatus.Published, _publicationResult.Result.Status); }
public void Should_start_a_thread_to_dequeue_on_priority_queue() { // Arrange var dequeueCount = new AutoResetEvent(false); var enqueueCount = new AutoResetEvent(false); var channel = Substitute.For <IModel>(); var queue = Substitute.For <IInMemoryPriorityQueue <GenericPriorityMessage <BasicDeliverEventArgs> > >(); queue.Dequeue().Returns(new GenericPriorityMessage <BasicDeliverEventArgs>(new BasicDeliverEventArgs(), 1)); queue.When(x => x.Dequeue()).Do(callInfo => dequeueCount.Set()); queue.When(x => x.Enqueue(Arg.Any <GenericPriorityMessage <BasicDeliverEventArgs> >())) .Do(callInfo => enqueueCount.Set()); var handler = Substitute.For <IMessageHandler>(); handler.When(h => h.HandleMessage(Arg.Any <BasicDeliverEventArgs>())) .Do(callInfo => handler.HandlingComplete += Raise.Event <MessageHandlingEvent>(new BasicDeliverEventArgs())); var consumer = new PriorityBurrowConsumer(channel, handler, Substitute.For <IRabbitWatcher>(), true, 1); var sub = Substitute.For <CompositeSubscription>(); sub.AddSubscription(new Subscription(channel) { ConsumerTag = "Burrow" }); consumer.Init(queue, sub, 1, Guid.NewGuid().ToString()); // Action consumer.Ready(); dequeueCount.WaitOne(); consumer.PriorityQueue.Enqueue(new GenericPriorityMessage <BasicDeliverEventArgs>(new BasicDeliverEventArgs(), 1)); enqueueCount.WaitOne(); // Assert consumer.Dispose(); }
public void CanRaiseEvents() { var calculator = Mock.Of <ICalculator>().Named("calculator"); var raised = false; EventHandler handler = (sender, args) => raised = true; calculator.TurnedOn += handler; calculator.TurnedOn += Raise.Event(); Assert.True(raised); raised = false; calculator.TurnedOn -= handler; calculator.TurnedOn -= handler; calculator.TurnedOn += Raise(); Assert.False(raised); }
public void DeleteTest() { var fileHandler = Substitute.For <IFileHandler>(); fileHandler.ReadAllLines(Arg.Any <string>()).Returns(Entries.vcfThreeEntry); var repo = Substitute.For <ContactRepository>(fileHandler); var view = Substitute.For <IMainView>(); var presenter = new MainPresenter(view, repo); view.NewFileOpened += Raise.EventWith(new EventArg <string>("aaa.vcf")); //Mouse click on second row. repo.Contacts[1].isSelected = true; //Delete the second one. view.DeleteContact += Raise.Event(); Assert.AreEqual(repo.Contacts.Count, 2); Assert.AreEqual(repo.Contacts[1].card.FormattedName, "Jean Dupont3"); }
public async Task TwoWay_Command_Does_Not_Throw_When_Command_Is_Misused() { var test = new TestInContextAsync() { Bind = (win) => HtmlBinding.Bind(win, _DataContext, JavascriptBindingMode.TwoWay), Test = async(mb) => { await DoSafeAsyncUI(() => { _Command.CanExecuteChanged += Raise.Event <EventHandler>(null, new EventArgs()); }); await WaitAnotherWebContextCycle(); await WaitAnotherUiCycle(); } }; Func <Task> @do = () => RunAsync(test); await @do.Should().NotThrowAsync(); }
public void CheckingPillsToTakeAt_12H_Test() { // Test Set ups testDependencyIntialize(new DateTime(2019, 1, 23, 12, 0, 0)); List <Tuple <Pill, Time> > recivedPillsToTakke = new List <Tuple <Pill, Time> >(); List <Tuple <Pill, Time> > exceptedPills = new List <Tuple <Pill, Time> >() { new Tuple <Pill, Time>(testPills[0], new Time(12, 0, 0)), new Tuple <Pill, Time>(testPills[2], new Time(12, 0, 0)) }.OrderBy(p => p.Item1.Name).ToList(); PillReminderManager reminderManager = new PillReminderManager(new Time(0, 5, 0), pillReminderIOMock, timeProvider, timerMock); reminderManager.OnNewTaskReminder += (o, s) => recivedPillsToTakke = s.PillToTakeWithTime; timerMock.Elapsed += Raise.Event <ElapsedEventHandler>(this, createElapsedEventArgs(new Time(12, 0, 0).ToDateTime())); Assert.That(recivedPillsToTakke.OrderBy(p => p.Item1.Name).ToList().SequenceEqual(exceptedPills)); }
public void Should_throw_exception_if_dedicated_publish_channel_is_not_connected() { // Arrange var newChannel = Substitute.For <IModel>(); newChannel.IsOpen.Returns(false); var routeFinder = Substitute.For <IRouteFinder>(); var durableConnection = Substitute.For <IDurableConnection>(); durableConnection.ConnectionFactory.Returns(Substitute.For <ConnectionFactory>()); durableConnection.When(x => x.Connect()).Do(callInfo => { durableConnection.Connected += Raise.Event <Action>(); durableConnection.IsConnected.Returns(true); }); durableConnection.CreateChannel().Returns(newChannel); var tunnel = new RabbitTunnelWithPriorityQueuesSupport(routeFinder, durableConnection); // Action tunnel.Publish("Muahaha", 10); }
public void When_response_returns_attachment_send_attachment() { var rocketMessage = AutoFixture.Create <RocketMessage>(); var basicResponses = AutoFixture.Build <AttachmentResponse>().CreateMany().ToList(); var responseMock = Substitute.For <IBotResponse>(); responseMock.CanRespond(Arg.Any <ResponseContext>()).Returns(true); responseMock.GetResponse(Arg.Any <ResponseContext>(), Arg.Any <RocketChatBot>()).Returns(basicResponses); var bot = new RocketChatBot(_driverMock, _loggerMock); bot.AddResponse(responseMock); // Act _driverMock.MessageReceived += Raise.Event <MessageReceived>(rocketMessage); Thread.Sleep(200); // Assert _driverMock.Received(basicResponses.Count) .SendCustomMessageAsync(Arg.Is <Attachment>(s => basicResponses.Any(x => x.Attachment.Equals(s))), Arg.Any <string>()); }
public void CurrentSessionChangesToNullIfNoPullRequestForCurrentBranch() { var service = CreatePullRequestService(); var teamExplorerContext = CreateTeamExplorerContext(CreateRepositoryModel()); var target = new PullRequestSessionManager( service, Substitute.For <IPullRequestSessionService>(), CreateConnectionManager(), CreateModelServiceFactory(), teamExplorerContext); Assert.That(target.CurrentSession, Is.Not.Null); Tuple <string, int> newPullRequest = null; service.GetPullRequestForCurrentBranch(null).ReturnsForAnyArgs(Observable.Return(newPullRequest)); teamExplorerContext.StatusChanged += Raise.Event(); var session = target.CurrentSession; Assert.That(session, Is.Null); }
public void RequestingSaveShouldCallSaveMethod() { // Arrange var configurationBuilder = Substitute.For <IConfigurationBuilder>(); var configuration = Substitute.For <IConfiguration>(); var saveActionExecuted = false; Action saveAction = () => { saveActionExecuted = true; }; var popupService = Substitute.For <IPopupService>(); var sut = new ProjectsSectionViewModel(configurationBuilder, configuration, saveAction, popupService); var model = Substitute.For <IProjectConfiguration>(); var project = Substitute.For <ProjectViewModel>(model, configuration); sut.AddProjectViewModel(project); // Act project.SaveRequested += Raise.Event(); // Assert Assert.True(saveActionExecuted); }
public void Publish_Where_Single_Publication_Published_And_Acked_Results_In_Task_Completion() { var _connection = Substitute.For <IConnection>(); var _channel = Substitute.For <IModel>(); var _publicationQueue = new BlockingCollection <Publication>(); var _messageProperties = Substitute.For <IBasicProperties>(); var _waitHandle = new AutoResetEvent(false); _connection.CreateModel().Returns(_channel); _channel.CreateBasicProperties().Returns(_messageProperties); _channel.NextPublishSeqNo.Returns(1UL); _channel .When(channel => channel.BasicPublish(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IBasicProperties>(), Arg.Any <byte[]>())) .Do(callInfo => _waitHandle.Set()); var _SUT = new Publisher(_connection, _publicationQueue, CancellationToken.None); _SUT.Start(); // Can't capture result due to compiler treating warnings as errors - var is not used var _messageDelivery = new MessageDelivery("test_publisher_confirms", typeof(MyEvent).Name, MessageDeliveryMode.Persistent, message => "ARoutingKey"); var _myEvent = new MyEvent(Guid.NewGuid(), "CorrlationId_1", "Detail", 1); var _taskCompletionSource = new TaskCompletionSource <PublicationResult>(); var _publication = new Publication(_messageDelivery, _myEvent, _taskCompletionSource); _publicationQueue.Add(_publication); _waitHandle.WaitOne(); // Allow publication to complete _channel.BasicAcks += Raise.Event <BasicAckEventHandler>(_channel, new BasicAckEventArgs { Multiple = false, DeliveryTag = 1 }); Assert.IsTrue(_publication.ResultTask.IsCompleted); _messageProperties.Received().ContentType = "application/json"; _messageProperties.Received().DeliveryMode = (byte)_messageDelivery.DeliveryMode; _messageProperties.Received().Type = _messageDelivery.TypeHeader; _messageProperties.Received().MessageId = _myEvent.Id.ToString(); _messageProperties.Received().CorrelationId = _myEvent.CorrelationId; _channel.Received().BasicPublish(_messageDelivery.ExchangeName, _messageDelivery.RoutingKeyFunc(_myEvent), _messageProperties, Arg.Any <byte[]>()); }
public void Publish_Where_Two_Messages_Being_Published_But_Channel_Is_Closed_Before_Acks_Received_Results_In_Two_Channel_Shutdown_Tasks() { var _connection = Substitute.For <IConnection>(); var _channel = Substitute.For <IModel>(); var _publicationQueue = new BlockingCollection <Publication>(); var _waitHandle = new CountdownEvent(2); _connection.CreateModel().Returns(_channel); _channel.NextPublishSeqNo.Returns(1Ul, 2UL); _channel .When(channel => channel.BasicPublish(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IBasicProperties>(), Arg.Any <byte[]>())) .Do(callInfo => _waitHandle.Signal()); var _SUT = new Publisher(_connection, _publicationQueue, CancellationToken.None); _SUT.Start(); var _messageDelivery = new MessageDelivery("test_publisher_confirms", typeof(MyEvent).Name, MessageDeliveryMode.Persistent, message => "ARoutingKey"); var _myEvent = new MyEvent(Guid.NewGuid(), "CorrlationId_1", "Detail", 100); var _taskCompletionSource1 = new TaskCompletionSource <PublicationResult>(); var _publication1 = new Publication(_messageDelivery, _myEvent, _taskCompletionSource1); var _taskCompletionSource2 = new TaskCompletionSource <PublicationResult>(); var _publication2 = new Publication(_messageDelivery, _myEvent, _taskCompletionSource2); _publicationQueue.Add(_publication1); _publicationQueue.Add(_publication2); _waitHandle.Wait(); // Allow channel publications to complete _channel.ModelShutdown += Raise.Event <ModelShutdownEventHandler>(_channel, new ShutdownEventArgs(ShutdownInitiator.Peer, 1, "Bang!")); // Since all running on the same thread we do not need to wait - this is also not relaistic as we know the channel shutdown event will happen on a different thread Assert.IsTrue(_publication1.ResultTask.IsCompleted); Assert.AreEqual(PublicationResultStatus.ChannelShutdown, _publication1.ResultTask.Result.Status); Assert.IsTrue(_publication1.ResultTask.Result.StatusContext.Contains("Bang!")); Assert.IsTrue(_publication2.ResultTask.IsCompleted); Assert.AreEqual(PublicationResultStatus.ChannelShutdown, _publication2.ResultTask.Result.Status); Assert.IsTrue(_publication2.ResultTask.Result.StatusContext.Contains("Bang!")); }
public async Task ShouldNotDisconnect_WhenDisconnectOnLockEnabledAndNotConnected() { // ARRANGE var id = "vpn1"; var vpn = new Vpn(id, "VPN 1"); var vpnConnectorDriver = Substitute.For <IVpnConnectorDriver>(); var vpnMonitorDriver = Substitute.For <IVpnMonitorDriver>(); vpnMonitorDriver.GetStatus(id).Returns(Task.FromResult(VpnStatus.Disconnected)); var systemEventsProvider = Substitute.For <ISystemEventsProvider>(); var sut = new VpnManager(vpn, vpnConnectorDriver, vpnMonitorDriver, systemEventsProvider) { DisconnectOnLock = true }; await sut.Monitor.Refresh(); // ACT systemEventsProvider.SessionLock += Raise.Event(); // ASSERT await vpnConnectorDriver.DidNotReceive().Disconnect(Arg.Is(id)); }
public void Changed_message_should_change_a_streaming_collection() { var payload = new { collection = AutoFixture.Create <string>(), id = AutoFixture.Create <string>(), fields = new { id = AutoFixture.Create <string>() } }; var mockCollection = Substitute.For <IStreamCollection>(); _mockCollectionDatabase.GetOrAddCollection(payload.collection).Returns(mockCollection); // Act _mockClient.DataReceivedRaw += Raise.Event <DataReceived>("changed", JObject.FromObject(payload)); // Assert mockCollection.Received().Changed(payload.id, Arg.Any <JObject>()); }
public void TreeShowsProperResult(ResultState resultState, int expectedIndex) { _model.IsPackageLoaded.Returns(true); _model.HasTests.Returns(true); var result = resultState.Status.ToString(); var label = resultState.Label; var testNode = new TestNode("<test-run id='1'><test-case id='123'/></test-run>"); var resultNode = new ResultNode(string.IsNullOrEmpty(label) ? string.Format($"<test-case id='123' result='{result}'/>") : string.Format($"<test-case id='123' result='{result}' label='{label}'/>")); _model.Tests.Returns(testNode); //var treeNode = _adapter.MakeTreeNode(result); //_adapter.NodeIndex[suiteResult.Id] = treeNode; _model.Events.TestLoaded += Raise.Event <TestNodeEventHandler>(new TestNodeEventArgs(testNode)); _model.Events.TestFinished += Raise.Event <TestResultEventHandler>(new TestResultEventArgs(resultNode)); _view.Tree.Received().SetImageIndex(Arg.Compat.Any <TreeNode>(), expectedIndex); }
public void Should_try_reconnect_by_retryPolicy_if_Connection_Shutdown_event_was_fired() { // Arrange var retryPolicy = Substitute.For <IRetryPolicy>(); var watcher = Substitute.For <IRabbitWatcher>(); IConnection rmqConnection; var connectionFactory = CreateMockConnectionFactory <ManagedConnectionFactory>("/", out rmqConnection); var durableConnection = new DurableConnection(retryPolicy, watcher, connectionFactory); durableConnection.Disconnected += () => { }; durableConnection.Connect(); Assert.AreEqual(1, ManagedConnectionFactory.SharedConnections.Count); // Action rmqConnection.ConnectionShutdown += Raise.Event <ConnectionShutdownEventHandler>(rmqConnection, new ShutdownEventArgs(ShutdownInitiator.Application, 0, "Connection dropped for unknow reason ;)")); //Assert Assert.AreEqual(0, ManagedConnectionFactory.SharedConnections.Count); retryPolicy.Received().WaitForNextRetry(Arg.Any <Action>()); }
public void When_response_returns_unsupported_response_throw() { var rocketMessage = AutoFixture.Create <RocketMessage>(); var basicResponses = AutoFixture.Build <MockMessageResponse>().CreateMany().ToList(); var responseMock = Substitute.For <IBotResponse>(); responseMock.CanRespond(Arg.Any <ResponseContext>()).Returns(true); responseMock.GetResponse(Arg.Any <ResponseContext>(), Arg.Any <RocketChatBot>()).Returns(basicResponses); var bot = new RocketChatBot(_driverMock, _loggerMock); bot.AddResponse(responseMock); // Act _driverMock.MessageReceived += Raise.Event <MessageReceived>(rocketMessage); Thread.Sleep(100); // Assert _driverMock.DidNotReceive().SendMessageAsync(Arg.Any <string>(), Arg.Any <string>()); _driverMock.DidNotReceive().SendCustomMessageAsync(Arg.Any <Attachment>(), Arg.Any <string>()); }
public void INDEX_BULK_EXCEPTION_IS_NOT_THROWN_IN_APPENDER() { //Arrange var appender = new ElasticSearchAppender(_elasticClientFactory, "index", "type", _timer, _tolerateCallsFactory, _bulk, _logEventConverterFactory, _elasticFilters, _fileAccessor, _eventWriter) { IndexAsync = false }; _elasticClient.WhenForAnyArgs(x => x.IndexBulkAsync(null)).Throw(new Exception()); var bulk = new List <InnerBulkOperation> { new InnerBulkOperation() }; _bulk.ResetBulk().Returns(bulk); appender.ActivateOptions(); //Act //Assert _timer.Elapsed += Raise.Event <EventHandler>(this, null); }
public void TestReduceStaminaWhenStructureDestroyedAndIsNoEarlyLevelReductionType(byte level, int expectedStamina) { var fixture = new Fixture().Customize(new AutoNSubstituteCustomization()); var target = Substitute.For <ICombatObject>(); target.Type.Returns((ushort)100); target.Lvl.Returns(level); target.ClassType.Returns(BattleClass.Structure); target.IsDead.Returns(true); var objectTypeFactory = Substitute.For <IObjectTypeFactory>(); objectTypeFactory.IsObjectType("BattleNoStaminaReductionEarlyLevels", 100).Returns(true); fixture.Register(() => objectTypeFactory); var battleFormulas = Substitute.For <IBattleFormulas>(); battleFormulas.GetStaminaStructureDestroyed(10, target).Returns((short)7); fixture.Register(() => battleFormulas); var battleManager = fixture.Freeze <IBattleManager>(); var staminaMonitor = fixture.Create <StaminaMonitor>(); staminaMonitor.Stamina = 10; battleManager.ActionAttacked += Raise.Event <BattleManager.OnAttack>(battleManager, BattleManager.BattleSide.Attack, Substitute.For <ICombatGroup>(), Substitute.For <ICombatObject>(), Substitute.For <ICombatGroup>(), target, 20m, 1, 1); staminaMonitor.Stamina.Should().Be((short)expectedStamina); }
public void ctor_WhenViewHasError_CallsLogger() { var stubView = Substitute.For <IView>(); var mockLogger = Substitute.For <ILogger>(); var presenter = new Presenter(stubView, mockLogger); // --- // var stubView = new Mock<IView>(); // var mockLogger = new Mock<ILogger>(); // var presenter = new Presenter(stubView.Object, mockLogger.Object); stubView.ErrorOccured += Raise.Event <Action <string> >("fake error"); // --- // stubView.Raise(view => view.ErrorOccured += null, "fake error"); mockLogger.Received() .LogError(Arg.Is <string>(s => s.Contains("fake error"))); // --- // mockLogger.Verify( // logger => logger.LogError(It.Is<string>( // s => s.Contains("fake error")))); }