test: service: develop: Run single

Signed-off-by: John Andersen <[email protected]>

Author: John Andersen

dffml/service/dev.py

@@ -208,27 +208,24 @@ async def run_op(self, name, opimp):
             except MissingConfig as error:
                 error.args = (f"{opimp.op.inputs}: {error.args[0]}",)
                 raise error
-        # Run the operation in an orchestrator
-        async with MemoryOrchestrator.basic_config(
-            opimp.imp, GetSingle.imp
-        ) as orchestrator:
-            async with orchestrator() as octx:
-                # TODO Assign a sha384 string as the random string context
-                await octx.ictx.sadd(
-                    str(uuid.uuid4()),
-                    Input(
-                        value=[
-                            definition.name
-                            for definition in opimp.op.outputs.values()
-                        ],
-                        definition=GetSingle.op.inputs["spec"],
-                    ),
-                    *inputs,
-                )
-                async for ctx, results in octx.run_operations():
-                    # TODO There is probably an issue if multiple outputs have
-                    # the same data type that only one will be shown
-                    return results[GetSingle.op.name]
+
+        # Run the operation in the memory orchestrator
+        async with MemoryOrchestrator.withconfig({}) as orchestrator:
+            # Orchestrate the running of these operations
+            async with orchestrator(DataFlow.auto(GetSingle, opimp)) as octx:
+                async for ctx, results in octx.run(
+                    [
+                        Input(
+                            value=[
+                                definition.name
+                                for definition in opimp.op.outputs.values()
+                            ],
+                            definition=GetSingle.op.inputs["spec"],
+                        ),
+                        *inputs,
+                    ]
+                ):
+                    return results
 
 
 class ListEntrypoints(CMD):

tests/test_integration_cli.py

@@ -51,17 +51,20 @@ class IntegrationCLITestCase(AsyncTestCase):
 
     async def setUp(self):
         super().setUp()
-        if not all(map(is_develop, self.REQUIRED_PLUGINS)):
-            self.skipTest(
-                f"Required plugins: {', '.join(self.REQUIRED_PLUGINS)} must be installed in development mode"
-            )
+        self.required_plugins(*self.REQUIRED_PLUGINS)
         self.stdout = io.StringIO()
         self._stack = contextlib.ExitStack().__enter__()
 
     async def tearDown(self):
         super().tearDown()
         self._stack.__exit__(None, None, None)
 
+    def required_plugins(self, *args):
+        if not all(map(is_develop, args)):
+            self.skipTest(
+                f"Required plugins: {', '.join(args)} must be installed in development mode"
+            )
+
     def mktempfile(self):
         return self._stack.enter_context(non_existant_tempfile())
 
@@ -136,17 +139,30 @@ async def test_memory_to_csv(self):
 
 
 class TestDevelop(IntegrationCLITestCase):
-
-    REQUIRED_PLUGINS = ["shouldi"]
-
     async def test_export(self):
+        self.required_plugins("shouldi")
         stdout = io.StringIO()
         # Use shouldi's dataflow for tests
         with relative_chdir("..", "examples", "shouldi"):
             with unittest.mock.patch("sys.stdout.buffer.write") as write:
                 await Develop.cli("export", "shouldi.cli:DATAFLOW")
             DataFlow._fromdict(**json.loads(write.call_args[0][0]))
 
+    async def test_run(self):
+        self.required_plugins("shouldi", "dffml-model-scratch")
+        results = await Develop.cli(
+            "run",
+            "-log",
+            "debug",
+            "shouldi.bandit:run_bandit",
+            "-pkg",
+            str(relative_path("..", "model", "scratch")),
+        )
+        self.assertIn("bandit_output", results)
+        self.assertIn(
+            "CONFIDENCE.HIGH_AND_SEVERITY.HIGH", results["bandit_output"]
+        )
+
 
 class TestDataFlow(IntegrationCLITestCase):