
Unit Testing in Visual Studio 2019
Course Length: 2 days
Delivery Methods:
Available as private class only
Course Overview
This two-day Unit Testing in Visual Studio 2019 training class provides students with the knowledge and skills to effectively use Visual Studio 2019 to design, write, and run high-quality .NET unit tests. The course focuses on the applicable features and capabilities of Visual Studio as it relates to unit testing and Test-Driven Development. This course
also introduces other popular unit testing tools and techniques, and demonstrates how they integrate with Visual
Studio and your team’s development lifecycle.
Course Benefits
- Why unit tests are critical to software quality
- How unit tests and integration tests differ
- Popular .NET unit testing frameworks
- Popular JavaScript unit testing frameworks
- MSTest V2 improvements and capabilities
- The anatomy of a unit test
- The 3A pattern (Arrange, Act, Assert)
- Using Assert, StringAssert, and CollectionAssert
- Testing for expected exceptions
- Test class inheritance
- Why and how to test internal APIs
- MSTest, NUnit, and xUnit test projects
- Unit testing .NET Core projects
- Using Test Explorer to manage your tests
- Organizing tests using traits and playlists
- Running unit tests in parallel
- In-Assembly Parallel (IAP) execution
- Parallelism by assembly, class, and method
- Running tests and managing test results
- Viewing, grouping, and filter tests and results
- Creating and using a .runsettings file
- Continuous testing in Visual Studio
- Test-Driven Development (TDD) as a design practice
- Why write your tests first
- Practicing TDD within Visual Studio
- How to effectively refactor within TDD
- How to effectively refactor legacy code
- Practices for writing good unit tests
- Happy path vs. sad path testing
- Testing boundary conditions (Right-BICEP)
- Organizing tests and test assemblies
- Test naming conventions (e.g. BDD)
- Why and how to analyze code coverage
- Using code coverage as a metric
- Parameterized (data-driven) unit tests
- Concurrent testing using Live Unit Tests
- Concurrent testing using NCrunch (3rd party)
- Testing difficult code with the use of doubles
- Using dummies, fakes, stubs, and mocks
- Using Microsoft Fakes to test difficult code
- Using Rhino Mocks to test difficult code
- Using NSubstitute to test difficult code
- Generating MSTest unit tests with IntelliTest
- Generating NUnit unit tests with IntelliTest
Course Outline
- Unit Testing in .NET
- What is (and isn’t) a unit test
- Why write unit tests
- .NET unit testing frameworks
- MSTest V2, NUnit, xUnit
- The anatomy of a unit test
- Writing and running your first unit test
- Unit Testing in Visual Studio
- Testing support in Visual Studio
- MSTest, NUnit, and xUnit test projects
- Test Explorer and other windows
- Writing and running unit tests in Visual Studio
- Managing a large number of tests and test results
- Organizing tests by grouping, filtering, and playlists
- Continuous testing in Visual Studio
- Test-Driven Development (TDD)
- TDD overview and benefits
- Practicing TDD within Visual Studio
- Effectively refactoring code
- Working with legacy code
- Using CodeLens to support TDD and refactoring
- Writing Good Unit Tests
- Analyzing code coverage
- Using code coverage as a metric
- Parameterized (data-driven) unit tests
- DataRow, DynamicData, and DataSource attributes
- Concurrent testing using Live Unit Testing
- Concurrent testing using NCrunch
- Testing Difficult Code
- The need to isolate code under test
- Doubles (dummies, stubs, fakes, and mocks)
- Microsoft Fakes framework (stubs and shims)
- Comparing mocking frameworks
- Using Rhino Mocks and NSubstitute frameworks
- Profiling slow running unit tests
- Using IntelliTest with legacy code
Class Materials
Each student will receive a comprehensive set of materials, including course notes and all the class examples.
Class Prerequisites
Experience in the following is required for this ASP.NET class:
- Experience or familiarity with the C# language.
- Experience or familiarity with Visual Studio 2015, 2017, or 2019.
- Experience or familiarity with writing, debugging, and maintaining code.
- Experience or familiarity with Application Lifecycle Management basics.
- Experience or familiarity with your organization’s development lifecycle.
- Experience or familiarity with building a high-quality software product.
Request a Private Class
- Private Class for your Team
- Online or On-location
- Customizable
- Expert Instructors