Merge pull request jenkinsci#8 from lesfurets/feature_global_lib

Test scripts with Pipeline Shared Libraries

README.md

@@ -221,6 +221,91 @@ This will work fine for such a project structure:
              └── TestExampleJob.groovy
 ```
 
+## Testing Shared Libraries
+
+With [Shared Libraries](https://jenkins.io/doc/book/pipeline/shared-libraries/) Jenkins lets you share common code 
+on pipelines across different repositories of your organization.
+Shared libraries are configured via a settings interface in Jenkins and imported 
+with `@Library` annotation in your scripts.
+
+Testing pipeline scripts using external libraries is not trivial because the shared library code 
+is checked in another repository.
+JenkinsPipelineUnit lets you test shared libraries and pipelines depending on these libraries.
+
+Here is an example pipeline using a shared library:
+
+```groovy
+@Library('commons')
+import net.courtanet.jenkins.Utils
+
+sayHello 'World'
+
+node() {
+    stage ('Checkout') {
+        def utils = new Utils()
+        checkout "${utils.gitTools()}"
+    }
+    stage ('Build') {
+        sh './gradlew build'
+    }
+    stage ('Post Build') {
+        String json = libraryResource 'net/courtanet/jenkins/request.json'
+        sh "curl -H 'Content-Type: application/json' -X POST -d '$json' ${acme.url}"
+    }
+}
+```
+
+This pipeline is using a shared library called `commons`.
+Now lets test it:
+
+```groovy
+    String clonePath = 'path/to/clone'
+
+    def library = library()
+                    .name('commons')
+                    .retriever(gitSource('git@gitlab.admin.courtanet.net:devteam/lesfurets-jenkins-shared.git'))
+                    .targetPath(clonePath)
+                    .defaultVersion("master")
+                    .allowOverride(true)
+                    .implicit(false)
+                    .build()
+    helper.registerSharedLibrary(library)
+    
+    loadScript("job/library/exampleJob.jenkins")
+    printCallStack()
+```
+
+Notice how we defined the shared library and registered it to the helper.
+Library definition is done via a fluent API which lets you set the same configurations as in 
+[Jenkins Global Pipeline Libraries](https://jenkins.io/doc/book/pipeline/shared-libraries/#using-libraries).
+
+The `retriever` and `targetPath` fields tell the framework how to fetch the sources of the library, in which local path.
+The framework comes with two naive but useful retrievers, `gitSource` and `localSource`.
+You can write your own retriever by implementing the `SourceRetriever` interface.
+
+Note that properties `defaultVersion`, `allowOverride` and `implicit` are optional with 
+default values `master`, `true` and `false`.
+
+Now if we execute this test, the framework will fetch the sources from the Git repository and 
+load classes, scripts, global variables and resources found in the library.
+The callstack of this execution will look like the following:
+
+```text
+Loading shared library commons with version master
+libraryJob.run()
+  libraryJob.sayHello(World)
+  sayHello.echo(Hello, World.)
+  libraryJob.node(groovy.lang.Closure)
+     libraryJob.stage(Checkout, groovy.lang.Closure)
+        Utils.gitTools()
+        libraryJob.checkout({branch=master})
+     libraryJob.stage(Build, groovy.lang.Closure)
+        libraryJob.sh(./gradlew build)
+     libraryJob.stage(Post Build, groovy.lang.Closure)
+        libraryJob.libraryResource(net/courtanet/jenkins/request.json)
+        libraryJob.sh(curl -H 'Content-Type: application/json' -X POST -d '{"name" : "Ben"}' http://acme.com)
+```
+
 ## Note on CPS
 
 If you already fiddled with Jenkins pipeline DSL, you experienced strange errors during execution on Jenkins.

build.gradle

@@ -22,9 +22,12 @@ archivesBaseName = "jenkins-pipeline-unit"
 version = "0.12-SNAPSHOT"
 
 dependencies {
-    compile group: 'org.codehaus.groovy',   name: 'groovy-all',     version: '2.4.6'
-    compile group: 'com.cloudbees',         name: 'groovy-cps',     version: '1.11'
-    compile group: 'org.assertj',           name: 'assertj-core',   version: '3.4.1'
+    compile     group: 'org.codehaus.groovy',   name: 'groovy-all',     version: '2.4.6'
+    compile     group: 'com.cloudbees',         name: 'groovy-cps',     version: '1.12'
+    compile     group: 'commons-io',            name: 'commons-io',     version: '2.5'
+    compile     group: 'org.apache.ivy',        name: 'ivy',            version: '2.4.0'
+    compileOnly group: 'org.assertj',           name: 'assertj-core',   version: '3.4.1'
+    testCompile group: 'org.assertj',           name: 'assertj-core',   version: '3.4.1'
     testCompile group: 'junit',                 name: 'junit',          version: '4.11'
 }
 
@@ -37,14 +40,6 @@ if (project.hasProperty('extProps')) {
     }
 }
 
-sourceSets {
-    main {
-        resources {
-            srcDirs = ['src/main/jenkins']
-            include '**/*.jenkins'
-        }
-    }
-}
 
 task javadocJar(type: Jar) {
     classifier = 'javadoc'

src/main/groovy/com/lesfurets/jenkins/unit/BasePipelineTest.groovy

@@ -16,6 +16,8 @@ abstract class BasePipelineTest {
 
     Binding binding = new Binding()
 
+    ClassLoader baseClassLoader = this.class.classLoader
+
     def stringInterceptor = { m -> m.variable }
 
     def withCredentialsInterceptor = { list, closure ->
@@ -31,15 +33,16 @@ abstract class BasePipelineTest {
 
     BasePipelineTest() {
         helper = new PipelineTestHelper()
-        helper.setScriptRoots scriptRoots
-        helper.setScriptExtension scriptExtension
-        helper.setBaseClassloader this.class.classLoader
-        helper.setImports imports
-        helper.setBaseScriptRoot baseScriptRoot
     }
 
     void setUp() throws Exception {
+        helper.setScriptRoots scriptRoots
+        helper.setScriptExtension scriptExtension
+        helper.setBaseClassloader baseClassLoader
+        helper.imports += imports
+        helper.setBaseScriptRoot baseScriptRoot
         helper.build()
+
         helper.registerAllowedMethod("stage", [String.class, Closure.class], null)
         helper.registerAllowedMethod("stage", [String.class, Closure.class], null)
         helper.registerAllowedMethod("node", [String.class, Closure.class], null)
@@ -75,7 +78,7 @@ abstract class BasePipelineTest {
      * Can be useful when mocking a jenkins method.
      * @param status job status to set
      */
-    void updateBuildStatus(String status){
+    void updateBuildStatus(String status) {
         binding.getVariable('currentBuild').result = status
     }
 

src/main/groovy/com/lesfurets/jenkins/unit/InterceptingGCL.groovy

@@ -0,0 +1,26 @@
+package com.lesfurets.jenkins.unit
+
+import org.codehaus.groovy.control.CompilationFailedException
+import org.codehaus.groovy.control.CompilerConfiguration
+
+class InterceptingGCL extends GroovyClassLoader {
+
+    PipelineTestHelper helper
+
+    InterceptingGCL(PipelineTestHelper helper,
+                    ClassLoader loader,
+                    CompilerConfiguration config) {
+        super(loader, config)
+        this.helper = helper
+    }
+
+    @Override
+    Class parseClass(GroovyCodeSource codeSource, boolean shouldCacheSource)
+                    throws CompilationFailedException {
+        Class clazz = super.parseClass(codeSource, shouldCacheSource)
+        clazz.metaClass.invokeMethod = helper.getMethodInterceptor()
+        clazz.metaClass.static.invokeMethod = helper.getMethodInterceptor()
+        clazz.metaClass.methodMissing = helper.getMethodMissingInterceptor()
+        return clazz
+    }
+}

src/main/groovy/com/lesfurets/jenkins/unit/MethodCall.groovy

@@ -4,6 +4,9 @@ import static com.lesfurets.jenkins.unit.MethodSignature.method
 
 import org.codehaus.groovy.runtime.MetaClassHelper
 
+import groovy.transform.CompileStatic
+
+@CompileStatic
 class MethodCall {
 
     Object target
@@ -70,7 +73,9 @@ class MethodCall {
 
     @Override
     String toString() {
-        return "${'   ' * (stackDepth)}${target.class.simpleName}.$methodName(${argsToString()})"
+        return "${'   ' * (stackDepth)}" +
+                        "${target instanceof Class ? target.simpleName : target.class.simpleName}." +
+                        "$methodName(${argsToString()})"
     }
 
     boolean equals(o) {

src/main/groovy/com/lesfurets/jenkins/unit/MethodSignature.groovy

@@ -2,6 +2,9 @@ package com.lesfurets.jenkins.unit
 
 import static org.codehaus.groovy.runtime.MetaClassHelper.isAssignableFrom
 
+import groovy.transform.CompileStatic
+
+@CompileStatic
 class MethodSignature {
     String name
     Class[] args
@@ -16,7 +19,7 @@ class MethodSignature {
     }
 
     String argsToString() {
-        return args.collect {
+        return args.collect { Class it ->
             if (it != null && Closure.isAssignableFrom(it)) {
                 Closure.class.toString()
             } else {

src/main/groovy/com/lesfurets/jenkins/unit/MockPipelineScript.groovy

@@ -1,32 +1,8 @@
 package com.lesfurets.jenkins.unit
 
+/**
+ * This class seems useless now
+ */
 abstract class MockPipelineScript extends Script {
 
-    def methodMissing(String name, args) {
-        if (this._TEST_HELPER.isMethodAllowed(name, args)) {
-            def result = null
-            if (args != null) {
-                for (argument in args) {
-                    result = callIfClosure(argument, result)
-                    if (argument instanceof Map) {
-                        argument.each { k, v ->
-                            result = callIfClosure(k, result)
-                            result = callIfClosure(v, result)
-                        }
-                    }
-                }
-            }
-            return result
-        } else {
-            throw new MissingMethodException(name, this.class, args)
-        }
-    }
-
-    def callIfClosure(Object closure, Object currentResult) {
-        if (closure instanceof Closure) {
-            currentResult = closure.call()
-        }
-        return currentResult
-    }
-
 }