Add capability for more complicated mocks

CHANGELOG.md

@@ -20,6 +20,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - Update output file name to explicitly specify `submodules`
 - Update documentation action to use tags and 'development' versions
 - Improved GitHub links in documentation links for tagged versions
+- Add dynamic mocks to Nextflow regression tests
 
 ### Fixed
 - No longer fail on missing `gh-pages` branch

run-nextflow-tests/README.md

@@ -31,6 +31,49 @@ Any methods that access files outside of the repository must be listed in `mocks
   }
 ```
 
+### Dynamic Mocks
+
+In very specific circumstances a mock function that returns a static value is insufficient - for example, a pipeline that requires paired input BAMs might check that they have separate sample IDs. That means that this mock...
+
+```json
+  "mocks": {
+    "parse_bam_header": {
+      "read_group": [
+        {
+          "SM": "495723"
+        }
+      ]
+    }
+  }
+```
+
+... would return the same sample ID for each input BAM and thus fail.
+
+To solve this, a dynamic mock like the following may be used:
+
+```json
+  "mocks": {
+    "DYNAMIC|parse_bam_header": {
+      "[\"/hot/software/pipeline/pipeline-SQC-DNA/Nextflow/development/test-input/HG002.N-n2.bam\"]": {
+        "read_group": [
+          {
+            "SM": "098765"
+          }
+        ]
+      },
+      "[\"/hot/software/pipeline/pipeline-SQC-DNA/Nextflow/development/test-input/S2.T-n2.bam\"]": {
+        "read_group": [
+          {
+            "SM": "52345245"
+          }
+        ]
+      }
+    }
+  }
+```
+
+Dynamic mocks have their method name prefixed with `DYNAMIC|`. Their values are maps with JSONified function arguments for keys and static return values as values. Note that the function arguments are always presented as a list, even for a single argument.
+
 ## Usage
 
 ### Workflow File

run-nextflow-tests/betterconfig.groovy

@@ -1,6 +1,7 @@
 import java.nio.file.Paths
 
 import groovy.json.JsonSlurper
+import groovy.json.JsonOutput
 import groovy.lang.Closure
 import groovy.lang.ProxyMetaClass
 import groovy.util.ConfigObject
@@ -22,12 +23,27 @@ class UserInterceptor implements Interceptor {
 
     boolean invokeMethod = true
     Map mocks
+    Map dynamic_mocks = [:]
 
     UserInterceptor(String mock_file) {
         def jsonSlurper = new JsonSlurper()
 
         this.mocks = jsonSlurper.parse(new File(mock_file))
         assert this.mocks instanceof Map
+
+        // Decode the "dynamic" mocks
+        def dynamic_pattern = /^DYNAMIC\|(?<name>.*)/
+
+        this.mocks.each { key, value ->
+            def match = key =~ dynamic_pattern
+            if (match) {
+                assert value instanceof Map
+
+                // Remove it from the plain mocks
+                this.mocks.remove(key)
+                this.dynamic_mocks[match.group("name")] = value
+            }
+        }
     }
 
     boolean doInvoke() {
@@ -38,8 +54,14 @@ class UserInterceptor implements Interceptor {
         if (mocks.containsKey(name)) {
             invokeMethod = false
             return mocks[name]
+        } else if (dynamic_mocks.containsKey(name)) {
+            def args_str = JsonOutput.toJson(args)
+            if (dynamic_mocks[name].containsKey(args_str)) {
+                invokeMethod = false
+                return dynamic_mocks[name][args_str]
+            }
+            throw new Exception("Dynamic mock $name does not contain $args_str")
         }
-
     }
 
     Object afterInvoke(Object obj, String name, Object[] args, Object result) {