def test_input_in_input_novalue_nooptional_nodefault(self): wf = WorkflowBuilder( "test_cwl_input_in_input_novalue_nooptional_nodefault") wf.input("inpId", String()) # included because no value, no default, and not optional self.assertDictEqual({"inpId": None}, self.translator.build_inputs_file(wf))
def test_add_non_scatter2(self): w = WorkflowBuilder("scatterededge") w.input("inp", Array(String())) w.step("stp", ArrayTestTool(inputs=w.inp)) e = first_value(w.stp.sources["inputs"].source_map) self.assertFalse(e.scatter)
def test_inputs_generator_secondary_files(self): w = WorkflowBuilder("tst") w.input("wsec", TestTypeWithSecondary, default="test.ext") # w._add_input(Input("wsec", TestTypeWithSecondary(), value="test.ext")) inpsdict = WdlTranslator().build_inputs_file(w, merge_resources=False) self.assertEqual("test.ext", inpsdict.get("tst.wsec")) self.assertEqual("test.txt", inpsdict.get("tst.wsec_txt"))
def test_two_similar_tools(self): w = WorkflowBuilder("testTwoToolsWithSameId") w.input("inp", str) w.step("stp1", TestTool(testtool=w.inp)) w.step("stp2", TestToolV2(testtool=w.inp)) wf_wdl, _ = WdlTranslator.translate_workflow(w) expected = """\ version development import "tools/TestTranslationtool.wdl" as T import "tools/TestTranslationtool_v0_0_2.wdl" as T2 workflow testTwoToolsWithSameId { input { String inp } call T.TestTranslationtool as stp1 { input: testtool=inp } call T2.TestTranslationtool as stp2 { input: testtool=inp } }""" self.assertEqual(expected, wf_wdl.get_string())
def test_workflow_string_not_null(self): w = WorkflowBuilder("wf") w.input("inp", Optional[str]) w.output("out", source=w.inp.assert_not_null()) cwltool = w.translate("cwl", allow_empty_container=True, to_console=False)[0] print(cwltool)
def test_dot_3(self): w = WorkflowBuilder("sbmf") w.input("inp", Array(str)) w.input("inp2", Array(str)) w.input("inp3", Array(str)) step = w.step( "dotTool", SingleTestTool(inputs=w.inp, input2=w.inp2, input3=w.inp3), scatter=ScatterDescription( fields=["inputs", "input2", "input3"], method=ScatterMethods.dot ), ) outp = wdl.translate_step_node( step, "A.SingleTestTool", {}, {"inp", "inp2", "inp3"} ) expected = """\ scatter (Q in zip(inp, zip(inp2, inp3))) { call A.SingleTestTool as dotTool { input: inputs=Q.left, input2=Q.right.left, input3=Q.right.right } }""" self.assertEqual(expected, outp.get_string(indent=0))
def test_add_single_to_array_edge(self): w = WorkflowBuilder("test_add_single_to_array_edge") w.input("inp1", String()) w.step("stp1", ArrayTestTool(inputs=w.inp1)) e = first_value(w.stp1.sources["inputs"].source_map) self.assertTrue(w.has_multiple_inputs) self.assertTrue(e.compatible_types)
def test_input_in_input_value_optional_default(self): wf = WorkflowBuilder("test_input_in_inputfile") wf.input("inpId", String(optional=True), default="1") self.assertDictEqual( {"test_input_in_inputfile.inpId": "1"}, self.translator.build_inputs_file(wf), )
def test_add_non_scatter_fail(self): w = WorkflowBuilder("scatterededge") w.input("inp", Array(str)) stp = w.step("stp", SingleTestTool(inputs=w.inp)) e = first_value(w.stp.sources["inputs"].source_map) self.assertFalse(e.compatible_types)
def test_add_single_to_array_edge(self): w = WorkflowBuilder("test_add_single_to_array_edge") w.input("inp1", str) w.step("stp1", ArrayTestTool(inputs=w.inp1)) c, _, _ = CwlTranslator().translate(w, to_console=False, allow_empty_container=True) self.assertEqual(cwl_multiinput, c)
def test_add_scatter_nested_arrays(self): w = WorkflowBuilder("scatterededge") w.input("inp", Array(Array(str))) stp = w.step("stp", ArrayTestTool(inps=w.inp), scatter="inps") e = w.stp.sources["inps"].source_map[0] self.assertTrue(e.compatible_types) self.assertListEqual(["inps"], stp.scatter.fields)
def test_add_scatter_incompatible(self): w = WorkflowBuilder("scatterededge") w.input("inp", Array(int)) stp = w.step("stp", SingleTestTool(inputs=w.inp), scatter="inputs") e = first_value(w.stp.sources["inputs"].source_map) self.assertTrue(e.scatter) self.assertFalse(e.compatible_types)
def test_add_scatter(self): w = WorkflowBuilder("scatterededge") w.input("inp", Array(str)) stp = w.step("stp", SingleTestTool(inputs=w.inp), scatter="inputs") e = first_value(w.stp.sources["inputs"].source_map) self.assertTrue(e.compatible_types) self.assertListEqual(["inputs"], stp.scatter.fields)
def test_input_in_input_novalue_optional_default(self): wf = WorkflowBuilder("test_input_in_inputfile") wf.input("inpId", String(optional=True), default="2") # new interpretation: defaults appear in inputs self.assertDictEqual( {"test_input_in_inputfile.inpId": "2"}, self.translator.build_inputs_file(wf), )
def test_add_scatter_nested_arrays_incompatible(self): w = WorkflowBuilder("scatterededge") w.input("inp", Array(Array(int))) stp = w.step("stp", ArrayTestTool(inputs=w.inp), scatter="inputs") e = first_value(w.stp.sources["inputs"].source_map) self.assertFalse(e.compatible_types) self.assertListEqual(["inputs"], stp.scatter.fields)
def test_alias_selector(self): w = WorkflowBuilder("wf") w.input("inp", str) w.step("echo", EchoTestTool(inp=w.inp.as_type(str))) w.output("out", source=w.echo.out) sn: List[cwlgen.WorkflowStep] = cwl.translate_step_node( w.step_nodes["echo"], inputs_dict={"inp": ToolInput("inp", str)} ) self.assertEqual("inp", sn[0].in_[0].source)
def process_subpipeline(**connections): w = WorkflowBuilder("split_bam_subpipeline") w.input("bam", BamBai) w.input("intervals", Bed(optional=True)) w.step("split_bam", gatk4.Gatk4SplitReads_4_1_3(bam=w.bam, intervals=w.intervals)) w.output("out", source=w.split_bam.out) return w(**connections)
def test_output_name_and_folder(self): w = WorkflowBuilder("wf") w.input("inp", str) w.step("print", Echo(inp=w.inp)) w.output("out", source=w.print, output_name=w.inp, output_folder=[w.inp]) inputs = {"inp": ["test1", "test2"]} modifier = BatchPipelineModifier(BatchRunRequirements(["inp"], "inp")) new_workflow = modifier.tool_modifier(w, inputs, {}) print(new_workflow)
def test_invalid_scatter_field_list(self): w = WorkflowBuilder("scatterededge") w.input("inp", Array(String())) self.assertRaises( Exception, w.step, identifier="stp", tool=ArrayTestTool(inputs=w.inp), scatter=["inputs", "randomfield"], )
def test_overrided_input_optional_default(self): wf = WorkflowBuilder("test_input_in_inputfile") wf.input("inpId", String(optional=True), default="2") ad = {"inpId": "4"} # new interpretation: defaults appear in inputs self.assertDictEqual( {"test_input_in_inputfile.inpId": "4"}, self.translator.build_inputs_file(wf, additional_inputs=ad), )
def test_translate_single_to_array_edge(self): w = WorkflowBuilder("wf") w.input("inp", str) stp1 = w.step("stp1", TestTool(testtool=w.inp), ignore_missing=True) stp2 = w.step("stp2", TestTool(arrayInp=stp1.std, testtool=w.inp), ignore_missing=True) outp = wdl.translate_step_node(stp2, stp2.id(), {}, set()) self.assertEqual(outp.get_string().split("\n")[3].strip(), f"arrayInp=[{stp1.id()}.std]")
def test_two_similar_tools(self): w = WorkflowBuilder("testTwoToolsWithSameId") w.input("inp", str) w.step("stp1", TestTool(testtool=w.inp)) w.step("stp2", TestToolV2(testtool=w.inp)) wf_cwl, _ = CwlTranslator.translate_workflow(w) stps = {stp.id: stp for stp in wf_cwl.steps} self.assertEqual("tools/TestTranslationtool.cwl", stps["stp1"].run) self.assertEqual("tools/TestTranslationtool_v0_0_2.cwl", stps["stp2"].run)
def test_add_rescatter_scattered(self): w = WorkflowBuilder("scatterededge") w.input("inp1", Array(String())) stp1 = w.step("stp1", SingleTestTool(inputs=w.inp1), scatter="inputs") stp2 = w.step("stp2", SingleTestTool(inputs=stp1), scatter="inputs") e1 = first_value(stp1.sources["inputs"].source_map) e2 = first_value(stp2.sources["inputs"].source_map) self.assertTrue(e1.scatter) self.assertTrue(e2.scatter)
def test_read_contents(self): w = WorkflowBuilder("wf") w.input("inp", str) w.step("stp", EchoTestTool(inp=w.inp)) w.output("out", source=w.stp.out.contents()) w_cwl = cwl.CwlTranslator().translate_workflow(w, with_container=False)[0] self.assertEqual(2, len(w_cwl.steps)) self.assertEqual( "${return {out: inputs._stpout.contents }}", w_cwl.steps[1].run.expression ) self.assertTrue(w_cwl.steps[1].run.inputs[0].loadContents)
def process_subpipeline(**connections): w = WorkflowBuilder("somatic_subpipeline") w.input("bam", BamBai) w.input("intervals", Bed) w.input("reference", FastaWithDict) w.input("known_sites", Array(VcfTabix)) w.step( "base_recalibrator", gatk4.Gatk4BaseRecalibratorLatest( bam=w.bam, intervals=w.intervals, reference=w.reference, knownSites=w.known_sites, ), ) w.step( "apply_bqsr", gatk4.Gatk4ApplyBqsrLatest( bam=w.bam, recalFile=w.base_recalibrator.out, intervals=w.intervals, reference=w.reference, ), ) w.output("out", source=w.apply_bqsr.out) return w(**connections)
def setUpClass(cls): wf = WorkflowBuilder("test_workflow_input_collection") cls.inmap = { "user": InputQualityType.user, "static": InputQualityType.static, "configuration": InputQualityType.configuration, "none": None, } for i, itype in cls.inmap.items(): wf.input(i, str, doc=InputDocumentation(None, quality=itype)) cls.wf = wf
def test_expression_default(self): wf = WorkflowBuilder("test_expression_defaults") wf.input("inp", Optional[str]) wf.step( "echo", EchoTestTool(inp="Hello, " + If(IsDefined(wf.inp), wf.inp, ", Michael!")), ) wf.output("out", source=wf.echo) wf.translate("cwl")
def test_subworkflow(self): w = WorkflowBuilder("test_subworkflow") sub_w = WorkflowBuilder("subworkflow") sub_w.input("sub_inp", str) sub_w.step("sub_stp", SingleTestTool(inputs=sub_w.sub_inp)) sub_w.output("sub_out", source=sub_w.sub_stp.out) w.input("inp", str) w.step("stp_workflow", sub_w(sub_inp=w.inp)) w.output("out", source=w.stp_workflow.sub_out) # would be good to come up with some tests # w.translate("wdl") self.assertTrue(True)
def test_merge(self): w = WorkflowBuilder("scatterededge") w.input("inp1", Array(String())) w.step("scatteredStp1", SingleTestTool(inputs=w.inp1), scatter="inputs") stp = w.step("mergeStp2", ArrayTestTool(inputs=w.scatteredStp1)) e1 = first_value(w.scatteredStp1.sources["inputs"].source_map) e2 = first_value(w.mergeStp2.sources["inputs"].source_map) self.assertTrue(e1.scatter) self.assertFalse(e2.scatter) self.assertTrue(e2.compatible_types)
def test_add_non_scatter(self): w = WorkflowBuilder("scatterededge") inp = w.input("inp", str) stp = w.step("stp", SingleTestTool(inputs=inp)) e = first_value(w.stp.sources["inputs"].source_map) self.assertIsNone(stp.scatter)