Unable to mock a method from the script

[obrejla]

Hi!
Let's say I have a whatever.groovy script like this:

#!groovy
def call() {
    echo 'Some steps...'
    foo('bar')
}

def foo(param) {
    echo param
}

And what I want to do is to mock the foo method and check, whether it was called or not when call() method was called. I.e. testfile looks like this:

class WhateverTest extends BasePipelineTest {

    def whatever

    @Before
    void setUp() {
        super.setUp()
        whatever = loadScript('vars/whatever.groovy')
    }

    @Test
    void testFooCalled() throws Exception {
        // here somehow mock a `foo` method...following obviously does not work:
        helper.registerAllowedMethod('foo', [String.class], null)

        whatever()
        
        // here somehow check that it was called...following does not work:
        assertTrue(helper.callStack.findAll { call ->
            call.methodName == 'foo'
        }.any { call ->
            callArgsToString(call).contains('bar')
        })
    }
}

I also tried to incorporate Mockito, but no success in this case.

Am I doing something wrong? Or is there a bug?

Thanks...I'm desperate ;)

[brianeray]

Try dumping the helper.callStack, looking at each methodName. I may be mis-remembering, but I'm wondering if you have to register whatever.foo instead of just plain old foo.

I've wrestled registerAllowedMethod() in weird edge cases too many times ...

[obrejla]

Thanks, I tried that approach earlier, but unfortunately, there is neither foo nor whatever.foo in the call stack... It just seems that those inner methods are skipped.

[obrejla]

Any other suggestions, plz?

[obrejla]

Hm...this seems to be working

import static org.mockito.Mockito.mock
import static org.mockito.Mockito.times
import static org.mockito.Mockito.verify

...

@Test
void testFooCalled() throws Exception {
    def fooMock = mock(Function)
    whatever.metaClass.foo = fooMock.&apply

    whatever()
        
    verify(fooMock, times(1)).apply('bar')
}

and also stubbing should work like this

import static org.mockito.Mockito.when

...

def fooStub = mock(Function)
whatever.metaClass.foo = fooStub.&apply
when(whatever.foo('bar')).thenReturn('some return vaue')

[dlovera]

Hi @obrejla, I came across the same issue.
I could not use the workaround you provided in my context, it looks like it does work only if the script provides an entry point method (such as a call method or execute), however my scripts look like this:

package scripts

node() {
    customMethod()
}

def customMethod() {
    echo 'executing custom method closure'
}

I've submitted a PR to allow registerAllowedMethod to mock any method from script (not limited to jenkins related methods).
Hope this helps !

I guess another/better way to solve this may be found with #61

[marshallford]

I'm still running into this issue... anyone else?

[dlovera]

Hi @marshallford

I can confirm this is fixed with current 1.2-SNAPSHOT, I've checked against the provided example in this issue (slightly modified):

#!groovy
def call() {
	echo 'Some steps...'
	foo('bar')
}

def foo(param) {
	echo param
}

import com.lesfurets.jenkins.unit.BasePipelineTest
import org.junit.Before
import org.junit.Test
import static org.assertj.core.api.Assertions.assertThat


class WhateverTest extends BasePipelineTest {

	def whatever

	@Before
	void setUp() {
		super.setUp()
	}

	@Test
	void testFooCalled() throws Exception {

		int fooCallCounter = 0

		helper.registerAllowedMethod('foo', [Object], { String str -> fooCallCounter++ })

		whatever = loadScript('vars/whatever.groovy')
		whatever()

		// verify foo was called once
		assertThat(fooCallCounter).is(1)
	}
}

I guess we'll have to wait for the 1.2 milestone.

In the meantime, what I did was to use the patched version of the loadScript method which does the trick.

In our context we rely on Spock framework for tests and use this class which delegates calls to BasePipelineTest.

import com.lesfurets.jenkins.unit.BasePipelineTest
import com.lesfurets.jenkins.unit.MethodSignature
import spock.lang.Specification

/**
 * Allow to use spock framework with pipeline unit
 * Delegate all calls to BasePipelineTest class from pipeline unit
 */
class BasePipelineSpec extends Specification {

    /**
     * Delegate to the base pipeline test
     */
    @Delegate
    BasePipelineTest basePipelineTest

    /**
     * Initialize setup using pipeline unit base pipeline test
     */
    def setup() {
        basePipelineTest = new BasePipelineTest() {
            // nothing to override from BasePipelineTest
        }
        basePipelineTest.setUp()
    }

    /**
     * Load the script with name and empty binding, returning the Script
     *
     * Replace script method closure with any matching allowed method closure
     * to allow custom method mocks from pipelineunit specs
     *
     *
     * @param scriptName the script's pathname
     * @return Script object
     */
    Script loadScript(String scriptName) {
        // delegate script loading to the base pipeline test helper
        Script script = helper.loadScript(scriptName, this.binding)

        // find and replace script method closure with any matching allowed method closure
        script.metaClass.methods.forEach { scriptMethod ->
            Map.Entry<MethodSignature, Closure> matchingAllowedMethod = helper.allowedMethodCallbacks.find { methodSignature, closure ->
                def scriptMethodArgsToString = scriptMethod.parameterTypes*.cachedClass.join(', ')
                methodSignature.name == scriptMethod.name && methodSignature.argsToString() == scriptMethodArgsToString
            }
            if (matchingAllowedMethod) {
                // a matching method was registered, replace script method execution call with the registered closure (mock)
                script.metaClass."$scriptMethod.name" = matchingAllowedMethod.value
            }
        }
        script
    }
}