Simplifying Unit Testing in Visual Studio: A Guide to Running Tests in Different Folders and Projects

Unit testing is an essential aspect of modern software development, ensuring that individual components work as intended before integrating them into a larger system. In environments like Visual Studio, it’s common to create separate projects for unit tests and integration tests. This structure can complicate the running of tests, especially when you want to quickly execute tests in specific folders or projects. In this post, we’ll walk through a solution for running your unit tests based on your project’s folder structure, making the process more efficient with the help of keyboard shortcuts and macros.

The Challenge

Many developers structure their Visual Studio solutions with distinct projects for unit tests and integration tests. This creates a need for a clear strategy to manage test executions, such as:

• Running unit tests frequently.
• Executing integration tests only in specific contexts.

Your goal might be to configure keyboard shortcuts to run tests in various projects without having to navigate through menus every time. For example, you’d want to achieve something like:

• Alt+1: Runs tests in the BLL.Test project.
• Alt+2: Runs tests in the DAL.Tests project.
• Alt+3: Runs all tests in the [Tests] folder.
• Alt+4: Runs tests in the [Tests.Integration] folder.

Fortunately, there is a way to streamline this process in Visual Studio.

A Practical Solution Using Macros

You can create a macro in Visual Studio that allows you to run tests in specific projects or folders with a simple keyboard command. Here’s how to set it up:

Step-by-Step Instructions to Create a Macro

1. Open Visual Studio: Launch your Visual Studio environment.

2. Create a Temporary Macro:

   • Navigate to the menu: Tools > Macros > Record TemporaryMacro.
   • This will start recording your actions.

3. Select Your Test Folder:

   • In the Solution Explorer, select the [Tests] folder (or your desired test folder).

4. Run the Tests:

   • Execute the command for running tests using ReSharper: ReSharper.UnitTest.ContextRun.

5. Stop Recording:

   • Once done, navigate back to Tools > Macros and stop the recording.

6. Edit the Macro:

   • You can find your recorded macro under Tools > Macros > MyMacros.
   • Modify it to fit your needs (you’ll find the code to run your specific test folder).

Example of a Recorded Macro

Here’s a sample macro code that you can adjust for your specific project structure:

Sub TemporaryMacro()
    DTE.Windows.Item(Constants.vsWindowKindSolutionExplorer).Activate
    DTE.ActiveWindow.Object.GetItem("TestUnitTest\Tests").Select(vsUISelectionType.vsUISelectionTypeSelect)
    DTE.ExecuteCommand("ReSharper.UnitTest_ContextRun")
End Sub

7. Bind the Macro to a Keyboard Shortcut:
   • Go to Tools > Options > Environment > Keyboard.
   • Find your macro in the list and assign a keyboard shortcut to it.

A More Generalized Approach with Configuration Files

While the above method provides a solid solution for running tests, it can be even better if you consider a more scalable approach. Imagine being able to configure which projects, folders, or classes to run via an XML file. This can:

• Facilitate version control.
• Ensure that everyone in your team follows the same test execution process.

Benefits of Using XML Configuration

• Consistency: All developers can share the same configurations.
• Flexibility: Easily modify test targets without altering code.
• Simplicity: Non-developers on your team can add or modify test settings without needing to engage in VS IDE.

In conclusion, by utilizing macros within Visual Studio and potentially incorporating configuration files, you can significantly enhance your development workflow. This system not only saves time but also ensures that your team can manage test executions effortlessly. Now, with the ability to run specific tests using just a keyboard shortcut, you can focus more on writing code and less on navigating through your IDE.