bizunit Work Item Rss Feed

Created Issue: Source Code Project Types Incompatible in Visual Studio 2008 [10671]

tolandmike — Tue, 22 Sep 2009 14:22:57 GMT

I can't open any of the source code projects nor any of the sample projects in VS 2008.

Created Issue: DBQueryStep - Validate Multiple Rows not working [10619]

sharathk — Fri, 11 Sep 2009 00:17:34 GMT

DBQuery Step doesnt work for multiple row validation

Row to validate is assigned the first row from DataSet in foreach loop

Source: DBQueryStep.cs
public void Execute(Context context)
{
\\\
bamDBRow = ds.Tables[0].Rows[0];
\\\
}

Need to assign correct row from the DataSet

Commented Issue: XMLValidationStepEx ExecuteValidation throws NullReferenceException

maakku — Thu, 02 Jul 2009 13:20:27 GMT

private IList<Pair> xPathValidations gets never initialized.

As a result method public void ExecuteValidation(Stream data, XmlNode validatorConfig, Context context) always throws NullReferenceException.
Comments: ** Comment from web user: maakku **

Sorry, not always, only if there are xpath expressions involved.

Created Issue: XMLValidationStepEx ExecuteValidation throws NullReferenceException

maakku — Thu, 02 Jul 2009 13:16:36 GMT

Commented Issue: The project type is not supported by this installation

twinpiloot — Wed, 01 Jul 2009 13:07:36 GMT

When opening the solution file of version 3.0, I get the error "The project type is not supported by this installation" for 4 of the C# projects in the solution.
For example BizUnit.UIAutomation.TestUI opens fine and BizUnit.Tests (both are C# projects) does not open.

I downloaded version 2.3 of BizUnit and the problem is gone.
Perhaps there is a prerequisite that I need to install?
Comments: ** Comment from web user: twinpiloot **

Meanwhile I found the problem. BizUnit depends on Visual Studio 2005 Team System.
Some projects have the type "Test Project" and this is not included with VS 2005 Professional for example.

Created Issue: The project type is not supported by this installation

twinpiloot — Wed, 01 Jul 2009 09:57:36 GMT

Created Issue: Error in helpfile on BizUnitTestCase code example

steveculshaw — Sat, 11 Apr 2009 20:07:37 GMT

Looking at the code example in the CHM file entry for BizUnitTestCase, it has an empty constructor, but it's only got the ... public BizUnitTestCase(string name)

// Create the BizUnitTestCase
BizUnitTestCase testCase = new BizUnitTestCase();

Created Issue: Minor point - correct home page content

steveculshaw — Sat, 11 Apr 2009 16:17:40 GMT

It would be nice to correct the typename references on the home page to take account of v3.x ...

<TestStep assemblyPath="" typeName="Microsoft.Services.BizTalkApplicationFramework.BizUnit.FileCreateStep">

Created Issue: Minor point - incorrect Assembly KeyFile

steveculshaw — Fri, 10 Apr 2009 14:03:47 GMT

I installed and started on the SDK examples, but got an error w.r.t. the key file

I think it should be ... C:\Program Files\BizUnit\BizUnit 3.0\Src\SDK\SampleSolution\src\BtsTestProj\key.snk

but it's installed with ... C:\Kevin\Code-Projects\BizUnit\BizUnit2.2\Src\BizUnit\BizUnit.snk

Created Issue: FileDeleteStep takeFromCtx

AlesDoganoc — Fri, 03 Apr 2009 13:09:24 GMT

I wanted to use this with this step and noticed it does not work that is why I'm putting it here as a suggestion to add to the step. I have already made the change myself in the source for the feature to work and attached the changed source file.

Created Issue: NullReferenceException when using Stream based constructor

santoshbenjamin — Tue, 24 Mar 2009 12:05:05 GMT

When we use the Stream (representing the config) instead of the XmlNode, we get a null reference exception. It appears to be due to an issue with the logger object not being set correctly.
Setting the logger to use the context logger explicitly (as discussed here: http://bizunit.codeplex.com/Thread/View.aspx?ThreadId=39393) solves the problem

Thanks
benjy

Created Issue: BizUnit Object not using Injected Logger from Context

santoshbenjamin — Tue, 24 Mar 2009 12:02:15 GMT

Please refer to the discussion and comment on this
http://bizunit.codeplex.com/Thread/View.aspx?ThreadId=39393
The context logger should be used to initialize the BizUnit logger.

Thanks
Benjy

Commented Issue: Problem with BizUnit.FileDeleteMultipleStep

santoshbenjamin — Mon, 23 Mar 2009 16:02:54 GMT

when i pass the directoryPath using Context object as follows the files will not be deleted

Context ctx = new Context();
ctx.Add("SalesReceiveLocation", ConfigurationManager.AppSettings["SalesReceiveLocation"]);
BizUnit.BizUnit bizUnit = new BizUnit.BizUnit(@"TestCases\ProcessSalesToFinanceOrchestrationWillCreateSalesResponsesFileWhenASalesFileIsReceived.xml",ctx);
bizUnit.RunTest();

i had to modify the Execute method in BizUnit code(FileDeleteMultipleStep.cs)

public void Execute(XmlNode testConfig, Context context)
{
this.directory = context.ReadConfigAsString( testConfig, "Directory" );
this.searchPattern = context.ReadConfigAsString( testConfig, "SearchPattern" );
Execute(context);
}

Arun
Comments: ** Comment from web user: santoshbenjamin **

This happens even for regular use (via the XML) because, as shown above, the Execute(context) is not being called.

Created Issue: Suggested Enhancement to WaitOnFileStep

fabio_m — Wed, 28 Jan 2009 11:40:09 GMT

Hello,
I've enhanced the WaitOnFileStep class to specify the name of the context key under which to store the name of the file waited for (see discussion at http://www.codeplex.com/bizunit/Thread/View.aspx?ThreadId=45364).

The source code and the XML test case are attached. Please note that in order to get this working I have also implemented work item 7921 (http://www.codeplex.com/bizunit/WorkItem/View.aspx?WorkItemId=7921).

Hope you find it useful...

Fabio

Created Issue: Concurrent test steps bug

abramsmj — Thu, 30 Oct 2008 12:33:57 GMT

I have been writing some automated unit tests that include concurrent test steps, and I think there is a bug in the logging functionality when a concurrent test step completes. When I try and run the BizUnit unit test "Test_11_WaitOnFile", I get the followign error:

*******************************************************************************
Error: Exception caught!
System.ApplicationException: This instance is not a concurrent test step!
at BizUnit.Logger.LogBufferedText(ILogger logger) in C:\Program Files\BizUnit\BizUnit 3.0\Src\BizUnit\Logger.cs:line 146
at BizUnit.BizUnit.FlushConcurrentQueue(Boolean waitingToFinish) in C:\Program Files\BizUnit\BizUnit 3.0\Src\BizUnit\BizUnit.cs:line 1015
at BizUnit.BizUnit.ExecuteSteps(XmlNodeList steps) in C:\Program Files\BizUnit\BizUnit 3.0\Src\BizUnit\BizUnit.cs:line 948
at BizUnit.BizUnit.Execute() in C:\Program Files\BizUnit\BizUnit 3.0\Src\BizUnit\BizUnit.cs:line 862
*******************************************************************************

I have traced the BizUnit source code as the test was running, and I think there is an error in the function Logger.LogBufferedText(ILogger logger). The code throws an exception if (!this.concurrentExecutionMode) evaluates to true, but the "this" instance is for the main thread that is used for non-concurrent test steps. The code needs to check the concurrentExecutionMode for the ILogger parameter, like this:

public void LogBufferedText(ILogger logger)
{
// CODE CHANGE
if ( !logger.ConcurrentExecutionMode )
{
throw new ApplicationException("This instance is not a concurrent test step!");
}

WriteLine(logger.BufferedText);
}

Now the unit test works.

Created Issue: Problem with BizUnit.FileDeleteMultipleStep

arungoPalam — Fri, 24 Oct 2008 12:52:47 GMT

Commented Issue: How to automate LoadGen using BizUnit - LoadGenExecuteStep

conlyn — Mon, 22 Sep 2008 15:59:36 GMT

I thought it would be usefull to record my finding, as I spent sometime trying to get this working.

Objective:
Try to automate Load and perfomance testing throught the use of BizUnit.

So I did the following:
1. Create a "LoadGen" Test:
1. LoadGen Configuration file
2. Sample File (or template) to be used by LoadGen
(to test this, I used the LoadGenConsole.exe)

2. created a BizUnit XML configuration file that runs few steps, example:
Step 1: Clean MsgBox
Step 2: Restart Host
Step 3: ..
Step 4: sing LoadGenStep in BizUnit, try to run the LoadGenConfiguration file created in #1

3. using VS Team System Testing tools, I crated the test class (you can use NUnit if you wish), and followed the normal BizUnit creation steps...

so easy... but .. does not work! some more work need to be done...

-Notes :
§ My Current System Configurations:
□ VS team edition
□ Load Gen (tried both)
□ Virtual Machine with normal BizTalk 2006 R2 standalone installation on windows 2003 server.
§ LoadGen 2007 assemblies can not be GACed as it the assemblies are not strongly named!, use old LoadGen instead.
§ LoadGen source code is not provided, very hard to debug and understand reasons for exception.
§ LoadGen library consumer MUST be in the same folder as ALL LoadGen binaries (C:\Program Files\LoadGen\Bins)
§ All LoadGen libraries are NOT GACed by default.
§ I don't think .NET framework 2 SDK is a required prerequisite for LoadGen if VS.Net is installed.
§ If you used the default installation and configuration, you can get the following:
□ If you try to start a BizUnit Test, VS send a message stating that a problem with "vstesthost.exe" or something similar, and the test ends!
□ If you step through bizUnit.LoadGenSteps project, an exception "Null Object Reference" is raised after code calls loadGen.Start() (the exception is thrown in a deferent thread!).
□ In the event log - 3 messages:
=>Message "Cannot Load Transport - HTTPTransport.dll"
=> Message "Start() Section [HttpSection] encountered the following exception!System.NullReferenceException: Object reference not set to an instance of an object.at LoadGen.NormalSectionThread.Start()"
=>Message"EventType clr20r3, P1 vstesthost.exe, P2 8.0.0.0, P3 4333df57, P4 loadgen, ... "
□ LoadGen logging information (which is accessed through the Test Results") shows that the LoadGen was Stopped without dropping any files.

What you need to do:
- Procedures:
§ LoadGen:
□ Optional: uninstall LoadGen 2007 (you may need to restart windows).
□ Install old version.
□ GAC all managed dlls in folder (C:\Program Files\LoadGen\Bins)

§ BizUnit.LoadGenSteps:
□ Change the build folder to (C:\Program Files\LoadGen\Bins)
□ Sign the dll (try to use the key provided with BizUnit version 2.3
□ Remove the reference to LoadGen, and add a new reference to the GACed LoadGen.dll file.
□ Build the project
□ GAC the assembly (bizUnit.LoadGenSteps.dll)
§ BizUnit XML configuration files:
<TestStep
assemblyPath="C:\Program Files\LoadGen\Bins\...BizUnit.LoadGenSteps.dll" typeName="Microsoft.Services.BizTalkApplicationFramework.BizUnit.LoadGenExecuteStep">
<LoadGenTestConfig>
...\LoadTest_Preparation_Success.xml
</LoadGenTestConfig>
</TestStep>

Note that the assemblyPath and TypeName are not done using the documented way in bizUnit documenations!

Hope that helps!!

Ayman Dabees
Comments: ** Comment from web user: conlyn **

I got this to work in a few less steps that what was done above using LoadGen 2004.

I added the loadgen.dll to the GAC using gacutil.exe and made sure I used the full path in the loadgen config file when pointing to the FileTransport.dll (Or HTTPtransport and so on). I.E.
<Section Name="FileSection">
<Transport Name="File">
<Assembly>C:\Program Files\LoadGen\Bins\FileTransport.dll/FileTransport.FileTransport</Assembly>
</Transport>

I left the loadgen call in the BizUnit TestStep in the default format:
<TestStep assemblyPath="" typeName="BizUnit.LoadGenSteps.LoadGenExecuteStep, BizUnit.LoadGenSteps, Version=3.0.0.0, Culture=neutral, PublicKeyToken=7eb7d82981ae5162">
<LoadGenTestConfig>.\LoadGen\BUTest.xml</LoadGenTestConfig>
</TestStep>

It still doesn't work with Loadgen 2007, but getting it to work with 2004 isn't quite the hassle as it might seem.

-Conlyn

Commented Issue: How to automate LoadGen using BizUnit - LoadGenExecuteStep

sarunprasath — Mon, 08 Sep 2008 12:44:51 GMT

So LoadGen 2007 version cannot be used with BizUnit. so how to go about the WCF Performance testing

Created Issue: Improved SOAPHTTPRequestResponse

BVeldhoen — Thu, 07 Aug 2008 15:46:36 GMT

Improved to include any imports within the wsdl.

//---------------------------------------------------------------------
// File: SOAPHTTPRequestResponseStep.cs
//
// Summary:
//
//---------------------------------------------------------------------
// Copyright (c) 2004-2008, Kevin B. Smith. All rights reserved.
//
// THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
// KIND, WHETHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
// PURPOSE.
//---------------------------------------------------------------------

namespace BizUnit
{
using System;
using System.IO;
using System.Xml;
using System.Net;
using System.Reflection;
using System.Xml.Serialization;
using Microsoft.CSharp;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Web.Services.Description;

/// <summary>
/// The SOAPHTTPRequestResponseStep test step may be used to call a Web Service and optionally validate it's response.
/// </summary>
///
/// <remarks>
/// The following shows an example of the Xml representation of this test step.
///
/// <code escaped="true">
/// <TestStep assemblyPath="" typeName="BizUnit.SOAPHTTPRequestResponseStep">
/// <WebServiceWSDLURL>http://machine/virdir/StockQuoteService.aspx?wsdl</WebServiceWSDLURL>
/// <ServiceName>Samples_StockQuoteService</ServiceName>
/// <WebMethod>GetQuote</WebMethod>
/// <InputMessageTypeName>QuoteRequest</InputMessageTypeName>
/// <MessagePayload>.\TestData\RequestMSFTQuote.xml</MessagePayload>
///
/// 
/// <ContextLoaderStep assemblyPath="" typeName="BizUnit.XmlContextLoader">
/// <XPath contextKey="PoNumber">/Po/Header/Id</XPath>
/// <XPath contextKey="Sender">/Po/Header/Id</XPath>
/// <XPath contextKey="Amount">/Po/Header/Id</XPath>
/// <XPath contextKey="Description">/Po/Header/Detail/Description</XPath>
/// </ContextLoaderStep>
///
/// 
/// <ValidationStep assemblyPath="" typeName="BizUnit.XmlValidationStep">
/// <XPathList>
/// <XPathValidation query="/StockQuote/Symbol">MSFT</XPathValidation>
/// <XPathValidation query="/StockQuote/LastPrice">35.36</XPathValidation>
/// </XPathList>
/// </ValidationStep>
/// </TestStep>
/// </code>
///
/// <list type="table">
/// <listheader>
/// <term>Tag</term>
/// <description>Description</description>
/// </listheader>
/// <item>
/// <term>WebServiceWSDLURL</term>
/// <description>The Url where the WSDL maybe obtained</description>
/// </item>
/// <item>
/// <term>ServiceName</term>
/// <description>The name of the Web Service to invoke</description>
/// </item>
/// <item>
/// <term>WebMethod</term>
/// <description>The Web Method (opperation) to invoke.</description>
/// </item>
/// <item>
/// <term>InputMessageTypeName/ContextProperty</term>
/// <description>The type of the input message.</description>
/// </item>
/// <item>
/// <term>MessagePayload</term>
/// <description>The path to the input data, note, this is the serialized object.</description>
/// </item>
/// <item>
/// <term>ContextLoaderStep</term>
/// <description>The configuration for the context loader step used to load data into the BizUnit context which may be used by subsequent test steps<para>(optional)</para></description>
/// </item>
/// <item>
/// <term>ValidationStep</term>
/// <description>Optional validation step.</description>
/// </item>
/// </list>
/// <para>
/// The example below illustrates the calling of the this step for a web service which takes
/// and returns no paramters:
/// <code escaped="true">
/// <TestStep assemblyPath="" typeName="BizUnit.SOAPHTTPRequestResponseStep">
/// <WebServiceWSDLURL>http://localhost/StockQuoteService/StockQuoteService.asmx?wsdl</WebServiceWSDLURL>
/// <ServiceName>StockQuoteService</ServiceName>
/// <WebMethod>VoidMethod</WebMethod>
/// </TestStep>
/// </code>
/// </para>
/// <para>
/// The following example illustrates the use of this step in order to invoke a stock quote web service
/// exposed via BizTalk.
/// An example HTTP request packet is shown below:
/// <code escaped="true">
/// POST /StockQuoteService_Proxy/StockQuoteService_QuoteService_Port_1.asmx HTTP/1.1
/// Host: localhost
/// Content-Type: application/soap+xml; charset=utf-8
/// Content-Length: length
///
/// <?xml version="1.0" encoding="utf-8"?>
/// <soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
/// <soap12:Body>
/// <Operation_1 xmlns="http://StockQuoteService.StockQuote">
/// <StockQuote>
/// <Symbol xmlns="">MSFT</Symbol>
/// <LastPrice xmlns=""></LastPrice>
/// </StockQuote>
/// </Operation_1>
/// </soap12:Body>
/// </soap12:Envelope>
/// </code>
/// </para>
/// <para>
/// An example HTTP response packet is shown below:
/// <code escaped="true">
/// HTTP/1.1 200 OK
/// Content-Type: application/soap+xml; charset=utf-8
/// Content-Length: length
///
/// <?xml version="1.0" encoding="utf-8"?>
/// <soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
/// <soap12:Body>
/// <Operation_1Response xmlns="http://StockQuoteService.StockQuote">
/// <StockQuote>
/// <Symbol xmlns="">MSFT</Symbol>
/// <LastPrice xmlns="">29.29</LastPrice>
/// </StockQuote>
/// </Operation_1Response>
/// </soap12:Body>
/// </soap12:Envelope>
/// </code>
/// </para>
/// <para>
/// An example test step for this web service is shown below:
/// <code escaped="true">
/// <TestStep assemblyPath="" typeName="BizUnit.SOAPHTTPRequestResponseStep">
///
/// <WebServiceWSDLURL>http://localhost/StockQuoteService_Proxy/StockQuoteService_QuoteService_Port_1.asmx?wsdl</WebServiceWSDLURL>
/// <ServiceName>StockQuoteService_QuoteService_Port_1</ServiceName>
/// <WebMethod>Operation_1</WebMethod>
/// <InputMessageTypeName>Operation_1StockQuote</InputMessageTypeName>
/// <MessagePayload>..\..\..\Test\BizUnit.Tests\Data\SOAPHTTPRequestResponse-RequestInput001.xml</MessagePayload>
///
/// <ValidationStep assemblyPath="" typeName="BizUnit.XmlValidationStep">
/// <XPathList>
/// <XPathValidation query="/Operation_1ResponseStockQuote/Symbol">MSFT</XPathValidation>
/// <XPathValidation query="/Operation_1ResponseStockQuote/LastPrice">29.29</XPathValidation>
/// </XPathList>
/// </ValidationStep>
///
/// </TestStep>
/// </code>
/// </para>
/// <para>
/// The contents of the input file SOAPHTTPRequestResponse-RequestInput001.xml is show below:
/// <code escaped="true">
/// <Operation_1StockQuote xmlns="http://StockQuoteService.StockQuote">
/// <Symbol xmlns="">MSFT</Symbol>
/// <LastPrice xmlns=""></LastPrice>
/// </Operation_1StockQuote>
/// </code>
/// </para>
/// </remarks>
public class SOAPHTTPRequestResponseStep : ITestStep
{
/// <summary>
/// ITestStep.Execute() implementation
/// </summary>
/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
public void Execute(XmlNode testConfig, Context context)
{
const string SOAPPROXYNAMESPACE = "BizUnit.Proxy";
Stream request = null;
Stream response = null;

// Turn on shadow copying of asseblies for the current appdomain.
AppDomain.CurrentDomain.SetShadowCopyFiles();

try
{
string wsdlFile = context.ReadConfigAsString(testConfig, "WebServiceWSDLURL");
string soapMessagePath = context.ReadConfigAsString(testConfig, "MessagePayload", true);
string inputMessageTypeName = context.ReadConfigAsString(testConfig, "InputMessageTypeName", true);
string webMethod = context.ReadConfigAsString(testConfig, "WebMethod");
string serviceName = context.ReadConfigAsString(testConfig, "ServiceName");

Assembly proxyAssembly = GetProxyAssembly(wsdlFile, SOAPPROXYNAMESPACE);

object objInputMessage = null;
if (null != inputMessageTypeName && null != soapMessagePath)
{
objInputMessage =
LoadMessage(proxyAssembly, SOAPPROXYNAMESPACE + "." + inputMessageTypeName, soapMessagePath);

if (null != objInputMessage)
{
request = GetOutputStream(objInputMessage);
context.LogData("SOAPHTTPRequestResponseStep request data", request);
}
}

object proxy = Activator.CreateInstance(proxyAssembly.GetType(SOAPPROXYNAMESPACE + "." + serviceName));

MethodInfo mi = proxy.GetType().GetMethod(webMethod);

context.LogInfo("SOAPHTTPRequestResponseStep about to post data from File: {0} to the Service: {1} defined in WSDL: {2}", soapMessagePath, serviceName, wsdlFile);

object outputMessage;
if (null != inputMessageTypeName && null != soapMessagePath)
{
outputMessage = mi.Invoke(proxy, new object[] { objInputMessage });
}
else
{
outputMessage = mi.Invoke(proxy, null);
}

if (null != outputMessage)
{
response = GetOutputStream(outputMessage);
context.LogData("SOAPHTTPRequestResponseStep response data", response);
}

// Execute ctx loader step if present...
if (null != response)
{
context.ExecuteContextLoader(response, testConfig.SelectSingleNode("ContextLoaderStep"), true);
}

// Validate the response...
try
{
context.ExecuteValidator(response, testConfig.SelectSingleNode("ValidationStep"), true);
}
catch (Exception e)
{
throw new ApplicationException("SOAPHTTPRequestResponseStep response stream was not correct!", e);
}
}
catch (Exception ex)
{
context.LogError("SOAPHTTPRequestResponseStep Failed");
context.LogException(ex);
throw;
}
finally
{
if (null != response)
{
response.Close();
}

if (null != request)
{
request.Close();
}
}
}

internal static Assembly GetProxyAssembly(string wsdlURI, string codeNamespace)
{
CSharpCodeProvider provider = new CSharpCodeProvider();
WebClient client;
Stream wsdlStream;
client = new WebClient();
string[] referenceAssemblies = new string[] { "system.dll", "System.Xml.dll", "System.Web.Services.dll" };
wsdlStream = client.OpenRead(wsdlURI);

ServiceDescription wsdl = ServiceDescription.Read(wsdlStream);
ServiceDescriptionImporter wsdlImport = new ServiceDescriptionImporter();
wsdlImport.AddServiceDescription(wsdl, null, null);

// Add any imported files
foreach (System.Xml.Schema.XmlSchema wsdlSchema in wsdl.Types.Schemas)
{
foreach (System.Xml.Schema.XmlSchemaObject externalSchema in wsdlSchema.Includes)
{
if (externalSchema is System.Xml.Schema.XmlSchemaImport)
{
Uri baseUri = new Uri(wsdlURI);
Uri schemaUri = new Uri(baseUri, ((System.Xml.Schema.XmlSchemaExternal)externalSchema).SchemaLocation);
wsdlStream = client.OpenRead(schemaUri);
System.Xml.Schema.XmlSchema schema = System.Xml.Schema.XmlSchema.Read(wsdlStream, null);
wsdlImport.Schemas.Add(schema);
}
}
}

CodeNamespace proxyClassNamespace = new CodeNamespace(codeNamespace);
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(proxyClassNamespace);

ServiceDescriptionImportWarnings warnings = wsdlImport.Import(proxyClassNamespace, codeCompileUnit);
if (warnings != 0)
{
throw new ApplicationException("SOAPHTTPRequestResponseStep experienced problems while importing the WSDL!");
}

CompilerParameters compileParam = new CompilerParameters(referenceAssemblies);
compileParam.GenerateInMemory = false;

compileParam.OutputAssembly = GetProxyFileName();
CompilerResults compilerResults = provider.CompileAssemblyFromDom(compileParam, codeCompileUnit);

if (compilerResults.Errors.HasErrors)
{
throw new ApplicationException("SOAPHTTPRequestResponseStep experienced problems while executing CompileAssemblyFromDom");
}

provider.Dispose();

return compilerResults.CompiledAssembly;
}

/// <summary>
/// Returns a name that can be used for the proxy assembly.
/// </summary>
/// <returns></returns>
internal static string GetProxyFileName()
{
int max = 20;
string baseName = "TestFrameWorkProxy";
string fname = "TestFrameWorkProxy.dll";

for (int i = 0; i <= max; i++)
{
fname = baseName + i + ".dll";

// try to delete the file if it exists
try
{
File.Delete(fname);
}
catch
{
}

if (!File.Exists(fname))
{
return fname;
}
}

return fname;
}

internal static MemoryStream GetOutputStream(object outputMessage)
{
MemoryStream ms = new MemoryStream();
XmlSerializer outputSerializer = new XmlSerializer(outputMessage.GetType());
outputSerializer.Serialize(ms, outputMessage);
ms.Seek(0, SeekOrigin.Begin);

return ms;
}

internal static string GetDefaultNamespace(Assembly assembly, string msgTypeName)
{
Type t = assembly.GetType(msgTypeName);

string ret = "";
object[] attributes = t.GetCustomAttributes(false);

for (int i = 0; i < attributes.Length; i++)
{
Attribute att = (Attribute)attributes[i];

if (att.ToString().Equals("System.Xml.Serialization.XmlTypeAttribute"))
{
System.Xml.Serialization.XmlTypeAttribute typeAtt = (System.Xml.Serialization.XmlTypeAttribute)att;
ret = typeAtt.Namespace;
break;
}
}

return ret;
}

internal static object LoadMessage(Assembly assembly, string msgTypeName, string messagePath)
{
XmlReader messageReader = null;
object objMessage;

try
{
// This object requires CreateInstanceFrom...however the proxy object instantiation
// does not require CreateInstancefrom
Activator.CreateInstanceFrom(assembly.Location, msgTypeName);
messageReader = new XmlTextReader(messagePath);

string defNamespace = GetDefaultNamespace(assembly, msgTypeName);

XmlSerializer serializer;

if (null != defNamespace && defNamespace.Length > 0)
{
serializer = new XmlSerializer(assembly.GetType(msgTypeName), defNamespace);
}
else
{
serializer = new XmlSerializer(assembly.GetType(msgTypeName));
}

objMessage = serializer.Deserialize(messageReader);
}
finally
{
if (messageReader != null)
{
messageReader.Close();
}
}

return objMessage;
}
}
}

Commented Issue: Improved XmlValidationStepEx

scox_nz — Thu, 07 Aug 2008 02:23:54 GMT

- Removed use of deprecated XmlValidatingReader.
- Added support for multiple schemas

//---------------------------------------------------------------------
// File: XmlValidationStepEx.cs
//
// Summary:
//
//---------------------------------------------------------------------
// Copyright (c) 2004-2008, Kevin B. Smith. All rights reserved.
//
// THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
// KIND, WHETHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
// PURPOSE.
//---------------------------------------------------------------------

namespace BizUnit
{
using System;
using System.IO;
using System.Xml;
using System.Xml.Schema;
using System.Xml.XPath;
using System.Collections.Generic;
using System.Web.UI;
using BizUnitOM;
using System.Text;

/// <summary>
/// The XmlValidationStepEx validates an Xml document, it may validate against a given schema, and also evaluate XPath queries.
/// The Xpath query is extended from XmlValidationStep to allow Xpath functions to be used which may not return a node set.
/// </summary>
///
/// <remarks>
/// The following shows an example of the Xml representation of this test step.
///
/// <code escaped="true">
/// <ValidationStep assemblyPath="" typeName="BizUnit.XmlValidationStepEx">
/// <XmlSchemaList>
/// <XmlSchema path=".\TestData\PurchaseOrder.xsd" namespace="urn:bookstore-schema" />
/// </XmlSchemaList>
/// <XPathList>
/// <XPathValidation query="/*[local-name()='PurchaseOrder' and namespace-uri()='http://SendMail.PurchaseOrder']/*[local-name()='PONumber' and namespace-uri()='']">PONumber_0</XPathValidation>
/// </XPathList>
/// </ValidationStep>
/// </code>
///
/// <list type="table">
/// <listheader>
/// <term>Tag</term>
/// <description>Description</description>
/// </listheader>
/// <item>
/// <term>XmlSchemaPath</term>
/// <description>The XSD schema to use to validate the XML data (optional)</description>
/// </item>
/// <item>
/// <term>XmlSchemaNameSpace</term>
/// <description>The XSD schema namespace to validate the XML data against (optional)</description>
/// </item>
/// <item>
/// <term>XPathList/XPathValidation</term>
/// <description>XPath expression to evaluate against the XML document (optional)(repeating).</description>
/// </item>
/// </list>
/// </remarks>
public class XmlValidationStepEx : IValidationStepOM
{
private IList<Pair> _xmlSchemas = new System.Collections.Generic.List<Pair>();
public IList<Pair> XmlSchemas
{
get { return _xmlSchemas; }
private set { _xmlSchemas = value; }
}

private IList<Pair> xPathValidations = new System.Collections.Generic.List<Pair>();
public IList<Pair> XPathValidations
{
get { return this.xPathValidations; }
private set { this.xPathValidations = value; }
}

private List<string> _errors = new List<string>();
public List<string> Errors
{
get { return _errors; }
set { _errors = value; }
}

private List<string> _warnings = new List<string>();
public List<string> Warnings
{
get { return _warnings; }
set { _warnings = value; }
}

/// <summary>
/// ITestStep.Execute() implementation
/// </summary>
/// <param name='data'>The stream cintaining the data to be validated.</param>
/// <param name='validatorConfig'>The Xml fragment containing the configuration for the test step</param>
/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
public void ExecuteValidation(Stream data, XmlNode validatorConfig, Context context)
{
XmlNodeList xmlSchemaList = validatorConfig.SelectNodes("XmlSchemaList/*");
foreach (XmlNode xmlSchema in xmlSchemaList)
{
string schemaPath = context.ReadConfigAsString(xmlSchema, "@path");
string schemaNamespace = context.ReadConfigAsString(xmlSchema, "@namespace");
this.XmlSchemas.Add(new Pair(schemaNamespace, schemaPath));
}

XmlNodeList xPathList = validatorConfig.SelectNodes("XPathList/*");
foreach (XmlNode xpath in xPathList)
{
string xpathExp = xpath.SelectSingleNode("@query").Value;
string expectedValue = context.ReadConfigAsString(xpath, ".");
this.xPathValidations.Add(new Pair(xpathExp, expectedValue));
}

ExecuteValidation(data, context);
}

/// <summary>
/// ITestStep.Execute() implementation
/// </summary>
/// <param name='data'>The stream cintaining the data to be validated.</param>
/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
public void ExecuteValidation(Stream data, Context context)
{
XmlReaderSettings readerSettings = new XmlReaderSettings();
foreach (Pair schema in this.XmlSchemas)
{
readerSettings.Schemas.Add((string)schema.First, (string)schema.Second);
readerSettings.ValidationFlags |= XmlSchemaValidationFlags.ReportValidationWarnings;
readerSettings.ValidationEventHandler += new ValidationEventHandler(this.ValidationHandler);
readerSettings.CheckCharacters = true;
}

this.Errors.Clear();
this.Warnings.Clear();

data.Seek(0, SeekOrigin.Begin);
XmlReader reader = XmlReader.Create(data, readerSettings);
while (reader.Read()) { }

if (this.Warnings.Count > 0)
{
context.LogInfo("Xml Validation warnings:");
foreach (string warning in this.Warnings)
{
context.LogInfo(warning);
}
}

if (this.Errors.Count > 0)
{
StringBuilder errorBuilder = new StringBuilder();
errorBuilder.AppendLine("Xml Validation errors:");
foreach (string error in this.Errors)
{
errorBuilder.AppendLine(error);
}
throw new ApplicationException(errorBuilder.ToString());
}

data.Seek(0, SeekOrigin.Begin);
XmlDocument doc = new XmlDocument();
doc.Load(data);

foreach (Pair validation in this.xPathValidations)
{
string xpathExp = (string)validation.First;
string expectedValue = (string)validation.Second;

context.LogInfo("XmlValidationStepEx evaluating XPath {0} equals \"{1}\"", xpathExp, expectedValue);

XPathNavigator xpn = doc.CreateNavigator();
object result = xpn.Evaluate(xpathExp);

string checkValue = null;
if (result.GetType().Name == "XPathSelectionIterator")
{
XPathNodeIterator xpi = result as XPathNodeIterator;
xpi.MoveNext(); // BUGBUG!
if (null != xpi)
{
checkValue = xpi.Current.ToString();
}
}
else
{
checkValue = result.ToString();
}

if (0 != expectedValue.CompareTo(checkValue))
{
throw new ApplicationException(string.Format("XmlValidationStepEx failed, compare {0} != {1}, xpath query used: {2}", expectedValue, checkValue, xpathExp));
}
}
}

private void ValidationHandler(object sender, ValidationEventArgs args)
{
switch (args.Severity)
{
case XmlSeverityType.Warning:
this.Warnings.Add(args.Message);
break;
case XmlSeverityType.Error:
this.Errors.Add(args.Message);
break;
default:
break;
}
}

public void Validate(Context context)
{
// xPathValidations - optional

if (null == this.XmlSchemas || 0 == this.XmlSchemas.Count)
{
throw new ArgumentNullException("XmlSchemas is either null or of zero length");
}
foreach (Pair schema in this.XmlSchemas)
{
schema.First = context.SubstituteWildCards((string)schema.First);
schema.Second = context.SubstituteWildCards((string)schema.Second);
}
}
}
}
Comments: ** Comment from web user: scox_nz **

The following code will support validating the XML against the schema and logging the error if it doesn't comply

//---------------------------------------------------------------------
// File: XmlValidationStepEx.cs
//
// Summary:
//
//---------------------------------------------------------------------
// Copyright (c) 2004-2008, Kevin B. Smith. All rights reserved.
//
// THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
// KIND, WHETHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
// PURPOSE.
//---------------------------------------------------------------------

namespace BizUnit
{
using System;
using System.IO;
using System.Xml;
using System.Xml.Schema;
using System.Xml.XPath;
using System.Collections.Generic;
using System.Web.UI;
using BizUnitOM;
using System.Text;

/// <summary>
/// The XmlValidationStepEx validates an Xml document, it may validate against a given schema, and also evaluate XPath queries.
/// The Xpath query is extended from XmlValidationStep to allow Xpath functions to be used which may not return a node set.
/// </summary>
///
/// <remarks>
/// The following shows an example of the Xml representation of this test step.
/// <code escaped="true">
/// <ValidationStep assemblyPath="" typeName="BizUnit.XmlValidationStepEx, BizUnit">
/// <XmlSchemaList>
/// <XmlSchema path=".\TestData\PurchaseOrder.xsd" namespace="urn:bookstore-schema" />
/// </XmlSchemaList>
/// <XPathList>
/// <XPathValidation query="/*[local-name()='PurchaseOrder' and namespace-uri()='http://SendMail.PurchaseOrder']/*[local-name()='PONumber' and namespace-uri()='']">PONumber_0</XPathValidation>
/// </XPathList>
/// </ValidationStep>
/// </code>
///
/// <list type="table">
/// <listheader>
/// <term>Tag</term>
/// <description>Description</description>
/// </listheader>
/// <item>
/// <term>XmlSchemaList/XmlSchema</term>
/// <description>The XSD schema to use to validate the XML data (optional)(repeating).</description>
/// </item>
/// <item>
/// <term>XmlSchemaList/XmlSchema/@path</term>
/// <description>The path to an XSD schema to use to validate the XML data (optional)(repeating).</description>
/// </item>
/// <item>
/// <term>XmlSchemaList/XmlSchema/@namespace</term>
/// <description>The XSD schema namespace to use to validate the XML data (optional)(repeating).</description>
/// </item>
/// <item>
/// <term>XPathList/XPathValidation</term>
/// <description>XPath expression to evaluate against the XML document (optional)(repeating).</description>
/// </item>
/// <item>
/// <term>XPathList/XPathValidation/@query</term>
/// <description>XPath expression to evaluate against the XML document (optional)(repeating).</description>
/// </item>
/// </list>
/// </remarks>
public class XmlValidationStepEx : IValidationStepOM
{
private IList<Pair> _xmlSchemas = new System.Collections.Generic.List<Pair>();
public IList<Pair> XmlSchemas
{
get { return _xmlSchemas; }
private set { _xmlSchemas = value; }
}

private IList<Pair> xPathValidations = new System.Collections.Generic.List<Pair>();
public IList<Pair> XPathValidations
{
get { return this.xPathValidations; }
private set { this.xPathValidations = value; }
}

private List<string> _errors = new List<string>();
public List<string> Errors
{
get { return _errors; }
set { _errors = value; }
}

private List<string> _warnings = new List<string>();
public List<string> Warnings
{
get { return _warnings; }
set { _warnings = value; }
}

/// <summary>
/// ITestStep.Execute() implementation
/// </summary>
/// <param name='data'>The stream cintaining the data to be validated.</param>
/// <param name='validatorConfig'>The Xml fragment containing the configuration for the test step</param>
/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
public void ExecuteValidation(Stream data, XmlNode validatorConfig, Context context)
{
XmlNodeList xmlSchemaList = validatorConfig.SelectNodes("XmlSchemaList/*");
foreach (XmlNode xmlSchema in xmlSchemaList)
{
string schemaPath = context.ReadConfigAsString(xmlSchema, "@path");
string schemaNamespace = context.ReadConfigAsString(xmlSchema, "@namespace");
this.XmlSchemas.Add(new Pair(schemaNamespace, schemaPath));
}

XmlNodeList xPathList = validatorConfig.SelectNodes("XPathList/*");
foreach (XmlNode xpath in xPathList)
{
string xpathExp = xpath.SelectSingleNode("@query").Value;
string expectedValue = context.ReadConfigAsString(xpath, ".");
this.xPathValidations.Add(new Pair(xpathExp, expectedValue));
}

ExecuteValidation(data, context);
}

/// <summary>
/// ITestStep.Execute() implementation
/// </summary>
/// <param name='data'>The stream cintaining the data to be validated.</param>
/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
public void ExecuteValidation(Stream data, Context context)
{
XmlReaderSettings readerSettings = new XmlReaderSettings();
foreach (Pair schema in this.XmlSchemas)
{
readerSettings.Schemas.Add((string)schema.First, (string)schema.Second);
readerSettings.ValidationFlags |= XmlSchemaValidationFlags.ReportValidationWarnings;
readerSettings.ValidationEventHandler += new ValidationEventHandler(this.ValidationHandler);
readerSettings.CheckCharacters = true;
readerSettings.ValidationType = ValidationType.Schema;
}

this.Errors.Clear();
this.Warnings.Clear();

data.Seek(0, SeekOrigin.Begin);
XmlReader reader = XmlReader.Create(data, readerSettings);

try {
while (reader.Read()) { }
}
catch (XmlSchemaValidationException ex)
{
context.LogError(ex.Message);
}

if (this.Warnings.Count > 0)
{
context.LogInfo("Xml Validation warnings:");
foreach (string warning in this.Warnings)
{
context.LogInfo(warning);
}
}

if (this.Errors.Count > 0)
{
StringBuilder errorBuilder = new StringBuilder();
errorBuilder.AppendLine("Xml Validation errors:");
foreach (string error in this.Errors)
{
errorBuilder.AppendLine(error);
}
throw new ApplicationException(errorBuilder.ToString());
}

data.Seek(0, SeekOrigin.Begin);
XmlDocument doc = new XmlDocument();
doc.Load(data);

foreach (Pair validation in this.xPathValidations)
{
string xpathExp = (string)validation.First;
string expectedValue = (string)validation.Second;

context.LogInfo("XmlValidationStepEx evaluating XPath {0} equals \"{1}\"", xpathExp, expectedValue);

XPathNavigator xpn = doc.CreateNavigator();
object result = xpn.Evaluate(xpathExp);

string checkValue = null;
if (result.GetType().Name == "XPathSelectionIterator")
{
XPathNodeIterator xpi = result as XPathNodeIterator;
xpi.MoveNext(); // BUGBUG!
if (null != xpi)
{
checkValue = xpi.Current.ToString();
}
}
else
{
checkValue = result.ToString();
}

if (0 != expectedValue.CompareTo(checkValue))
{
throw new ApplicationException(string.Format("XmlValidationStepEx failed, compare {0} != {1}, xpath query used: {2}", expectedValue, checkValue, xpathExp));
}
}
}

// Display any validation errors.
private static void ValidationCallBack(object sender, ValidationEventArgs e)
{
XmlValidationStepEx validator = (XmlValidationStepEx)sender;
//context.LogInfo("Validation Error: {0}", e.Message);
}

private void ValidationHandler(object sender, ValidationEventArgs args)
{
switch (args.Severity)
{
case XmlSeverityType.Warning:
this.Warnings.Add(args.Message);
break;
case XmlSeverityType.Error:
this.Errors.Add(args.Message);
break;
default:
break;
}
}

public void Validate(Context context)
{
// xPathValidations - optional

if (null == this.XmlSchemas || 0 == this.XmlSchemas.Count)
{
throw new ArgumentNullException("XmlSchemas is either null or of zero length");
}
foreach (Pair schema in this.XmlSchemas)
{
schema.First = context.SubstituteWildCards((string)schema.First);
schema.Second = context.SubstituteWildCards((string)schema.Second);
}
}
}
}