Visual Studio Testing Extensions

Created Issue: Cannot see methods in Object Browser [7740]

robcube — Thu, 16 Feb 2012 22:13:51 GMT

Please expose them so they're a good reference point. Thanks!

Updated Wiki: AssertHelper

jeremiahclark — Tue, 07 Feb 2012 16:47:58 GMT

AssertHelper

These methods help with creating custom assertions.

AssertFailure

AssertFailure

Creates a custom AssertFailedException and provides information for the exception.

Usage

public static void AssertFailed(string assertionName, string message, params object[] parameters)

Supported Releases: 1.2 and later

Updated Wiki: AssertHelper

jeremiahclark — Tue, 07 Feb 2012 16:45:18 GMT

AssertHelper

These methods help with creating custom assertions.

AssertFailure

AssertFailure

Asserts that the Action should throw an exception.

Usage

Where TExceptionType is an Exception

public static TExceptionType ShouldThrowException<TExceptionType>(Action action) 
public static TExceptionType ShouldThrowException<TExceptionType>(Action action, string message) 
public static TExceptionType ShouldThrowException<TExceptionType>(Action action, string message, params object[] parameters)

Remarks

This method is contained in the Testing static class of the library.
Unlike the default Exception testing in Visual Studio, you can test multiple Exceptions within the same test method.

Example

[TestMethod]
public void Test()
{
   int zero = 0;
   Testing.ShouldThrowException<DivideByZeroException>( () => int x = 12 / zero );
}

[TestMethod]
public void Test()
{
   // Multiple expected exceptions can be tested in the same test method
   int zero = 0;
   Testing.ShouldThrowException<DivideByZeroException>( () => int x = 12 / zero );
   Testing.ShouldThrowException<InvalidCastException>( () => bool x = (bool)DateTime.Now );
}

Supported Releases: All

Updated Wiki: TypeAssertions

jeremiahclark — Tue, 07 Feb 2012 16:43:11 GMT

Type Assertions

These assertion extension methods can be applied to only Type object types.

ShouldBeAssignableFrom

ShouldBeAssignableFrom

Asserts that this type value is assignable from another type.

Usage

public static Type ShouldBeAssignableFrom(this Type source, Type comparer)
public static Type ShouldBeAssignableFrom(this Type source, Type comparer, string message)
public static Type ShouldBeAssignableFrom(this Type source, Type comparer, string message, params object[] parameters)
public static Type ShouldBeAssignableFrom<TComparer>(this Type source)
public static Type ShouldBeAssignableFrom<TComparer>((this Type source, string message)
public static Type ShouldBeAssignableFrom<TComparer>((this Type source, string message, params object[] parameters)

Example

[TestMethod]
public void Test()
{
   Type foo = typeof(ICollection);
   foo.ShouldBeAssignableFrom(IEnumerable);

   Type foo = typeof(IList);
   foo.ShouldBeAssignableFrom<IEnumerable>();
}

Supported Releases: 1.2 and later

Updated Wiki: TypeAssertions

jeremiahclark — Tue, 07 Feb 2012 16:42:29 GMT

Type Assertions

These assertion extension methods can be applied to only Type object types.

ShouldBeAssignableFrom

ShouldBeAssignableFrom

Asserts that this type value is assignable from another type.

Usage

public static Type ShouldBeAssignableFrom(this Type source, Type comparer)
public static Type ShouldBeAssignableFrom(this Type source, Type comparer, string message)
public static Type ShouldBeAssignableFrom(this Type source, Type comparer, string message, params object[] parameters)
public static Type ShouldBeAssignableFrom<TComparer>(this Type source)
public static Type ShouldBeAssignableFrom<TComparer>((this Type source, string message)
public static Type ShouldBeAssignableFrom<TComparer>((this Type source, string message, params object[] parameters)

Example

[TestMethod]
public void Test()
{
   Type foo = typeof(ICollection);
   foo.ShouldBeAssignableFrom(IEnumerable);

   Type foo = typeof(IList);
   foo.ShouldBeAssignableFrom<IEnumerable>();
}

Supported Releases: All

Updated Wiki: Documentation

jeremiahclark — Tue, 07 Feb 2012 16:37:24 GMT

Visual Studio Testing Extensions Documentation

This is the documentation for the Visual Studio Testing Extensions. As new versions are released, any changes, additions or deletions will be annotated in the documentation.

Introduction

Using the Testing Extensions

Types of Assertions

Source code checked in, #72226

jeremiahclark — Tue, 07 Feb 2012 15:56:15 GMT

Branched Main to Releases/1.2.0.0 to maintain the 1.2.0.0 release state

Updated Release: Visual Studio Testing Extensions 1.2 (Feb 07, 2012)

JeremiahClark — Tue, 07 Feb 2012 15:54:25 GMT

This is the release version (1.2.0.0) of the SoftwareApproach.TestingExtensions library that enables readable unit testing assertions in Visual Studio.

Released: Visual Studio Testing Extensions 1.2 (Feb 07, 2012)

Tue, 07 Feb 2012 15:54:25 GMT

This is the release version (1.2.0.0) of the SoftwareApproach.TestingExtensions library that enables readable unit testing assertions in Visual Studio.

Source code checked in, #72225

jeremiahclark — Tue, 07 Feb 2012 15:45:45 GMT

Updating version to 1.2.0.0 for release

Source code checked in, #72224

jeremiahclark — Tue, 07 Feb 2012 15:43:42 GMT

Added Type assertions to check for assignability

Source code checked in, #72223

jeremiahclark — Tue, 07 Feb 2012 15:20:51 GMT

Added AssertHelper.AssertFailed method to allow the creation of custom assertions.

Updated Wiki: Home

jeremiahclark — Tue, 26 Jul 2011 19:43:47 GMT

Project Description

The Visual Studio Testing Extensions is a library that exposes a set of extension methods to provide a way to write more readable unit tests in the Visual Studio Unit Testing environment. It is developed in C# 4.0 and requires the .NET 4.0 runtime.

Latest News

Now on NuGet: http://nuget.org/List/Packages/VisualStudioTestingExtensions

Documentation

Detailed documentation can be found here: Documentation

Summary

This project was created to add to the basic assertions that unit testing in Visual Studio (VS) provides. In VS, the way to do unit testing assertions is to write test code such as the following:

[TestMethod]
public void OldWay_Test()
{
   int number = 5;
   Assert.AreEqual(number, 5);
   Assert.IsTrue(number > 4);
   Assert.IsTrue(number > -1);
}

While this approach is sufficient for most cases, I was looking to provide a more readable way to write unit tests. This library contains a number or extension methods that allow you to perform assertions using the following syntax:

[TestMethod]
public void NewWay_Test()
{
   int number = 5;
   number.ShouldEqual(5);
   number.ShouldBeGreaterThan(4);
   number.ShouldBePositive();
}

Another feature of this library is the ability to chain assertions. Each assertion method returns the original source value, so the same test above can also be written the following way:

[TestMethod]
public void NewWay_Test()
{
   int number = 5;
   number.ShouldEqual(5) 
      .ShouldBeGreaterThan(4)
      .ShouldBePositive();
}

When an assertion fails, the failure notification is the same behavior that VS provides out of the box, displaying the assertion that caused the failure and the arguments associated with the assertion.

The other feature that this library provides is the ability to assert multiple expected exceptions in a single test method, rather than being limited to one expected exception like VS provides. You can provide the snippet to test for an exception via an Action() delegate. An example of this is shown below:

[TestMethod]
public void Testing_ExceptionsTest()
{
   int zero = 0;
   Testing.ShouldThrowException<DivideByZeroException>(() => { int y = 15 / zero; });
   Testing.ShouldThrowException<ArgumentNullException>(() => { throw new ArgumentNullException(); });
}

The source release for this project contains a complete suite of unit tests to validate the expected functionality that the library provides. In addition, the unit tests are a good example of the various extension methods that the library provides.

If you are interested in contributing to this project, please let me know.
There will also be more information on the project available here: http://blogs.msdn.com/miah
Feel free to ask me questions also on Twitter

New Post: Prefix suggestion

gblmarquez — Thu, 21 Jul 2011 23:28:11 GMT

xUnit library have less or no prefix in methods.

I like this way, it saves a lot of reduntante writing.

Maybe this can be a valid suggestion?

[]'s

New Post: On Nuget primary feed

gblmarquez — Thu, 21 Jul 2011 23:24:31 GMT

@JeremiahClark, NuGet Package is not available, you must submit it again.

Thanks for this projects.

Updated Wiki: Home

jeremiahclark — Tue, 22 Feb 2011 20:51:21 GMT

Project Description

Latest News

Now on NuGet: http://nuget.org/Packages/Packages/Details/VisualStudioTestingExtensions-1-1-0-0

Documentation

Detailed documentation can be found here: Documentation

Summary

This project was created to add to the basic assertions that unit testing in Visual Studio (VS) provides. In VS, the way to do unit testing assertions is to write test code such as the following:

[TestMethod]
public void OldWay_Test()
{
   int number = 5;
   Assert.AreEqual(number, 5);
   Assert.IsTrue(number > 4);
   Assert.IsTrue(number > -1);
}

[TestMethod]
public void NewWay_Test()
{
   int number = 5;
   number.ShouldEqual(5);
   number.ShouldBeGreaterThan(4);
   number.ShouldBePositive();
}

Another feature of this library is the ability to chain assertions. Each assertion method returns the original source value, so the same test above can also be written the following way:

[TestMethod]
public void NewWay_Test()
{
   int number = 5;
   number.ShouldEqual(5) 
      .ShouldBeGreaterThan(4)
      .ShouldBePositive();
}

[TestMethod]
public void Testing_ExceptionsTest()
{
   int zero = 0;
   Testing.ShouldThrowException<DivideByZeroException>(() => { int y = 15 / zero; });
   Testing.ShouldThrowException<ArgumentNullException>(() => { throw new ArgumentNullException(); });
}

New Post: On Nuget primary feed

JeremiahClark — Thu, 20 Jan 2011 19:38:47 GMT

Thanks for the suggestion. Version 1.1.0.0 is now on the NuGet feed!

Updated Wiki: Home

jeremiahclark — Thu, 20 Jan 2011 19:37:26 GMT

Project Description

Latest News

Now on NuGet: http://nuget.org/Packages/Packages/Details/Visual-Studio-Testing-Extensions-1-1-0-0

Documentation

Detailed documentation can be found here: Documentation

Summary

This project was created to add to the basic assertions that unit testing in Visual Studio (VS) provides. In VS, the way to do unit testing assertions is to write test code such as the following:

[TestMethod]
public void OldWay_Test()
{
   int number = 5;
   Assert.AreEqual(number, 5);
   Assert.IsTrue(number > 4);
   Assert.IsTrue(number > -1);
}

[TestMethod]
public void NewWay_Test()
{
   int number = 5;
   number.ShouldEqual(5);
   number.ShouldBeGreaterThan(4);
   number.ShouldBePositive();
}

Another feature of this library is the ability to chain assertions. Each assertion method returns the original source value, so the same test above can also be written the following way:

[TestMethod]
public void NewWay_Test()
{
   int number = 5;
   number.ShouldEqual(5) 
      .ShouldBeGreaterThan(4)
      .ShouldBePositive();
}

[TestMethod]
public void Testing_ExceptionsTest()
{
   int zero = 0;
   Testing.ShouldThrowException<DivideByZeroException>(() => { int y = 15 / zero; });
   Testing.ShouldThrowException<ArgumentNullException>(() => { throw new ArgumentNullException(); });
}

New Post: StackTrace

iainxt — Thu, 13 Jan 2011 02:31:40 GMT

I have modified the code to remove stack traces lines from SoftwareApproach.TestingExtensions. What do you think?

        internal static void HandleFail(string assertionName, string message, params object[] parameters)
        {
            var exp = new AssertFailedMinialStackTraceException(string.Format("{0} failed. {1}", assertionName, message));
            exp.StackTraceFilter = a => !a.Contains("SoftwareApproach.TestingExtensions.");
            throw exp;
        }

And the Exception

public class AssertFailedMinialStackTraceException : AssertFailedException
    {
        public AssertFailedMinialStackTraceException(string msg, Exception ex)
            : base(msg, ex)
        {
        }

        public AssertFailedMinialStackTraceException(string msg)
            : base(msg)
        {
        }

        public AssertFailedMinialStackTraceException()
        {
        }

        protected AssertFailedMinialStackTraceException(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
        }

        public Func<String, bool> StackTraceFilter { get; set; }
        private string filteredStackTrace;
        public override string StackTrace
        {
            get
            {
                if (filteredStackTrace != null)
                    return filteredStackTrace;
                var before = base.StackTrace;
                var parts = before.Split('\n');
                var filtered = parts
                    .Where(a => !string.IsNullOrEmpty(a))
                    .Where(StackTraceFilter);
                var after = String.Join("\r\n", filtered.ToArray());
                filteredStackTrace = after;
                return filteredStackTrace;
            }
        }
    }

New Post: Feature Solicitation

iainxt — Thu, 13 Jan 2011 02:27:53 GMT

+1 for IEnumerable.

And its not that hard, just change ICollection to IEnumerable, and use Count(). It worked for me :o)