Data Driven Testing

example/data-driven-example.nf.test

@@ -0,0 +1,111 @@
+nextflow_process {
+
+    name "Test process SAY_HELLO with Spock-style data-driven testing"
+    script "example/say-hello.nf"
+    process "SAY_HELLO"
+
+    // Spock-style data table testing
+    testEach("Test with name=#name and number=#number") {
+        when {
+            process {
+                """
+                input[0] = "$name"
+                input[1] = Channel.of($number)
+                """
+            }
+        }
+
+        then {
+            assert process.success
+            assert process.out.my_tuples.size() == expectedSize
+            assert process.out.my_tuples[0][0] == number
+            assert process.out.my_tuples[0][1] == name
+        }
+
+        where("""
+        name      | number | expectedSize
+        "alice"   | 1      | 1
+        "bob"     | 2      | 1  
+        "charlie" | 3      | 1
+        """)
+    }
+
+    // Spock-style data pipes testing
+    testEach("Data pipes test #name-#number") {
+        when {
+            process {
+                """
+                input[0] = "$name"
+                input[1] = Channel.of($number)
+                """
+            }
+        }
+
+        then {
+            if (shouldFail) {
+                assert process.failed
+            } else {
+                assert process.success
+                assert process.out.my_tuples[0][1] == name
+            }
+        }
+
+        where("""
+        name << ["", "valid-name", "special!@#", "normal"]
+        number << [1, 2, 3, 4]
+        shouldFail << [true, false, true, false]
+        """)
+    }
+
+    // Mixed data pipes and assignments
+    testEach("Complex test #name with #result") {
+        when {
+            process {
+                """
+                input[0] = "$name"
+                input[1] = Channel.of($number)
+                """
+            }
+        }
+
+        then {
+            assert process.success
+            assert process.out.my_tuples[0][0] == number
+            assert result.contains(name)
+        }
+
+        where("""
+        name << ["test1", "test2", "test3"]
+        number << [10, 20, 30]
+        result = name + "-" + number
+        """)
+    }
+
+    // Alternative: Data table with || separator (like Spock)
+    testEach("Edge cases #input || #expected") {
+        when {
+            process {
+                """
+                input[0] = "$input"
+                input[1] = Channel.of(1)
+                """
+            }
+        }
+
+        then {
+            if (expected) {
+                assert process.success
+            } else {
+                assert process.failed
+            }
+        }
+
+        where("""
+        input           || expected
+        "valid"         || true
+        ""              || false
+        "special!@#"    || false
+        "normal-name"   || true
+        """)
+    }
+}

example/data-table-test.nf.test

@@ -0,0 +1,31 @@
+nextflow_process {
+
+    name "Data table syntax test"
+    script "example/say-hello.nf"
+    process "SAY_HELLO"
+
+    // Test the pipe-separated data table syntax
+    testEach("Table test with #name and #number") {
+        when {
+            process {
+                """
+                input[0] = "$name"
+                input[1] = Channel.of($number)
+                """
+            }
+        }
+
+        then {
+            assert process.success
+            assert process.out.my_tuples[0][1] == name
+            assert process.out.my_tuples[0][0] == number
+        }
+
+        where("""
+        name      | number
+        "alice"   | 1
+        "bob"     | 2
+        "charlie" | 3
+        """)
+    }
+}

example/double-pipe-test.nf.test

@@ -0,0 +1,35 @@
+nextflow_process {
+
+    name "Double pipe syntax test"
+    script "example/say-hello.nf"
+    process "SAY_HELLO"
+
+    // Test the double pipe separator syntax (input || expected)
+    testEach("Test #name || should be #expected") {
+        when {
+            process {
+                """
+                input[0] = "$name"
+                input[1] = Channel.of(1)
+                """
+            }
+        }
+
+        then {
+            if (expected) {
+                assert process.success
+                assert process.out.my_tuples[0][1] == name
+            } else {
+                // For this test, all should succeed, but this shows the pattern
+                assert process.success
+            }
+        }
+
+        where("""
+        name        || expected
+        "alice"     || true
+        "bob"       || true
+        "charlie"   || true
+        """)
+    }
+}

example/mixed-syntax-test.nf.test

@@ -0,0 +1,31 @@
+nextflow_process {
+
+    name "Mixed syntax test"
+    script "example/say-hello.nf"
+    process "SAY_HELLO"
+
+    // Test mixed data pipes and computed assignments
+    testEach("Test #name with result=#result") {
+        when {
+            process {
+                """
+                input[0] = "$name"
+                input[1] = Channel.of($number)
+                """
+            }
+        }
+
+        then {
+            assert process.success
+            assert process.out.my_tuples[0][1] == name
+            assert process.out.my_tuples[0][0] == number
+            assert result == name + "-" + number
+        }
+
+        where("""
+        name << ["test1", "test2", "test3"]
+        number << [10, 20, 30]
+        result = name + "-" + number
+        """)
+    }
+}

example/simple-data-driven.nf.test

@@ -0,0 +1,27 @@
+nextflow_process {
+
+    name "Simple data-driven test"
+    script "example/say-hello.nf"
+    process "SAY_HELLO"
+
+    // Basic data table test
+    testEach("Simple test with #name") {
+        when {
+            process {
+                """
+                input[0] = "$name"
+                input[1] = Channel.of(1)
+                """
+            }
+        }
+
+        then {
+            assert process.success
+            assert process.out.my_tuples[0][1] == name
+        }
+
+        where("""
+        name << ["alice", "bob"]
+        """)
+    }
+}

src/main/java/com/askimed/nf/test/core/AbstractTest.java

@@ -8,6 +8,11 @@
 import com.askimed.nf.test.util.HashUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import java.math.BigInteger;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.HashMap;
+import java.util.Map;
 
 import com.askimed.nf.test.config.Config;
 import com.askimed.nf.test.util.FileUtil;
@@ -63,6 +68,9 @@ public abstract class AbstractTest implements ITest {
 	private boolean updateSnapshot = false;
 
 	private boolean ciMode = false;
+	private Map<String, Object> parameters = new HashMap<String, Object>();
+
+	public AbstractTest() {
 
 	private boolean debug = false;
 
@@ -261,4 +269,12 @@ public String toString() {
 		return getHash().substring(0, 8) + ": " + getName();
 	}
 
+	public void setParameters(Map<String, Object> parameters) {
+		this.parameters = parameters;
+	}
+
+	public Map<String, Object> getParameters() {
+		return parameters;
+	}
+
 }

src/main/java/com/askimed/nf/test/core/ITest.java

@@ -1,6 +1,7 @@
 package com.askimed.nf.test.core;
 
 import java.io.File;
+import java.util.Map;
 
 import com.askimed.nf.test.config.Config;
 
@@ -38,4 +39,8 @@ public interface ITest extends ITaggable {
 
 	public boolean isCIMode();
 
+	public void setParameters(Map<String, Object> parameters);
+
+	public Map<String, Object> getParameters();
+
 }

src/main/java/com/askimed/nf/test/lang/DataDrivenTest.java

@@ -0,0 +1,81 @@
+package com.askimed.nf.test.lang;
+
+import com.askimed.nf.test.core.ITestSuite;
+import com.askimed.nf.test.lang.DataTableParser.DataTable;
+
+import groovy.lang.Closure;
+
+public class DataDrivenTest {
+
+    private ITestSuite testSuite;
+    private DataTable dataTable;
+    private Closure setupClosure;
+    private Closure whenClosure;
+    private Closure thenClosure;
+    private Closure cleanupClosure;
+
+    public DataDrivenTest(ITestSuite testSuite) {
+        this.testSuite = testSuite;
+    }
+
+    public void setup(Closure closure) {
+        this.setupClosure = closure;
+    }
+
+    public void when(Closure closure) {
+        this.whenClosure = closure;
+    }
+
+    public void then(Closure closure) {
+        this.thenClosure = closure;
+    }
+
+    public void cleanup(Closure closure) {
+        this.cleanupClosure = closure;
+    }
+
+    /**
+     * Parse the where block using Spock-style syntax supporting:
+     * 1. Data tables: a | b || c
+     * 2. Data pipes: a << [1,2,3]
+     * 3. Variable assignments: c = a + b
+     */
+    public void where(String whereBlockText) {
+        this.dataTable = DataTableParser.parseWhereBlock(whereBlockText);
+    }
+
+    /**
+     * Alternative where method that accepts a closure for Groovy DSL style
+     * This would capture the closure content and parse it
+     */
+    public void where(Closure closure) {
+        // TODO: Implement closure-based where blocks
+        // This would require more sophisticated AST parsing of the closure
+        throw new UnsupportedOperationException("Closure-based where blocks not yet implemented. Please use string-based where blocks.");
+    }
+
+    // Getters
+    public DataTable getDataTable() {
+        return dataTable;
+    }
+
+    public Closure getSetupClosure() {
+        return setupClosure;
+    }
+
+    public Closure getWhenClosure() {
+        return whenClosure;
+    }
+
+    public Closure getThenClosure() {
+        return thenClosure;
+    }
+
+    public Closure getCleanupClosure() {
+        return cleanupClosure;
+    }
+
+    public ITestSuite getTestSuite() {
+        return testSuite;
+    }
+}