Groovy methods in pipelines in Jenkins - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a simple Groovy method in a Jenkins pipeline.

Jenkins

def greet() {
    echo [1] 
}

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

Aprintln "Hello, Jenkins!"

BHello, Jenkins!

C"Hello, Jenkins!"

Decho "Hello, Jenkins!"

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting quotes around the string

Using println instead of echo in Jenkins pipeline

The echo step requires a string argument. The string must be quoted.

2fill in blank

medium

Complete the code to call the method greet inside the pipeline script.

Jenkins

pipeline {
    agent any
    stages {
        stage('Say Hello') {
            steps {
                [1]()
            }
        }
    }
}

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

Aecho

Bprint

CsayHello

Dgreet

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different method name

Forgetting parentheses when calling the method

The method defined is named greet, so calling greet() runs it.

3fill in blank

hard

Fix the error in the method definition to accept a parameter name and print a greeting.

Jenkins

def greet([1]) {
    echo "Hello, ${name}!"
}

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

AString name

Bname String

Cdef name

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Reversing parameter type and name

Omitting the type when required

Groovy method parameters need the type before the name, like String name.

4fill in blank

hard

Fill both blanks to define a method that returns the length of a string parameter.

Jenkins

def getLength([1]) {
    return [2].length()
}

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

AString text

Btext

CString name

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Using a parameter name that doesn't match inside the method

Forgetting to specify the parameter type

The method parameter is String text, and we call text.length() to get its length.

5fill in blank

hard

Fill all three blanks to create a method that filters a list of strings, returning only those longer than 3 characters.

Jenkins

def filterLong([1]) {
    return [2].findAll { it [3] 3 }
}

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

AList<String> words

Bwords

C.length() >

D.size() >

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong parameter type

Using size() instead of length() on strings

Mismatching parameter name inside the method

The method takes a list of strings named words. We use findAll to keep items where it.length() > 3.

Practice

1. What is the correct way to define a reusable method in a Jenkins pipeline using Groovy?

easy

A. Use def methodName() { } inside a script block

B. Use function methodName() { } outside the pipeline

C. Use method methodName() { } inside steps

D. Use def methodName[] { } inside environment

Solution

1. Step 1: Understand Groovy method syntax in Jenkins

   Groovy methods are defined with def methodName() { } syntax inside script blocks in Jenkins pipelines.

2. Step 2: Identify correct placement

   Methods must be inside script blocks to be recognized and used in declarative pipelines.

3. Final Answer:

   Use def methodName() { } inside a script block -> Option A

4. Quick Check:

   Groovy method = def methodName() { } [OK]

Hint: Remember: def + methodName() inside script block [OK]

Common Mistakes:

• Using 'function' keyword instead of 'def'
• Defining methods outside script blocks
• Using incorrect syntax like square brackets
• Placing methods inside environment block

2. Which of the following is the correct syntax to call a Groovy method named buildApp with a parameter version inside a Jenkins pipeline?

easy

A. buildApp version

B. buildApp->version

C. call buildApp(version)

D. buildApp(version)

Solution

1. Step 1: Recall method call syntax in Groovy

   Groovy methods are called with parentheses enclosing parameters, like methodName(param).

2. Step 2: Match the correct option

   buildApp(version) uses buildApp(version), which is the correct way to call the method with a parameter.

3. Final Answer:

   buildApp(version) -> Option D

4. Quick Check:

   Method call with parentheses = buildApp(version) [OK]

Hint: Call methods with parentheses around parameters [OK]

Common Mistakes:

• Calling method without parentheses
• Using 'call' keyword unnecessarily
• Using arrow syntax which is invalid
• Passing parameters without parentheses

3. Given the following Jenkins pipeline snippet, what will be printed in the console?

pipeline {
  agent any
  stages {
    stage('Test') {
      steps {
        script {
          def greet(name) {
            return "Hello, ${name}!"
          }
          echo greet('Alice')
        }
      }
    }
  }
}

medium

A. Error: Method not found

B. Hello, Alice!

C. Hello, ${name}!

D. greet(Alice)

Solution

1. Step 1: Understand method definition and call

   The method greet takes a parameter name and returns a string with the name inserted.

2. Step 2: Evaluate the method call inside echo

   Calling greet('Alice') returns "Hello, Alice!" which is printed by echo.

3. Final Answer:

   Hello, Alice! -> Option B

4. Quick Check:

   Method returns greeting string = Hello, Alice! [OK]

Hint: Method returns string with parameter replaced [OK]

Common Mistakes:

• Expecting literal ${name} instead of substituted value
• Thinking method call prints method name
• Assuming method is undefined causing error
• Confusing method call syntax

4. Identify the error in this Jenkins pipeline Groovy method usage:

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        script {
          def compile() {
            echo 'Compiling...'
          }
          compile
        }
      }
    }
  }
}

medium

A. Method compile is called without parentheses causing no execution

B. Method compile is not defined properly with def

C. echo cannot be used inside methods

D. script block cannot contain method definitions

Solution

1. Step 1: Check method call syntax

   The method compile is defined correctly but called without parentheses, so it is treated as a reference, not executed.

2. Step 2: Understand Groovy method invocation

   To execute the method, parentheses are required: compile().

3. Final Answer:

   Method compile is called without parentheses causing no execution -> Option A

4. Quick Check:

   Call methods with () to execute [OK]

Hint: Always add () when calling methods to run them [OK]

Common Mistakes:

• Calling method without parentheses
• Thinking def is missing for method
• Assuming echo can't be inside methods
• Believing script block forbids method definitions

5. You want to create a Groovy method in a Jenkins pipeline that takes a list of strings and returns a single string with all items joined by commas. Which method implementation is correct?

hard

A. def joinList(items) { return items + "," }

B. def joinList(items) { items.join }

C. def joinList(items) { return items.join(",") }

D. def joinList(items) { items.collect { it + "," } }

Solution

1. Step 1: Understand Groovy list joining

   The join method on a list combines elements into a string separated by the given delimiter.

2. Step 2: Check method correctness

   def joinList(items) { return items.join(",") } correctly returns items.join(",") which joins list items with commas.

3. Final Answer:

   def joinList(items) { return items.join(",") } -> Option C

4. Quick Check:

   Use list.join(",") to combine items [OK]

Hint: Use list.join(",") to join list elements into string [OK]

Common Mistakes:

• Forgetting to return the joined string
• Using + operator which concatenates incorrectly
• Using collect which returns a list, not string
• Omitting parentheses in join method