Rory Primrose

Using testrunconfig sometimes fails to deploy dependencies

Rory — Fri, 23 Oct 2009 11:45:00 +0600

I’ve never been a fan of deploying test dependencies using testrunconfig. I prefer dependencies to be located as closely as possible to where they are used, ideally on an individual unit test. Using testrunconfig means that the dependencies are deploy at the solution level.

Having dependencies attached to each unit test for my current project has become unmaintainable however as almost all unit tests require the same dependencies. This makes testrunconfig appropriate in this case.

The issue I found with deploying dependencies with testrunconfig is that the dependency is not deployed into the TestResults directory when a new dependency reference is added to the config. This appears to be a bug in Visual Studio where the testrunconfig contents is cached. The workaround is to reload the solution. Each time this happens I have actually closed the IDE and opened the solution again. When the test run is executed the dependencies are not deployed as expected.

Changing a TFS bound solution namespace

Rory — Tue, 06 Oct 2009 11:17:00 +0600

Changing the namespace of a solution that has already progressed significantly down the development path can be a pain. Visual Studio doesn’t native support namespace refactoring and tools like ReSharper can get bogged down with a huge set of changes. There is usually a dirty result if either of these tools are used as the project and solution directories are not renamed. These need to be done manually in Source Code Explorer which then throws out the relative paths stored in the solution file.

Changing a namespace can be a messy job. In these circumstances it’s often best to hand craft an external solution to this problem. I’ve finally written that solution as a console app after doing this job the painful manual way too many times.

The attached file contains the console application code. There is no defensive code against exceptions so it’s best to run this in the IDE. There are three constants you need to update before running this. These are the root path, find text and replace text. The code records everything that happens out to the console and a log file that is unique for each run.

Program.cs (11.54 kb)

ThreadStatic gotcha with ASP.Net

Rory — Wed, 23 Sep 2009 06:40:42 +0600

I had a requirement recently in a service implementation that business rules at any point throughout the execution of a service request could determine a message to return in the header of the response. Because these circumstances don’t affect the execution of the request (no exception is thrown), I needed a loosely coupled way of recording all the required messages and handling them higher up the stack.

Storing data against the executing thread was the obvious solution. I considered manually storing information in the context data of the thread, but then thought this would be a great opportunity to use the ThreadStaticAttribute. I coded this up and it all seemed to work well.

Yesterday a bug was raised against this code because messages unrelated to the service request were being returned. I looked at the code and rechecked the ThreadStatic documentation. It shouldn’t be possible, but it was definitely happening.

I quickly realised that the thread must be being reused across multiple service requests. This reminded me that ASP.Net uses a ThreadPool and it would not be doing any clean up of ThreadStatic data as it reused an existing thread for a new service request.

The simple fix was to reset the ThreadStatic reference when the response is generated.

DisconnectedContext when debugging with MSTest

Rory — Fri, 18 Sep 2009 10:42:46 +0600

I have been hitting a DisconnectedContext issue when I’ve been running MSTest in the Visual Studio IDE with the debugger attached. At first I thought it was an issue with debugging WF, but it is now also happening with LINQ to SQL.

The debugging on the thread of the executing test appears to be stopped when this is hit. Other threads/tests in the test run will still hit breakpoints however.

Searching the net hasn’t yielded any pointers. Anyone out there have some information about this?

Adding delete comment support to the Commentor extension

Rory — Tue, 15 Sep 2009 09:24:52 +0600

The Commentor extension for BlogEngine.Net written by rtur is a great extension for catching comment spam on the blog. Unfortunately the custom rules you can apply to comments only support a Block or Allow action.

What I want is to prevent the comments being saved at all if a manual rule has been violated. This is better for my needs as I don’t need to clean up the comments on the blog and I don’t get hassled by constant emails regarding comments that require moderation.

The changes to the extension to support this are relatively minor.

First is a change to the User controls\Commentor\Settings.aspx user control. The action dropdown now has a Delete action.

<td>
    <asp:DropDownList ID="ddAction" runat="server">
        <asp:ListItem Text="Block" Value="Block" Selected=true></asp:ListItem>
        <asp:ListItem Text="Allow" Value="Allow" Selected=false></asp:ListItem>
        <asp:ListItem Text="Delete" Value="Delete" Selected=false></asp:ListItem>
    </asp:DropDownList>
</td>

The next set of changes were to implement the Delete action in the App_Code\Extensions\Commentor.Community Server class.

The ManualFilter enum definition has been extended to include the Delete action.

private enum ManualFilter { None, Block, Allow }

The Post_AddingComment method now supports this enum value in its processing of a new comment.

// validate against filter
switch (CheckFilter(comment))
{
    case ManualFilter.Block:
        comment.IsApproved = false;
        return;
    case ManualFilter.Allow:
        comment.IsApproved = true;
        return;
    case ManualFilter.Delete:
        comment.IsApproved = false;
        e.Cancel = true;
        return;
    default:
        break;
}

And finally, the CheckRow method has been updated to use the new Delete action.

if (match)
{
    if (action == "Block")
        return ManualFilter.Block;
    if (action == "Delete")
        return ManualFilter.Delete;
    return ManualFilter.Allow;
}

Make these changes and you will be able to use delete actions to prevent comments from being saved.

NOTE: The settings for existing rules will need to be updated where they are stored (most likely in a database or xml file) in order for them to use the Delete action. A restart of the website will be required to pick up these changes that were made directly against the settings datastore. Alternatively you will need to delete and recreate any existing custom rules that you want to use the Delete action with.

My Commentor extension settings now look like the following.

Sense of satisfaction

Rory — Tue, 15 Sep 2009 04:46:24 +0600

I just found out that something I came up with a few years ago in another job has hit production and is making a big difference. There were a lot of people involved in supporting the idea and some innovators who took the concept and applied it in ways I didn’t think of. Overall it is a great result and I’m very happy to see such a change being applied.

Quick tip for undoing unchanged TFS checkouts

Rory — Wed, 09 Sep 2009 05:13:26 +0600

Reviewing changesets with a large number of files that haven’t changed can be a significant waste of time. Sliming changesets down to only changed files is a great idea before checking in files.

I have previously been doing this manually which in itself is time consuming. Fortunately the TFS power toys package comes with a handy utility to automatically uncheck out any files that haven’t changed. Running TFPT.exe uu /r will do the trick. Running up an instance of the Visual Studio command prompt and entering in this command can also be a hassle. Thankfully Visual Studio makes this easy with the support for external tools.

To set this up, go to Tools –> External Tools which will display the following dialog:

Click Add and enter the following settings (full Command value is C:\Program Files\Microsoft Team Foundation Server 2008 Power Tools\TFPT.exe)

Sending the output to the Output Window makes this setup really easy to review the changes.

The Tools menu should now contain the Undo Null Changes command.

Enjoy.

Update: Set initial directory to $(SolutionDir) as sometimes the workspace can’t be determined depending on the context of how the command is launched.

Custom fields support with SqlMetadataStore in the sync framework

Rory — Wed, 19 Aug 2009 08:59:52 +0600

I am putting together a sync framework provider and have come across some issues that do not appear to be documented. I’m adding custom fields to the item metadata so that I can store additional information for items that are synchronised with another provider. To do this, you define the custom fields for items as part of initializing the metadata store. The tricky thing is that it isn’t clear what data types are supported and how to correctly use the data types that are supported.

I have the following initialization code.

List<FieldSchema> customFields = new List<FieldSchema>
                                     {
                                         new FieldSchema("IsContainer", typeof(Boolean)),
                                         new FieldSchema("Name", typeof(String)),
                                         new FieldSchema("Path", typeof(String))
                                     };
String[] indexFieldNames = new[]
                               {
                                   "IsContainer", "Name", "Path"
                               };
List<IndexSchema> indexFields = new List<IndexSchema>
                                    {
                                        new IndexSchema(indexFieldNames, true)
                                    };

Metadata = MetaStore.InitializeReplicaMetadata(IdFormats, ReplicaId, customFields, indexFields);

This code throws the following exception:

Microsoft.Synchronization.MetadataStorage.MetadataStoreInvalidOperationException: Incorrect constructor used

It turns out that defining a FieldSchema as a string requires a defined length, hence the incorrect constructor has been used as there is another constructor that takes the size in addition to the name and type used here. This is not a good exception message as it does not adequately describe why there is a problem or how to fix it. The remarks documentation for the name and type constructor overload is also incorrect as it says the following.

This form of the constructor sets MaxLength to the size of dataType, in bytes.

There must be something wrong with the implementation of this constructor as this does not appear to be the case. If the length is provided to the constructor overload then no exception is thrown when constructing FieldSchema instances.

The code now looks like the following:

List<FieldSchema> customFields = new List<FieldSchema>
                                     {
                                         new FieldSchema("IsContainer", typeof(Boolean)),
                                         new FieldSchema("Name", typeof(String), 256),
                                         new FieldSchema("Path", typeof(String), 256)
                                     };
String[] indexFieldNames = new[]
                               {
                                   "IsContainer", "Name", "Path"
                               };
List<IndexSchema> indexFields = new List<IndexSchema>
                                    {
                                        new IndexSchema(indexFieldNames, true)
                                    };

Metadata = MetaStore.InitializeReplicaMetadata(IdFormats, ReplicaId, customFields, indexFields);

This now throws an exception saying:

System.NotSupportedException: The data type is not supported.

With a stack trace that looks like the following:

Microsoft.Synchronization.MetadataStorage.Utility.ConvertDataTypeToSyncMetadataFieldType(Type dataType)
Microsoft.Synchronization.MetadataStorage.SqlMetadataStore.CreateCustomFieldDefinition(FieldSchema fieldSchema, String parameterName)
Microsoft.Synchronization.MetadataStorage.SqlMetadataStore.InitializeReplicaMetadata(SyncIdFormatGroup idFormats, SyncId replicaId, IEnumerable`1 customItemFieldSchemas, IEnumerable`1 customIndexedFieldSchemas)
Neovolve.Jabiru.Client.Synchronization.Remote.StoreSyncProvider.LoadMetadataStore() in R:\CodePlex\Jabiru\Jabiru\Neovolve.Jabiru.Client\Neovolve.Jabiru.Client.Synchronization.Remote\StoreSyncProvider.Community Server: line 668
Neovolve.Jabiru.Client.Synchronization.Remote.StoreSyncProvider..ctor(IStoreProcessor processor) in R:\CodePlex\Jabiru\Jabiru\Neovolve.Jabiru.Client\Neovolve.Jabiru.Client.Synchronization.Remote\StoreSyncProvider.Community Server: line 64
Neovolve.Jabiru.Client.Synchronization.Remote.UnitTests.ServiceSyncProviderTests.RunSync(String localPath, IStoreProcessor processor, Guid storeGuid) in R:\CodePlex\Jabiru\Jabiru\Neovolve.Jabiru.Client\Neovolve.Jabiru.Client.Synchronization.Remote.UnitTests\ServiceSyncProviderTests.Community Server: line 160
Neovolve.Jabiru.Client.Synchronization.Remote.UnitTests.ServiceSyncProviderTests.SyncDeletesItemFromProcessorWhenFileIsDeletedTest() in R:\CodePlex\Jabiru\Jabiru\Neovolve.Jabiru.Client\Neovolve.Jabiru.Client.Synchronization.Remote.UnitTests\ServiceSyncProviderTests.Community Server: line 116

If you follow down the rabbit hole using Reflector, Microsoft.Synchronization.MetadataStorage.Utility.ConvertDataTypeToSyncMetadataFieldType has the following code:

internal static SYNC_METADATA_FIELD_TYPE ConvertDataTypeToSyncMetadataFieldType(Type dataType)
{
    if (dataType == typeof(byte[]))
    {
        return SYNC_METADATA_FIELD_TYPE.SYNC_METADATA_FIELD_TYPE_BYTEARRAY;
    }
    if (dataType == typeof(string))
    {
        return SYNC_METADATA_FIELD_TYPE.SYNC_METADATA_FIELD_TYPE_STRING;
    }
    if (dataType == typeof(byte))
    {
        return SYNC_METADATA_FIELD_TYPE.SYNC_METADATA_FIELD_TYPE_UINT8;
    }
    if (dataType == typeof(ushort))
    {
        return SYNC_METADATA_FIELD_TYPE.SYNC_METADATA_FIELD_TYPE_UINT16;
    }
    if (dataType == typeof(uint))
    {
        return SYNC_METADATA_FIELD_TYPE.SYNC_METADATA_FIELD_TYPE_UINT32;
    }
    if (dataType == typeof(ulong))
    {
        return SYNC_METADATA_FIELD_TYPE.SYNC_METADATA_FIELD_TYPE_UINT64;
    }
    if (dataType != typeof(Guid))
    {
        throw new NotSupportedException(StringResources.NotSupportedDataType);
    }
    return SYNC_METADATA_FIELD_TYPE.SYNC_METADATA_FIELD_TYPE_GUID;
}

The answer to this issue is that the Boolean data type is not supported. Unfortunately the documentation for InitializeReplicaMetadata does not to mention this. The way around this is to use a byte value to represent the Boolean state.

Code that successfully executes now looks like this:

List<FieldSchema> customFields = new List<FieldSchema>
                                     {
                                         new FieldSchema("IsContainer", typeof(Byte)),
                                         new FieldSchema("Name", typeof(String), 256),
                                         new FieldSchema("Path", typeof(String), 256)
                                     };
String[] indexFieldNames = new[]
                               {
                                   "IsContainer", "Name", "Path"
                               };
List<IndexSchema> indexFields = new List<IndexSchema>
                                    {
                                        new IndexSchema(indexFieldNames, true)
                                    };

Metadata = MetaStore.InitializeReplicaMetadata(IdFormats, ReplicaId, customFields, indexFields);

Transport connection closed exception with nDumbster

Rory — Fri, 14 Aug 2009 05:49:46 +0600

I have been using nDumbster on a project to unit test sending emails. It has been an interesting experience working with this little tool. It is a great product but has been out of development for a while and has some issues.

The more I started using nDumbster in test runs, the more I was finding that it wasn’t working so well. I was consistently getting the following exception:

Test method [TestName] threw exception: System.Net.Mail.SmtpException: Failure sending mail. ---> System.IO.IOException: Unable to read data from the transport connection: net_io_connectionclosed..

System.Net.Mail.SmtpReplyReaderFactory.ProcessRead(Byte[] buffer, Int32 offset, Int32 read, Boolean readLine)

System.Net.Mail.SmtpReplyReaderFactory.ReadLines(SmtpReplyReader caller, Boolean oneLine)

System.Net.Mail.SmtpReplyReaderFactory.ReadLine(SmtpReplyReader caller)

System.Net.Mail.CheckCommand.Send(SmtpConnection conn, String& response)

System.Net.Mail.MailCommand.Send(SmtpConnection conn, Byte[] command, String from)

System.Net.Mail.SmtpTransport.SendMail(MailAddress sender, MailAddressCollection recipients, String deliveryNotify, SmtpFailedRecipientException& exception)

System.Net.Mail.SmtpClient.Send(MailMessage message)

System.Net.Mail.SmtpClient.Send(MailMessage message)

I worked on this one for a while. Without wanting to get my fingers into the nDumbster code, I found a solution that works from within the unit testing code itself. The solution is to create a new instance of the nDumbster SMTP server using a unique port number for each test. This ensures that there is a fresh connection for each test in the test run.

The unit test code looks like the following.

/// <summary>
/// Stores the random generator.
/// </summary>
private static readonly Random RandomPort = new Random(Environment.TickCount);

/// <summary>
/// Stores the SMTP server.
/// </summary>
private static SimpleSmtpServer _server;

#region Setup/Teardown

/// <summary>
/// Cleans up after running a unit test.
/// </summary>
[TestCleanup]
public void TestCleanup()
{
    _server.Stop();
    _server = null;
}

/// <summary>
/// Initializes the test.
/// </summary>
[TestInitialize]
public void TestInitialize()
{
    // HACK: The test must recreate the nDumbster server for each test using a different port number
    // This gets around issues where some tests consistently failed when the whole test class was run because the server
    // was not handling the connection properly. This appears to be the only solution that works.
    Int32 nextPortNumber = RandomPort.Next(1024, 6666);

    _server = SimpleSmtpServer.Start(nextPortNumber);
}

#endregion

Mocking IUnityContainer and avoiding BadImageFormatException

Rory — Fri, 07 Aug 2009 08:30:21 +0600

There is an issue with mocking IUnityContainer from RhinoMocks. A BadImageFormatException is thrown when you attempt to create a mock or a stub of IUnityContainer. For example:

using Microsoft.Practices.Unity;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Rhino.Mocks;

namespace TestProject1
{
    public interface ITestInterface
    {
        void DoSomething();
    }

    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void MockingIUnityContainerFailsTest()
        {
            // This throws a BadImageFormatException
            IUnityContainer container = MockRepository.GenerateStub<IUnityContainer>();
            ITestInterface test = MockRepository.GenerateStub<ITestInterface>();

            container.Stub(x => x.Resolve<ITestInterface>()).Return(test);

            ITestInterface resolvedTest = container.Resolve<ITestInterface>();

            resolvedTest.DoSomething();
        }
    }
}

This test results in the following failure:

Test method TestProject1.UnitTest1.MockingIUnityContainerFailsTest threw exception: System.BadImageFormatException: An attempt was made to load a program with an incorrect format. (Exception from HRESULT: 0x8007000B).

System.Reflection.Emit.TypeBuilder._TermCreateClass(Int32 handle, Module module)
System.Reflection.Emit.TypeBuilder.CreateTypeNoLock()
System.Reflection.Emit.TypeBuilder.CreateType()
Castle.DynamicProxy.Generators.Emitters.AbstractTypeEmitter.BuildType()
Castle.DynamicProxy.Generators.Emitters.AbstractTypeEmitter.BuildType()
Castle.DynamicProxy.Generators.InterfaceProxyWithTargetGenerator.GenerateCode(Type proxyTargetType, Type[] interfaces, ProxyGenerationOptions options)
Castle.DynamicProxy.DefaultProxyBuilder.CreateInterfaceProxyTypeWithoutTarget(Type theInterface, Type[] interfaces, ProxyGenerationOptions options)
Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyTypeWithoutTarget(Type theInterface, Type[] interfaces, ProxyGenerationOptions options)
Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget(Type theInterface, Type[] interfaces, ProxyGenerationOptions options, IInterceptor[] interceptors)
Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget(Type theInterface, Type[] interfaces, IInterceptor[] interceptors)
Rhino.Mocks.MockRepository.MockInterface(CreateMockState mockStateFactory, Type type, Type[] extras)
Rhino.Mocks.MockRepository.CreateMockObject(Type type, CreateMockState factory, Type[] extras, Object[] argumentsForConstructor)
Rhino.Mocks.MockRepository.Stub(Type type, Object[] argumentsForConstructor)
Rhino.Mocks.MockRepository.GenerateStub(Type type, Object[] argumentsForConstructor)
Rhino.Mocks.MockRepository.GenerateStub[T](Object[] argumentsForConstructor)
TestProject1.UnitTest1.MockingIUnityContainerFailsTest() in C:\Users\rprimrose\Documents\Visual Studio 2008\Projects\TestProject1\TestProject1\UnitTest1.Community Server: line 19

You can see in the stack trace that this is not actually an issue with RhinoMocks but an issue with Castle. As Moq also uses Castle internally it suffers from the same problem. Many people have raised this as an issue and asked for a solution. There does not seem to be an adequate answer out there other than a solution from Roy Osherove which is a bit heavy handed for what I want.

The answer is actually really simple. Reflector indicates the inheritance hierarchy of IUnityContainer as the following.

You can use either of these types to get the expected outcome and avoiding the BadImageFormatException. This exception seems to be an issue with mocking/stubbing the interface rather than its implemented types.

For example, both of the following tests pass.

[TestMethod]
public void MockingUnityContainerBaseSucceedsTest()
{
    IUnityContainer container = MockRepository.GenerateStub<UnityContainerBase>();
    ITestInterface test = MockRepository.GenerateStub<ITestInterface>();

    container.Stub(x => x.Resolve<ITestInterface>()).Return(test);

    ITestInterface resolvedTest = container.Resolve<ITestInterface>();

    resolvedTest.DoSomething();
}

[TestMethod]
public void MockingUnityContainerSucceedsTest()
{
    IUnityContainer container = MockRepository.GenerateStub<UnityContainer>();
    ITestInterface test = MockRepository.GenerateStub<ITestInterface>();

    container.Stub(x => x.Resolve<ITestInterface>()).Return(test);

    ITestInterface resolvedTest = container.Resolve<ITestInterface>();

    resolvedTest.DoSomething();
}

Easy fix.