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