public void MakeCollectBlockOperation_BlockShouldNotBeManaged_ResultIsSkipped(CollectBlockTestCase testCase) { var testContext = new TestContext() { ManageOtherGrids = testCase.ManageOtherGrids, AutoManageThisGrid = testCase.AutoManageThisGrid, AutoManageOtherGrids = testCase.AutoManageOtherGrids, IsBlockSameGrid = testCase.IsBlockSameGrid, IsBlockIgnored = testCase.IsBlockIgnored, IsBlockManaged = testCase.IsBlockManaged }; var mockBackgroundWorker = new FakeBackgroundWorker(); var result = testContext.Uut.MakeCollectBlockOperation(testContext.MockBlock.Object); result .ShouldRunToCompletion(mockBackgroundWorker); testContext.MockManagedBlockConfigManager .ShouldHaveReceived(x => x.MakeParseOperation(testContext.MockBlock.Object), 1); mockBackgroundWorker.MockSubOperationScheduler .ShouldHaveReceived(x => x(testContext.MockParseOperation.Object), 1); result.Result.IsSkipped.ShouldBeTrue(); }
public void CaptureMessage_AttachStacktraceFalse_DoesNotIncludeStackTrace() { // Arrange var worker = new FakeBackgroundWorker(); var hub = new Hub(new SentryOptions { Dsn = DsnSamples.ValidDsnWithSecret, BackgroundWorker = worker, AttachStacktrace = true }); // Act hub.CaptureMessage("test"); // Assert var envelope = worker.Queue.Single(); var stackTrace = envelope.Items .Select(i => i.Payload) .OfType <JsonSerializable>() .Select(i => i.Source) .OfType <SentryEvent>() .Single() .SentryExceptionValues; stackTrace.Should().BeNull(); }
public TestContext() { MockGasTankManager = new Mock <IGasTankManager>(); MockGasTankManager .Setup(x => x.Blocks.Count) .Returns(() => GasTankCount); MockLogger = new Mock <ILogger>(); MockDockingManagerSettingsProvider = new Mock <IDockingManagerSettingsProvider>(); MockDockingManagerSettingsProvider .Setup(x => x.Settings) .Returns(() => new DockingManagerSettings() { IgnoreBatteryBlocks = IgnoreOtherBlocks, IgnoreBeacons = IgnoreOtherBlocks, IgnoreGasGenerators = IgnoreOtherBlocks, IgnoreGasTanks = IgnoreGasTanks, IgnoreGyros = IgnoreOtherBlocks, IgnoreLandingGears = IgnoreOtherBlocks, IgnoreLightingBlocks = IgnoreOtherBlocks, IgnoreRadioAntennae = IgnoreOtherBlocks, IgnoreReactors = IgnoreOtherBlocks }); Uut = new GasTankCollectionHandler( MockGasTankManager.Object, MockLogger.Object, MockDockingManagerSettingsProvider.Object); MockBackgroundWorker = new FakeBackgroundWorker(); }
public TestContext() { BlockName = "blockName"; BlockTag = "blockTag"; MockLogger = new Mock <ILogger>(); _mockManagedBlockConfigParseHandlers = new List <Mock <IManagedBlockConfigParseHandler> >(); _managedBlockConfigParseHandlers = new List <IManagedBlockConfigParseHandler>(); MockManagerSettingsProvider = new Mock <IManagerSettingsProvider>(); MockManagerSettingsProvider .Setup(x => x.Settings) .Returns(() => new ManagerSettings() { BlockTag = BlockTag }); Uut = new ManagedBlockConfigManager( MockLogger.Object, _managedBlockConfigParseHandlers, MockManagerSettingsProvider.Object); MockBlock = new Mock <IMyTerminalBlock>(); MockBlock .Setup(x => x.CustomName) .Returns(() => BlockName); MockBlock .Setup(x => x.CustomData) .Returns(() => Config); MockBackgroundWorker = new FakeBackgroundWorker(); }
public void MakeCollectBlocksOperation_OperationIsDisposed_OperationIsRecycled(int handlerCount, int blockCount) { var testContext = new TestContext(); var mockBackgroundWorker = new FakeBackgroundWorker(); foreach (var _ in Enumerable.Repeat(0, blockCount)) { testContext.AddMockBlock(); } foreach (var _ in Enumerable.Repeat(0, handlerCount)) { testContext.AddMockBlockCollectionHandler(BlockCollectionResult.Ignored); } var result = testContext.Uut.MakeCollectBlocksOperation(); result.ShouldRunToCompletion(mockBackgroundWorker); var mockBlocksInvocations = testContext.MockBlocks .Select(x => x.Invocations.ToArray()) .ToArray(); var mockBlockCollectionHandlersInvocations = testContext.MockBlockCollectionHandlers .Select(x => x.Invocations.ToArray()) .ToArray(); result.ShouldBeAssignableTo <IDisposable>(); (result as IDisposable).Dispose(); testContext.MockBlocks .ForEach(x => x.Invocations.Clear()); testContext.MockBlockCollectionHandlers .ForEach(x => x.Invocations.Clear()); testContext.Uut.MakeCollectBlocksOperation() .ShouldBeSameAs(result); result.ShouldRunToCompletion(mockBackgroundWorker); foreach (var i in Enumerable.Range(0, mockBlocksInvocations.Length)) { testContext.MockBlocks[i].Invocations.Count.ShouldBe(mockBlocksInvocations[i].Length); foreach (var j in Enumerable.Range(0, mockBlocksInvocations[i].Length)) { testContext.MockBlocks[i].Invocations[j].ShouldBe(mockBlocksInvocations[i][j]); } } foreach (var i in Enumerable.Range(0, mockBlockCollectionHandlersInvocations.Length)) { testContext.MockBlockCollectionHandlers[i].Invocations.Count.ShouldBe(mockBlockCollectionHandlersInvocations[i].Length); foreach (var j in Enumerable.Range(0, mockBlockCollectionHandlersInvocations[i].Length)) { testContext.MockBlockCollectionHandlers[i].Invocations[j].ShouldBe(mockBlockCollectionHandlersInvocations[i][j]); } } }
public TestContext() { MockFunctionalBlockManager = new Mock <IFunctionalBlockManager>(); MockFunctionalBlockManager .Setup(x => x.BeaconCount) .Returns(() => BeaconCount); MockFunctionalBlockManager .Setup(x => x.GasGeneratorCount) .Returns(() => GasGeneratorCount); MockFunctionalBlockManager .Setup(x => x.GyroCount) .Returns(() => GyroCount); MockFunctionalBlockManager .Setup(x => x.LightingBlockCount) .Returns(() => LightingBlockCount); MockFunctionalBlockManager .Setup(x => x.RadioAntennaCount) .Returns(() => RadioAntennaCount); MockFunctionalBlockManager .Setup(x => x.ReactorCount) .Returns(() => ReactorCount); MockFunctionalBlockManager .Setup(x => x.ThrusterCount) .Returns(() => ThrusterCount); MockLogger = new Mock <ILogger>(); MockDockingManagerSettingsProvider = new Mock <IDockingManagerSettingsProvider>(); MockDockingManagerSettingsProvider .Setup(x => x.Settings) .Returns(() => new DockingManagerSettings() { IgnoreBatteryBlocks = IgnoreOtherBlocks, IgnoreBeacons = IgnoreBeacons, IgnoreGasGenerators = IgnoreGasGenerators, IgnoreGasTanks = IgnoreOtherBlocks, IgnoreGyros = IgnoreGyros, IgnoreLandingGears = IgnoreOtherBlocks, IgnoreLightingBlocks = IgnoreLightingBlocks, IgnoreRadioAntennae = IgnoreRadioAntennae, IgnoreReactors = IgnoreReactors, IgnoreThrusters = IgnoreThrusters }); Uut = new FunctionalBlockCollectionHandler( MockFunctionalBlockManager.Object, MockLogger.Object, MockDockingManagerSettingsProvider.Object); MockBackgroundWorker = new FakeBackgroundWorker(); }
public TestContext() { MockConnectorManager = new Mock <IConnectorManager>(); MockConnectorManager .Setup(x => x.Blocks.Count) .Returns(() => ConnectorCount); MockLogger = new Mock <ILogger>(); Uut = new ConnectorCollectionHandler( MockConnectorManager.Object, MockLogger.Object); MockBackgroundWorker = new FakeBackgroundWorker(); }
public void MakeCollectBlocksOperation_BlockCollectionResultsAreSkipped_TerminatesBlockCollectionEarly(int handlerCount, int blockCount) { var testContext = new TestContext(); var mockBackgroundWorker = new FakeBackgroundWorker(); foreach (var _ in Enumerable.Repeat(0, blockCount)) { testContext.AddMockBlock(); } foreach (var _ in Enumerable.Repeat(0, handlerCount)) { testContext.AddMockBlockCollectionHandler(BlockCollectionResult.Skipped); } testContext.Uut.MakeCollectBlocksOperation() .ShouldRunToCompletion(mockBackgroundWorker); testContext.ShouldHaveReceivedGetBlocks(); foreach (var mockBlockCollectionHandler in testContext.MockBlockCollectionHandlers) { mockBlockCollectionHandler .ShouldHaveReceived(x => x.OnStarting(), 1); mockBlockCollectionHandler .ShouldHaveReceived(x => x.OnCompleted(), 1); } foreach (var mockBlock in testContext.MockBlocks) { testContext.MockBlockCollectionHandlers.First() .ShouldHaveReceived(x => x.MakeCollectBlockOperation(mockBlock.Object), 1); foreach (var mockBlockCollectionHandler in testContext.MockBlockCollectionHandlers.Skip(1)) { mockBlockCollectionHandler .ShouldNotHaveReceived(x => x.MakeCollectBlockOperation(It.IsAny <IMyTerminalBlock>())); } } testContext.MockCollectBlockOperations.Count.ShouldBe(blockCount); foreach (var mockCollectBlockOperation in testContext.MockCollectBlockOperations) { mockBackgroundWorker.MockSubOperationScheduler .ShouldHaveReceived(x => x(mockCollectBlockOperation.Object)); } }
public TestContext() { _mockConfigParseHandlers = new List <Mock <IConfigParseHandler> >(); _configParseHandlers = new List <IConfigParseHandler>(); MockLogger = new Mock <ILogger>(); MockProgrammableBlock = new Mock <IMyProgrammableBlock>(); MockProgrammableBlock .Setup(x => x.CustomData) .Returns(() => Config); Uut = new ConfigManager( _configParseHandlers, MockLogger.Object, MockProgrammableBlock.Object); MockBackgroundWorker = new FakeBackgroundWorker(); }
public void MakeCollectBlocksOperation_BlockCollectionResultsAreIgnored_PerformsAllBlockCollections(int handlerCount, int blockCount) { var testContext = new TestContext(); var mockBackgroundWorker = new FakeBackgroundWorker(); foreach (var _ in Enumerable.Repeat(0, blockCount)) { testContext.AddMockBlock(); } foreach (var _ in Enumerable.Repeat(0, handlerCount)) { testContext.AddMockBlockCollectionHandler(BlockCollectionResult.Ignored); } testContext.Uut.MakeCollectBlocksOperation() .ShouldRunToCompletion(mockBackgroundWorker); testContext.ShouldHaveReceivedGetBlocks(); foreach (var mockBlockCollectionHandler in testContext.MockBlockCollectionHandlers) { mockBlockCollectionHandler .ShouldHaveReceived(x => x.OnStarting(), 1); foreach (var mockBlock in testContext.MockBlocks) { mockBlockCollectionHandler .ShouldHaveReceived(x => x.MakeCollectBlockOperation(mockBlock.Object), 1); } mockBlockCollectionHandler .ShouldHaveReceived(x => x.OnCompleted(), 1); } testContext.MockCollectBlockOperations.Count.ShouldBe(handlerCount * blockCount); foreach (var mockCollectBlockOperation in testContext.MockCollectBlockOperations) { mockBackgroundWorker.MockSubOperationScheduler .ShouldHaveReceived(x => x(mockCollectBlockOperation.Object)); } }
public void MakeCollectBlockOperation_BlockIsOtherGridAndOtherGridIsNotManaged_CompletesImmediately() { var testContext = new TestContext() { ManageOtherGrids = false, IsBlockSameGrid = false }; var mockBackgroundWorker = new FakeBackgroundWorker(); var result = testContext.Uut.MakeCollectBlockOperation(testContext.MockBlock.Object); result .ShouldRunToCompletionIn(mockBackgroundWorker, 1); mockBackgroundWorker.MockSubOperationScheduler .ShouldNotHaveReceived(x => x(It.IsAny <IBackgroundOperation>())); testContext.MockManagedBlockConfigManager .Invocations.Count.ShouldBe(0); result.Result.IsSkipped.ShouldBeTrue(); }
public TestContext() { MockDoorManager = new Mock <IDoorManager>(); MockDoorManager .Setup(x => x.DoorCount) .Returns(() => DoorCount); MockLogger = new Mock <ILogger>(); MockManagedDoorSettingsProvider = new Mock <IManagedDoorSettingsProvider>(); MockManagedDoorSettingsProvider .Setup(x => x.Settings) .Returns(() => new ManagedDoorSettings() { AutoCloseInterval = AutoCloseInterval }); Uut = new ManagedDoorCollectionHandler( MockDoorManager.Object, MockLogger.Object, MockManagedDoorSettingsProvider.Object); MockBackgroundWorker = new FakeBackgroundWorker(); }
public TestContext() { MockLogger = new Mock <ILogger>(); MockBatteryBlockManager = new Mock <IBatteryBlockManager>(); MockBatteryBlockManager .Setup(x => x.MakeOnUndockingOperation()) .Returns(() => MockBatteryBlocksOnUndockingOperation.Object); MockBatteryBlockManager .Setup(x => x.MakeOnDockingOperation()) .Returns(() => MockBatteryBlocksOnDockingOperation.Object); MockConnectorManager = new Mock <IConnectorManager>(); MockConnectorManager .Setup(x => x.Blocks) .Returns(() => _connectors); MockConnectorManager .Setup(x => x.MakeOnDockingOperation()) .Returns(() => MockConnectorsOnDockingOperation.Object); MockConnectorManager .Setup(x => x.MakeOnUndockingOperation()) .Returns(() => MockConnectorsOnUndockingOperation.Object); MockFunctionalBlockManager = new Mock <IFunctionalBlockManager>(); MockFunctionalBlockManager .Setup(x => x.MakeOnUndockingOperation()) .Returns(() => MockFunctionalBlocksOnDockingOperation.Object); MockFunctionalBlockManager .Setup(x => x.MakeOnDockingOperation()) .Returns(() => MockFunctionalBlocksOnUndockingOperation.Object); MockGasTankManager = new Mock <IGasTankManager>(); MockGasTankManager .Setup(x => x.MakeOnDockingOperation()) .Returns(() => MockGasTanksOnDockingOperation.Object); MockGasTankManager .Setup(x => x.MakeOnUndockingOperation()) .Returns(() => MockGasTanksOnUndockingOperation.Object); MockLandingGearManager = new Mock <ILandingGearManager>(); MockLandingGearManager .Setup(x => x.MakeOnDockingOperation()) .Returns(() => MockLandingGearsOnDockingOperation.Object); MockLandingGearManager .Setup(x => x.MakeOnUndockingOperation()) .Returns(() => MockLandingGearsOnUndockingOperation.Object); Uut = new DockingManager( MockLogger.Object, MockBatteryBlockManager.Object, MockConnectorManager.Object, MockFunctionalBlockManager.Object, MockGasTankManager.Object, MockLandingGearManager.Object); MockBackgroundWorker = new FakeBackgroundWorker(); _mockConnectors = new List <Mock <IMyShipConnector> >(); _connectors = new List <IMyShipConnector>(); MockBatteryBlocksOnDockingOperation = MakeFakeBackgroundOperation(); MockBatteryBlocksOnUndockingOperation = MakeFakeBackgroundOperation(); MockConnectorsOnDockingOperation = MakeFakeBackgroundOperation(); MockConnectorsOnUndockingOperation = MakeFakeBackgroundOperation(); MockFunctionalBlocksOnDockingOperation = MakeFakeBackgroundOperation(); MockFunctionalBlocksOnUndockingOperation = MakeFakeBackgroundOperation(); MockGasTanksOnDockingOperation = MakeFakeBackgroundOperation(); MockGasTanksOnUndockingOperation = MakeFakeBackgroundOperation(); MockLandingGearsOnDockingOperation = MakeFakeBackgroundOperation(); MockLandingGearsOnUndockingOperation = MakeFakeBackgroundOperation(); }
public void MakeCollectBlockOperation_OperationIsDisposed_OperationIsRecycled(CollectBlockTestCase testCase) { var testContext = new TestContext() { ManageOtherGrids = testCase.ManageOtherGrids, AutoManageThisGrid = testCase.AutoManageThisGrid, AutoManageOtherGrids = testCase.AutoManageOtherGrids, IsBlockSameGrid = testCase.IsBlockSameGrid, IsBlockIgnored = testCase.IsBlockIgnored, IsBlockManaged = testCase.IsBlockManaged }; var mockBackgroundWorker = new FakeBackgroundWorker(); var result = testContext.Uut.MakeCollectBlockOperation(testContext.MockBlock.Object); result.ShouldRunToCompletion(mockBackgroundWorker); var mockBlockInvocations = testContext.MockBlock .Invocations.ToArray(); var mockManagedBlockConfigManagerInvocations = testContext.MockManagedBlockConfigManager .Invocations.ToArray(); var mockSubOperationSchedulerInvocations = mockBackgroundWorker.MockSubOperationScheduler .Invocations.ToArray(); result.ShouldBeAssignableTo <IDisposable>(); (result as IDisposable).Dispose(); var secondMockBlock = new Mock <IMyTerminalBlock>(); secondMockBlock .Setup(x => x.CubeGrid) .Returns(() => testContext.MockBlock.Object.CubeGrid); testContext.MockManagedBlockConfigManager .Invocations.Clear(); mockBackgroundWorker.MockSubOperationScheduler .Invocations.Clear(); testContext.Uut.MakeCollectBlockOperation(secondMockBlock.Object) .ShouldBeSameAs(result); result.ShouldRunToCompletion(mockBackgroundWorker); secondMockBlock.Invocations.Count.ShouldBe(mockBlockInvocations.Length); foreach (var i in Enumerable.Range(0, mockBlockInvocations.Length)) { secondMockBlock.Invocations[i].ShouldBe(mockBlockInvocations[i]); } testContext.MockManagedBlockConfigManager.Invocations.Count.ShouldBe(mockManagedBlockConfigManagerInvocations.Length); foreach (var i in Enumerable.Range(0, mockManagedBlockConfigManagerInvocations.Length)) { testContext.MockManagedBlockConfigManager.Invocations[i].ShouldBe(mockManagedBlockConfigManagerInvocations[i]); } mockBackgroundWorker.MockSubOperationScheduler.Invocations.Count.ShouldBe(mockSubOperationSchedulerInvocations.Length); foreach (var i in Enumerable.Range(0, mockSubOperationSchedulerInvocations.Length)) { mockBackgroundWorker.MockSubOperationScheduler.Invocations[i].ShouldBe(mockSubOperationSchedulerInvocations[i]); } }
public static void ShouldRunToCompletionIn(this IBackgroundOperation backgroundOperation, FakeBackgroundWorker backgroundWorker, int expectedExecuteCount) => backgroundWorker.ShouldCompleteOperationIn(backgroundOperation, expectedExecuteCount);
public static void ShouldRunToCompletion(this IBackgroundOperation backgroundOperation, FakeBackgroundWorker backgroundWorker) => backgroundWorker.ShouldCompleteOperation(backgroundOperation);
protected void Application_Start(object sender, EventArgs e) { FakeBackgroundWorker.Begin(); }