What Happens When Compilation or Unit Tests Fail in Azure Pipelines?

1. What Happens?

In Azure DevOps, when compilation or unit tests fail, the corresponding pipeline step fails and the pipeline normally stops executing subsequent dependent steps.

This prevents incorrect or untested application code from being deployed to SIT, UAT, or Production.

Main purpose:

• Detect compilation errors early.

• Identify failed unit tests.

• Prevent defective builds from being deployed.

• Notify developers about pipeline failures.

• Maintain application quality and stability.

2. How Does It Work?

Developer Pushes Code
          |
          v
    Azure CI Pipeline
          |
          v
     dotnet restore
          |
          v
      dotnet build
          |
          +---- FAILED
          |       |
          |       v
          |   Pipeline Failed
          |   Deployment Blocked
          |
          v
      dotnet test
          |
          +---- FAILED
          |       |
          |       v
          |   Pipeline Failed
          |   Deployment Blocked
          |
          v
     dotnet publish
          |
          v
    Publish Artifact
          |
          v
     CD Deployment

Important: By default, Azure Pipelines runs subsequent steps only when previous steps have succeeded. A failed build or test normally prevents artifact generation and deployment.

3. Compilation Failure

Compilation failure occurs when dotnet build cannot compile the application.

Common reasons:

• C# syntax errors.

• Missing project references.

• Incorrect method signatures.

• Type conversion errors.

• Missing NuGet dependencies.

Example:

public int Add(int a, int b)
{
    return a + name; // Compilation error
}

Pipeline command:

- script: dotnet build MyApplication.sln --configuration Release
  displayName: 'Build Application'

Example output:

error CS0103:
The name 'name' does not exist
in the current context.

Build FAILED.

0 Warning(s)
1 Error(s)

Result: The build task fails, the pipeline run is marked failed, and subsequent publish and deployment steps are skipped under the default conditions.

4. Unit Test Failure

Unit test failure occurs when the application compiles successfully but one or more automated tests fail.

Example:

[Fact]
public void Add_ShouldReturnCorrectResult()
{
    int result = calculator.Add(10, 20);

    Assert.Equal(30, result);
}

Suppose the Add() method incorrectly returns 25.

Pipeline command:

- script: >
    dotnet test tests/MyApp.Tests/MyApp.Tests.csproj
    --configuration Release
    --no-build
  displayName: 'Run Unit Tests'

Example output:

Total Tests: 50
Passed:      48
Failed:       2
Skipped:      0

Test Run Failed.

Result: The test step fails, the pipeline normally stops, and artifact publishing is skipped.

5. How Do You Handle Pipeline Failures?

Example: Fixing a failed pipeline

Pipeline Failed
      |
      v
Developer Checks Logs
      |
      v
Identifies Compilation/Test Error
      |
      v
Fixes Code Locally
      |
      v
Runs dotnet build / dotnet test
      |
      v
Commits and Pushes Fix
      |
      v
Pipeline Runs Again
      |
      v
Build + Tests Passed
      |
      v
Artifact Published

6. Important YAML Conditions

Azure Pipelines supports conditions that control whether a step, job, or stage executes.

Example:

steps:

- script: dotnet build MyApplication.sln
  displayName: 'Build'

- script: dotnet test MyApplication.sln --no-build
  displayName: 'Unit Tests'
  condition: succeeded()

- script: echo "Build or Test Failed"
  displayName: 'Failure Message'
  condition: failed()

- script: echo "Pipeline execution completed"
  displayName: 'Final Message'
  condition: always()

Important: continueOnError: true can allow execution to continue after a failed task, but it should not normally be used to bypass compilation or mandatory unit-test failures.

7. Important Interview Questions

Q1. What happens when dotnet build fails?

The build step fails, subsequent dependent steps are normally skipped, and deployment is blocked.

Q2. What happens when unit tests fail?

dotnet test normally returns a nonzero exit code, causing the test step to fail. Artifact publishing and deployment are normally skipped.

Q3. Can we execute a task even after a pipeline failure?

Yes. We can use condition: failed() or condition: always() for tasks such as publishing test reports or collecting diagnostic logs.

Q4. How do developers identify pipeline failures?

By reviewing Azure DevOps pipeline logs, compilation errors, test results, and diagnostic reports.

Q5. Can Azure Pipelines send notifications when a build fails?

Yes. Azure DevOps supports notifications for build failures, which can be delivered through configured notification subscriptions and integrations.

Q6. Can a failed pipeline be rerun?

Yes. Developers can rerun a pipeline or push corrected code to trigger a new run. Rerunning without fixing a deterministic code error will generally fail again.

8. Interview-Ready Answer

In Azure DevOps, if compilation or unit tests fail, the corresponding pipeline task fails and the pipeline normally stops executing subsequent dependent steps.

For example, if dotnet build fails due to a compilation error, the unit tests and publishing steps are skipped. Similarly, if dotnet test fails, the artifact is normally not published and deployment is blocked.

Developers can review pipeline logs and test results to identify the problem, fix the code, and push the changes to trigger the pipeline again.

We can also configure notifications and use conditions such as failed() or always() to execute diagnostic or reporting tasks even when the pipeline fails.

Key point to remember:

Build Failed → Pipeline Failed → Deployment Blocked

Test Failed  → Pipeline Failed → Deployment Blocked

Build + Tests Passed → Artifact → Deployment

This behavior applies to the standard pipeline configuration. Custom conditions and error-handling settings can change which steps continue after a failure.