public void GivenViewModelAndCalculationThrowsKernelCalculationException_WhenCalculating_ThenErrorMessagesLogged()
{
// Given
var viewModel = new MainViewModel();
using (new BalancedFieldLengthCalculationModuleFactoryConfig())
{
var instance = (TestBalancedFieldLengthCalculationModuleFactory)
BalancedFieldLengthCalculationModuleFactory.Instance;
TestBalancedFieldLengthCalculationModule testModule = instance.TestModule;
testModule.ThrowKernelCalculationException = true;
// Precondition
MessageWindowViewModel messageWindowViewModel = viewModel.MessageWindowViewModel;
ReadOnlyObservableCollection <MessageContext> logMessages = messageWindowViewModel.Messages;
Assert.That(logMessages, Is.Empty);
// When
viewModel.CalculateCommand.Execute(null);
// Then
Assert.That(viewModel.OutputViewModel, Is.Null);
Assert.That(logMessages, Has.Count.EqualTo(2));
Assert.That(logMessages.Select(m => m.MessageType), Is.All.EqualTo(MessageType.Error));
Assert.That(logMessages[0].MessageType, Is.EqualTo(MessageType.Error));
Assert.That(logMessages[0].Message, Is.EqualTo("Calculation failed."));
Assert.That(logMessages[1].MessageType, Is.EqualTo(MessageType.Error));
Assert.That(logMessages[1].Message, Is.EqualTo("Exception"));
}
}
public void GivenViewModelAndCalculationSuccessful_WhenCalculating_ThenOutputGenerated()
{
// Given
var random = new Random(21);
var calculatedOutput = new BalancedFieldLengthOutput(random.NextDouble(), random.NextDouble());
var viewModel = new MainViewModel();
using (new BalancedFieldLengthCalculationModuleFactoryConfig())
{
var instance = (TestBalancedFieldLengthCalculationModuleFactory)
BalancedFieldLengthCalculationModuleFactory.Instance;
TestBalancedFieldLengthCalculationModule testModule = instance.TestModule;
testModule.Output = calculatedOutput;
// Precondition
MessageWindowViewModel messageWindowViewModel = viewModel.MessageWindowViewModel;
Assert.That(messageWindowViewModel.Messages, Is.Empty);
// When
viewModel.CalculateCommand.Execute(null);
// Then
OutputViewModel outputViewModel = viewModel.OutputViewModel;
Assert.That(outputViewModel, Is.Not.Null);
Assert.That(outputViewModel.BalancedFieldLengthDistance, Is.EqualTo(calculatedOutput.Distance));
Assert.That(outputViewModel.BalancedFieldLengthVelocity, Is.EqualTo(calculatedOutput.Velocity));
Assert.That(messageWindowViewModel.Messages, Has.Count.EqualTo(1));
MessageContext message = messageWindowViewModel.Messages.Single();
Assert.That(message.MessageType, Is.EqualTo(MessageType.Info));
Assert.That(message.Message, Is.EqualTo("Calculation completed."));
}
}
public void Constructor_ExpectedValues()
{
// Call
var calculationModule = new TestBalancedFieldLengthCalculationModule();
// Assert
Assert.That(calculationModule, Is.InstanceOf <IBalancedFieldLengthCalculationModule>());
}
public void GivenViewModelWithInvalidCalculation_WhenCalculationPressed_ThenErrorLoggedAndInputNotSent()
{
// Given
var random = new Random(21);
var viewModel = new MainViewModel();
TabControlViewModel tabControlViewModel = viewModel.TabControlViewModel;
ObservableCollection <ITabViewModel> tabs = tabControlViewModel.Tabs;
// Precondition
Assert.That(tabs, Has.Count.EqualTo(3));
Assert.That(tabs[0], Is.TypeOf <GeneralSimulationSettingsTabViewModel>());
Assert.That(tabs[1], Is.TypeOf <EngineSettingsTabViewModel>());
Assert.That(tabs[2], Is.TypeOf <AircraftDataTabViewModel>());
var generalSimulationSettingsViewModel = (GeneralSimulationSettingsTabViewModel)tabs[0];
var engineSettingsViewModel = (EngineSettingsTabViewModel)tabs[1];
var aircraftDataViewModel = (AircraftDataTabViewModel)tabs[2];
SetGeneralSettings(generalSimulationSettingsViewModel, random.Next());
SetEngineData(engineSettingsViewModel, random.Next());
SetAircraftData(aircraftDataViewModel, random.Next());
aircraftDataViewModel.TakeOffWeight = double.NaN; // Set an invalid value
using (new BalancedFieldLengthCalculationModuleFactoryConfig())
{
var instance = (TestBalancedFieldLengthCalculationModuleFactory)
BalancedFieldLengthCalculationModuleFactory.Instance;
TestBalancedFieldLengthCalculationModule testModule = instance.TestModule;
// Precondition
MessageWindowViewModel messageWindowViewModel = viewModel.MessageWindowViewModel;
Assert.That(messageWindowViewModel.Messages, Is.Empty);
// When
viewModel.CalculateCommand.Execute(null);
// Then
Assert.That(testModule.InputCalculation, Is.Null);
OutputViewModel outputViewModel = viewModel.OutputViewModel;
Assert.That(outputViewModel, Is.Null);
IEnumerable <MessageType> messageTypes = messageWindowViewModel.Messages.Select(m => m.MessageType);
Assert.That(messageTypes, Is.All.EqualTo(MessageType.Error));
MessageContext firstMessage = messageWindowViewModel.Messages.First();
Assert.That(firstMessage.Message, Is.EqualTo("Calculation failed."));
}
}
public void Calculate_WithThrowKernelCalculationExceptionTrue_ThrowsKernelCalculationException()
{
// Given
var calculationModule = new TestBalancedFieldLengthCalculationModule
{
ThrowKernelCalculationException = true
};
// When
TestDelegate call = () => calculationModule.Calculate(null);
// Then
Assert.That(call, Throws.Exception.TypeOf <KernelCalculationException>()
.And.Message.Not.Empty);
}
public void Validate_WithConfiguredCalculationModule_ExpectedValues()
{
// Given
IEnumerable <string> messages = Enumerable.Empty <string>();
var calculationModule = new TestBalancedFieldLengthCalculationModule
{
ValidationMessages = messages
};
var calculation = new BalancedFieldLengthCalculation();
// When
IEnumerable <string> actualMessages = calculationModule.Validate(calculation);
// Then
Assert.That(actualMessages, Is.SameAs(messages));
Assert.That(calculationModule.InputCalculation, Is.SameAs(calculation));
}
public void Calculate_WithConfiguredCalculationModule_ExpectedValues()
{
// Given
var random = new Random(21);
var output = new BalancedFieldLengthOutput(random.NextDouble(), random.NextDouble());
var calculationModule = new TestBalancedFieldLengthCalculationModule
{
Output = output
};
var calculation = new BalancedFieldLengthCalculation();
// When
BalancedFieldLengthOutput actualOutput = calculationModule.Calculate(calculation);
// Then
Assert.That(actualOutput, Is.SameAs(output));
Assert.That(calculationModule.InputCalculation, Is.SameAs(calculation));
}
public void GivenViewModel_WhenCalculationPressed_ThenInputArgumentSent()
{
// Given
var random = new Random(21);
var viewModel = new MainViewModel();
TabControlViewModel tabControlViewModel = viewModel.TabControlViewModel;
ObservableCollection <ITabViewModel> tabs = tabControlViewModel.Tabs;
// Precondition
Assert.That(tabs, Has.Count.EqualTo(3));
Assert.That(tabs[0], Is.TypeOf <GeneralSimulationSettingsTabViewModel>());
Assert.That(tabs[1], Is.TypeOf <EngineSettingsTabViewModel>());
Assert.That(tabs[2], Is.TypeOf <AircraftDataTabViewModel>());
var generalSimulationSettingsViewModel = (GeneralSimulationSettingsTabViewModel)tabs[0];
var engineSettingsViewModel = (EngineSettingsTabViewModel)tabs[1];
var aircraftDataViewModel = (AircraftDataTabViewModel)tabs[2];
SetGeneralSettings(generalSimulationSettingsViewModel, random.Next());
SetEngineData(engineSettingsViewModel, random.Next());
SetAircraftData(aircraftDataViewModel, random.Next());
using (new BalancedFieldLengthCalculationModuleFactoryConfig())
{
var instance = (TestBalancedFieldLengthCalculationModuleFactory)
BalancedFieldLengthCalculationModuleFactory.Instance;
TestBalancedFieldLengthCalculationModule testModule = instance.TestModule;
testModule.Output = new BalancedFieldLengthOutput(random.NextDouble(), random.NextDouble());
// When
viewModel.CalculateCommand.Execute(null);
// Then
BalancedFieldLengthCalculation calculationInput = testModule.InputCalculation;
AssertGeneralSettings(generalSimulationSettingsViewModel, calculationInput.SimulationSettings);
AssertEngineData(engineSettingsViewModel, calculationInput.EngineData);
AssertAircraftData(aircraftDataViewModel, calculationInput.AircraftData);
}
}
public TestBalancedFieldLengthCalculationModuleFactory()
{
TestModule = new TestBalancedFieldLengthCalculationModule();
}
