public void SetupResponseExpectationAgainstSpecificMessageType()
{
_soapStub.As <ISolicitResponse>()
.Setup(s => s.Request(SchemaMetadata.For <btf2_services_header>().DocumentSpec))
.Returns(new StringStream("<response />"));
var client = SoapClient <IMessageService> .For(_soapStubHost.Endpoint);
try
{
var response = client.Invoke(
System.ServiceModel.Channels.Message.CreateMessage(
MessageVersion.Soap11,
"urn:services.stateless.be:unit:work:request",
XmlReader.Create(new StringReader(MessageBodyFactory.Create <btf2_services_header>().OuterXml))));
var reader = response !.GetReaderAtBodyContents();
reader.MoveToContent();
var outerXml = reader.ReadOuterXml();
outerXml.Should().Be("<response />");
client.Close();
}
catch (Exception)
{
client.Abort();
throw;
}
}
public void BatchContentIsTransformedToSpecificEnvelope()
{
string expectedEnvelopeContent;
var envelopeStream = new StringStream(EnvelopeFactory.Create <Envelope>().OuterXml);
var batchContentStream = MessageBodyFactory.Create <Batch.Content>(MessageBody.Samples.LoadString("Message.BatchContent.xml")).AsStream();
var transformedStream = new[] { envelopeStream, batchContentStream }.Transform().Apply(typeof(BatchContentToAnyEnvelope), new UTF8Encoding(false));
using (var expectedReader = XmlReader.Create(transformedStream, new XmlReaderSettings {
CloseInput = true
}))
{
expectedReader.Read();
expectedEnvelopeContent = expectedReader.ReadOuterXml();
}
using (var stream = MessageBody.Samples.Load("Message.BatchContent.xml"))
{
MessageMock.Object.BodyPart.Data = stream;
PipelineContextMock
.Setup(pc => pc.GetDocumentSpecByType(SchemaMetadata.For <Envelope>().MessageType))
.Returns(SchemaMetadata.For <Envelope>().DocumentSpec);
var sut = new EnvelopeBuilder();
sut.Execute(PipelineContextMock.Object, MessageMock.Object);
using (var actualReader = XmlReader.Create(MessageMock.Object.BodyPart.Data, new XmlReaderSettings {
CloseInput = true, IgnoreWhitespace = true
}))
{
actualReader.Read();
var actualEnvelopeContent = actualReader.ReadOuterXml();
actualEnvelopeContent.Should().Be(expectedEnvelopeContent);
}
}
}
public void TransformBatchContentWithEnvironmentTagAndPartition()
{
var setup = Given(
input => input
.Message(EnvelopeFactory.Create <Envelope>().AsStream())
.Message(MessageBodyFactory.Create <Batch.Content>(MessageBody.Samples.LoadString("Message.BatchContentWithEnvironmentTagAndPartition.xml")).AsStream()))
.Transform
.OutputsXml(
output => output
.ConformingTo <Envelope>()
.ConformingTo <Batch.Release>()
.WithStrictConformanceLevel());
var result = setup.Validate();
result.NamespaceManager.AddNamespace("env", SchemaMetadata.For <Envelope>().TargetNamespace);
result.NamespaceManager.AddNamespace("tns", SchemaMetadata.For <Batch.Release>().TargetNamespace);
result.SelectSingleNode("/*") !.LocalName.Should().Be("Envelope");
result.Select("/env:Envelope/tns:ReleaseBatch").Cast <object>().Should().HaveCount(3);
result.Select("/env:Envelope/*").Cast <object>().Should().HaveCount(3);
var part = result.SelectSingleNode("/env:Envelope/tns:ReleaseBatch[3]");
part !.SelectSingleNode("tns:EnvelopeSpecName") !.Value.Should().Be(SchemaMetadata.For <Batch.Release>().DocumentSpec.DocSpecName);
part !.SelectSingleNode("tns:EnvironmentTag") !.Value.Should().Be("graffiti");
part !.SelectSingleNode("tns:Partition") !.Value.Should().Be("A");
}
public void ValidatingValidXmlDoesNotThrow()
{
var instance = MessageBodyFactory.Create <btf2_services_header>(
ResourceManager.Load(Assembly.GetExecutingAssembly(), "Be.Stateless.BizTalk.Resources.Message.xml", s => s.ReadToEnd()));
Invoking(() => new DocumentSchemaFixture().ValidateInstanceDocument(instance))
.Should().NotThrow();
}
public void ValidatingInvalidXmlDocumentThrows()
{
var instance = MessageBodyFactory.Create <btf2_services_header>();
Invoking(() => new DocumentSchemaFixture().ValidateInstanceDocument(instance))
.Should().Throw <XmlSchemaValidationException>()
.WithMessage(
"Error: The 'http://schemas.biztalk.org/btf-2-0/services:sendBy' element is invalid - The value '' is invalid according to its datatype 'http://www.w3.org/2001/XMLSchema:dateTime'*");
}
public void InvalidTransformResultThrows()
{
using (var stream = MessageBodyFactory.Create <btf2_services_header>().AsStream())
{
var setup = Given(input => input.Message(stream))
.Transform
.OutputsXml(output => output.ConformingTo <btf2_services_header>().WithStrictConformanceLevel());
Invoking(() => setup.Validate()).Should().Throw <XmlSchemaValidationException>();
}
}
public void SetupXmlTransformWithoutConformingSchemaAndConformanceLevel()
{
using (var stream = MessageBodyFactory.Create <btf2_services_header>().AsStream())
{
var setup = Given(input => input.Message(stream))
.Transform
.OutputsXml(
output => output
.WithValuednessValidationCallback((_, args) => args.Severity = XmlSeverityType.Warning)
.WithNoConformanceLevel());
Invoking(() => setup.Validate()).Should().NotThrow();
}
}
public void ValidateTransformWithPartition()
{
var instance = MessageBodyFactory.Create <Schemas.Xml.Batch.Release>(MessageBody.Samples.LoadString("Message.ReleaseBatchWithPartition.xml"));
using (var stream = instance.AsStream())
{
var setup = Given(input => input.Message(stream).Context(new Mock <IBaseMessageContext>().Object))
.Transform
.OutputsXml(output => output.ConformingTo <QueueControlledRelease>().WithStrictConformanceLevel());
var result = setup.Validate();
result.SelectSingleNode("//usp:envelopeSpecName") !.Value.Should().Be(SchemaMetadata.For <Envelope>().DocumentSpec.DocSpecStrongName);
result.SelectSingleNode("//usp:partition") !.Value.Should().Be("A");
}
}
public void SetupFailureExpectationAgainstMessageType()
{
_soapStub.As <ISolicitResponse>()
.Setup(s => s.Request(SchemaMetadata.For <btf2_services_header>().DocumentSpec))
.Aborts();
var client = SoapClient <IMessageService> .For(_soapStubHost.Endpoint);
Invoking(
() => client.Invoke(
System.ServiceModel.Channels.Message.CreateMessage(
MessageVersion.Soap11,
"urn:services.stateless.be:unit:work:request",
XmlReader.Create(new StringReader(MessageBodyFactory.Create <btf2_services_header>().OuterXml)))))
.Should().Throw <CommunicationException>();
client.Abort();
}
public void SetupValuednessValidationCallbackConfirmingSeverity()
{
using (var stream = MessageBodyFactory.Create <btf2_services_header>().AsStream())
{
var setup = Given(input => input.Message(stream))
.Transform
.OutputsXml(
output => output
.WithValuednessValidationCallback((_, args) => args.Severity = XmlSeverityType.Error)
.ConformingTo <btf2_services_header>().WithNoConformanceLevel());
Invoking(() => setup.Validate())
.Should().Throw <XmlException>()
.Where(
exception => exception.Message.Contains("/ns0:services/ns0:deliveryReceiptRequest/ns0:sendTo/ns0:address") &&
exception.Message.Contains("/ns0:services/ns0:deliveryReceiptRequest/ns0:sendBy") &&
exception.Message.Contains("/ns0:services/ns0:commitmentReceiptRequest/ns0:sendBy"));
}
}
public void ValidateTransformWithProcessActivityId()
{
var contextMock = new Mock <IBaseMessageContext>();
contextMock
.Setup(c => c.Read(TrackingProperties.ProcessActivityId.Name, TrackingProperties.ProcessActivityId.Namespace))
.Returns("D4D3A8E583024BAC9D35EC98C5422E82");
var instance = MessageBodyFactory.Create <Schemas.Xml.Batch.Release>(MessageBody.Samples.LoadString("Message.ReleaseBatch.xml"));
using (var stream = instance.AsStream())
{
var setup = Given(input => input.Message(stream).Context(contextMock.Object))
.Transform
.OutputsXml(output => output.ConformingTo <QueueControlledRelease>().WithStrictConformanceLevel());
var result = setup.Validate();
result.SelectSingleNode("//usp:envelopeSpecName") !.Value.Should().Be(SchemaMetadata.For <Envelope>().DocumentSpec.DocSpecStrongName);
result.Select("//usp:partition").Should().BeEmpty();
result.SelectSingleNode("//usp:processActivityId") !.Value.Should().Be("D4D3A8E583024BAC9D35EC98C5422E82");
}
}
public static XmlDocument CreateReleaseFor <TSchema>(string partition = null)
where TSchema : SchemaBase
{
var builder = new StringBuilder();
using (var writer = XmlWriter.Create(builder, new() { Indent = false, OmitXmlDeclaration = true, Encoding = Encoding.UTF8 }))
{
const string prefix = "ns";
var schemaMetadata = SchemaMetadata.For <Schemas.Xml.Batch.Release>();
var ns = schemaMetadata.TargetNamespace;
writer.WriteStartElement(prefix, schemaMetadata.RootElementName, ns);
{
writer.WriteElementString(prefix, nameof(BatchDescriptor.EnvelopeSpecName), ns, SchemaMetadata.For <TSchema>().DocumentSpec.DocSpecStrongName);
if (!partition.IsNullOrWhiteSpace())
{
writer.WriteElementString(prefix, nameof(BatchDescriptor.Partition), ns, partition);
}
}
writer.WriteEndElement();
}
return(MessageBodyFactory.Create <Schemas.Xml.Batch.Release>(builder.ToString()));
}
public void ValidateReleaseBatch(string name)
{
Invoking(() => MessageBodyFactory.Create <Batch.Release>(MessageBody.Samples.LoadString($"Message.{name}")))
.Should().NotThrow();
}
public void InvokeSucceeds()
{
_soapStub.As <ISolicitResponse>()
.Setup(s => s.Request(SchemaMetadata.For <btf2_services_header>().DocumentSpec))
.Returns(new StringStream("<response />"));
using (var response = SoapClient.Invoke(_soapStubHost.Endpoint, new StringStream(MessageBodyFactory.Create <btf2_services_header>().OuterXml)))
{
new StreamReader(response).ReadToEnd().Should().Be("<response />");
}
}
