public void ResponseSigning_Is_Required_When_UseNRRFormat_Is_Enabled(
bool isEnabled,
bool useNrrFormat,
bool expected)
{
// Arrange
var pmode = new ReceivingProcessingMode
{
Id = "not-empty-id",
ReplyHandling =
{
ReceiptHandling = { UseNRRFormat = useNrrFormat },
ResponseSigning =
{
IsEnabled = isEnabled,
SigningCertificateInformation = new CertificateFindCriteria
{
CertificateFindType = X509FindType.FindBySubjectName,
CertificateFindValue = "some-certificate-subject-name"
}
}
}
};
// Act
ValidationResult result = ExerciseValidation(pmode);
// Assert
Assert.True(
expected == result.IsValid,
result.AppendValidationErrorsToErrorMessage("Invalid PMode: "));
}
private static InvalidDataException CreateInvalidPModeException(IPMode pmode, ValidationResult result)
{
var errorMessage = result.AppendValidationErrorsToErrorMessage($"Receiving PMode {pmode.Id} is not valid");
Logger.Error(errorMessage);
return(new InvalidDataException(errorMessage));
}
public Property ReplyHandling_Must_Be_Specified_When_There_Isnt_A_Forward_Element(
string responsePMode,
string forwardPMode)
{
var genForward = Gen.OneOf(
Gen.Constant((object)null),
Gen.Fresh(() => (object)new Forward {
SendingPMode = forwardPMode
}),
Gen.Fresh(() => (object)new Deliver()));
var genReplyHandling = Gen.OneOf(
Gen.Constant((ReplyHandling)null),
Gen.Fresh(() => new ReplyHandling
{
ResponseConfiguration = new PushConfiguration
{
Protocol = { Url = "http://not/empty/url" }
}
}));
return(Prop.ForAll(
genForward.ToArbitrary(),
genReplyHandling.ToArbitrary(),
(messageHandlingImp, replyHandling) =>
{
// Arrange
ReceivingProcessingMode pmode = CreateValidPMode();
pmode.ReplyHandling = replyHandling;
pmode.MessageHandling.Item = messageHandlingImp;
// Act
ValidationResult result = ExerciseValidation(pmode);
// Assert
bool specifiedDeliver = messageHandlingImp is Deliver;
bool specifiedForward =
messageHandlingImp is Forward f &&
!String.IsNullOrWhiteSpace(f.SendingPMode);
bool specifiedReplyHandling =
replyHandling?.ResponseConfiguration != null;
return result.IsValid
.Equals(specifiedReplyHandling && specifiedDeliver)
.Or(!specifiedReplyHandling && specifiedForward)
.Or(specifiedReplyHandling && specifiedForward)
.Label(
$"Validation has {(result.IsValid ? "succeeded" : "failed")} "
+ $"but ReplyHandling {(specifiedReplyHandling ? "is" : "isn't")} specified and "
+ $"MessageHandling is {(specifiedDeliver ? "a Deliver" : specifiedForward ? "a Forward" : "empty")} element. "
+ $"{(result.IsValid ? String.Empty : result.AppendValidationErrorsToErrorMessage("Validation Failure: "))}");
}));
}
public void DynamicDiscovery_Invalid_With_Empty_SmpProfile(string xml, bool expected)
{
// Arrange
var pmode = AS4XmlSerializer.FromString <SendingProcessingMode>(xml);
// Act
ValidationResult result = ExerciseValidation(pmode);
// Assert
Assert.True(
expected == result.IsValid,
result.AppendValidationErrorsToErrorMessage("Invalid SendingPMode: "));
}
public Property Decryption_Certificate_Should_Be_Specified_When_Decryption_Is_Allowed_Or_Required(
Limit encryption,
string findValue,
string certificate,
string password)
{
return(Prop.ForAll(
CreatePrivateKeyCertificateGen(findValue, certificate, password)
.ToArbitrary(),
cert =>
{
// Arrange
ReceivingProcessingMode pmode = CreateValidPMode();
pmode.Security.Decryption = new Decryption
{
Encryption = encryption,
DecryptCertificateInformation = cert.Item2,
CertificateType = cert.Item1
};
// Act
ValidationResult result = ExerciseValidation(pmode);
// Assert
bool allowedOrRequired =
encryption == Limit.Allowed ||
encryption == Limit.Required;
bool specifiedCertFindCriteria =
cert.Item1 == PrivateKeyCertificateChoiceType.CertificateFindCriteria &&
cert.Item2 is CertificateFindCriteria c &&
!String.IsNullOrWhiteSpace(c.CertificateFindValue);
bool specifiedPrivateKeyCert =
cert.Item1 == PrivateKeyCertificateChoiceType.PrivateKeyCertificate &&
cert.Item2 is PrivateKeyCertificate k &&
!String.IsNullOrWhiteSpace(k.Certificate) &&
!String.IsNullOrWhiteSpace(k.Password);
bool specifiedDecryptionCert = specifiedCertFindCriteria || specifiedPrivateKeyCert;
return result.IsValid.Equals(specifiedDecryptionCert && allowedOrRequired)
.Or(!allowedOrRequired)
.Label(
$"Validation has {(result.IsValid ? "succeeded" : "failed")} "
+ $"but decryption certificate {(specifiedDecryptionCert ? "is" : "isn't")} specified "
+ $"with a {cert.Item1} while the encryption limit is {encryption}. "
+ $"{(result.IsValid ? String.Empty : result.AppendValidationErrorsToErrorMessage("Validation Failure: "))}");
}));
}
private static Property TestRelialityForEnabledFlag(
bool isEnabled,
int retryCount,
TimeSpan retryInterval,
Func <ReceivingProcessingMode, RetryReliability> getReliability,
Action <ReceivingProcessingMode> extraFixtureSetup = null)
{
return(Prop.ForAll(
Gen.Frequency(
Tuple.Create(2, Gen.Constant(retryInterval.ToString())),
Tuple.Create(1, Arb.From <string>().Generator))
.ToArbitrary(),
retryIntervalText =>
{
// Arrange
ReceivingProcessingMode pmode = CreateValidPMode();
RetryReliability r = getReliability(pmode);
r.IsEnabled = isEnabled;
r.RetryCount = retryCount;
r.RetryInterval = retryIntervalText;
extraFixtureSetup?.Invoke(pmode);
// Act
ValidationResult result = ReceivingProcessingModeValidator.Instance.Validate(pmode);
// Assert
bool correctConfigured =
retryCount > 0 &&
r.RetryInterval.AsTimeSpan() > default(TimeSpan);
bool expected =
!isEnabled && !correctConfigured ||
!isEnabled ||
correctConfigured;
return expected.Equals(result.IsValid)
.Label(result.AppendValidationErrorsToErrorMessage(string.Empty))
.Classify(result.IsValid, "Valid PMode")
.Classify(!result.IsValid, "Invalid PMode")
.Classify(correctConfigured, "Correct Reliability")
.Classify(!correctConfigured, "Incorrect Reliability")
.Classify(isEnabled, "Reliability is enabled")
.Classify(!isEnabled, "Reliability is disabled");
}));
}
public InvalidPModeException(string message, ValidationResult validationResult) :
base(validationResult.AppendValidationErrorsToErrorMessage(message))
{
}
