private void Calculate()
{
DataModelValidatorResult validationResult = GetValidationResult();
if (validationResult != DataModelValidatorResult.ValidResult)
{
LogValidationResultMessages(validationResult);
return;
}
try
{
IBalancedFieldLengthCalculationModuleFactory factory = BalancedFieldLengthCalculationModuleFactory.Instance;
IBalancedFieldLengthCalculationModule calculationModule = factory.CreateModule();
BalancedFieldLengthOutput output = calculationModule.Calculate(calculation);
OutputViewModel = new OutputViewModel(output);
MessageWindowViewModel.AddMessage(new MessageContext(MessageType.Info, Resources.MainViewModel_Calculate_Calculation_completed));
}
catch (Exception e) when(e is CreateKernelDataException || e is KernelCalculationException)
{
MessageWindowViewModel.AddMessage(new MessageContext(MessageType.Error, e.Message));
MessageWindowViewModel.AddMessage(new MessageContext(MessageType.Error, Resources.MainViewModel_Calculate_Calculation_failed));
}
}
public void ValidResult_Always_ReturnsExpectedValidationRuleResult()
{
// Call
DataModelValidatorResult result = DataModelValidatorResult.ValidResult;
// Assert
Assert.That(result.IsValid, Is.True);
Assert.That(result.ValidationMessages, Is.Empty);
}
private void LogValidationResultMessages(DataModelValidatorResult validationResult)
{
foreach (string validationMessage in validationResult.ValidationMessages)
{
MessageWindowViewModel.AddMessage(new MessageContext(MessageType.Error, validationMessage));
}
MessageWindowViewModel.AddMessage(new MessageContext(MessageType.Error, Resources.MainViewModel_Calculate_Calculation_failed));
}
public void CreateInvalidResult_MessagesNull_ThrowsArgumentNullException()
{
// Call
TestDelegate call = () => DataModelValidatorResult.CreateInvalidResult(null);
// Assert
Assert.That(call, Throws.ArgumentNullException
.With.Property(nameof(ArgumentNullException.ParamName))
.EqualTo("messages"));
}
public void Validate_WithTwoInvalidModels_ExecutesAllRulesAndReturnsInvalidResult()
{
// Setup
var validationRuleOne = Substitute.For <IDataModelValidationRule>();
validationRuleOne.Execute().Returns(ValidationRuleResult.ValidResult);
const string validationErrorOne = "Validation Error One";
var invalidValidationRuleOne = Substitute.For <IDataModelValidationRule>();
invalidValidationRuleOne.Execute().Returns(ValidationRuleResult.CreateInvalidResult(validationErrorOne));
var invalidProviderOne = Substitute.For <IDataModelRuleProvider>();
invalidProviderOne.GetDataModelValidationRules().Returns(new[]
{
validationRuleOne,
invalidValidationRuleOne
});
var validationRuleTwo = Substitute.For <IDataModelValidationRule>();
validationRuleTwo.Execute().Returns(ValidationRuleResult.ValidResult);
const string validationErrorTwo = "Validation Error Two";
var invalidValidationRuleTwo = Substitute.For <IDataModelValidationRule>();
invalidValidationRuleTwo.Execute().Returns(ValidationRuleResult.CreateInvalidResult(validationErrorTwo));
var invalidProviderTwo = Substitute.For <IDataModelRuleProvider>();
invalidProviderTwo.GetDataModelValidationRules().Returns(new[]
{
validationRuleTwo,
invalidValidationRuleTwo
});
IDataModelRuleProvider[] models =
{
invalidProviderOne,
invalidProviderTwo
};
// Call
DataModelValidatorResult result = DataModelValidator.Validate(models);
// Assert
Assert.That(result.IsValid, Is.False);
CollectionAssert.AreEquivalent(new[]
{
validationErrorOne,
validationErrorTwo
}, result.ValidationMessages);
}
public void CreateInvalidResult_WithValidMessage_ReturnsExpectedValidationRuleResult()
{
// Setup
IEnumerable <string> messages = Enumerable.Empty <string>();
// Call
var result = DataModelValidatorResult.CreateInvalidResult(messages);
// Assert
Assert.That(result.IsValid, Is.False);
Assert.That(result.ValidationMessages, Is.SameAs(messages));
}
public void Validate_WithOneValidAndOneInvalidDataModel_ExecutesAllRulesAndReturnsInvalidResult()
{
// Setup
var validationRuleOne = Substitute.For <IDataModelValidationRule>();
validationRuleOne.Execute().Returns(ValidationRuleResult.ValidResult);
var validProvider = Substitute.For <IDataModelRuleProvider>();
validProvider.GetDataModelValidationRules().Returns(new[]
{
validationRuleOne
});
var validationRuleTwo = Substitute.For <IDataModelValidationRule>();
validationRuleTwo.Execute().Returns(ValidationRuleResult.ValidResult);
const string validationError = "Validation Error";
var invalidValidationRule = Substitute.For <IDataModelValidationRule>();
invalidValidationRule.Execute().Returns(ValidationRuleResult.CreateInvalidResult(validationError));
var invalidProvider = Substitute.For <IDataModelRuleProvider>();
invalidProvider.GetDataModelValidationRules().Returns(new[]
{
validationRuleTwo,
invalidValidationRule
});
IDataModelRuleProvider[] models =
{
validProvider,
invalidProvider
};
// Call
DataModelValidatorResult result = DataModelValidator.Validate(models);
// Assert
Assert.That(result.IsValid, Is.False);
CollectionAssert.AreEqual(new[]
{
validationError
}, result.ValidationMessages);
}
public void Validate_WithValidDataModels_ThenExecutesAllRulesAndReturnsValidResult()
{
// Setup
var validationRuleOne = Substitute.For <IDataModelValidationRule>();
validationRuleOne.Execute().Returns(ValidationRuleResult.ValidResult);
var validProviderOne = Substitute.For <IDataModelRuleProvider>();
validProviderOne.GetDataModelValidationRules().Returns(new[]
{
validationRuleOne
});
var validationRuleTwo = Substitute.For <IDataModelValidationRule>();
validationRuleTwo.Execute().Returns(ValidationRuleResult.ValidResult);
var validProviderTwo = Substitute.For <IDataModelRuleProvider>();
validProviderTwo.GetDataModelValidationRules().Returns(new[]
{
validationRuleTwo
});
IDataModelRuleProvider[] models =
{
validProviderOne,
validProviderTwo
};
// Call
DataModelValidatorResult result = DataModelValidator.Validate(models);
// Assert
Assert.That(result.IsValid, Is.True);
Assert.That(result.ValidationMessages, Is.Empty);
validProviderOne.Received(1).GetDataModelValidationRules();
validationRuleOne.Received(1).Execute();
validProviderTwo.Received(1).GetDataModelValidationRules();
validationRuleTwo.Received(1).Execute();
}
