BizTalk Testing

Bizmonade Followup

Michael Stephenson — Fri, 30 Oct 2009 13:35:36 GMT

Ive been having a few discussions with Christos Karras and Jason Hyland about Bizmonade over the last few days as a followup to some thoughts and questions i posted about Bizmonade.

Christos has posted a response to some of my questions on the below link, and i must say i think his plan for Bizmonade looks really good and it should become an important tool in the biztalk development cycle.

Check out his response here : http://www.nootaikok.com/2009/10/more-about-bizmonade.html

Configuration Manager - New Release

Michael Stephenson — Fri, 14 Aug 2009 22:35:17 GMT

Ive just released a new version of the configuration manager tool which I used in the BizTalk Light and Easy viewing video. This tool is used to help you manage the different settings needed for binding and configuration files across different environments and allows you to connect this with your build process.

The tool is available on codeplex at: http://configsettingstool.codeplex.com/

The light and easy video is at: http://blogs.breezetraining.com.au/mickb/2009/07/08/UnofficalLaunchOfTheBizTalk2009LightAndEasyWebCastSeries.aspx

Testing BizTalk Maps with Custom XSLT

Michael Stephenson — Thu, 09 Jul 2009 09:31:34 GMT

A while back I wrote a couple of posts about Testing maps in BizTalk. They are at the following links:

BizTalk 2006 R2

http://geekswithblogs.net/michaelstephenson/archive/2008/03/30/120851.aspx

BizTalk 2009

http://geekswithblogs.net/michaelstephenson/archive/2008/12/12/127826.aspx

One possible extension to this might be if you have a map which rather than using the map designer imports a custom XSLT to perform the mapping. (If you are not familiar with this refer to MSDN).

So if you have a custom XSLT then you really have a couple of choices with regard to testing it. The first choice is that you can just run the testing approaches which are described above, or you could also test the XSLT before you use it in the BizTalk map or do both.

If you wish to test the XSLT in isolation you can use the XslCompiledTransform class within the System.Xml.Xsl namespace. This will allow you to load the xsl and then transform an input file to an output file like in the below example. You could then perform a binary comparison on the output file against what it is expected to look like.

Summary

So you can see above this is easy to do. I would probably in practice do 1 test which would test the BizTalk map to ensure it works correctly when loading the custom XSLT and the rest of my tests will focus on testing the XSLT in isolation and testing different cases within the map.

Testing BizTalk Flat File Schemas

Michael Stephenson — Wed, 08 Jul 2009 20:27:12 GMT

I got some feedback a while ago asking for some advice on how we test flat file schemas and have eventually got around to writing this post.

The aim of testing schemas which have been created to represent a flat file (positional or delimited) is to be able to test the schema in isolation to ensure that it can be used to parse and assemble a message correctly.

The reason testing the schema in isolation is important is that it allows you to ensure it works before the schema is used within BizTalk where problems will take more time to troubleshoot and require deployment to BizTalk to do any testing.

Normally when this is done people will create BizTalk pipelines and test this with BizUnit but we have actually used the Pipeline Component Test Library which actually contains some classes which make this really easy to do.

The Sample

In the below sample you can see I have creates a solution structure containing two projects. One is a BizTalk project containing flat file schemas. One schema represents a positional file and the other represents a delimited file.

In the C# Test project I have creates tests for each schema and there are input files for each schema to support testing of assembly and disassembly with each schema.

There are 4 tests.

The assembly tests will take an xml input file representing the schema and then run the assemble process and produce the appropriate flat file.

The disassembly tests will take a flat file and run the disassembly process to produce an xml file of the parsed input in an xml format.

The below code snippet from the tests shows how we use the SchemaTester which is a generic class which you can type to be relevant to your BizTalk schema type. The SchemaTester then provides methods to do each of the types of testing.

Normally what I would do after SchemaTester has ran and produced the output file is to do some kind of binary comparison against a known expected copy of what the xml should look like.

Summary

Hopefully you can see this is quick and easy to implement and can save you a lot of time in getting these schemas right.

The downloadable sample is available from the following location:

http://code.msdn.microsoft.com/flatfileschemas/Wiki/View.aspx?title=Home

BizTalk Testing Guidance - Stub Of Dynamics AX

Michael Stephenson — Wed, 13 May 2009 21:57:49 GMT

Following on from my previous article, one of my old colleagues has written up an article about how a project he worked on was able to simulate the behaviour of Dynamics AX by using one of the approaches I described in my article about how to simulate external systems in testing.

Check out Charlies article here: http://geekswithblogs.net/charliemott/archive/2009/05/13/stub-of-dynamics-ax-for-biztalk-development-and-bizunit-testing.aspx

BizTalk Testing Guidance - Revisited

Michael Stephenson — Fri, 12 Dec 2008 07:42:21 GMT

I've updated my BizTalk Testing Guidance with some new articles based on what we learned today about BizTalk 2009. Please find the latest index below:

Title	Link
Introduction	http://geekswithblogs.net/michaelstephenson/archive/2008/03/30/120849.aspx
Testing Schemas	http://geekswithblogs.net/michaelstephenson/archive/2008/03/30/120850.aspx
Testing Maps	http://geekswithblogs.net/michaelstephenson/archive/2008/03/30/120851.aspx
Testing Pipeline Components	http://geekswithblogs.net/michaelstephenson/archive/2008/03/30/120852.aspx
Testing Pipelines	http://geekswithblogs.net/michaelstephenson/archive/2008/03/30/120853.aspx
Testing Orchestrations	http://geekswithblogs.net/michaelstephenson/archive/2008/03/30/120854.aspx
Testing .net Components	http://geekswithblogs.net/michaelstephenson/archive/2008/03/30/120855.aspx
Testing Schemas with BizTalk 2009	http://geekswithblogs.net/michaelstephenson/archive/2008/12/12/127825.aspx
Testing Maps with BizTalk 2009	http://geekswithblogs.net/michaelstephenson/archive/2008/12/12/127826.aspx
Testing Pipelines and Pipeline Components with BizTalk 2009	http://geekswithblogs.net/michaelstephenson/archive/2008/12/12/127826.aspx

BizTalk Testing Series – Testing Pipelines and Pipeline Components in BizTalk 2009

Michael Stephenson — Fri, 12 Dec 2008 07:33:17 GMT

A while back in my series of articles about testing with BizTalk I covered a technique for testing pipelines and pipeline components. The background to the approach is still valid in BizTalk 2009, but the technique is improved. To review the previous article refer to the following link:

Pipeline Components - http://geekswithblogs.net/michaelstephenson/archive/2008/03/30/120852.aspx

Pipelines - http://geekswithblogs.net/michaelstephenson/archive/2008/03/30/120853.aspx

In this post although we could do testing of pipelines and pipelines components using the excellent pipeline component test library. While that component is excellent for testing, I think the new model provides a simpler option and to be honest with Pipeline Component Test Library it sometimes took a little bit of fiddling with setting up the pipeline wrappers to get your test to work. My gut feeling is that the new approach will just be that bit more straightforward.

I will extend on the sample from the previous post about testing schemas. So our solution now looks like the below picture containing a pipeline

Configure your BizTalk Project for Tests

Just to reiterate this step from the previous post you need to ensure the enable unit testing property is set for the BizTalk project.

Adding references to your test assembly

Again reiterating this step, in your test project you will need to add a couple of references, the main one is the new Microsoft.BizTalk.TestTools assembly which is in the Visual Studio Add Reference list. This will allow you to use these new testing features. You would also need to add references to the pipeline assemblies highlighted in the below picture

The test code

In the below code you can see that I will construct an instance of the TestableReceivePipeline which is what my custom receive pipeline will derive from. I can then provide documents and schema information and then execute my pipeline. Unfortunately the documentation of these objects doesn't seem to be complete in the initial CTP so Im guessing there are a few more ways you can configure these objects, but they will give you an easy way to test send and receive pipelines.

What about Pipeline Components

In the Pipeline Component Test Library there was the ability to be able to construct a pipeline wrapper in code so you could simulate adding your custom pipeline component to different types of pipeline. I'm not sure that you can do this in the new features of BizTalk 2009, however you can just create a pipeline artefact and add your component to that. The other cool feature is you might not (haven't tried this) even have to add a new project for the BizTalk artefact as you can have BizTalk and C# files in the same project.

Summary

As you can see this new technique appears like it will be a simpler way to encourage testing.

The sample for this demo is available at the following location: http://www.box.net/shared/7rb81bcxsm

If you have problems accessing it then let me know.

BizTalk Testing Series – Testing Maps in BizTalk 2009

Michael Stephenson — Fri, 12 Dec 2008 06:45:25 GMT

A while back in my series of articles about testing with BizTalk I covered a technique for testing maps. The background to the approach is still valid in BizTalk 2009, but the technique is improved. To review the previous article refer to the following link:

http://geekswithblogs.net/michaelstephenson/archive/2008/03/30/120851.aspx

In this post although we could do testing of maps, to be honest it was a little bit of a pain. In the newly released BizTalk 2009 CTP there have been some improvements in how you can do some of the testing and I would like to demonstrate this. I will walk through the steps to test your schema.

I will extend on the sample from the previous post about testing schemas. So our solution now looks like the below picture containing an additional schema and a new map.

Configure your BizTalk Project for Tests

Just to reiterate this step from the previous post you need to ensure the enable unit testing property is set for the BizTalk project.

Adding references to your test assembly

The test code

In the below picture you can see that I am doing two things. The first is that I create an instance of the new TestableMapBase class which my map derives from. I can use this to execute my map by passing the details of an input file. The results are written to the output file.

I'm also using the schema validation to confirm that the message is valid that comes out. I think there are also properties of the TestableMapBase object which can do this.

In practice when I use this technique I will probably execute the map with a known input file and then compare the results of the output file with a predefined example output file so rather than just validating the schema I'm actually also ensuring the content is exactly as expected. You can do this with a binary comparison of the file.

Summary

As you can see this new technique just simplifies what we had been doing in BizTalk 2006 R2 and is a very nice interface to support this testing.

The sample for this demo is available at the following location: http://www.box.net/shared/yro0poto3m

If you have problems accessing it then let me know.

BizTalk Testing Series – Testing Schema in BizTalk 2009

Michael Stephenson — Fri, 12 Dec 2008 06:43:51 GMT

A while back in my series of articles about testing with BizTalk I covered a technique for testing schema. The background to the approach is still valid in BizTalk 2009, but the technique is improved. To review the previous article refer to the following link:

http://geekswithblogs.net/michaelstephenson/archive/2008/03/30/120850.aspx

In the newly released BizTalk 2009 CTP there have been some improvements in how you can do some of the testing and I would like to demonstrate this. I will walk through the steps to test your schema.

Before I go into the details, we start with a simple project with two projects. The first is a BizTalk project with a schema and the second is a C# test project. The following steps need to be taken to setup your tests

Configure your BizTalk Project for Tests

The first step is to open the properties for your new BizTalk project. If you go to the Deployment section you can see highlighted in the below picture the setting which will turn on the generation of some additional code to allow you to test BizTalk artefacts.

Adding references to your test assembly

In your test project you will need to add a couple of references, the main one is the new Microsoft.BizTalk.TestTools assembly which is in the Visual Studio Add Reference list. This will allow you to use these new testing features.

The test code

The following code snippet shows how you can create an instance of your schema which derives from the new TestableSchemaBase object. This has the new ValidateInstance method which allows you to pass in the path to a file containing the message you wish to validate.

Summary

As you can see this new technique just simplifies what we had been doing in BizTalk 2006 R2 and is a very nice interface to support this testing.

The sample for this demo is available at the following location: http://www.box.net/shared/2ojysf5ys3

If you have problems accessing it then let me know.

Detecting BizTalk Event with BizUnit

Michael Stephenson — Wed, 23 Jul 2008 22:48:12 GMT

I came across an annoying one the other day, I havent had time to look into it in more detail, but here are some notes about it.

In some of the tests we do with BizUnit we sometimes check the event log to see that certain messages have occured. I came across an example I havent noticed before the other day.

In my test I do a bunch of stuff then I wait until a custom event with a specific Event Id is logged to the event log. I use the BizUnit event log check step and it finds my event fine.

Later in the test I will do the following:

Stop the application pool for a web service I will call
Allow BizTalk to call the service and then suspend the service instance because the web service is unavailable
My test will detect the event logged by BizTalk Event ID - 5754 to indicate a call has failed. I will also use the ValidationRegEx node to confirm the event message relates to my port
I will then start the application pool back up
I will then use a custom BizUnit step to resume the suspended instance
Finally I will check the process worked correctly

This was working as far as the point of detecting the BizTalk event. I could see in the event log the event I was expecting was there, but for some reason my step didnt spot it.

Because I was using the regex feature this was my first thought, but the expression was simple and even if I took it away the event wasnt spotted still.

It turns out when I wrote a little C# to check what comes back in the event log was that although the event in Event Viewer displays with the event number 5754, the event log instance from System.Diagnostics comes back with the following property values:

- Event Id: 12588666

- Instance Id: 3233814138

When I changed the event number as appropriate it worked fine. Frustrating but there you go.