public void GivenInvalidAircraftDataCausingException_WhenCallingValidate_ReturnsErrorMessages()
{
// Setup
var calculation = new BalancedFieldLengthCalculation();
SetValidAircraftData(calculation.AircraftData);
SetEngineData(calculation.EngineData);
calculation.AircraftData.AspectRatio = double.NaN;
var kernel = Substitute.For <IAggregatedDistanceCalculatorKernel>();
var testFactory = new TestKernelFactory(kernel);
using (new BalancedFieldLengthKernelFactoryConfig(testFactory))
{
var module = new BalancedFieldLengthCalculationModule();
// Call
IEnumerable <string> messages = module.Validate(calculation);
// Assert
CollectionAssert.AreEqual(new[]
{
"aspectRatio must be a concrete number and cannot be NaN or Infinity."
}, messages);
}
}
public void Validate_InvalidEndFailureSpeed_ReturnsValidationMessage(int invalidEndFailureSpeed)
{
// Setup
var calculation = new BalancedFieldLengthCalculation();
SetValidAircraftData(calculation.AircraftData);
SetEngineData(calculation.EngineData);
SetSimulationSettingsData(calculation.SimulationSettings);
calculation.SimulationSettings.EndFailureVelocity = invalidEndFailureSpeed;
var kernel = Substitute.For <IAggregatedDistanceCalculatorKernel>();
kernel.Validate(Arg.Any <KernelAircraftData>(),
Arg.Any <double>(),
Arg.Any <double>(),
Arg.Any <int>())
.ReturnsForAnyArgs(KernelValidationError.None);
var testFactory = new TestKernelFactory(kernel);
using (new BalancedFieldLengthKernelFactoryConfig(testFactory))
{
var module = new BalancedFieldLengthCalculationModule();
// Call
IEnumerable <string> messages = module.Validate(calculation);
// Assert
CollectionAssert.AreEqual(new[]
{
"End failure velocity must be larger than 0."
}, messages);
}
}
public void Validate_WithArgumentAndKernelValidationErrorOccurs_ReturnsErrorMessages(KernelValidationError error,
string expectedMessage)
{
// Setup
var calculation = new BalancedFieldLengthCalculation();
SetValidAircraftData(calculation.AircraftData);
SetEngineData(calculation.EngineData);
SetSimulationSettingsData(calculation.SimulationSettings);
var kernel = Substitute.For <IAggregatedDistanceCalculatorKernel>();
kernel.Validate(Arg.Any <KernelAircraftData>(),
Arg.Any <double>(),
Arg.Any <double>(),
Arg.Any <int>())
.ReturnsForAnyArgs(error);
var testFactory = new TestKernelFactory(kernel);
using (new BalancedFieldLengthKernelFactoryConfig(testFactory))
{
var module = new BalancedFieldLengthCalculationModule();
// Call
IEnumerable <string> messages = module.Validate(calculation);
// Assert
CollectionAssert.AreEqual(new[]
{
expectedMessage
}, messages);
}
}
public void Validate_WithArgumentAndNoErrorOccurs_ReturnsNoErrorMessages()
{
// Setup
var random = new Random(21);
int nrOfFailedEngines = random.Next();
var calculation = new BalancedFieldLengthCalculation();
SetValidAircraftData(calculation.AircraftData);
SetEngineData(calculation.EngineData);
SetSimulationSettingsData(calculation.SimulationSettings);
calculation.EngineData.NrOfFailedEngines = nrOfFailedEngines;
var kernel = Substitute.For <IAggregatedDistanceCalculatorKernel>();
kernel.Validate(Arg.Any <KernelAircraftData>(),
Arg.Any <double>(),
Arg.Any <double>(),
Arg.Any <int>())
.ReturnsForAnyArgs(KernelValidationError.None);
var testFactory = new TestKernelFactory(kernel);
using (new BalancedFieldLengthKernelFactoryConfig(testFactory))
{
var module = new BalancedFieldLengthCalculationModule();
// Call
IEnumerable <string> messages = module.Validate(calculation);
// Assert
CollectionAssert.IsEmpty(messages);
}
}
public void Calculate_WithValidArgumentsAndResult_ReturnsExpectedOutput()
{
// Setup
var random = new Random(21);
int nrOfFailedEngines = random.Next();
double density = random.NextDouble();
double gravitationalAcceleration = random.NextDouble();
var calculation = new BalancedFieldLengthCalculation();
SetValidAircraftData(calculation.AircraftData);
SetEngineData(calculation.EngineData);
SetSimulationSettingsData(calculation.SimulationSettings);
calculation.SimulationSettings.Density = density;
calculation.SimulationSettings.GravitationalAcceleration = gravitationalAcceleration;
calculation.SimulationSettings.EndFailureVelocity = 3;
calculation.EngineData.NrOfFailedEngines = nrOfFailedEngines;
const double expectedVelocity = 11;
const double expectedDistance = 20;
var outputs = new[]
{
new AggregatedDistanceOutput(10, 10, 30),
new AggregatedDistanceOutput(expectedVelocity, expectedDistance, 20),
new AggregatedDistanceOutput(12, 30, 10)
};
var kernel = Substitute.For <IAggregatedDistanceCalculatorKernel>();
kernel.Calculate(Arg.Any <KernelAircraftData>(),
Arg.Any <EulerIntegrator>(),
Arg.Any <int>(),
Arg.Any <double>(),
Arg.Any <double>(),
Arg.Any <CalculationSettings>())
.Returns(outputs[0], outputs[1], outputs[2]);
var testFactory = new TestKernelFactory(kernel);
using (new BalancedFieldLengthKernelFactoryConfig(testFactory))
{
var module = new BalancedFieldLengthCalculationModule();
// Call
BalancedFieldLengthOutput output = module.Calculate(calculation);
// Assert
Assert.That(output.Velocity, Is.EqualTo(expectedVelocity));
Assert.That(output.Distance, Is.EqualTo(expectedDistance));
ICall[] calls = kernel.ReceivedCalls().ToArray();
Assert.That(calls.Length, Is.EqualTo(3));
AssertCalculateCall(calls[0], calculation, 0);
AssertCalculateCall(calls[1], calculation, 1);
AssertCalculateCall(calls[2], calculation, 2);
}
}
public void Constructor_ExpectedValues()
{
// Setup
var testKernel = Substitute.For <IAggregatedDistanceCalculatorKernel>();
// Call
var factory = new TestKernelFactory(testKernel);
// Assert
Assert.That(factory, Is.InstanceOf <IBalancedFieldLengthKernelFactory>());
}
public void CreateDistanceCalculatorKernel_Always_ReturnsExpectedKernel()
{
// Setup
var testKernel = Substitute.For <IAggregatedDistanceCalculatorKernel>();
var factory = new TestKernelFactory(testKernel);
// Call
IAggregatedDistanceCalculatorKernel kernel = factory.CreateDistanceCalculatorKernel();
// Assert
Assert.That(kernel, Is.SameAs(testKernel));
}
public void Validate_Always_FactoryReceiveCorrectData()
{
// Setup
var calculation = new BalancedFieldLengthCalculation();
SetValidAircraftData(calculation.AircraftData);
SetEngineData(calculation.EngineData);
SetSimulationSettingsData(calculation.SimulationSettings);
var kernel = Substitute.For <IAggregatedDistanceCalculatorKernel>();
kernel.Validate(Arg.Any <KernelAircraftData>(),
Arg.Any <double>(),
Arg.Any <double>(),
Arg.Any <int>())
.ReturnsForAnyArgs(KernelValidationError.None);
var testFactory = new TestKernelFactory(kernel);
using (new BalancedFieldLengthKernelFactoryConfig(testFactory))
{
var module = new BalancedFieldLengthCalculationModule();
// Call
module.Validate(calculation);
// Assert
ICall calls = kernel.ReceivedCalls().Single();
object[] arguments = calls.GetArguments();
AircraftDataTestHelper.AssertAircraftData(calculation.AircraftData,
calculation.EngineData,
(KernelAircraftData)arguments[0]);
GeneralSimulationSettingsData simulationSettings = calculation.SimulationSettings;
Assert.That(arguments[1], Is.EqualTo(simulationSettings.Density));
Assert.That(arguments[2], Is.EqualTo(simulationSettings.GravitationalAcceleration));
Assert.That(arguments[3], Is.EqualTo(calculation.EngineData.NrOfFailedEngines));
}
}
public void Calculate_CalculatorThrowsCalculateException_ThrowsKernelCalculateException()
{
// Setup
var calculation = new BalancedFieldLengthCalculation();
SetValidAircraftData(calculation.AircraftData);
SetEngineData(calculation.EngineData);
SetSimulationSettingsData(calculation.SimulationSettings);
calculation.SimulationSettings.EndFailureVelocity = 1;
var kernel = Substitute.For <IAggregatedDistanceCalculatorKernel>();
var calculatorException = new CalculatorException("Can't calculate this.");
kernel.Calculate(Arg.Any <KernelAircraftData>(),
Arg.Any <EulerIntegrator>(),
Arg.Any <int>(),
Arg.Any <double>(),
Arg.Any <double>(),
Arg.Any <CalculationSettings>())
.ThrowsForAnyArgs(calculatorException);
var testFactory = new TestKernelFactory(kernel);
using (new BalancedFieldLengthKernelFactoryConfig(testFactory))
{
var module = new BalancedFieldLengthCalculationModule();
// Call
TestDelegate call = () => module.Calculate(calculation);
// Assert
var exception = Assert.Throws <KernelCalculationException>(call);
Assert.That(exception.InnerException, Is.SameAs(calculatorException));
Assert.That(exception.Message, Is.EqualTo(calculatorException.Message));
}
}
