Using Test Plans in Azure DevOps for Dynamics

In any Dynamics 365 project, quality assurance is a cornerstone of successful deployments and stable environments. With frequent updates, customizations, and integrations, it’s crucial to have a structured and traceable approach to testing. Azure DevOps Test Plans provides a robust testing platform that integrates seamlessly with Dynamics 365 projects, making it easier to manage manual, automated, and exploratory testing processes.

This guide will walk you through what Azure DevOps Test Plans are, how they can be used effectively in Dynamics 365 implementations, and best practices for integrating them into your development lifecycle.

What are Azure DevOps Test Plans?

Azure Test Plans is a service within Azure DevOps that provides a comprehensive solution for managing test cases, executing manual and exploratory tests, and integrating with automated testing frameworks. It enables testers, developers, and project managers to collaborate within a centralized platform to ensure the delivery of high-quality software.

Key components include:

Test Plans: Collections of test suites.
Test Suites: Logical groups of test cases (static, requirement-based, or query-based).
Test Cases: Individual test scenarios that define inputs, expected results, and steps.
Test Runs: Executions of test cases for specific builds or releases.

Why Use Azure Test Plans with Dynamics 365?

Dynamics 365, especially with Power Platform, introduces complexities such as:

Business rules and workflows
Custom plugins and JavaScript
Third-party integrations
Frequent Microsoft platform updates

Azure Test Plans helps manage and streamline testing across all these areas.

Benefits include:

Centralized Test Management
Traceability between Requirements and Test Cases
Manual and Automated Testing Support
Integration with CI/CD pipelines
Role-Based Access Control and Auditing

Setting Up Azure Test Plans for Dynamics Projects

Step 1: Create a Project in Azure DevOps

Navigate to dev.azure.com
Create a new project (e.g., “CRM Implementation”)
Enable the Test Plans service

Step 2: Define Work Items (Requirements or User Stories)

Use Epics, Features, and User Stories to map your Dynamics 365 requirements.

Example:

Epic: Implement Lead Management
- User Story: As a sales user, I want to qualify a lead to an opportunity.

Step 3: Create a Test Plan

Go to Test Plans → New Test Plan
Give it a name like “UAT – Release 1.0”
Assign it to the relevant iteration/sprint

Step 4: Create Test Suites

You can use:

Static suites: Manual grouping of related test cases
Requirement-based suites: Linked to user stories or features
Query-based suites: Based on work item queries

Step 5: Author Test Cases

Each test case includes:

Title (e.g., “Qualify a Lead”)
Test Steps (Step, Action, Expected Result)
Priority, Assigned To, Tags, and Automation Status

Executing Manual Tests

Manual testing is still essential in many Dynamics 365 projects, especially during UAT and functional testing.

To run a manual test:

Navigate to a test plan and open a test suite
Click on a test case
Click Run for Web Application
Mark each step as Passed, Failed, or Blocked
Attach screenshots, notes, or file evidence
Log bugs directly from failed steps

Pros of Manual Testing in Azure DevOps:

Step-by-step traceability
Bug tracking linked to test runs
Reusability of test cases across plans
Reporting on test coverage and outcomes

Integrating Automated Tests (e.g., EasyRepro)

For Dynamics 365 projects that utilize automation tools like EasyRepro, you can integrate these into your DevOps pipeline.

Steps:

Author automated tests in C# (e.g., using MSTest or NUnit)
Set the test case’s Automation Status in Azure DevOps to “Automated”
Link it to a test case using Test Case ID or Azure Test Runner
Configure your CI/CD pipeline in Azure DevOps to run the tests and publish results

Example pipeline task:

- task: VSTest@2
  inputs:
    testSelector: 'testAssemblies'
    testAssemblyVer2: '**\*Tests.dll'
    searchFolder: '$(Build.SourcesDirectory)'

Benefits of Automated Testing:

Faster regression testing
Reliable and repeatable results
Integrated reporting with DevOps dashboards

Exploratory Testing

Exploratory testing is useful when testing Dynamics UI or validating scenarios that aren’t fully scripted.

Open Test Plans > Exploratory Testing
Launch the browser-based test recorder
Interact with Dynamics 365 manually
Take notes, file bugs, and capture screenshots
Save the session for later review

When to Use:

Testing new features
Validating user experience
Discovering edge cases

Reporting and Analytics

Azure Test Plans provides detailed analytics on:

Test case status
Pass/fail rates
Test run durations
Bug trends

Use built-in widgets or create dashboards with:

Test Results Trend
Test Plan Progress
Test Case Readiness

These are particularly helpful in Dynamics projects during:

UAT
Go-live readiness assessments
Post-deployment reviews

🔄 Regression Testing After Deployment

After deploying solutions to higher environments (e.g., UAT, Production), regression testing ensures stability.

How Test Plans helps:

Reuse existing test cases from past sprints
Execute tests on new builds
Track defects tied to builds
Ensure all critical business processes (e.g., Opportunity flow, Case Resolution) still work

Tip: Maintain a regression test suite and update it after every sprint.

Test Case Traceability & Audit

One of the strongest features of Azure Test Plans is its traceability:

Link test cases to user stories
Link bugs to test runs
View requirements coverage in Test Plans

This is useful for:

Regulatory audits (e.g., in healthcare or finance industries)
ISO/ITIL-compliant testing processes
Ensuring all requirements are validated before go-live

Use Case: Dynamics 365 Sales Deployment

Scenario:

You’re deploying a new Sales Process in Dynamics 365, including custom plugins, business process flows, and UI changes.

Test Plan Structure:

Suite Type	Example
Static Suite	“Lead Qualification”
Requirement-based	Linked to “Qualify Lead to Opportunity” story
Test Case Example	“Verify BPF stage movement from New to Qualified”
Exploratory Session	UI feedback from end users

All test results are documented, bugs filed, and automation linked to test cases where applicable.

Best Practices

Start early: Define test cases during the development phase
Use requirement-based suites: Maintains traceability with stories
Automate what’s stable: Automate repetitive and regression-prone scenarios
Review test results regularly: Use dashboards and widgets for insights
Tag test cases: By module (e.g., “Leads”, “Opportunities”), test type, or risk level

Common Pitfalls

Duplicate test cases: Reuse across plans instead of rewriting
Not maintaining test cases: Update them with UI or logic changes
Lack of test ownership: Assign test cases to owners for accountability
Over-reliance on manual testing: Balance with automation for scalability

Security & Access

Azure DevOps provides fine-grained access control:

Only testers can edit test steps
Project admins can manage test plans
Developers can view and run test cases

You can also integrate with Azure Active Directory to manage access across environments securely.