UnitTest

I am currently involved in writing library which will be used by couple of external teams. In that library we have a quite a lot classes which are only used internally and won’t be a part of public API. The natural way of keeping that code inaccessible for other assemblies is to use internal access modifier. However this makes the code also inaccessible directly for testing. Of course you can still test your internal code through public API but usually this is inconvenient and forces you to write a lot of additional code in test. This is particularly painful for me, because our build process requires 100% test coverage. Fortunately there is an easy way to make internal classes visible for certain assemblies without making them public. All you have to do is to use InternalsVisibleToAttribute and specify assembly name which is allowed to use code with internal access modifier. This attribute is most commonly added to AssemblyInfo.cs file. For example, assuming that my library is in TestingInternalClasses.Lib assembly and my tests are in TestingInternalClasses.Tests I should add

[assembly: InternalsVisibleTo("TestingInternalClasses.Tests")]

1	[assembly: InternalsVisibleTo("TestingInternalClasses.Tests")]

to AssemblyInfo.cs located in TestingInternalClasses.Lib project. However you can also use this attribute in a class definition file – just like that

using System;
using System.IO;
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("TestingInternalClasses.Tests")]

namespace TestingInternalClasses.Lib
{
    internal class VanillaSerializer : ISerializer
    {
        public Stream Serialize(object obj)
        {
            if (obj == null)
                throw new ArgumentNullException(nameof(obj));

            // rest of the code
            // ...
            // ...
        }

        public T Deserialize(Stream stream)
        {
            if (stream == null)
                throw new ArgumentNullException(nameof(stream));

            // rest of the code
            // ...
            // ...
        }
    }
}

using System;

using System.IO;

using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("TestingInternalClasses.Tests")]

namespace TestingInternalClasses.Lib

{

internal class VanillaSerializer : ISerializer

{

public Stream Serialize(object obj)

{

if (obj == null)

throw new ArgumentNullException(nameof(obj));

// rest of the code

// ...

}

public T Deserialize(Stream stream)

{

if (stream == null)

throw new ArgumentNullException(nameof(stream));

// rest of the code

// ...

}

From now on I can easily test internal classes from TestingInternalClasses.Lib project in TestingInternalClasses.Tests. Source code for this post can be found here

I think all Resharper users are familiar with snippets. Resharper’s snippet basically generates a piece of code, which can be easily customised on the fly. All you have to do is to press TAB, and you can change names of auto-generated variables etc. Today, I decided to write my own snippet, which would make writing unit tests easier. In general, all my unit test methods looks like this

[Test]
public void MethodName_Scenario_ExpectedResult_Test()
{
    //test logic goes in here            
}

[Test]

public void MethodName_Scenario_ExpectedResult_Test()

{

//test logic goes in here

}

So let’s write a snippet which will generate a method with this signature. In order to do this, let’s choose a Templates Explorer… from the Resharper’s menu.

In the opened window, click on the plus sign and a new tab should appear.

Let’s name our snippet test and paste the following code into the main editor.

[Test]
public void MethodName_Scenario_ExpectedResult_Test()
{
           
}

[Test]

public void MethodName_Scenario_ExpectedResult_Test()

{

}

Now, we’ve created a simplified snippet for generating our test function signature. However, this snippet is not really useful as its user cannot navigate through the underscored chunks. In order to employ the Resharper’s navigation features, we have to slightly modify our snippet. Let’s replace the previous code with this one:

[Test]
public void $MethodName$_$Scenario$_$ExpectedResult$_Test()
{
    $END$
}

[Test]

public void $MethodName$_$Scenario$_$ExpectedResult$_Test()

{

$END$

}

Please notice that now some parts of the method’s name are written between dollar signs. Thanks to this syntax, the Resharper is able to iterate over these parts and lets us change their names on the fly. $END$ is a special control sequence which tells the Resharper where to stop iteration over variables. At this moment, our snippet is fully functional and we can use it by typing the word test and hitting the TAB button.

.NET BLOG

.NET, C# blog

C# – testing internal classes

Resharper – custom snippet