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