Integration test stages in Jenkins - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a Jenkins stage named 'Integration Test'.

Jenkins

stage('[1]') {
    steps {
        echo 'Running integration tests'
    }
}

Drag options to blanks, or click blank then click option'

ABuild

BIntegration Test

CDeploy

DTest

Attempts:

3 left

💡 Hint

Common Mistakes

Using a generic stage name like 'Test' instead of 'Integration Test'.

Misspelling the stage name.

The stage name should be 'Integration Test' to clearly indicate the integration testing phase.

2fill in blank

medium

Complete the code to run the integration test script using a shell command.

Jenkins

stage('Integration Test') {
    steps {
        sh '[1]'
    }
}

Drag options to blanks, or click blank then click option'

A./run_integration_tests.sh

Brun_tests.sh

Cintegration_test.py

Dnpm test

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting './' which may cause the script not to be found.

Using a Python or npm command instead of the shell script.

The shell command should execute the integration test script with the correct relative path './run_integration_tests.sh'.

3fill in blank

hard

Fix the error in the Jenkins pipeline snippet to correctly archive the test results.

Jenkins

stage('Integration Test') {
    steps {
        archiveArtifacts [1]
    }
}

Drag options to blanks, or click blank then click option'

A'test-results/*.xml'

B**/test-results/*.xml

C'**/test-results/*.xml'

Dtest-results/*.xml

Attempts:

3 left

💡 Hint

Common Mistakes

Not quoting the pattern string causing syntax errors.

Using a pattern without '**/' which misses nested files.

The pattern must be a quoted string with the correct glob pattern '**/test-results/*.xml' to archive all XML test result files recursively.

4fill in blank

hard

Fill both blanks to define a post action that always runs to clean the workspace after integration tests.

Jenkins

stage('Integration Test') {
    steps {
        sh './run_integration_tests.sh'
    }
    post {
        [1] {
            [2] {
                cleanWs()
            }
        }
    }
}

Drag options to blanks, or click blank then click option'

Aalways

Bsuccess

Cscript

Dfailure

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'success' or 'failure' which only run conditionally.

Omitting 'script' causing syntax errors.

The 'always' block ensures the cleanup runs regardless of test success or failure, and 'script' allows running the Groovy script 'cleanWs()'.

5fill in blank

hard

Fill all three blanks to define a Jenkins pipeline stage that runs integration tests, archives results, and cleans workspace on failure.

Jenkins

stage('[1]') {
    steps {
        sh '[2]'
    }
    post {
        failure {
            [3] {
                cleanWs()
            }
        }
        success {
            archiveArtifacts '**/test-results/*.xml'
        }
    }
}

Drag options to blanks, or click blank then click option'

AIntegration Test

B./run_integration_tests.sh

Cscript

Dalways

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'always' instead of 'failure' for cleanup.

Not quoting the stage name.

Omitting './' in the shell command.

The stage name is 'Integration Test', the shell command runs the integration test script, and 'script' is used to run the Groovy cleanup command on failure.

Practice

1. What is the main purpose of an integration test stage in a Jenkins pipeline?

easy

A. To check if different parts of the software work together correctly

B. To deploy the software to production

C. To compile the source code

D. To clean up temporary files after deployment

Solution

1. Step 1: Understand the role of integration tests

   Integration tests verify that different modules or components of software interact correctly.

2. Step 2: Identify the stage purpose in Jenkins

   In Jenkins pipelines, integration test stages run after building the code but before deployment to ensure combined parts work well.

3. Final Answer:

   To check if different parts of the software work together correctly -> Option A

4. Quick Check:

   Integration test purpose = verify combined parts work [OK]

Hint: Integration tests check combined parts, not deployment or build [OK]

Common Mistakes:

• Confusing integration tests with deployment steps
• Thinking integration tests compile code
• Assuming integration tests clean files

2. Which of the following is the correct syntax to define an integration test stage in a Jenkins declarative pipeline?

easy

A. stage: 'Integration Test' steps: sh 'run-tests.sh'

B. integrationTest { steps { sh 'run-tests.sh' } }

C. stage('Integration Test') { steps { sh 'run-tests.sh' } }

D. testStage('Integration Test') { shell 'run-tests.sh' }

Solution

1. Step 1: Recall Jenkins declarative pipeline stage syntax

   The correct syntax uses stage('Name') { steps { ... } } to define stages.

2. Step 2: Match the options to syntax

   stage('Integration Test') { steps { sh 'run-tests.sh' } } matches the correct syntax with stage('Integration Test') { steps { sh 'run-tests.sh' } }.

3. Final Answer:

   stage('Integration Test') { steps { sh 'run-tests.sh' } } -> Option C

4. Quick Check:

   Jenkins stage syntax = stage('name') { steps { ... } } [OK]

Hint: Jenkins stages use stage('name') { steps { ... } } syntax [OK]

Common Mistakes:

• Using incorrect keywords like integrationTest or testStage
• Missing curly braces or wrong colon usage
• Using shell instead of sh for shell commands

3. Given this Jenkins pipeline snippet, what will be the output if the integration tests fail?

pipeline {
  agent any
  stages {
    stage('Build') {
      steps { echo 'Building...' }
    }
    stage('Integration Test') {
      steps { sh 'exit 1' }
    }
    stage('Deploy') {
      steps { echo 'Deploying...' }
    }
  }
}

medium

A. The pipeline retries Integration Test automatically

B. The pipeline continues to Deploy stage despite failure

C. The pipeline skips Build and runs Deploy only

D. The pipeline stops after the Integration Test stage with failure

Solution

1. Step 1: Understand shell command exit codes in Jenkins

   The command sh 'exit 1' simulates a failure because exit code 1 means error.

2. Step 2: Jenkins pipeline behavior on failure

   By default, Jenkins stops the pipeline on any stage failure and does not proceed to next stages.

3. Final Answer:

   The pipeline stops after the Integration Test stage with failure -> Option D

4. Quick Check:

   Failure exit code stops pipeline [OK]

Hint: Exit code 1 in sh step causes pipeline failure and stop [OK]

Common Mistakes:

• Assuming pipeline continues after failure
• Thinking Jenkins retries failed stages automatically
• Confusing exit 0 (success) with exit 1 (failure)

4. You wrote this Jenkins pipeline stage for integration tests:

stage('Integration Test') {
  steps {
    sh 'run-integration-tests.sh'
  }
}

But the pipeline fails with a syntax error. What is the likely cause?

medium

A. Missing steps block inside the stage

B. The pipeline is missing the pipeline block wrapper

C. Incorrect indentation of the sh command

D. The stage keyword is misspelled

Solution

1. Step 1: Check Jenkins declarative pipeline structure

   Every declarative pipeline must start with a pipeline { ... } block wrapping all stages.

2. Step 2: Identify missing pipeline block

   The snippet shows only a stage block without the required pipeline wrapper, causing syntax error.

3. Final Answer:

   The pipeline is missing the pipeline block wrapper -> Option B

4. Quick Check:

   Declarative pipelines need pipeline { stages { ... } } [OK]

Hint: Always wrap stages inside pipeline { } block [OK]

Common Mistakes:

• Assuming indentation causes syntax error
• Forgetting the pipeline block wrapper
• Misspelling stage keyword (not shown here)

5. You want to add an integration test stage that runs only if the build stage succeeds and skips deployment if tests fail. Which Jenkins pipeline snippet correctly implements this logic?

medium

A. stage('Integration Test') {
steps {
sh 'run-tests.sh'
}
}
stage('Deploy') {
steps {
sh 'deploy.sh'
}
}

B. stage('Integration Test') {
steps {
sh 'run-tests.sh'
}
post {
failure { error 'Tests failed, stop pipeline' }
}
}
stage('Deploy') {
steps {
sh 'deploy.sh'
}
}

C. stage('Integration Test') {
steps {
sh 'run-tests.sh || true'
}
}
stage('Deploy') {
steps {
sh 'deploy.sh'
}
}

D. stage('Integration Test') {
steps {
sh 'run-tests.sh'
}
}
stage('Deploy') {
when {
expression { currentBuild.result == null || currentBuild.result == 'SUCCESS' }
}
steps {
sh 'deploy.sh'
}
}

Solution

1. Step 1: Ensure integration tests run after build and affect deployment

   The integration test stage runs normally after build; deployment should only happen if tests pass.

2. Step 2: Identify the correct sequential stage implementation

   In Jenkins pipelines, stages run sequentially by default. A failure in 'Integration Test' (non-zero exit from sh) causes the pipeline to fail and skip the 'Deploy' stage. stage('Integration Test') { steps { sh 'run-tests.sh' } } stage('Deploy') { steps { sh 'deploy.sh' } } correctly implements this logic.

3. Final Answer:

   stage('Integration Test') { steps { sh 'run-tests.sh' } } stage('Deploy') { steps { sh 'deploy.sh' } } -> Option A

4. Quick Check:

   Sequential stage failure skips subsequent stages [OK]

Hint: Default sequential execution stops pipeline on test failure, skipping deploy [OK]

Common Mistakes:

• Ignoring test failure and always deploying
• Using post failure to stop pipeline but not gating deploy
• Forcing tests to pass with || true, hiding failures