As I mentioned on a previous
post, I've been working on a helper library to test BizTalk Pipelines and
Custom Pipeline Components using NUnit or your unit testing framework of choice.
I've uploaded V1.0 of the library, which you can download from here.
The library is pretty straightforward to use, but I'm going to document its
features on this and following posts so that you can get started with it
Preparing to use the library
First of all, you'll need to build the library from the downloaded source
code distribution, using Visual Studio 2005. The distribution includes the unit
tests for the library, which you can run to verify it is working correctly, if
To use the library once you've built it, you'll want your projects to
reference the following three libraries:
To test a pipeline component, or a pipeline, the first thing you'll need to
do pretty much is instantiate a pipeline. The library supports two different
ways of doing this: Create an empty pipeline and add the necessary components
using code, or create an instance of an existing BizTalk pipeline. Both of these
operations are supported for send and receive pipelines through the methods in
the PipelineFactory class.
- CreateEmptyReceivePipeline() and CreateEmptySendPipeline() create a new
receive or send pipeline respectively, that has no components configured
on any of its stages. You then are responsable for adding the necessary
components to configure your pipeline as necessary; I'll show later how this
can be done.
Here's an example of how these methods can be called:
- CreateReceivePipeline() and CreateSendPipeline() create a new instance of
an existing BizTalk pipeline. Each of these methods take a Type handle as an
argument. When you compile a BizTalk project that contains a pipeline, said
pipeline is generated as a new CLR type into your BizTalk assembly (with the
same name as the .BTP file it is derived from).
This is very convenient, as it allows you to just add a project or file
reference to the BizTalk project where you designed the pipeline and use the
type directly. In fact, built-in pipelines like the XMLTransmit or XMLReceive
pipeline can be used just this way: simply reference the
Microsoft.BizTalk.DefaultPipelines.dll assembly and write this:
If you've created an instance of an existing pipeline, you've probably
set to go and can skip this part (though you can still add new components to an
existing pipeline this way), if not, you'll now want to add some components to
each of the stages you're interested in to your pipeline.
To do this, you can use the AddComponent() method of each of the pipeline
classes, which take an object implementing IBaseComponent (a pipeline component)
and an object of type PipelineStage representing the stage you want to add that
component to. The PipelineStage class contains a set of static readonly objects
you can use to refer to the possible stages you can use, so you'll never create
an instance of this type directly.
So, for example, if you want to add a new XML Disassembler component to the
disassemble stage of a receive pipeline, you can write this:
component = new XmlDasmComp();
Here's an example of adding an encoding component to a send pipeline:
encoder = new
encoder.AddSigningCertToMessage = true;
In a following post I'll talk about configuring document specifications
(schemas) and executing the pipelines.