Improve stdin support for files

Author: niknetniko

tested/dsl/schema-strict.json

@@ -276,11 +276,18 @@
         },
         "stdin" : {
           "description" : "Stdin for this context",
-          "type" : [
-            "string",
-            "number",
-            "integer",
-            "boolean"
+          "oneOf" : [
+            {
+              "type" : [
+                "string",
+                "number",
+                "integer",
+                "boolean"
+              ]
+            },
+            {
+              "$ref": "#/definitions/fileData"
+            }
           ]
         },
         "arguments" : {
@@ -890,6 +897,35 @@
           "$ref" : "#/definitions/fileConfigurationOptions"
         }
       }
+    },
+    "fileData": {
+      "type": "object",
+      "additionalProperties" : false,
+      "anyOf" : [
+        {
+          "required" : [
+            "content"
+          ]
+        },
+        {
+          "required" : [
+            "path"
+          ]
+        }
+      ],
+      "properties": {
+        "content": {
+          "type": [
+            "string",
+            "path"
+          ],
+          "description" : "Content of the file, which will be provided inline or written to disk in the workdir. If a !path, the file contents will be read from the provided path."
+        },
+        "path": {
+          "type": "string",
+          "description" : "Path to the file, relative to the workdir. Used to display in the output."
+        }
+      }
     }
   }
 }

tested/dsl/schema.json

@@ -276,11 +276,18 @@
         },
         "stdin" : {
           "description" : "Stdin for this context",
-          "type" : [
-            "string",
-            "number",
-            "integer",
-            "boolean"
+          "oneOf" : [
+            {
+              "type" : [
+                "string",
+                "number",
+                "integer",
+                "boolean"
+              ]
+            },
+            {
+              "$ref": "#/definitions/fileData"
+            }
           ]
         },
         "arguments" : {
@@ -884,6 +891,32 @@
           "$ref" : "#/definitions/fileConfigurationOptions"
         }
       }
+    },
+    "fileData": {
+      "type": "object",
+      "additionalProperties" : false,
+      "anyOf" : [
+        {
+          "required" : [
+            "content"
+          ]
+        },
+        {
+          "required" : [
+            "path"
+          ]
+        }
+      ],
+      "properties": {
+        "content": {
+          "type": "string",
+          "description" : "Content of the file, which will be provided inline or written to disk in the workdir. If a !path, the file contents will be read from the provided path."
+        },
+        "path": {
+          "type": "string",
+          "description" : "Path to the file, relative to the workdir. Used to display in the output."
+        }
+      }
     }
   }
 }

tested/dsl/translate_parser.py

@@ -45,6 +45,7 @@
     Value,
 )
 from tested.testsuite import (
+    ContentPath,
     Context,
     CustomCheckOracle,
     EmptyChannel,
@@ -88,9 +89,22 @@ class ReturnOracle(dict):
     pass
 
 
+class ContentPathString(str):
+    pass
+
+
 OptionDict = dict[str, int | bool]
 YamlObject = (
-    YamlDict | list | bool | float | int | str | None | ExpressionString | ReturnOracle
+    YamlDict
+    | list
+    | bool
+    | float
+    | int
+    | str
+    | None
+    | ExpressionString
+    | ReturnOracle
+    | ContentPathString
 )
 
 
@@ -138,6 +152,12 @@ def _return_oracle(loader: yaml.Loader, node: yaml.Node) -> ReturnOracle:
     return ReturnOracle(result)
 
 
+def _return_path(loader: yaml.Loader, node: yaml.Node) -> ContentPathString:
+    result = _parse_yaml_value(loader, node)
+    assert isinstance(result, str), f"A path must be a string, got {result}"
+    return ContentPathString(result)
+
+
 def _parse_yaml(yaml_stream: str) -> YamlObject:
     """
     Parse a string or stream to YAML.
@@ -148,6 +168,7 @@ def _parse_yaml(yaml_stream: str) -> YamlObject:
             yaml.add_constructor("!" + actual_type, _custom_type_constructors, loader)
     yaml.add_constructor("!expression", _expression_string, loader)
     yaml.add_constructor("!oracle", _return_oracle, loader)
+    yaml.add_constructor("!path", _return_path, loader)
 
     try:
         return yaml.load(yaml_stream, loader)
@@ -187,6 +208,10 @@ def is_expression(_checker: TypeChecker, instance: Any) -> bool:
     return isinstance(instance, ExpressionString)
 
 
+def is_path(_checker: TypeChecker, instance: Any) -> bool:
+    return isinstance(instance, ContentPathString)
+
+
 def load_schema_validator(
     dsl_object: YamlObject = None, file: str = "schema-strict.json"
 ) -> Validator:
@@ -215,9 +240,13 @@ def validate_tested_dsl_expression(value: object) -> bool:
         schema_object = json.load(schema_file)
 
     original_validator: Type[Validator] = validator_for(schema_object)
-    type_checker = original_validator.TYPE_CHECKER.redefine(
-        "oracle", is_oracle
-    ).redefine("expression", is_expression)
+    type_checker = original_validator.TYPE_CHECKER.redefine_many(
+        {
+            "oracle": is_oracle,
+            "expression": is_expression,
+            "path": is_path,
+        }
+    )
     format_checker = original_validator.FORMAT_CHECKER
     format_checker.checks("tested-dsl-expression", SyntaxError)(
         validate_tested_dsl_expression
@@ -469,16 +498,16 @@ def _convert_text_output_channel(
         data = raw_data
 
     if isinstance(stream, str):
-        return TextOutputChannel(data=data, oracle=GenericTextOracle(options=config))
+        return TextOutputChannel(content=data, oracle=GenericTextOracle(options=config))
     else:
         assert isinstance(stream, dict)
         if "oracle" not in stream or stream["oracle"] == "builtin":
             return TextOutputChannel(
-                data=data, oracle=GenericTextOracle(options=config)
+                content=data, oracle=GenericTextOracle(options=config)
             )
         elif stream["oracle"] == "custom_check":
             return TextOutputChannel(
-                data=data, oracle=_convert_custom_check_oracle(stream)
+                content=data, oracle=_convert_custom_check_oracle(stream)
             )
         raise TypeError(f"Unknown text oracle type: {stream['oracle']}")
 
@@ -599,8 +628,33 @@ def _convert_testcase(testcase: YamlDict, context: DslContext) -> Testcase:
         return_channel = IgnoredChannel.IGNORED if "statement" in testcase else None
     else:
         if "stdin" in testcase:
-            assert isinstance(testcase["stdin"], str)
-            stdin = TextData(data=_ensure_trailing_newline(testcase["stdin"]))
+            if isinstance(testcase["stdin"], dict):
+                stdin_object = testcase["stdin"]
+                raw_content = stdin_object.get("content")
+                raw_path = stdin_object.get("path")
+
+                if isinstance(raw_content, ContentPathString):
+                    file_content = ContentPath(path=raw_content)
+                elif isinstance(raw_content, str):
+                    file_content = _ensure_trailing_newline(raw_content)
+                elif isinstance(raw_path, str):
+                    file_content = ContentPath(path=raw_path)
+                else:
+                    assert (
+                        False
+                    ), f"Invalid stdin content is required but got {type(raw_content)}"
+
+                assert raw_path is None or isinstance(
+                    raw_path, str
+                ), "Path must be a string if given."
+
+                file_path = raw_path
+            else:
+                assert isinstance(testcase["stdin"], str)
+                file_content = _ensure_trailing_newline(testcase["stdin"])
+                file_path = None
+
+            stdin = TextData(content=file_content, path=file_path)
         else:
             stdin = EmptyChannel.NONE
         arguments = testcase.get("arguments", [])

tested/languages/generation.py

@@ -38,7 +38,6 @@
     MainInput,
     Testcase,
     TextData,
-    TextChannelType,
 )
 from tested.utils import is_statement_strict
 
@@ -129,8 +128,8 @@ def get_readable_input(
         args = f"$ {command}"
         # Determine the stdin
         if isinstance(case.input.stdin, TextData):
-            if case.input.stdin.type == TextChannelType.FILE:
-                stdin = Path(case.input.stdin.data)
+            if case.input.stdin.path is not None:
+                stdin = Path(case.input.stdin.path)
             else:
                 stdin = case.input.stdin.get_data_as_string(bundle.config.resources)
         else:

tested/languages/preparation.py

@@ -487,10 +487,10 @@ def prepare_context(
     """
     language = bundle.config.programming_language
     resources = bundle.config.resources
-    before_code = context.before.get(language, TextData(data="")).get_data_as_string(
+    before_code = context.before.get(language, TextData(content="")).get_data_as_string(
         resources
     )
-    after_code = context.after.get(language, TextData(data="")).get_data_as_string(
+    after_code = context.after.get(language, TextData(content="")).get_data_as_string(
         resources
     )
     testcases, evaluator_names = prepare_testcases(bundle, context)

tested/parsing.py

@@ -8,7 +8,7 @@
 import logging
 from collections.abc import Callable
 from decimal import Decimal
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Optional
 
 from cattrs import Converter
 from cattrs.gen import make_dict_structure_fn
@@ -133,7 +133,7 @@ def structure(d, cl):
 
 def custom_fallback_field(
     converter_arg: Converter,
-    old_to_new_field: dict[str, tuple[str, Callable[[Any], Any]]],
+    old_to_new_field: dict[str, tuple[str, Callable[[Any, Optional[Any]], Any]]],
 ):
     def decorator(cls):
         struct = make_dict_structure_fn(
@@ -147,7 +147,7 @@ def structure(d, cl):
                         raise ValueError(
                             f"You cannot use {new_name} and {k} simultaneously. Migrate to {new_name}."
                         )
-                    d[new_name] = mapper(d[k])
+                    d[new_name] = mapper(d[k], d)
 
             return struct(d, cl)