@voxgig/sdkgen 0.35.2 → 0.37.0

package/project/.sdk/tm/py/feature/test_feature.py

@@ -0,0 +1,164 @@
+# ProjectName SDK test feature
+
+from __future__ import annotations
+import random
+
+from utility.voxgig_struct import voxgig_struct as vs
+from feature.base_feature import ProjectNameBaseFeature
+
+
+class ProjectNameTestFeature(ProjectNameBaseFeature):
+    def __init__(self):
+        super().__init__()
+        self.version = "0.0.1"
+        self.name = "test"
+        self.active = True
+        self.client = None
+        self.options = None
+
+    def init(self, ctx, options):
+        self.client = ctx.client
+        self.options = options
+
+        entity = vs.getprop(options, "entity")
+        if not isinstance(entity, dict):
+            entity = {}
+
+        self.client.mode = "test"
+
+        # Ensure entity ids are correct.
+        vs.walk(entity, lambda key, val, parent, path: (
+            val.__setitem__("id", key) if len(path) == 2 and isinstance(val, dict) and key is not None else None,
+            val
+        )[-1])
+
+        test_self = self
+
+        def test_fetcher(fctx, _fullurl, _fetchdef):
+            def respond(status, data, extra=None):
+                out = {
+                    "status": status,
+                    "statusText": "OK",
+                    "json": lambda: data,
+                    "body": "not-used",
+                }
+                if isinstance(extra, dict):
+                    for k, v in extra.items():
+                        out[k] = v
+                return out, None
+
+            op = fctx.op
+            entmap = vs.getprop(entity, op.entity)
+            if not isinstance(entmap, dict):
+                entmap = {}
+
+            if op.name == "load":
+                args = test_self.build_args(fctx, op, fctx.reqmatch)
+                found = vs.select(entmap, args)
+                ent = vs.getelem(found, 0)
+                if ent is None:
+                    return respond(404, None, {"statusText": "Not found"})
+                vs.delprop(ent, "$KEY")
+                out = vs.clone(ent)
+                return respond(200, out)
+
+            elif op.name == "list":
+                args = test_self.build_args(fctx, op, fctx.reqmatch)
+                found = vs.select(entmap, args)
+                if found is None:
+                    return respond(404, None, {"statusText": "Not found"})
+                if isinstance(found, list):
+                    for item in found:
+                        vs.delprop(item, "$KEY")
+                out = vs.clone(found)
+                return respond(200, out)
+
+            elif op.name == "update":
+                args = test_self.build_args(fctx, op, fctx.reqdata)
+                found = vs.select(entmap, args)
+                ent = vs.getelem(found, 0)
+                if ent is None:
+                    return respond(404, None, {"statusText": "Not found"})
+                if isinstance(ent, dict):
+                    reqdata = fctx.reqdata
+                    if reqdata is not None:
+                        for k, v in reqdata.items():
+                            ent[k] = v
+                vs.delprop(ent, "$KEY")
+                out = vs.clone(ent)
+                return respond(200, out)
+
+            elif op.name == "remove":
+                args = test_self.build_args(fctx, op, fctx.reqmatch)
+                found = vs.select(entmap, args)
+                ent = vs.getelem(found, 0)
+                if ent is None:
+                    return respond(404, None, {"statusText": "Not found"})
+                if isinstance(ent, dict):
+                    eid = vs.getprop(ent, "id")
+                    vs.delprop(entmap, eid)
+                return respond(200, None)
+
+            elif op.name == "create":
+                test_self.build_args(fctx, op, fctx.reqdata)
+                eid = fctx.utility.param(fctx, "id")
+                if eid is None:
+                    eid = "%04x%04x%04x%04x" % (
+                        random.randint(0, 0xFFFF), random.randint(0, 0xFFFF),
+                        random.randint(0, 0xFFFF), random.randint(0, 0xFFFF))
+
+                ent = vs.clone(fctx.reqdata)
+                if isinstance(ent, dict):
+                    ent["id"] = eid
+                    if isinstance(eid, str):
+                        entmap[eid] = ent
+                    vs.delprop(ent, "$KEY")
+                    out = vs.clone(ent)
+                    return respond(200, out)
+                return respond(200, ent)
+
+            return respond(404, None, {"statusText": "Unknown operation"})
+
+        ctx.utility.fetcher = test_fetcher
+
+    def build_args(self, ctx, op, args):
+        opname = op.name
+
+        # Get last point from config.
+        points = vs.getpath(ctx.config, "entity." + ctx.entity.get_name() + ".op." + opname + ".points")
+        point = vs.getelem(points, -1)
+
+        # Get required params.
+        params_path = vs.getpath(point, "args.params")
+        reqd_params = vs.select(params_path, {"reqd": True})
+        reqd = vs.transform(reqd_params, ["`$EACH`", "", "`$KEY.name`"])
+
+        qand = []
+        q = {"`$AND`": qand}
+
+        if args is not None:
+            keys = vs.keysof(args)
+            if keys is not None:
+                for key in keys:
+                    is_id = (key == "id")
+                    selected = vs.select(reqd, key)
+                    is_reqd = not vs.isempty(selected)
+
+                    if is_id or is_reqd:
+                        v = ctx.utility.param(ctx, key)
+                        ka = None
+                        if op.alias is not None:
+                            ka = vs.getprop(op.alias, key)
+
+                        qor = [{key: v}]
+                        if ka is not None and isinstance(ka, str):
+                            qor.append({ka: v})
+
+                        qand.append({"`$OR`": qor})
+
+        q["`$AND`"] = qand
+
+        if ctx.ctrl.explain is not None:
+            ctx.ctrl.explain["test"] = {"query": q}
+
+        return q

package/project/.sdk/tm/py/src/feature/README.md

@@ -0,0 +1,3 @@
+# Features
+
+This folder contains the feature source templates.

package/project/.sdk/tm/py/test/runner.py

@@ -0,0 +1,90 @@
+# ProjectName SDK test runner
+
+from __future__ import annotations
+import os
+import json
+
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+class ProjectNameTestRunner:
+    _env = {}
+
+    @staticmethod
+    def load_env_local():
+        try:
+            with open("../../.env.local", "r") as f:
+                content = f.read()
+        except (FileNotFoundError, IOError):
+            return
+
+        for line in content.splitlines():
+            line = line.strip()
+            if line == "" or line.startswith("#"):
+                continue
+            eq_idx = line.find("=")
+            if eq_idx < 0:
+                continue
+            key = line[:eq_idx].strip()
+            val = line[eq_idx + 1:].strip()
+            ProjectNameTestRunner._env[key] = val
+
+    @staticmethod
+    def getenv(key):
+        val = ProjectNameTestRunner._env.get(key)
+        if val is not None:
+            return val
+        return os.environ.get(key)
+
+    @staticmethod
+    def env_override(m):
+        live = ProjectNameTestRunner.getenv("PROJECTNAME_TEST_LIVE")
+        override = ProjectNameTestRunner.getenv("PROJECTNAME_TEST_OVERRIDE")
+
+        if live == "TRUE" or override == "TRUE":
+            for key in list(m.keys()):
+                envval = ProjectNameTestRunner.getenv(key)
+                if envval is not None and envval != "":
+                    envval = envval.strip()
+                    if envval.startswith("{"):
+                        try:
+                            parsed = json.loads(envval)
+                            if parsed is not None:
+                                m[key] = parsed
+                                continue
+                        except Exception:
+                            pass
+                    m[key] = envval
+
+        explain = ProjectNameTestRunner.getenv("PROJECTNAME_TEST_EXPLAIN")
+        if explain is not None and explain != "":
+            m["PROJECTNAME_TEST_EXPLAIN"] = explain
+
+        return m
+
+    @staticmethod
+    def entity_list_to_data(lst):
+        out = []
+        for item in lst:
+            if isinstance(item, dict):
+                out.append(item)
+            elif hasattr(item, "data_get") and callable(item.data_get):
+                d = item.data_get()
+                if isinstance(d, dict):
+                    out.append(d)
+            else:
+                out.append(item)
+        return out
+
+
+# Module-level convenience functions.
+def load_env_local():
+    ProjectNameTestRunner.load_env_local()
+
+
+def env_override(m):
+    return ProjectNameTestRunner.env_override(m)
+
+
+def entity_list_to_data(lst):
+    return ProjectNameTestRunner.entity_list_to_data(lst)

package/project/.sdk/tm/py/test/struct_runner.py

@@ -0,0 +1,411 @@
+# Vendored from voxgig/struct/py
+# Test runner that uses the test model in build/test.
+
+import os
+import json
+import re
+from typing import Any, Dict, List, Callable, TypedDict, Optional, Union
+
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+NULLMARK = '__NULL__'  # Value is JSON null
+UNDEFMARK = '__UNDEF__'  # Value is not present (thus, undefined)
+EXISTSMARK = '__EXISTS__' # Value exists (not undefined).
+
+
+class RunPack(TypedDict):
+    spec: Dict[str, Any]
+    runset: Callable
+    runsetflags: Callable
+    subject: Callable
+    client: Optional[Any]
+
+
+def makeRunner(testfile: str, client: Any):
+
+    def runner(
+        name: str,
+        store: Any = None,
+    ) -> RunPack:
+        store = store or {}
+
+        utility = client.utility()
+        structUtils = utility.struct
+
+        spec = resolve_spec(name, testfile)
+        clients = resolve_clients(client, spec, store, structUtils)
+        subject = resolve_subject(name, utility)
+
+        def runsetflags(testspec, flags, testsubject):
+            nonlocal subject, clients
+
+            subject = testsubject or subject
+            flags = resolve_flags(flags)
+            testspecmap = fixJSON(testspec, flags)
+            testset = testspecmap['set']
+
+            for entry in testset:
+                try:
+                    entry = resolve_entry(entry, flags)
+
+                    testpack = resolve_testpack(name, entry, subject, client, clients)
+                    args = resolve_args(entry, testpack, utility, structUtils)
+
+                    # Execute the test function
+                    res = testpack["subject"](*args)
+                    res = fixJSON(res, flags)
+                    entry['res'] = res
+                    check_result(entry, args, res, structUtils)
+
+                except Exception as err:
+                    handle_error(entry, err, structUtils)
+
+        def runset(testspec, testsubject):
+            return runsetflags(testspec, {}, testsubject)
+
+        runpack = {
+            "spec": spec,
+            "runset": runset,
+            "runsetflags": runsetflags,
+            "subject": subject,
+            "client": client
+        }
+
+        return runpack
+
+    return runner
+
+
+def resolve_spec(name: str, testfile: str) -> Dict[str, Any]:
+    with open(testfile, 'r', encoding='utf-8') as f:
+        alltests = json.load(f)
+
+    if 'primary' in alltests and name in alltests['primary']:
+        spec = alltests['primary'][name]
+    elif name in alltests:
+        spec = alltests[name]
+    else:
+        spec = alltests
+
+    return spec
+
+
+def resolve_clients(client: Any, spec: Dict[str, Any], store: Any, structUtils: Any) -> Dict[str, Any]:
+    clients = {}
+    if 'DEF' in spec and 'client' in spec['DEF']:
+        for client_name, client_val in structUtils.items(spec['DEF']['client']):
+            # Get client options
+            client_opts = client_val.get('test', {}).get('options', {})
+
+            # Apply store injections if needed
+            if isinstance(store, dict) and structUtils.inject:
+                structUtils.inject(client_opts, store)
+
+            # Create and store the client using the passed client object
+            clients[client_name] = client.tester(client_opts)
+
+    return clients
+
+
+def resolve_subject(name: str, container: Any):
+    return getattr(container, name, getattr(container.struct, name, None))
+
+
+def check_result(entry, args, res, structUtils):
+    matched = False
+
+    if 'match' in entry:
+        result = {'in': entry.get('in'), 'args': args, 'out': entry.get('res'), 'ctx': entry.get('ctx')}
+        match(
+            entry['match'],
+            result,
+            structUtils
+        )
+        matched = True
+
+    out = entry.get('out')
+
+    if out == res:
+        return
+
+    # NOTE: allow match with no out
+    if matched and (NULLMARK == out or out is None):
+        return
+
+    try:
+        cleaned_res = json.loads(json.dumps(res, default=str))
+    except:
+        # If can't be serialized just use the original
+        cleaned_res = res
+
+    # Compare result with expected output using deep equality
+    if cleaned_res != out:
+        raise AssertionError(
+            f"Expected: {out}, got: {cleaned_res}\n"
+            f"Test: {entry.get('name', 'unknown')}"
+        )
+
+
+def handle_error(entry, err, structUtils):
+    # Record the error in the entry
+    entry['thrown'] = err
+    entry_err = entry.get('err')
+
+    # If the test expects an error
+    if entry_err is not None:
+        # If it's any error or matches expected pattern
+        if entry_err is True or matchval(entry_err, str(err), structUtils):
+            # If we also need to match error details
+            if 'match' in entry:
+                match(
+                    entry['match'],
+                    {
+                        'in': entry.get('in'),
+                        'out': entry.get('res'),
+                        'ctx': entry.get('ctx'),
+                        'err': fixJSON(err)
+                    },
+                    structUtils
+                )
+            # Error was expected, continue
+            return True
+
+        # Expected error didn't match the actual error
+        raise AssertionError(
+            f"ERROR MATCH: [{structUtils.stringify(entry_err)}] <=> [{str(err)}]"
+        )
+    # If the test doesn't expect an error
+    elif isinstance(err, AssertionError):
+        # Propagate assertion errors with added context
+        raise AssertionError(
+            f"{str(err)}\nTest: {entry.get('name', 'unknown')}"
+        )
+    else:
+        # For other errors, include the full error stack
+        import traceback
+        raise AssertionError(
+            f"{traceback.format_exc()}\nTest: {entry.get('name', 'unknown')}"
+        )
+
+
+def resolve_testpack(
+        name,
+        entry,
+        subject,
+        client,
+        clients,
+):
+    testpack = {
+        "client": client,
+        "subject": subject,
+        "utility": client.utility(),
+    }
+
+    if 'client' in entry:
+        testpack["client"] = clients[entry['client']]
+        testpack["utility"] = testpack["client"].utility()
+        testpack["subject"] = resolve_subject(name, testpack["utility"])
+
+    return testpack
+
+
+def resolve_args(entry, testpack, utility, structUtils):
+    args = []
+
+    if 'ctx' in entry:
+        args = [entry['ctx']]
+    elif 'args' in entry:
+        args = entry['args']
+    elif 'in' in entry:
+        args = [structUtils.clone(entry['in'])]
+
+    # If we have context or arguments, we might need to patch them
+    if ('ctx' in entry or 'args' in entry) and len(args) > 0:
+        first = args[0]
+        if structUtils.ismap(first):
+            # Clone the argument
+            first = structUtils.clone(first)
+            first = utility.contextify(first)
+            args[0] = first
+            entry['ctx'] = first
+            first.client = testpack["client"]
+            first.utility = testpack["utility"]
+
+    return args
+
+
+def resolve_flags(flags: Dict[str, Any] = None) -> Dict[str, bool]:
+    if flags is None:
+        flags = {}
+
+    flags["null"] = flags.get("null", True)
+
+    return flags
+
+
+def resolve_entry(entry: Dict[str, Any], flags: Dict[str, bool]) -> Dict[str, Any]:
+    # Set default output value for missing 'out' field
+    if 'out' not in entry and flags.get("null", True):
+        entry["out"] = NULLMARK
+
+    return entry
+
+
+def fixJSON(obj, flags={}):
+    # Handle nulls
+    if obj is None:
+        return NULLMARK if flags.get("null", True) else None
+
+    # Handle errors
+    if isinstance(obj, Exception):
+        return {
+            **vars(obj),
+            'name': type(obj).__name__,
+            'message': str(obj)
+        }
+
+    # Handle collections recursively
+    elif isinstance(obj, list):
+        return [fixJSON(item, flags) for item in obj]
+    elif isinstance(obj, dict):
+        return {k: fixJSON(v, flags) for k, v in obj.items()}
+
+    # Return everything else unchanged
+    return obj
+
+
+def jsonfallback(obj):
+    return f"<non-serializable: {type(obj).__name__}>"
+
+
+def match(check, base, structUtils):
+    base = structUtils.clone(base)
+
+    # Use walk function to iterate through the check structure
+    def walk_apply(_key, val, _parent, path):
+        if not structUtils.isnode(val):
+            baseval = structUtils.getpath(base, path)
+
+            if baseval == val:
+                return val
+
+            # Explicit undefined expected
+            if UNDEFMARK == val and baseval is None:
+                return val
+
+            # Explicit defined expected
+            if EXISTSMARK == val and baseval is not None:
+                return val
+
+            if not matchval(val, baseval, structUtils):
+                raise AssertionError(
+                    f"MATCH: {'.'.join(map(str, path))}: "
+                    f"[{structUtils.stringify(val)}] <=> [{structUtils.stringify(baseval)}]"
+                )
+        return val
+
+    # Use walk to apply the check function to each node
+    structUtils.walk(check, walk_apply)
+
+
+def matchval(check, base, structUtils):
+    # Handle undefined special case
+    if check == '__UNDEF__' or check == NULLMARK:
+        check = None
+
+    if check == base:
+        return True
+
+    # String-based pattern matching
+    if isinstance(check, str):
+        # Convert base to string for comparison
+        base_str = structUtils.stringify(base)
+
+        # Check for regex pattern with /pattern/ syntax
+        regex_match = re.match(r'^/(.+)/$', check)
+
+        if regex_match:
+            pattern = regex_match.group(1)
+            return re.search(pattern, base_str) is not None
+        else:
+            # Case-insensitive substring check
+            return structUtils.stringify(check).lower() in base_str.lower()
+
+    # Functions automatically pass
+    elif callable(check):
+        return True
+
+    # No match
+    return False
+
+
+def nullModifier(val, key, parent, _state=None, _current=None, _store=None):
+    if NULLMARK == val:
+        parent[key] = None
+    elif isinstance(val, str):
+        parent[key] = val.replace(NULLMARK, "null")
+
+
+# StructTestClient shim for running struct tests in the SDK context.
+# Wraps voxgig_struct as the struct utility, providing the client
+# interface expected by the runner.
+
+class StructContext:
+    def __init__(self):
+        self.client = None
+        self.utility = None
+        self.meta = {}
+
+
+class StructTestUtility:
+    def __init__(self, opts=None):
+        self._opts = opts
+        self.struct = vs.StructUtility()
+
+    def contextify(self, ctxmap):
+        ctx = StructContext()
+        meta = ctxmap.get('meta', {})
+        for k, v in meta.items():
+            ctx.meta[k] = v
+        return ctx
+
+    def check(self, ctx):
+        zed = "ZED"
+
+        if self._opts is None:
+            zed += ""
+        else:
+            foo = self._opts.get("foo")
+            zed += "0" if foo is None else str(foo)
+
+        zed += "_"
+        zed += str(ctx.meta.get("bar"))
+
+        return {"zed": zed}
+
+
+class StructTestClient:
+    def __init__(self, opts=None):
+        self._opts = opts or {}
+        self._utility = StructTestUtility(opts)
+
+    @staticmethod
+    def test(opts=None):
+        return StructTestClient(opts)
+
+    def tester(self, opts=None):
+        return StructTestClient(self._opts if opts is None else opts)
+
+    def utility(self):
+        return self._utility
+
+
+# Export the necessary components similar to TypeScript
+__all__ = [
+    'NULLMARK',
+    'UNDEFMARK',
+    'nullModifier',
+    'makeRunner',
+    'StructTestClient',
+]