classtester Wiki & Documentation Rss Feed

UPDATED WIKI: AssemblyTester

molmorg — Wed, 09 Jan 2008 16:19:11 GMT

The AssemblyTester

The AssemblyTester uses the PropertyTester and ConstructorTester and can remove much of the coding previously required to use them by applying these tests to all the types in an assembly, subject to exclusions that you can specify.

How it works

To test an assembly simply create an instance of the AssemblyTester passing it the name of the Assembly to test.

AssemblyTester tester = new AssemblyTester("TheJoyOfCode.QualityTools");

Now you can call the AssemblyTesters TestAssembly method which looks like this:

     public void TestAssembly(bool testProperties, bool testConstructors)

The testProperties and testConstructors parameters should be fairly self explanatory!

The example below aims to test both constructors and properties in the "TheJoyOfCode.QualityTools.Tests.DummyProject" assembly.

     AssemblyTester tester = new AssemblyTester("ExampleAssembly");
     tester.TestAssembly(true, true);

The AssemblyTester will throw an exception with a detailed description of errors encountered when testing an assembly. Here's an example:

AssemblyTesterTest.AssemblyTester_PassWithExclusions : FailedTheJoyOfCode.QualityTools.AssemblyTestException: 
Testing the assembly TheJoyOfCode.QualityTools.Tests.DummyProject produced the following errors:
------------
The get value of the 'Dummy4' property on the type 'TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties' 
did not equal the set value (in: '', out: 'fe6faacc-3ea8-45a0-8c5c-dc2e0021065b')
 [TestProperties,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties]
 
The value of the 'Dummy1' property did not equal the value set with the 'dummy1' 
constructor parameter (in: 'cf04ca44-73dc-4147-bb3e-2a1a0d2c52b3', out: '819e635d-4dc6-4e6c-b141-75f0212cb242')
 [TestConstructors,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectConstructors]
 
The type TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1 is an open 
Generic Definition (e.g. Class<T>. Only closed generic types Class<int> are currently supported.
 [TestConstructors,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1[T]]
 
Cannot create an instance of TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1[T] 
because Type.ContainsGenericParameters is true. 
[TestProperties,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1[T]]

Not all types in an assembly qualify for automatic testing of constructors or properties. Looking at the errors produced above it is clear that the two first errors are should be fixed (A property which is not mapped correctly and a constructor which does not map correctly to the corresponding property). The last two errors indicates that the AssemblyTester can not test this particular type because it contains generic parameters.

Exclusions

To still use the AssemblyTester on this module we can skip these last two issues. This can be done in two ways, specifying one or more types to exclude or specifying a namespace to exclude.

Excluding a type

The example excludes the class which is not qualified for automatic testing to the AssemblyTester.

     AssemblyTester tester = new AssemblyTester("TheJoyOfCode.QualityTools.Tests.DummyProject");
     tester.Exclusions.AddType(typeof(GenericClass<>));
     tester.TestAssembly(AssemblyTester.TestTarget.Properties | AssemblyTester.TestTarget.Constructors);

When running the test again the AssemblyTester only produces the following errors.

TheJoyOfCode.QualityTools.AssemblyTestException: Testing the assembly 
TheJoyOfCode.QualityTools.Tests.DummyProject produced the following errors:
------------
The get value of the 'Dummy4' property on the type 'TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties' 
did not equal the set value (in: '', out: '1e5101b5-e9e9-4d69-b13c-83863f70a7b6')
 [TestProperties,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties]
 
The value of the 'Dummy1' property did not equal the value set with the 'dummy1' 
constructor parameter (in: '2bf2002e-b505-4413-a8f9-97036c40f720', out: '8a447a00-2f17-4d27-bb25-1fc66bf2c39d')
 [TestConstructors,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectConstructors]

The errors above are errors which the AssemblyTester has been designed to detect; errors in mapping properties to fields and mapping values to constructors. So to make the test pass we need to fix those errors!

Excluding a namespace

The example below excludes all types in the namepace "ExampleAssembly.SomeNamespace" namespace but does not exclude types in any sub namespaces.

     tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", false);

We could specify that all types within a numespace and sub-namespaces are excluded like so:

     tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", true);

For example, this would also exclude any type in the "ExampleAssembly.SomeNamespace.SomeSubNamespace" too.

You can have as many exclusions as you like and can combine type exclusions with namespace exclusions. Easy peasy.

If you need to exclude a type from an assembly test because of one funky property or constructor you can always target that type directly with the PropertyTester or ConstructorTester and exclude the property/type specifically. Best of both worlds.

Adding your own exclusion rules

It's easy to extend the exclusion policies available in the AssemblyTester by creating your own class that inherits from TestExclusion. Imagine you want to be able to exclude any class that starts with the letter 'S'. First we need a new

private class StartsWithSExclusion : TestExclusion
{
    public override bool IsExcluded(Type type)
    {
        return type.Name.StartsWith("S");
    }
}

Now we just have to add that type to the Exclusions as follows:

     tester.Exclusions.Add(new StartsWithSExclusion());

... and any types whose name starts with an S won't be tested.

FAQ

Q: It's nice that I can exclude whole types and namespaces using the AssemblyTester but why can't I specify a single property on a type that should be excluded.
A: This feature is deliberately not included to date. The practice in this case is to exclude the type from the assembly test like so:

AssemblyTester tester = new AssemblyTester("MyType, MyAssembly");
tester.Exclusions.AddType(typeof(TypeWithUntestableProperty));
tester.TestAssembly(true, true);

Now, add another test to target that class using the PropertyTester directly:

PropertyTester tester = new PropertyTester(new TypeWithUntestableProperty));
tester.TestProperties();

UPDATED WIKI: AssemblyTester

molmorg — Wed, 09 Jan 2008 15:35:04 GMT

The AssemblyTester

How it works

To test an assembly simply create an instance of the AssemblyTester passing it the name of the Assembly to test.

AssemblyTester tester = new AssemblyTester("TheJoyOfCode.QualityTools");

Now you can call the AssemblyTesters TestAssembly method which looks like this:

     public void TestAssembly(bool testProperties, bool testConstructors)

     AssemblyTester tester = new AssemblyTester("ExampleAssembly");
     tester.TestAssembly(true, true);

The AssemblyTester will throw an exception with a detailed description of errors encountered when testing an assembly. Here's an example:

AssemblyTesterTest.AssemblyTester_PassWithExclusions : FailedTheJoyOfCode.QualityTools.AssemblyTestException: 
Testing the assembly TheJoyOfCode.QualityTools.Tests.DummyProject produced the following errors:
------------
The get value of the 'Dummy4' property on the type 'TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties' 
did not equal the set value (in: '', out: 'fe6faacc-3ea8-45a0-8c5c-dc2e0021065b')
 [TestProperties,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties]
 
The value of the 'Dummy1' property did not equal the value set with the 'dummy1' 
constructor parameter (in: 'cf04ca44-73dc-4147-bb3e-2a1a0d2c52b3', out: '819e635d-4dc6-4e6c-b141-75f0212cb242')
 [TestConstructors,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectConstructors]
 
The type TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1 is an open 
Generic Definition (e.g. Class<T>. Only closed generic types Class<int> are currently supported.
 [TestConstructors,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1[T]]
 
Cannot create an instance of TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1[T] 
because Type.ContainsGenericParameters is true. 
[TestProperties,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1[T]]

Exclusions

To still use the AssemblyTester on this module we can skip these last two issues. This can be done in two ways, specifying one or more types to exclude or specifying a namespace to exclude.

Excluding a type

The example excludes the class which is not qualified for automatic testing to the AssemblyTester.

     AssemblyTester tester = new AssemblyTester("TheJoyOfCode.QualityTools.Tests.DummyProject");
     tester.Exclusions.AddType(typeof(GenericClass<>));
     tester.TestAssembly(AssemblyTester.TestTarget.Properties | AssemblyTester.TestTarget.Constructors);

When running the test again the AssemblyTester only produces the following errors.

TheJoyOfCode.QualityTools.AssemblyTestException: Testing the assembly 
TheJoyOfCode.QualityTools.Tests.DummyProject produced the following errors:
------------
The get value of the 'Dummy4' property on the type 'TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties' 
did not equal the set value (in: '', out: '1e5101b5-e9e9-4d69-b13c-83863f70a7b6')
 [TestProperties,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties]
 
The value of the 'Dummy1' property did not equal the value set with the 'dummy1' 
constructor parameter (in: '2bf2002e-b505-4413-a8f9-97036c40f720', out: '8a447a00-2f17-4d27-bb25-1fc66bf2c39d')
 [TestConstructors,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectConstructors]

Excluding a namespace

The example below excludes all types in the namepace "ExampleAssembly.SomeNamespace" namespace but does not exclude types in any sub namespaces.

     tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", false);

We could specify that all types within a numespace and sub-namespaces are excluded like so:

     tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", true);

Adding your own exclusion rules

private class StartsWithSExclusion : TestExclusion
{
    public override bool IsExcluded(Type type)
    {
        return type.Name.StartsWith("S");
    }
}

Now we just have to add that type to the Exclusions as follows:

     tester.Exclusions.Add(new StartsWithSExclusion());

... and any types whose name starts with an S won't be tested.

FAQ

AssemblyTester tester = new AssemblyTester("MyType, MyAssembly");
tester.Exclusions.AddType(typeof(TypeWithUntestableProperty));
tester.TestAssembly(true, true);

And add another test to target that class using the PropertyTester

/// TODO + unfinished +

UPDATED WIKI: TypeFactory

molmorg — Fri, 04 Jan 2008 14:42:48 GMT

TheJoyOfCode.QualityTools.TypeFactory

The current version of the TypeFactory supports creation of the following types. The TypeFactory tries to create random values for each type where possible.

Boolean
Byte
Char
DateTime
Decimal
Double
Int16
Int32
Int64
SByte
Single
String
UInt16
UInt32
UInt64
Guid
TimeSpan
Enums
NullableTypes (where a value type in this list)
Type (a random type is compiled at runtime using the codedom)
Types with a default constructors

The most notable limitations are are abstract classes (including interfaces), arrays and classes with non-default constructors. If you'd like these features please vote for these features here: Work Items

UPDATED WIKI: TypeFactory

molmorg — Fri, 04 Jan 2008 14:42:33 GMT

TheJoyOfCode.QualityTools.TypeFactory

The current version of the TypeFactory supports creation of the following types. The TypeFactory tries to create random values for each type where possible.

Boolean
Byte
Char
DateTime
Decimal
Double
Int16
Int32
Int64
SByte
Single
String
UInt16
UInt32
UInt64
Guid
Enums
NullableTypes (where a value type in this list)
Type (a random type is compiled at runtime using the codedom)
Types with a default constructors

UPDATED WIKI: AssemblyTester

molmorg — Fri, 04 Jan 2008 14:03:39 GMT

The AssemblyTester

How it works

To test an assembly simply create an instance of the AssemblyTester passing it the name of the Assembly to test.

AssemblyTester tester = new AssemblyTester("TheJoyOfCode.QualityTools");

Now you can call the AssemblyTesters TestAssembly method which looks like this:

     public void TestAssembly(bool testProperties, bool testConstructors)

     AssemblyTester tester = new AssemblyTester("ExampleAssembly");
     tester.TestAssembly(true, true);

The AssemblyTester will throw an exception with a detailed description of errors encountered when testing an assembly. Here's an example:

AssemblyTesterTest.AssemblyTester_PassWithExclusions : FailedTheJoyOfCode.QualityTools.AssemblyTestException: 
Testing the assembly TheJoyOfCode.QualityTools.Tests.DummyProject produced the following errors:
------------
The get value of the 'Dummy4' property on the type 'TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties' 
did not equal the set value (in: '', out: 'fe6faacc-3ea8-45a0-8c5c-dc2e0021065b')
 [TestProperties,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties]
 
The value of the 'Dummy1' property did not equal the value set with the 'dummy1' 
constructor parameter (in: 'cf04ca44-73dc-4147-bb3e-2a1a0d2c52b3', out: '819e635d-4dc6-4e6c-b141-75f0212cb242')
 [TestConstructors,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectConstructors]
 
The type TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1 is an open 
Generic Definition (e.g. Class<T>. Only closed generic types Class<int> are currently supported.
 [TestConstructors,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1[T]]
 
Cannot create an instance of TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1[T] 
because Type.ContainsGenericParameters is true. 
[TestProperties,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1[T]]

Exclusions

To still use the AssemblyTester on this module we can skip these last two issues. This can be done in two ways, specifying one or more types to exclude or specifying a namespace to exclude.

Excluding a type

The example excludes the class which is not qualified for automatic testing to the AssemblyTester.

     AssemblyTester tester = new AssemblyTester("TheJoyOfCode.QualityTools.Tests.DummyProject");
     tester.Exclusions.AddType(typeof(GenericClass<>));
     tester.TestAssembly(AssemblyTester.TestTarget.Properties | AssemblyTester.TestTarget.Constructors);

When running the test again the AssemblyTester only produces the following errors.

TheJoyOfCode.QualityTools.AssemblyTestException: Testing the assembly 
TheJoyOfCode.QualityTools.Tests.DummyProject produced the following errors:
------------
The get value of the 'Dummy4' property on the type 'TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties' 
did not equal the set value (in: '', out: '1e5101b5-e9e9-4d69-b13c-83863f70a7b6')
 [TestProperties,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties]
 
The value of the 'Dummy1' property did not equal the value set with the 'dummy1' 
constructor parameter (in: '2bf2002e-b505-4413-a8f9-97036c40f720', out: '8a447a00-2f17-4d27-bb25-1fc66bf2c39d')
 [TestConstructors,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectConstructors]

Excluding a namespace

The example below excludes all types in the namepace "ExampleAssembly.SomeNamespace" namespace but does not exclude types in any sub namespaces.

     tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", false);

We could specify that all types within a numespace and sub-namespaces are excluded like so:

     tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", true);

Adding your own exclusion rules

private class StartsWithSExclusion : TestExclusion
{
    public override bool IsExcluded(Type type)
    {
        return type.Name.StartsWith("S");
    }
}

Now we just have to add that type to the Exclusions as follows:

     tester.Exclusions.Add(new StartsWithSExclusion());

... any any types whose name starts with an S won't be tested.

UPDATED WIKI: Home

molmorg — Fri, 04 Jan 2008 13:06:26 GMT

Welcome to the Class Tester

This project started life as a blog post and some source code (read the original post) but due to public demand (at least 2 comments!) it has now gone open source. The project has undergone a fairly significant refactoring since then with a number of new features and improvements:

A new PropertyTester! (formerly the ClassTester)
A new ConstructorTester! (formerly part of the ClassTester)
A new AssemblyTester!

Click the links above for more information on each of the pieces.

Project Description

The idea is pretty simple - a way to easily test your domain classes. You know, the plain old data shapes that look something like this:

public class Person
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
 
    private DateTime _dateOfBirth;
 
    public DateTime DateOfBirth
    {
        get { return _dateOfBirth; }
        set { _dateOfBirth = value; }
    }
 
    // etc..
}

Stuff that nobody ever tests directly because it would be so time consuming. I found this very annoying because of the loss of code coverage in my test suite and then disaster struck. I made a change to such code that accidentally broke one of the properties (two different public getters returned the same private string).

Something had to be done and the Automatic Class Tester project was born!

What it can do:

Automatically test properties, spotting any miswired getters or setters
Increase code coverage, reaching parts manual tests don't even try to
Supports ignoring specified properties if you have any funky logic in there that needs a manual test
Tests for PropertyChanged events if your class implements INotifyPropertyChanged
Tests constructors and that they map parameters to properties
An exception is thrown when a problem is found which should cause your tests to fail.

How it works

The PropertyTester simply uses reflection to discover the subject's properties. Random values are then injected via the property setters and the getter is invoked and the ClassTester verifies that we get the same value back. Here we test our Person class above:

See PropertyTester for more information...

[TestMethod]
public void TestPerson()
{
    ClassTester tester = new ClassTester(new Person());
    tester.TestProperties();
}

Some properties just can't be tested in this way, either because they perform some funky logic that is dependant on other state in the class or because they don't return the same value that was set. Like this nonsensical example below that we'll add to our person class:

private int _nonsensicalProperty;
 
public DateTime NonsensicalProperty
{
    get { return 0; }
    set { _nonsensicalProperty = value; }
}

No problem, we can still use the tester by specifying that this property should be ignored.

[TestMethod]
public void TestPerson()
{
    PropertyTester tester = new PropertyTester(new Person());
    tester.IgnoredProperties.Add("NonsensicalProperty");
    tester.TestProperties();
}

INotifyPropertyChanged support

This is perhaps the most compelling use of the tester given how easy it is to mess up firing the INotifyPropertyChanged due to the lack of compile time support (it's based on strings).

public class Person : INotifyPropertyChanged
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set 
        { 
            _name = value; 
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs("Name"));
        }
    }
 
    // etc..

Again, if a specific property doesn't support INotifyPropertyChanged for some reason, then just add it to the ignored list and test it manually.

Testing Constructors

See ConstructorTester for more information

The QualityTools library can also help you test your constructors thanks to the ConstructorTester. It's a very common practice to create a custom constructor to help inject property values at construction time. Like this:

public class Person
{
    public Person(string name, DateTime dateOfBirth)
    {
        _name = name;    
    }
    
    // etc

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    tester.TestConstructors(true);
}

This static method will test all constructors available on the object by creating random values for each parameter (as best it can). Again, if there are some constructors that you need to skip over because they have some funky logic you can add them to a blacklist. Maybe you have to blacklist a particular constructor because it takes a parameter that the ConstructorTester can't create, like an Interface.

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    // we specify the signature of the constructor to be ignored
    tester.IgnoredConstructors.Add(typeof(string), typeof(ISomeInterface), typeof(object));
    tester.TestConstructors(true);
}

Testing whole assemblies

see AssemblyTester for more information

To help you test large numbers of classes at once there is even an assembly tester that will test all the properties and constructors, of all the classes.

[Test]
public void AssemblyTester_PassWithExclusions()
{
    AssemblyTester tester = new AssemblyTester("ExampleAssembly");
    // exclude a namespace from the test scope but not child namespaces
    tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", false);
    // first parameters says test properties, second parameter says test constructors
    tester.TestAssembly(true, true);
}

In this example we're going to test all the types within the ExampleAssembly (obviously, it uses the PropertyTester and ConstructorTester under the covers). We also specifically exclude the ExampleAssembly.SomeNamespace so any types belonging to that namespace won't be tested.

Remember kids! This is just a helper and isn't intended to remove the need to write unit tests. It's only there to cover the basic stuff that people don't normally test. If you exclude a namespace, type, property or constructor then you should consider adding a manual test.

UPDATED WIKI: TypeFactory

molmorg — Fri, 04 Jan 2008 13:04:26 GMT

TheJoyOfCode.QualityTools.TypeFactory

The current version of the TypeFactory supports creation of the following types. The TypeFactory tries to create random values for each type where possible.

Boolean
Byte
Char
DateTime
Decimal
Double
Int16
Int32
Int64
SByte
Single
String
UInt16
UInt32
UInt64
Guid
Enums
NullableTypes (where a value type in this list)
Type (a random type is compiled at runtime using the codedom)
Types with a default constructors

The most notable limitations are are abstract classes (including interfaces) and classes with non-default constructors. If you'd like these features please vote for these features here: Work Items

UPDATED WIKI: ConstructorTester

molmorg — Fri, 04 Jan 2008 12:57:11 GMT

TheJoyOfCode.QualityTools.ConstructorTester

public class Person
{
    public Person(string name, DateTime dateOfBirth)
    {
        Name = name;    
    }
 
    public string Name { get; set; }
    public string DateOfBirth { get; set; }

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    tester.TestConstructors(false);
}

This static method will test all constructors available on the object by creating random values using the TypeFactory (follow the link for supported types). Obviously, in this basic example no logic is validated the constructor is just called and if no exception is raised your test will pass.

Mapped properties.

The TestConstructors method has a testMappedProperties parameter which, if set to true, will test that any properties on the new object that have a namesake on the constructor (case insensitive matching) have the same value that was injected at construction.

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    tester.TestConstructors(true);
}

In this case our test will fail because our example object above takes a dateOfBirth parameter at construction and has a DateOfBirth property but this property is never wired up. The resulting ConstructorTestException would have the following message: "The value of the 'DateOfBirth' property did not equal the value set with the 'dateOfBirth' constructor parameter (in: '2007-09-22', out: '1900-01-01')"

Exclusions

Again, if there are some constructors that you need to skip over because they have some funky logic you can add them to a blacklist. Maybe you have to blacklist a particular constructor because it takes a parameter that the TypeFactory can't create.

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    // we specify the signature of the constructor to be ignored
    tester.IgnoredConstructors.Add(typeof(string), typeof(ISomeInterface), typeof(object));
    tester.TestConstructors(true);
}

UPDATED WIKI: Home

molmorg — Fri, 04 Jan 2008 12:47:23 GMT

Welcome to the Class Tester

A new PropertyTester! (formerly the ClassTester)
A new ConstructorTester! (formerly part of the ClassTester)
A new AssemblyTester!

Click the links above for more information on each of the pieces.

Project Description

The idea is pretty simple - a way to easily test your domain classes. You know, the plain old data shapes that look something like this:

public class Person
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
 
    private DateTime _dateOfBirth;
 
    public DateTime DateOfBirth
    {
        get { return _dateOfBirth; }
        set { _dateOfBirth = value; }
    }
 
    // etc..
}

Something had to be done and the Automatic Class Tester project was born!

What it can do:

Automatically test properties, spotting any miswired getters or setters
Increase code coverage, reaching parts manual tests don't even try to
Supports ignoring specified properties if you have any funky logic in there that needs a manual test
Tests for PropertyChanged events if your class implements INotifyPropertyChanged
Tests constructors and that they map parameters to properties
An exception is thrown when a problem is found which should cause your tests to fail.

How it works

See PropertyTester for more information...

[TestMethod]
public void TestPerson()
{
    ClassTester tester = new ClassTester(new Person());
    tester.TestProperties();
}

private int _nonsensicalProperty;
 
public DateTime NonsensicalProperty
{
    get { return 0; }
    set { _nonsensicalProperty = value; }
}

No problem, we can still use the tester by specifying that this property should be ignored.

[TestMethod]
public void TestPerson()
{
    PropertyTester tester = new PropertyTester(new Person());
    tester.IgnoredProperties.Add("NonsensicalProperty");
    tester.TestProperties();
}

INotifyPropertyChanged support

This is perhaps the most compelling use of the tester given how easy it is to mess up firing the INotifyPropertyChanged due to the lack of compile time support (it's based on strings).

public class Person : INotifyPropertyChanged
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set 
        { 
            _name = value; 
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs("Name"));
        }
    }
 
    // etc..

Again, if a specific property doesn't support INotifyPropertyChanged for some reason, then just add it to the ignored list and test it manually.

Testing Constructors

public class Person
{
    public Person(string name, DateTime dateOfBirth)
    {
        _name = name;    
    }
    
    // etc

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    tester.TestConstructors(true);
}

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    // we specify the signature of the constructor to be ignored
    tester.IgnoredConstructors.Add(typeof(string), typeof(ISomeInterface), typeof(object));
    tester.TestConstructors(true);
}

Testing whole assemblies

see AssemblyTester for more information

To help you test large numbers of classes at once there is even an assembly tester that will test all the properties and constructors, of all the classes.

[Test]
public void AssemblyTester_PassWithExclusions()
{
    AssemblyTester tester = new AssemblyTester("ExampleAssembly");
    // exclude a namespace from the test scope but not child namespaces
    tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", false);
    // first parameters says test properties, second parameter says test constructors
    tester.TestAssembly(true, true);
}

In this example we're going to test all the types within the ExampleAssembly (obviously, it uses the PropertyTester and ConstructorTester under the covers). We also specifically exclude the ExampleAssembly.SomeNamespace so any types belonging to that namespace won't be tested.

Remember kids! This is just a helper and isn't intended to remove the need to write unit tests. It's only there to cover the basic stuff that people don't normally test. If you exlude a namespace, type, property or constructor then you should consider adding a manual test.

UPDATED WIKI: PropertyTester

molmorg — Fri, 04 Jan 2008 12:46:07 GMT

TheJoyOfCode.QualityTools.PropertyTester

The PropertyTester (formerly known as the ClassTester) automatically tests properties by calling the set and get methods and ensuring that the same value is returned. If the property is a set only or get only then this check can't be made but the set and get will be called.

Here's an example object that might be targetted with such a test:

public class Person
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
 
    private DateTime _dateOfBirth;
 
    public DateTime DateOfBirth
    {
        get { return _dateOfBirth; }
        set { _dateOfBirth = value; }
    }
 
    public double AgeInDays
    {
         get {  return (DateTime.Today.Subtract(_dateOfBirth).TotalDays);  }
    }
 
    private ISomeProvider _provider
 
    public ISomeProvider Provider
    {
        get { return _provider; }
        set { _provider= value; }
    }
    // etc..
}

Which could be tested like so.

   PropertyTester tester = new PropertyTester(new Person());
   tester.TestProperties();

This would give great coverage of this class testing Name, DateOfBirth and AgeInDays properties with only one problem...

Obviously, to call set the PropertyTester must create a type to pass as a value. It has a TypeFactory to support the creation of types but there are limitations to the types that it can create. For more information see TypeFactory. The most obvious limitations are abstract classes (including interfaces) and classes with non-default constructors.

Note: The functionality in the AgeInDays property is NOT validated by the PropertyTester and we'd recommend you test this using a seperate, manual unit test.

If you try to TestProperties() on a Class that exposes a property of an unsupported type (like our ISomeProvider type) you will get a PropertyTestException thrown with a message along the lines of:

"Cannot generate type 'ISomeProvider' to set on property 'Provider'. Consider ignoring this property on the type 'Person'"

This doesn't mean that you can't use the PropertyTester with this type, we just need to exclude that particular property.

Exclusions

It's easy to exclude a property from the test:

    PropertyTester tester = new PropertyTester(new Person());
    tester.IgnoredProperties.Add("Provider");
    tester.TestProperties();

INotifyPropertyChanged support

One of the key motivations for creating the original ClassTester was to test that classes implementing INotifyPropertyChanged fire the correct events appropriately. Here's an example implementation:

public class Person : INotifyPropertyChanged
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set 
        { 
            _name = value; 
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs("Name"));
        }
    }

As you can imagine, authoring such classes is error prone and therefore testing this functionality is important.

The PropertyTester automatically inspects classes to see if they implement INotifyPropertyChanged and verifies that PropertyChangedEvents are raised when the value of the property changes.

Note: The PropertyTester will try to set the value once and then set it again with a different value to test for PropertyChangedEvents (because you may implement INotifyPropertyChanged to only fire if the value actually changes!). Therefore, if the TypeFactory can't generate two different random values you will get a PropertyTestException: "Could not generate two different values for the type 'SomeType'. Consider ignoring the 'YourProperty' property on the type 'YourType' or increasing the MaxLoopsPerProperty value above 1000".

UPDATED WIKI: TypeFactory

molmorg — Fri, 04 Jan 2008 12:36:04 GMT

TheJoyOfCode.QualityTools.TypeFactory

The current version of the TypeFactory supports creation of the following types. The TypeFactory tries to create random values for each type where possible.

Boolean
Byte
Char
DateTime
Decimal
Double
Int16
Int32
Int64
SByte
Single
String
UInt16
UInt32
UInt64
Guid
Enums
NullableTypes (where a value type in this list)
Type (a random type is compiled at runtime using the codedom)
Types with a default constructors

UPDATED WIKI: TypeFactory

molmorg — Fri, 04 Jan 2008 12:33:53 GMT

TheJoyOfCode.QualityTools.TypeFactory

The current version of the TypeFactory supports creation of the following types. The TypeFactory tries to create random values for each type where possible.

Boolean
Byte
Char
DateTime
Decimal
Double
Int16
Int32
Int64
SByte
Single
String
UInt16
UInt32
UInt64
Guid
Enums
NullableTypes (where a value type in this list)
Type (a random type is compiled at runtime using the codedom)
Types with a default constructors

UPDATED WIKI: TypeFactory

molmorg — Fri, 04 Jan 2008 12:32:22 GMT

!TheJoyOfCode.QualityTools.TypeFactory

The current version of the TypeFactory supports creation of the following types. The TypeFactory tries to create random values for each type where possible.

Boolean
Byte
Char
DateTime
Decimal
Double
Int16
Int32
Int64
SByte
Single
String
UInt16
UInt32
UInt64
Guid
Enums
NullableTypes (where a value type in this list)
Type (a random type is compiled at runtime using the codedom)
Types with a default constructors

UPDATED WIKI: PropertyTester

molmorg — Fri, 04 Jan 2008 12:27:13 GMT

TheJoyOfCode.QualityTools.PropertyTester

public class Person
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
 
    private DateTime _dateOfBirth;
 
    public DateTime DateOfBirth
    {
        get { return _dateOfBirth; }
        set { _dateOfBirth = value; }
    }
 
    public double AgeInDays
    {
         get {  return (DateTime.Today.Subtract(_dateOfBirth).TotalDays);  }
    }
 
    private ISomeProvider _provider
 
    public ISomeProvider Provider
    {
        get { return _provider; }
        set { _provider= value; }
    }
    // etc..
}

Which could be tested like so.

   PropertyTester tester = new PropertyTester(new Person());
   tester.TestProperties();

This would give great coverage of this class testing Name, DateOfBirth and AgeInDays properties with only one problem...

Obviously, to call set the PropertyTester must create a type to pass as a value. It has a TypeFactory to support the creation of types but there are limitations to the types that it can create. For more information see TypeFactory. The most obvious limitations are abstract classes (including interfaces) and classes with non-default constructors.

If you try to TestProperties() on a Class that exposes a property of an unsupported type (like our ISomeProvider type) you will get a PropertyTestException thrown with a message along the lines of:

"Cannot generate type 'ISomeProvider' to set on property 'Provider'. Consider ignoring this property on the type 'Person'"

This doesn't mean that you can't use the PropertyTester with this type, we just need to exclude that particular property.

Exclusions

UPDATED WIKI: Home

molmorg — Thu, 03 Jan 2008 17:44:12 GMT

Welcome to the Class Tester

A new PropertyTester! (formerly the ClassTester)
A new ConstructorTester! (formerly part of the ClassTester)
A new AssemblyTester!

Click the links above for more information on each of the pieces.

Project Description

The idea is pretty simple - a way to easily test your domain classes. You know, the plain old data shapes that look something like this:

public class Person
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
 
    private DateTime _dateOfBirth;
 
    public DateTime DateOfBirth
    {
        get { return _dateOfBirth; }
        set { _dateOfBirth = value; }
    }
 
    // etc..
}

Something had to be done and the Automatic Class Tester project was born!

What it can do:

Automatically test properties, spotting any miswired getters or setters
Increase code coverage, reaching parts manual tests don't even try to
Supports ignoring specified properties if you have any funky logic in there that needs a manual test
Tests for PropertyChanged events if your class implements INotifyPropertyChanged
Tests constructors and that they map parameters to properties
An exception is thrown when a problem is found which should cause your tests to fail.

How it works

See PropertyTester for more information...

[TestMethod]
public void TestPerson()
{
    ClassTester tester = new ClassTester(new Person());
    tester.TestProperties();
}

private int _nonsensicalProperty;
 
public DateTime NonsensicalProperty
{
    get { return 0; }
    set { _nonsensicalProperty = value; }
}

No problem, we can still use the tester by specifying that this property should be ignored.

[TestMethod]
public void TestPerson()
{
    PropertyTester tester = new PropertyTester(new Person());
    tester.IgnoredProperties.Add("NonsensicalProperty");
    tester.TestProperties();
}

INotifyPropertyChanged support

This is perhaps the most compelling use of the tester given how easy it is to mess up firing the INotifyPropertyChanged due to the lack of compile time support (it's based on strings).

public class Person : INotifyPropertyChanged
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set 
        { 
            _name = value; 
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs("Name"));
        }
    }
 
    // etc..

Again, if a specific property doesn't support INotifyPropertyChanged for some reason, then just add it to the ignored list and test it manually.

Testing Constructors

See ConstructorTester for more information

public class Person
{
    public Person(string name, DateTime dateOfBirth)
    {
        _name = name;    
    }
    
    // etc

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    tester.TestConstructors(true);
}

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    // we specify the signature of the constructor to be ignored
    tester.IgnoredConstructors.Add(typeof(string), typeof(ISomeInterface), typeof(object));
    tester.TestConstructors(true);
}

Testing whole assemblies

see AssemblyTester for more information

To help you test large numbers of classes at once there is even an assembly tester that will test all the properties and constructors, of all the classes.

[Test]
public void AssemblyTester_PassWithExclusions()
{
    AssemblyTester tester = new AssemblyTester("ExampleAssembly");
    // exclude a namespace from the test scope but not child namespaces
    tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", false);
    // first parameters says test properties, second parameter says test constructors
    tester.TestAssembly(true, true);
}

In this example we're going to test all the types within the ExampleAssembly (obviously, it uses the PropertyTester and ConstructorTester under the covers). We also specifically exclude the ExampleAssembly.SomeNamespace so any types belonging to that namespace won't be tested.

Remember kids! This is just a helper and isn't intended to remove the need to write unit tests. It's only there to cover the basic stuff that people don't normally test. If you exlude a namespace, type, property or constructor then you should consider adding a manual test.

UPDATED WIKI: AssemblyTester

molmorg — Thu, 03 Jan 2008 17:37:06 GMT

The AssemblyTester

How it works

To test an assembly simply create an instance of the AssemblyTester passing it the name of the Assembly to test.

AssemblyTester tester = new AssemblyTester("TheJoyOfCode.QualityTools");

Now you can call the AssemblyTesters TestAssembly method which looks like this:

     public void TestAssembly(bool testProperties, bool testConstructors)

     AssemblyTester tester = new AssemblyTester("ExampleAssembly");
     tester.TestAssembly(true, true);

The AssemblyTester will throw an exception with a detailed description of errors encountered when testing an assembly. Here's an example:

AssemblyTesterTest.AssemblyTester_PassWithExclusions : FailedTheJoyOfCode.QualityTools.AssemblyTestException: 
Testing the assembly TheJoyOfCode.QualityTools.Tests.DummyProject produced the following errors:
------------
The get value of the 'Dummy4' property on the type 'TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties' 
did not equal the set value (in: '', out: 'fe6faacc-3ea8-45a0-8c5c-dc2e0021065b')
 [TestProperties,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties]
 
The value of the 'Dummy1' property did not equal the value set with the 'dummy1' 
constructor parameter (in: 'cf04ca44-73dc-4147-bb3e-2a1a0d2c52b3', out: '819e635d-4dc6-4e6c-b141-75f0212cb242')
 [TestConstructors,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectConstructors]
 
The type TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1 is an open 
Generic Definition (e.g. Class<T>. Only closed generic types Class<int> are currently supported.
 [TestConstructors,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1[T]]
 
Cannot create an instance of TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1[T] 
because Type.ContainsGenericParameters is true. 
[TestProperties,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.GenericClass`1[T]]

Exclusions

To still use the AssemblyTester on this module we can skip these last two issues. This can be done in two ways, specifying one or more types to exclude or specifying a namespace to exclude.

Excluding a type

The example excludes the class which is not qualified for automatic testing to the AssemblyTester.

     AssemblyTester tester = new AssemblyTester("TheJoyOfCode.QualityTools.Tests.DummyProject");
     tester.Exclusions.AddType(typeof(GenericClass<>));
     tester.TestAssembly(AssemblyTester.TestTarget.Properties | AssemblyTester.TestTarget.Constructors);

When running the test again the AssemblyTester only produces the following errors.

TheJoyOfCode.QualityTools.AssemblyTestException: Testing the assembly 
TheJoyOfCode.QualityTools.Tests.DummyProject produced the following errors:
------------
The get value of the 'Dummy4' property on the type 'TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties' 
did not equal the set value (in: '', out: '1e5101b5-e9e9-4d69-b13c-83863f70a7b6')
 [TestProperties,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectProperties]
 
The value of the 'Dummy1' property did not equal the value set with the 'dummy1' 
constructor parameter (in: '2bf2002e-b505-4413-a8f9-97036c40f720', out: '8a447a00-2f17-4d27-bb25-1fc66bf2c39d')
 [TestConstructors,Type:TheJoyOfCode.QualityTools.Tests.DummyProject.WithErrors.IncorrectConstructors]

Excluding a namespace

The example below excludes all types in the namepace "ExampleAssembly.SomeNamespace" namespace but does not exclude types in any sub namespaces.

     tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", false);

We could specify that all types within a numespace and sub-namespaces are excluded like so:

     tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", true);

UPDATED WIKI: Home

molmorg — Thu, 03 Jan 2008 17:25:04 GMT

Welcome to the Class Tester

A new AssemblyTester!
A new PropertyTester (formerly the ClassTester)!
A new and improved ConstructorTester!

Click the links above for more information on each of the pieces.

Project Description

The idea is pretty simple - a way to easily test your domain classes. You know, the plain old data shapes that look something like this:

public class Person
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
 
    private DateTime _dateOfBirth;
 
    public DateTime DateOfBirth
    {
        get { return _dateOfBirth; }
        set { _dateOfBirth = value; }
    }
 
    // etc..
}

Something had to be done and the Automatic Class Tester project was born!

What it can do:

Automatically test properties, spotting any miswired getters or setters
Increase code coverage, reaching parts manual tests don't even try to
Supports ignoring specified properties if you have any funky logic in there that needs a manual test
Tests for PropertyChanged events if your class implements INotifyPropertyChanged
Tests constructors and that they map parameters to properties
An exception is thrown when a problem is found which should cause your tests to fail.

How it works

See PropertyTester for more information...

[TestMethod]
public void TestPerson()
{
    ClassTester tester = new ClassTester(new Person());
    tester.TestProperties();
}

private int _nonsensicalProperty;
 
public DateTime NonsensicalProperty
{
    get { return 0; }
    set { _nonsensicalProperty = value; }
}

No problem, we can still use the tester by specifying that this property should be ignored.

[TestMethod]
public void TestPerson()
{
    PropertyTester tester = new PropertyTester(new Person());
    tester.IgnoredProperties.Add("NonsensicalProperty");
    tester.TestProperties();
}

INotifyPropertyChanged support

This is perhaps the most compelling use of the tester given how easy it is to mess up firing the INotifyPropertyChanged due to the lack of compile time support (it's based on strings).

public class Person : INotifyPropertyChanged
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set 
        { 
            _name = value; 
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs("Name"));
        }
    }
 
    // etc..

Again, if a specific property doesn't support INotifyPropertyChanged for some reason, then just add it to the ignored list and test it manually.

Testing Constructors

See ConstructorTester for more information

public class Person
{
    public Person(string name, DateTime dateOfBirth)
    {
        _name = name;    
    }
    
    // etc

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    tester.TestConstructors(true);
}

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    // we specify the signature of the constructor to be ignored
    tester.IgnoredConstructors.Add(typeof(string), typeof(ISomeInterface), typeof(object));
    tester.TestConstructors(true);
}

Testing whole assemblies

see AssemblyTester for more information

To help you test large numbers of classes at once there is even an assembly tester that will test all the properties and constructors, of all the classes.

[Test]
public void AssemblyTester_PassWithExclusions()
{
    AssemblyTester tester = new AssemblyTester("ExampleAssembly");
    // exclude a namespace from the test scope but not child namespaces
    tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", false);
    // first parameters says test properties, second parameter says test constructors
    tester.TestAssembly(true, true);
}

In this example we're going to test all the types within the ExampleAssembly (obviously, it uses the PropertyTester and ConstructorTester under the covers). We also specifically exclude the ExampleAssembly.SomeNamespace so any types belonging to that namespace won't be tested.

Remember kids! This is just a helper and isn't intended to remove the need to write unit tests. It's only there to cover the basic stuff that people don't normally test. If you exlude a namespace, type, property or constructor then you should consider adding a manual test.

UPDATED WIKI: Home

molmorg — Thu, 03 Jan 2008 17:24:15 GMT

Welcome to the Class Tester

This project started life as a blog post and some source code (read the orignal post) but due to public demand (at least 2 comments!) it has now gone open source. The project has undergone a fairly significant refactoring since then with a number of new features and improvements:

A new AssemblyTester!
A new PropertyTester (formerly the ClassTester)!
A new and improved ConstructorTester!

Click the links above for more information on each of the pieces.

Project Description

The idea is pretty simple - a way to easily test your domain classes. You know, the plain old data shapes that look something like this:

public class Person
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
 
    private DateTime _dateOfBirth;
 
    public DateTime DateOfBirth
    {
        get { return _dateOfBirth; }
        set { _dateOfBirth = value; }
    }
 
    // etc..
}

Something had to be done and the Automatic Class Tester project was born!

What it can do:

Automatically test properties, spotting any miswired getters or setters
Increase code coverage, reaching parts manual tests don't even try to
Supports ignoring specified properties if you have any funky logic in there that needs a manual test
Tests for PropertyChanged events if your class implements INotifyPropertyChanged
Tests constructors and that they map parameters to properties
An exception is thrown when a problem is found which should cause your tests to fail.

How it works

See PropertyTester for more information...

[TestMethod]
public void TestPerson()
{
    ClassTester tester = new ClassTester(new Person());
    tester.TestProperties();
}

private int _nonsensicalProperty;
 
public DateTime NonsensicalProperty
{
    get { return 0; }
    set { _nonsensicalProperty = value; }
}

No problem, we can still use the tester by specifying that this property should be ignored.

[TestMethod]
public void TestPerson()
{
    PropertyTester tester = new PropertyTester(new Person());
    tester.IgnoredProperties.Add("NonsensicalProperty");
    tester.TestProperties();
}

INotifyPropertyChanged support

This is perhaps the most compelling use of the tester given how easy it is to mess up firing the INotifyPropertyChanged due to the lack of compile time support (it's based on strings).

public class Person : INotifyPropertyChanged
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set 
        { 
            _name = value; 
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs("Name"));
        }
    }
 
    // etc..

Again, if a specific property doesn't support INotifyPropertyChanged for some reason, then just add it to the ignored list and test it manually.

Testing Constructors

See ConstructorTester for more information

public class Person
{
    public Person(string name, DateTime dateOfBirth)
    {
        _name = name;    
    }
    
    // etc

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    tester.TestConstructors(true);
}

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    // we specify the signature of the constructor to be ignored
    tester.IgnoredConstructors.Add(typeof(string), typeof(ISomeInterface), typeof(object));
    tester.TestConstructors(true);
}

Testing whole assemblies

see AssemblyTester for more information

To help you test large numbers of classes at once there is even an assembly tester that will test all the properties and constructors, of all the classes.

[Test]
public void AssemblyTester_PassWithExclusions()
{
    AssemblyTester tester = new AssemblyTester("ExampleAssembly");
    // exclude a namespace from the test scope but not child namespaces
    tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", false);
    // first parameters says test properties, second parameter says test constructors
    tester.TestAssembly(true, true);
}

In this example we're going to test all the types within the ExampleAssembly (obviously, it uses the PropertyTester and ConstructorTester under the covers). We also specifically exclude the ExampleAssembly.SomeNamespace so any types belonging to that namespace won't be tested.

Remember kids! This is just a helper and isn't intended to remove the need to write unit tests. It's only there to cover the basic stuff that people don't normally test. If you exlude a namespace, type, property or constructor then you should consider adding a manual test.

UPDATED WIKI: Home

molmorg — Thu, 03 Jan 2008 17:23:46 GMT

Welcome to the Class Tester

A new AssemblyTester!
A new PropertyTester (formerly the ClassTester)!
A new and improved ConstructorTester!

Click the links above for more information on each of the pieces.

Project Description

The idea is pretty simple - a way to easily test your domain classes. You know, the plain old data shapes that look something like this:

public class Person
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
 
    private DateTime _dateOfBirth;
 
    public DateTime DateOfBirth
    {
        get { return _dateOfBirth; }
        set { _dateOfBirth = value; }
    }
 
    // etc..
}

Something had to be done and the ClassTester was born.

What it can do:

Automatically test properties, spotting any miswired getters or setters
Increase code coverage, reaching parts manual tests don't even try to
Supports ignoring specified properties if you have any funky logic in there that needs a manual test
Tests for PropertyChanged events if your class implements INotifyPropertyChanged
Tests constructors and that they map parameters to properties
An exception is thrown when a problem is found which should cause your tests to fail.

How it works

See PropertyTester for more information...

[TestMethod]
public void TestPerson()
{
    ClassTester tester = new ClassTester(new Person());
    tester.TestProperties();
}

private int _nonsensicalProperty;
 
public DateTime NonsensicalProperty
{
    get { return 0; }
    set { _nonsensicalProperty = value; }
}

No problem, we can still use the tester by specifying that this property should be ignored.

[TestMethod]
public void TestPerson()
{
    PropertyTester tester = new PropertyTester(new Person());
    tester.IgnoredProperties.Add("NonsensicalProperty");
    tester.TestProperties();
}

INotifyPropertyChanged support

This is perhaps the most compelling use of the tester given how easy it is to mess up firing the INotifyPropertyChanged due to the lack of compile time support (it's based on strings).

public class Person : INotifyPropertyChanged
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set 
        { 
            _name = value; 
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs("Name"));
        }
    }
 
    // etc..

Again, if a specific property doesn't support INotifyPropertyChanged for some reason, then just add it to the ignored list and test it manually.

Testing Constructors

See ConstructorTester for more information

public class Person
{
    public Person(string name, DateTime dateOfBirth)
    {
        _name = name;    
    }
    
    // etc

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    tester.TestConstructors(true);
}

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    // we specify the signature of the constructor to be ignored
    tester.IgnoredConstructors.Add(typeof(string), typeof(ISomeInterface), typeof(object));
    tester.TestConstructors(true);
}

Testing whole assemblies

see AssemblyTester for more information

To help you test large numbers of classes at once there is even an assembly tester that will test all the properties and constructors, of all the classes.

[Test]
public void AssemblyTester_PassWithExclusions()
{
    AssemblyTester tester = new AssemblyTester("ExampleAssembly");
    // exclude a namespace from the test scope but not child namespaces
    tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", false);
    // first parameters says test properties, second parameter says test constructors
    tester.TestAssembly(true, true);
}

In this example we're going to test all the types within the ExampleAssembly (obviously, it uses the PropertyTester and ConstructorTester under the covers). We also specifically exclude the ExampleAssembly.SomeNamespace so any types belonging to that namespace won't be tested.

Remember kids! This is just a helper and isn't intended to remove the need to write unit tests. It's only there to cover the basic stuff that people don't normally test. If you exlude a namespace, type, property or constructor then you should consider adding a manual test.

UPDATED WIKI: Home

molmorg — Thu, 03 Jan 2008 17:21:40 GMT

Welcome to the Class Tester

A new AssemblyTester!
A new PropertyTester (formerly the ClassTester)!
A new and improved ConstructorTester!

Click the links above for more information on each of the pieces.

Project Description

See PropertyTester for more information...

The idea is pretty simple - a way to easily test your domain classes. You know, the plain old data shapes that look something like this:

public class Person
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
 
    private DateTime _dateOfBirth;
 
    public DateTime DateOfBirth
    {
        get { return _dateOfBirth; }
        set { _dateOfBirth = value; }
    }
 
    // etc..
}

Something had to be done and the ClassTester was born.

What it can do:

Automatically test properties, spotting any miswired getters or setters
Increase code coverage, reaching parts manual tests don't even try to
Supports ignoring specified properties if you have any funky logic in there that needs a manual test
Tests for PropertyChanged events if your class implements INotifyPropertyChanged
Tests constructors and that they map parameters to properties
An exception is thrown when a problem is found which should cause your tests to fail.

How it works

The ClassTester simply uses reflection to discover the subject's properties. Random values are then injected via the property setters and the getter is invoked and the ClassTester verifies that we get the same value back. Here we test our Person class above:

[TestMethod]
public void TestPerson()
{
    ClassTester tester = new ClassTester(new Person());
    tester.TestProperties();
}

If the ClassTester fails and throws a ClassTesterException then the test fails. Perfick!
The ClassTester is reasonably type aware but will skip properties with non default types (such as interfaces). It is important to utilise this test in conjunction with a code coverage tool to ensure the bits you think are being tested actually are!!.

Some properties just can't be tested in this way, either because they perform some funky logic that is dependant on other state in the class or because they don't return the same value that was set. Like this nonsensical example below that we'll add to our person class:

private int _nonsensicalProperty;
 
public DateTime NonsensicalProperty
{
    get { return 0; }
    set { _nonsensicalProperty = value; }
}

No problem, we can still use the tester by specifying that this property should be ignored.

[TestMethod]
public void TestPerson()
{
    PropertyTester tester = new PropertyTester(new Person());
    tester.IgnoredProperties.Add("NonsensicalProperty");
    tester.TestProperties();
}

INotifyPropertyChanged support

This is perhaps the most compelling use of the tester given how easy it is to mess up firing the INotifyPropertyChanged due to the lack of compile time support (it's based on strings).

public class Person : INotifyPropertyChanged
{
    private string _name;
 
    public string Name
    {
        get { return _name; }
        set 
        { 
            _name = value; 
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs("Name"));
        }
    }
 
    // etc..

Again, if a specific property doesn't support INotifyPropertyChanged for some reason, then just add it to the ignored list and test it manually.

Testing Constructors

See ConstructorTester for more information

public class Person
{
    public Person(string name, DateTime dateOfBirth)
    {
        _name = name;    
    }
    
    // etc

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    tester.TestConstructors(true);
}

[Test]
public void TestPersonConstructors()
{
    ConstructorTester tester = new ConstructorTester(typeof(Person));
    // we specify the signature of the constructor to be ignored
    tester.IgnoredConstructors.Add(typeof(string), typeof(ISomeInterface), typeof(object));
    tester.TestConstructors(true);
}

Testing whole assemblies

see AssemblyTester for more information

To help you test large numbers of classes at once there is even an assembly tester that will test all the properties and constructors, of all the classes.

[Test]
public void AssemblyTester_PassWithExclusions()
{
    AssemblyTester tester = new AssemblyTester("ExampleAssembly");
    // exclude a namespace from the test scope but not child namespaces
    tester.Exclusions.AddNamespace("ExampleAssembly.SomeNamespace", false);
    // first parameters says test properties, second parameter says test constructors
    tester.TestAssembly(true, true);
}

In this example we're going to test all the types within the ExampleAssembly (obviously, it uses the PropertyTester and ConstructorTester under the covers). We also specifically exclude the ExampleAssembly.SomeNamespace so any types belonging to that namespace won't be tested.

Remember kids! This is just a helper and isn't intended to remove the need to write unit tests. It's only there to cover the basic stuff that people don't normally test. If you exlude a namespace, type, property or constructor then you should consider adding a manual test.