test: add more flow example (#445)

* test: add progress flow to validate report_progress API

Add test flow that calls context.report_progress() 4 times
with values 0, 25, 50, 75 to verify BlockProgress events.

* test: add warning flow to validate BlockWarning on undefined output handle

When a block returns an output key not defined in outputs_def,
the SDK should emit a BlockWarning event. This test returns 'c'
when only 'a' and 'b' are defined.

* test: add nullable flow to validate nullable input handling

Adds test flow that verifies inputs with nullable: true can accept
null/empty values. First node validates input is None, second node
receives output from first node plus its own nullable input.

* test: add subflow-progress flow to validate BlockProgress events in subflows

Add test case with a subflow containing 2 nodes that each report progress
4 times (0%, 25%, 50%, 75%), generating at least 8 BlockProgress events
total. The main flow calls the subflow and passes output to an end node.

* test: add from flow to validate inputs_from modes

Tests three inputs_from connection types:
- value: direct input value (input=2)
- from_node: output from another node (+python#2 outputs 3)
- value+from_node: value node (+value#1=4) with fallback value (5)

Expected result: 2 + 3 + 4 = 9

* test: add additional-block flow to validate dynamic inputs/outputs

Add a block with additional_inputs: true and additional_outputs: true
to test dynamic input/output handling at node level.

* test: add test cases for progress, warning, nullable, subflow-progress, from, and additional-block flows

Add 6 new test cases to flow.test.ts:
- progress: validates BlockProgress events and output count
- warning: validates BlockWarning message on undefined handle
- nullable: validates nullable input handling
- subflow-progress: validates BlockProgress in subflows (>=8 events, all in [0,100])
- from: validates from_node, value, and value node inputs
- additional-block: validates dynamic inputs/outputs

* test: strengthen test assertions for progress, from, and additional-block flows

- Add BlockProgress event validation to progress test
- Add output value assertion (9) to from flow test
- Add merged output assertion (helloworld) to additional-block test

* fix: update searchPaths to use array instead of string

The new @oomol/oocana 0.24.1 expects searchPaths as an array

* fix: correct progress flow test assertion

The progress flow returns {"count": 3} via return statement, not via
context.output(). BlockOutput events are only generated when calling
context.output(), so the original assertion was checking a non-existent
event. Changed to verify result.count from BlockFinished event instead.

* fix: use toContain for warning message assertion

The BlockWarning event may contain repeated warning messages.
Changed from strict equality (toBe) to substring check (toContain)
to handle cases where the warning message is duplicated.

* fix: use substring check for additional-block test

The iteration order of context.inputs_def is not guaranteed, so the
merged output order may vary. Changed from strict equality to substring
checks to verify both "hello" and "world" are present in the output.

* fix: update bindPaths to use object array format

The @oomol/oocana 0.24.1 expects bindPaths as BindPath[] (object array
with src/dst properties) instead of string array.

Author: leavesster

flow-examples/test/flow.test.ts

@@ -186,6 +186,94 @@ describe(
       const { code } = await run("pkg-dir");
       expect(code).toBe(0);
     });
+
+    it("run progress flow", async () => {
+      files.delete("progress");
+      const { code, events } = await run("progress");
+      expect(code).toBe(0);
+
+      const progressEvents = events.filter(e => e.event === "BlockProgress");
+      expect(progressEvents.length).greaterThanOrEqual(4);
+
+      const latestFinished = events.findLast(e => e.event === "BlockFinished");
+      const lastNode = latestFinished?.data.stacks?.[0].node_id;
+      expect(lastNode).toBe("end");
+
+      // Validate the return value: {"count": 3}
+      expect(latestFinished?.data.result?.count).toBe(3);
+    });
+
+    it("run warning flow", async () => {
+      files.delete("warning");
+      const { code, events } = await run("warning");
+      expect(code).toBe(0);
+
+      const latestBlockWarning = events.findLast(
+        e => e.event === "BlockWarning"
+      )?.data?.warning;
+      expect(latestBlockWarning).toContain(
+        "Output handle key: [c] is not defined in Block outputs schema."
+      );
+    });
+
+    it("run nullable flow", async () => {
+      files.delete("nullable");
+      const { code, events } = await run("nullable");
+      expect(code).toBe(0);
+
+      const latestFinished = events.findLast(e => e.event === "BlockFinished");
+      const lastNode = latestFinished?.data.stacks?.[0].node_id;
+      expect(lastNode).toBe("end");
+    });
+
+    it("run subflow-progress flow", async () => {
+      files.delete("subflow-progress");
+      const { code, events } = await run("subflow-progress");
+      expect(code).toBe(0);
+
+      const progressEvents = events.filter(e => e.event === "BlockProgress");
+
+      expect(
+        progressEvents.every(
+          e => e.data.progress >= 0 && e.data.progress <= 100
+        )
+      ).toBe(true);
+
+      expect(progressEvents.length).greaterThanOrEqual(8);
+
+      const latestFinished = events.findLast(e => e.event === "BlockFinished");
+      const lastNode = latestFinished?.data.stacks?.[0].node_id;
+      expect(lastNode).toBe("end");
+    });
+
+    it("run from flow", async () => {
+      files.delete("from");
+      const { code, events } = await run("from");
+      expect(code).toBe(0);
+
+      const latestFinished = events.findLast(e => e.event === "BlockFinished");
+      const lastNode = latestFinished?.data.stacks?.[0].node_id;
+      expect(lastNode).toBe("end");
+
+      // Validate the computed result: input(2) + output(3) + value1(4) = 9
+      expect(latestFinished?.data.result?.output).toBe(9);
+    });
+
+    it("run additional-block flow", async () => {
+      files.delete("additional-block");
+      const { code, events } = await run("additional-block");
+      expect(code).toBe(0);
+
+      const latestFinished = events.findLast(e => e.event === "BlockFinished");
+      const lastNode = latestFinished?.data.stacks?.[0].node_id;
+      expect(lastNode).toBe("end");
+
+      // Validate the dynamic I/O merged result contains both "hello" and "world"
+      // Note: iteration order of inputs_def is not guaranteed, so we check for substrings
+      const output = latestFinished?.data.result?.output;
+      expect(output).toContain("hello");
+      expect(output).toContain("world");
+    });
   }
 );
 
@@ -206,8 +294,11 @@ async function run(
 
   const task = await cli.runFlow({
     flowPath: path.join(workspace, "flows", flow, "flow.oo.yaml"),
-    searchPaths: [packages, path.join(workspace, "blocks")].join(","),
-    bindPaths: [`src=${homedir()}/.oocana,dst=/root/.oocana`, `src=${tmpdir()},dst=${tmpdir()}`],
+    searchPaths: [packages, path.join(workspace, "blocks")],
+    bindPaths: [
+      { src: `${homedir()}/.oocana`, dst: "/root/.oocana" },
+      { src: tmpdir(), dst: tmpdir() },
+    ],
     excludePackages: [workspace],
     sessionId: flow,
     tempRoot: tmpdir(),

flow-examples/workspace/blocks/additional/__init__.py

@@ -0,0 +1,18 @@
+from oocana import Context
+
+
+def main(inputs: dict, context: Context):
+    print("inputs_def", context.inputs_def)
+    print("outputs_def", context.outputs_def)
+
+    merged = ""
+    for key in context.inputs_def:
+        value = inputs.get(key)
+        if value is not None:
+            merged += str(value)
+
+    result = {}
+    for key in context.outputs_def:
+        result[key] = merged
+
+    return result

flow-examples/workspace/blocks/additional/block.oo.yaml

@@ -0,0 +1,15 @@
+executor:
+  name: python
+  options:
+    entry: __init__.py
+inputs_def:
+  - handle: input
+    json_schema:
+      type: string
+      ContentMediaType: oomol/secret
+outputs_def:
+  - handle: output
+    json_schema: {}
+title: additional-block
+additional_inputs: true
+additional_outputs: true

flow-examples/workspace/flows/additional-block/flow.oo.yaml

@@ -0,0 +1,55 @@
+nodes:
+  - node_id: +python#1
+    task:
+      inputs_def: []
+      outputs_def:
+        - handle: output
+          json_schema: {}
+        - handle: output1
+          json_schema: {}
+      executor:
+        name: python
+        options:
+          entry: scriptlets/+python#1.py
+  - node_id: a#1
+    task: self::additional
+    inputs_from:
+      - handle: input
+        from_node:
+          - node_id: +python#1
+            output_handle: output
+      - handle: input1
+        from_node:
+          - node_id: +python#1
+            output_handle: output1
+    inputs_def:
+      - handle: input1
+        json_schema: {}
+        nullable: false
+    outputs_def:
+      - handle: output1
+        json_schema: {}
+  - node_id: end
+    task:
+      inputs_def:
+        - handle: input
+          json_schema: {}
+        - handle: output1
+          json_schema: {}
+          nullable: false
+      outputs_def:
+        - handle: output
+          json_schema: {}
+      executor:
+        name: python
+        options:
+          entry: scriptlets/+python#2.py
+    inputs_from:
+      - handle: input
+        from_node:
+          - node_id: a#1
+            output_handle: output
+      - handle: output1
+        from_node:
+          - node_id: a#1
+            output_handle: output1

flow-examples/workspace/flows/additional-block/scriptlets/+python#1.py

@@ -0,0 +1,8 @@
+from oocana import Context
+
+
+def main(inputs: dict, context: Context):
+    return {
+        "output": "hello",
+        "output1": "world",
+    }

flow-examples/workspace/flows/additional-block/scriptlets/+python#2.py

@@ -0,0 +1,8 @@
+from oocana import Context
+
+
+def main(inputs: dict, context: Context):
+    print("end node inputs:", inputs)
+    return {
+        "output": inputs.get("input") + inputs.get("output1"),
+    }

flow-examples/workspace/flows/from/flow.oo.yaml

@@ -0,0 +1,75 @@
+nodes:
+  - node_id: +python#1
+    title: "Python #1"
+    task:
+      inputs_def:
+        - handle: input
+          json_schema: {}
+        - handle: output
+          json_schema:
+            type: number
+          nullable: false
+        - handle: value1
+          json_schema:
+            type: number
+          nullable: false
+      outputs_def:
+        - handle: output
+          json_schema:
+            type: number
+      executor:
+        name: python
+        options:
+          entry: scriptlets/+python#1.py
+    inputs_from:
+      - handle: input
+        schema_overrides:
+          - schema:
+              type: number
+        value: 2
+      - handle: output
+        from_node:
+          - node_id: +python#2
+            output_handle: output
+      - handle: value1
+        value: 5
+        from_node:
+          - node_id: +value#1
+            output_handle: value1
+  - node_id: +python#2
+    title: "Python #2"
+    task:
+      inputs_def: []
+      outputs_def:
+        - handle: output
+          json_schema:
+            type: number
+      executor:
+        name: python
+        options:
+          entry: scriptlets/+python#2.py
+  - node_id: +value#1
+    title: "Value #1"
+    values:
+      - handle: value1
+        json_schema:
+          type: number
+        value: 4
+  - node_id: end
+    title: "end"
+    task:
+      inputs_def:
+        - handle: input
+          json_schema: {}
+      outputs_def:
+        - handle: output
+          json_schema: {}
+      executor:
+        name: python
+        options:
+          entry: scriptlets/+python#3.py
+    inputs_from:
+      - handle: input
+        from_node:
+          - node_id: +python#1
+            output_handle: output

flow-examples/workspace/flows/from/scriptlets/+python#1.py

@@ -0,0 +1,15 @@
+from oocana import Context
+
+def main(inputs: dict, context: Context):
+    # Receives inputs from three sources:
+    # - input: direct value (2)
+    # - output: from +python#2 node (3)
+    # - value1: from +value#1 node (4), with fallback value 5
+    input_val = inputs.get("input")
+    output_val = inputs.get("output")
+    value1_val = inputs.get("value1")
+
+    result = input_val + output_val + value1_val
+    print(f"Calculating: {input_val} + {output_val} + {value1_val} = {result}")
+
+    return {"output": result}

flow-examples/workspace/flows/from/scriptlets/+python#2.py

@@ -0,0 +1,5 @@
+from oocana import Context
+
+def main(inputs: dict, context: Context):
+    # Simple node that outputs a number
+    return {"output": 3}

flow-examples/workspace/flows/from/scriptlets/+python#3.py

@@ -0,0 +1,5 @@
+from oocana import Context
+
+def main(inputs: dict, context: Context):
+    # End node: receives output from +python#1 and passes through
+    return {"output": inputs.get("input")}