UNIT TESTINGUsing Visual Studio 2010

By Karen Gayda

Creating the Test Project

The test project is created by selecting “New Project” from the File Menu.

Expand Visual C# from the tree view on the left-hand side of the dialog.

Select “Test” from the list of options. In the center pane, select “Test Project”. Give the project a name and add it to

your application’s solution.

Creating the Test Project

The Test Project

Contains special classes designated by the [TestClass] attribute which are intended to run groups of tests.

Generally speaking, each class in the application project will have a corresponding class in the unit test project.

Some classes, such as UI classes, may not be tested by the Unit Test class for UI interactivity. This is tested with a macro-style test class type called a Coded UI Test.

Non-UI methods/properties of a UI class can still be tested with a standard Unit Test class.

The Test Project

Must have at least one test class in project.

Project may have test data files for use by the unit tests.

Project may have utility/helper classes for common functionality used by test classes and test methods.

Project may use configuration files to setup state or provide environment information to the tests.

The Test Project

Structure of a Unit Test Class

Microsoft.VisualStudio.TestTools.UnitTesting namespace: The namespace has many classes to help you with your

unit tests including: Assert classes that you can use to verify conditions in unit

tests Initialization and cleanup attributes to run code before or

after unit tests run to ensure a specific beginning and ending state

The ExpectedException attribute to verify that a certain type of exception is thrown during unit test execution

The TestContext class which stores information that is provided to unit tests such as data connection for data-driven tests and information that is required to run unit tests for ASP.NET Web Services

Structure of a Unit Test Class

TestClass attribute: When you create a unit test, the TestClass

attribute is included in the test file to indicate that this particular class may contain methods marked with the [TestMethod()] attribute. Without the TestClass attribute, the test methods are ignored.

A test class can inherit methods from another test class that is in the same assembly. This means that you can create test methods in a base test class and then use those methods in derived test classes.

Structure of a Unit Test Class

TestContext - When you create unit tests, a class private variable called testContextInstance is included for each test class. It is of type TestContext.

The properties of the TestContext class store information about the currently running test class.

Structure of a Unit Test Class

Unit Test Class Special Methods

ClassInitialize method Designated by the [ClassInitialize()] attribute. Used to setup anything needed by all the test

methods that will be run in the class. Examples of this would be to create test databases, to create tables, to copy test files, etc.

Takes TestContext variable as parameter. One class initialization method per unit test

class.

Unit Test Class Special Methods

Unit Test Class Special Methods

ClassCleanUp method Designated by the [ClassCleanUp()] attribute. Used to cleanup artifacts of the test class for

the test run. Usually used to delete data, files, tables or

databases created by the class. One class cleanup method per test class.

Unit Test Class Special Methods

Unit Test Class Special Methods

TestInitialize method Designated by the [TestInitialize()] attribut.e Method that runs before the execution of

every test in the class. Used to manage resources shared by the test

methods in the class. Used to setup test environment to an

initialized/known state prior to a test executing.

One test initialize method per unit test class.

Unit Test Class Special Methods

TestCleanUp method Designated by the [TestCleanUp()] attribute Method runs after the execution of every test

method in the unit test class. Used to return the test environment to a

known state or clean up the artifacts created by a test.

One test clean up method per unit test class.

Test Methods

Designated by the [TestMethod] attribute. 1 – n test methods per Unit Test class. 1 method per major application

requirement. 1 method per public

property/method/web method as well (in most cases).

A test method should test a single requirement only.

A test method should be atomic.

Test Methods

IMPORTANT: Test methods must run independently of one another!!!

Test methods can run in any order, therefore their operation cannot rely on state set by other test methods.

Test methods expecting any state or environment setup should always have that set by ClassInitialze or TestInitialize.

It is not recommended that any state be setup in the test method itself. Avoid doing so whenever possible.

Test Methods

Test method names should clearly indicate the purpose of the test.

For tests that test a public property/class method/web method, use the name with the word Test appended. An example of this would be “ConnectionStringTest”.

For tests that test a specific requirement, use a clear requirement descriptor with the word Test appended to the end. An example of this would be “AllFilesProcessedTest”.

Test Methods

Test Methods

Test Methods

Tests are deterministic. For a given environment state and known input

value(s), an expected result is the outcome of an assertion.

Hard-coded, expected values are normal/acceptable. Use the Assert class to check for various expected

conditions/state such as equality, inequality, Boolean value, etc.

Use the ExpectedException attribute of the test method to insure that a specific exception is thrown if the application should throw it for expected errors.

If anyAssert method fails within a test, the test result will indicate failure.

Unhandled exceptions are treated as failures

Test Methods

Test methods can have information about resources they should use passed to them via attributes.

The [DeploymentItem] attribute is used to specify deployment items such as a file or a directory to be used by a specific test.

The [DeploymentItem] can also be applied to an entire test class.

There can be multiple deployment items specified for a method or class.

The [TestProperty] attribute is used to pass general name/value pair data to a test.

Test methods can have multiple test property attributes specified.

Test Method Comments

Best practice to have a good comment header for each test method to clearly indicate what is being tested.

Should include the following:Purpose: Short description of aspect of application

being tested.Prerequisites: Assumptions being made before test can

run such as a database with certain data exists and is accessible to the test project.

Test Data: Data being used and list of possible values or ranges.

Steps: List of steps in test.Remarks: Any pertinent information about test not

covered elsewhere but important to note.

Creating Unit Tests

Usually created manually in test class by developer.

Skeleton tests can be generated by Visual Studio for existing code.

Generated tests can be created only for properties/methods in existing code classes or interfaces.

Tests for specific requirements must be coded manually.

Creating Unit Tests

There are several ways to add tests to a test project.

To add a standard unit test class to your project, go to the “Test” main menu option of the VS 2010 IDE and select “New Test”

Select the “Unit Test” item from the dialog box. (The other test types available in VS 2010 are not covered in this presentation).

Give your test class a descriptive name and click OK.

Creating Unit Tests

Creating Unit Tests

Creating Unit Tests

To add your own unit tests to class, add public void, parameterless methods decorated with the test method attribute.

Any method decorated with the [TestMethod] attribute is considered a test by the unit testing framework if it is contained within a test class.

Uncomment the initialize/cleanup methods in the region “Additional Test Attributes” if you wish to use and customize them for your test class.

Creating Unit Tests

To generate tests from existing code, use the Unit Test Wizard.

From the “Test” main menu option of the VS 2010 IDE, select “New Test”.

Select the “Unit Test Wizard” option. Select your unit test project from

dropdown list. Click OK to run the wizard.

Creating Unit Tests

Creating Unit Tests

Expand the namespaces for your application assembly in the tree view on the wizard.

Expand the classes in the tree view to view the individual proprties/methods of the classes.

Select the classes and/or methods for which you would like to generate unit tests.

Click the settings button if you would like to modify the default code generation settings.

Click the Add Assembly button if you want to generate tests from an additional assembly.

Click OK to generate skeleton tests.

Creating Unit Tests

Creating Unit Tests

Additional tests are easily added to existing test class from application project.

Right-clicking from within your application class method gives context menu option to “Create unit test”.

Wizard automatically selects current method in application (where cursor is positioned) and chooses the same target class in the test project as existing test methods for application class.

Running Unit Tests

The Test List Editor window is the easiest way to manually run tests from the Visual Studio 2010 IDE.

They can also be run from the command line in an automated fashion, from the Microsoft Test Manager application (both not covered in this presentation), from the Test Results window of the VS2010 IDE and from the Test View window of the VS 2010 IDE.

Running Unit Tests

From the “Test” main menu option of the VS 2010 IDE, select “Windows”

Choose the “Test List Editor” option The test list editor window gives you the

ability to group, run and debug your tests and then view the results of the test run’s execution.

Running Unit Tests

Running Unit Tests

Test results are displayed in the Test Results window.

This window is automatically displayed by the Test List Editor when your test run completes

All tests have a green “Passed” icon by them if the tests executed correctly

Any test with a red “Failed” icon should be debugged to determine the reason for failure.

Running Unit Tests

Running Unit Tests

Test result window displays a summary of all of the test results.

Clicking an individual result in the results grid will open the results detail window and display more detailed information about the outcome of the selected test.

Test Result Detail window provides detail error information if a test fails.

Running Unit Tests

Running Unit Tests

Each test run creates a log of the results of the test run execution.

Visual Studio will save the last 25 test runs by default.

Different test runs can be viewed in the Test Results window.

Test Results window will load most recent run by default.

Select run name from dropdown at top of test results window to view other than most recent test run.

Regression Testing

Unit tests help with regression testing so that you may determine if new requirements/code changes have broken existing functionality in the code.

The VS 2010 test framework includes a feature called Test Impact Analysis which helps to streamline regression testing.

You can use Test Impact Analysis to record a baseline after initial unit test development.

From then on, Test Impact Analysis will keep track of what tests need to be run after code changes to insure proper regression testing without running all of the tests.

Summary

Visual Studio 2010 testing framework makes it easy to create and run unit tests for your Visual Studio 2010 projects.

Good unit tests must follow industry standard best practices.

Visual Studio does not impose any restrictions on what you put in your test.

It is incumbent on the unit test creator to write good tests.

References

http://msdn.microsoft.com/en-us/library/dd264975.aspx

http://msdn.microsoft.com/en-us/library/ms182409

http://blog.stevensanderson.com/2009/08/24/writing-great-unit-tests-best-and-worst-practises/

http://en.wikipedia.org/wiki/Unit_testing

References

http://www.softwaretestingstuff.com/2010/09/unit-testing-best-practices-techniques.html

http://www.amazon.com/dp/0321146530/?tag=stackoverfl08-20

http://msdn.microsoft.com/en-us/magazine/cc163665.aspx

http://www.codeproject.com/Articles/10870/New-Version-Of-Rhino-Mocks

References

http://weblogs.asp.net/adilakhter/archive/2008/05/04/more-on-unit-testing-testcontext.aspx

http://www.c-sharpcorner.com/uploadfile/dommym/a-test-driven-development-tutorial-in-C-Sharp-4-0/

http://msdn.microsoft.com/en-us/vstudio/ff718185.aspx

http://www.simple-talk.com/sql/t-sql-programming/close-these-loopholes---reproduce-database-errors/