private static Property NotifyMethod_Should_Be_Specified_When_We_Notify_MessageProducer(
bool notifyMessageProducer,
Func <SendingProcessingMode, SendHandling> getHandling)
{
return(Prop.ForAll(
CreateMethodGen().ToArbitrary(),
method =>
{
// Arrange
var pmode = ValidSendingPModeFactory.Create();
SendHandling sendHandling = getHandling(pmode);
sendHandling.NotifyMessageProducer = notifyMessageProducer;
sendHandling.NotifyMethod = method;
// Act
ValidationResult result = ExerciseValidation(pmode);
// Assert
bool specifiedNotifyMethod = SpecifiedMethod(method);
return result.IsValid
.Equals(notifyMessageProducer && specifiedNotifyMethod)
.Or(!notifyMessageProducer)
.Label(
$"Validation has {(result.IsValid ? "succeeded" : "failed")} " +
$"but the NotifyMethod {(specifiedNotifyMethod ? "is" : "isn't")} specified " +
$"while the NotifyMessageProducer is {(notifyMessageProducer ? "enabled" : "disabled")}");
}));
}
private static SendingProcessingMode CreateAnonymousSendingPModeWith(string expectedMpc)
{
SendingProcessingMode expectedSendingPMode = ValidSendingPModeFactory.Create("expected-id");
expectedSendingPMode.MessagePackaging.Mpc = expectedMpc;
return(expectedSendingPMode);
}
/// <summary>
/// Retrieve the PMode from the Global Settings
/// </summary>
/// <param name="id"></param>
/// <exception cref="Exception"></exception>
/// <returns></returns>
public override SendingProcessingMode GetSendingPMode(string id)
{
SendingProcessingMode pmode = ValidSendingPModeFactory.Create();
pmode.MessagePackaging.MessageProperties = new List <AS4.Model.PMode.MessageProperty>();
return(pmode);
}
public void ValidSendingPMode_IfKeySizeIs(int beforeKeySize, int afterKeySize)
{
SendingProcessingMode pmode = ValidSendingPModeFactory.Create();
pmode.Security.Encryption.IsEnabled = true;
pmode.Security.Encryption.AlgorithmKeySize = beforeKeySize;
// Act
ExerciseValidation(pmode);
// Assert
Assert.True(pmode.Security.Encryption.AlgorithmKeySize == afterKeySize);
}
public Property Encryption_Certificate_Should_Be_Specified_When_Encryption_Is_Enabled_For_A_Non_DynamicDiscovery_Setup(
bool isEnabled,
string findValue,
string certificate)
{
var genDynamicDiscoveryProfile =
Gen.Fresh(() => new DynamicDiscoveryConfiguration())
.OrNull();
return(Prop.ForAll(
CreateEncryptionCertificateInfoGen(findValue, certificate).ToArbitrary(),
genDynamicDiscoveryProfile.ToArbitrary(),
(cert, dynamicDiscovery) =>
{
// Arrange
var pmode = ValidSendingPModeFactory.Create();
pmode.DynamicDiscovery = dynamicDiscovery;
pmode.Security.Encryption = new Encryption
{
IsEnabled = isEnabled,
EncryptionCertificateInformation = cert.Item2,
CertificateType = cert.Item1
};
// Act
ValidationResult result = ExerciseValidation(pmode);
// Assert
bool specifiedDynamicDiscoveryProfile = pmode.DynamicDiscoverySpecified;
bool specifiedCertFindCriteria =
cert.Item1 == PublicKeyCertificateChoiceType.CertificateFindCriteria &&
cert.Item2 is CertificateFindCriteria c &&
!String.IsNullOrWhiteSpace(c.CertificateFindValue);
bool specifiedPublicKeyCert =
cert.Item1 == PublicKeyCertificateChoiceType.PublicKeyCertificate &&
cert.Item2 is PublicKeyCertificate k &&
!String.IsNullOrWhiteSpace(k.Certificate);
bool specifiedEncryptionCert = specifiedCertFindCriteria || specifiedPublicKeyCert;
return result.IsValid
.Equals(specifiedEncryptionCert && isEnabled && !specifiedDynamicDiscoveryProfile)
.Or(!isEnabled)
.Or(specifiedDynamicDiscoveryProfile)
.Label(
$"Validation has {(result.IsValid ? "succeeded" : "failed")} " +
$"but encryption certificate {(specifiedEncryptionCert ? "is" : "isn't")} specified " +
$"with a {cert.Item1} while the encryption is {(isEnabled ? "enabled" : "disabled")} " +
$"for a {(specifiedDynamicDiscoveryProfile ? "configured" : "non-configured")} Dynamic Discovery");
}));
}
private static SendingProcessingMode CreateSendingPMode(AS4.Model.PMode.Party fromParty, AS4.Model.PMode.Party toParty)
{
SendingProcessingMode pmode = ValidSendingPModeFactory.Create();
pmode.MessagePackaging = new SendMessagePackaging
{
PartyInfo = new PartyInfo
{
FromParty = fromParty,
ToParty = toParty
}
};
return(pmode);
}
public async Task FailsToRetrievePMode_IfInvalidPMode()
{
// Arrange
const string pmodeId = "01-pmode";
var internalMessage = new MessagingContext(GetStubSubmitMessage(pmodeId));
SendingProcessingMode invalidPMode = ValidSendingPModeFactory.Create(pmodeId);
invalidPMode.ReceiptHandling.NotifyMessageProducer = true;
invalidPMode.ReceiptHandling.NotifyMethod = null;
var sut = new RetrieveSendingPModeStep(CreateStubConfigWithSendingPMode(invalidPMode));
// Act / Assert
await Assert.ThrowsAnyAsync <Exception>(() => sut.ExecuteAsync(internalMessage));
}
public Property Tls_Certificate_Should_Be_Specified_When_Tls_Is_Enabled(
bool isEnabled,
string clientCertFindValue,
string password,
string certificate)
{
return(Prop.ForAll(
CreateTlsCertificateInfoGen(clientCertFindValue, password, certificate)
.ToArbitrary(),
tls =>
{
// Arrange
SendingProcessingMode pmode = ValidSendingPModeFactory.Create();
pmode.PushConfiguration.TlsConfiguration = new TlsConfiguration
{
IsEnabled = isEnabled,
ClientCertificateInformation = tls.Item2,
CertificateType = tls.Item1
};
// Act
ValidationResult result = ExerciseValidation(pmode);
// Assert
bool specifiedClientCertRef =
tls.Item1 == TlsCertificateChoiceType.ClientCertificateReference &&
tls.Item2 is ClientCertificateReference clientCertRef &&
!String.IsNullOrWhiteSpace(clientCertRef.ClientCertificateFindValue);
bool specifiedPrivateKeyCert =
tls.Item1 == TlsCertificateChoiceType.PrivateKeyCertificate &&
tls.Item2 is PrivateKeyCertificate privateKeyCert &&
!String.IsNullOrWhiteSpace(privateKeyCert.Certificate) &&
!String.IsNullOrWhiteSpace(privateKeyCert.Password);
bool specifiedCert = specifiedClientCertRef || specifiedPrivateKeyCert;
return result.IsValid
.Equals(specifiedCert && isEnabled)
.Or(!isEnabled)
.Label(
$"Validation has {(result.IsValid ? "succeeded" : "failed")} " +
$"but TLS client certificate {(specifiedCert ? "is" : "isn't")} specified " +
$"with a {tls.Item1} while the TLS configuration is {(isEnabled ? "enabled" : "disabled")}");
}));
}
public Property Signing_Certificate_Should_Be_Specified_When_Signing_Is_Enabled(
bool isEnabled,
string findValue,
string certificate,
string password)
{
return(Prop.ForAll(
CreatePrivateKeyCertificateGen(findValue, certificate, password)
.ToArbitrary(),
cert =>
{
// Arrange
SendingProcessingMode pmode = ValidSendingPModeFactory.Create();
pmode.Security.Signing = new Signing
{
IsEnabled = isEnabled,
SigningCertificateInformation = cert.Item2,
CertificateType = cert.Item1
};
// Act
ValidationResult result = ExerciseValidation(pmode);
// Assert
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 specifiedCertInfo = specifiedCertFindCriteria || specifiedPrivateKeyCert;
return result.IsValid
.Equals(specifiedCertInfo && isEnabled)
.Or(!isEnabled)
.Label(
$"Validation has {(result.IsValid ? "succeeded" : "failed")} " +
$"but signing certificate {(specifiedCertInfo ? "is" : "isn't")} specified " +
$"with a {cert.Item1} while the signing is {(isEnabled ? "enabled" : "disabled")}");
}));
}
private static Property TestRelialityForEnabledFlag(
bool isEnabled,
int retryCount,
TimeSpan retryInterval,
Func <SendingProcessingMode, RetryReliability> getReliability)
{
return(Prop.ForAll(
Gen.Frequency(
Tuple.Create(1, Arb.From <string>().Generator),
Tuple.Create(2, Gen.Constant(retryInterval.ToString())))
.ToArbitrary(),
retryIntervalText =>
{
// Arrange
SendingProcessingMode pmode = ValidSendingPModeFactory.Create();
RetryReliability r = getReliability(pmode);
r.IsEnabled = isEnabled;
r.RetryCount = retryCount;
r.RetryInterval = retryIntervalText;
// Act
ValidationResult result = ExerciseValidation(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 async Task MessageIsntCreated_IfDuplicatePayloadIdsAreFound()
{
// Arrange
SendingProcessingMode pmode = ValidSendingPModeFactory.Create();
var submit = new SubmitMessage
{
PMode = pmode,
Payloads = new []
{
new Payload("earth", "location", "mime"),
new Payload("earth", "location", "mime")
}
};
var context = new MessagingContext(submit)
{
SendingPMode = pmode
};
// Act / Assert
await Assert.ThrowsAsync <InvalidMessageException>(() => ExerciseCreation(context));
}
public Property RetryCount_And_RetryInterval_Should_Be_Specified_When_ReceptionAwarness_Is_Enabled(
bool isEnabled,
int retryCount,
TimeSpan retryInterval)
{
return(Prop.ForAll(
Gen.Frequency(
Tuple.Create(1, Arb.Generate <string>()),
Tuple.Create(2, Gen.Constant(retryInterval.ToString())))
.ToArbitrary(),
retryIntervalText =>
{
// Arrange
SendingProcessingMode pmode = ValidSendingPModeFactory.Create();
var r = new ReceptionAwareness
{
IsEnabled = isEnabled,
RetryCount = retryCount,
RetryInterval = retryIntervalText
};
pmode.Reliability.ReceptionAwareness = r;
// Act
ValidationResult result = ExerciseValidation(pmode);
// Assert
bool validRetryCount = r.RetryCount > 0;
bool validRetryInterval = r.RetryInterval.AsTimeSpan() > default(TimeSpan);
return result.IsValid
.Equals(isEnabled &&
validRetryCount &&
validRetryInterval)
.Or(!isEnabled)
.Label(
$"Validation has {(result.IsValid ? "succeeded" : "failed")} " +
$"but the RetryCount {(validRetryCount ? ">" : "<=")} 0 (was {r.RetryCount}) and " +
$"RetryInterval {(validRetryInterval ? ">" : "<=")} {default(TimeSpan)} (was {r.RetryInterval}) " +
$"while the ReceptionAwareness is {(isEnabled ? "enabled" : "disabled")}");
}));
}
