@voxgig/sdkgen 4.8.2 → 4.9.0

package/project/.sdk/tm/php/test/StructRunner.php

@@ -1,275 +0,0 @@
-<?php
-
-namespace Voxgig\Struct;
-
-use Exception;
-
-// Vendored from voxgig/struct/php
-require_once __DIR__ . '/../utility/struct/Struct.php';
-
-class Runner {
-
-    private const NULLMARK  = "__NULL__";
-    private const UNDEFMARK = "__UNDEF__";
-
-    public static function makeRunner(string $testfile, $client): callable {
-        return function (string $name, $store = null) use ($testfile, $client) {
-            $store = $store ?? [];
-            $utility = $client->utility();
-            $structUtils = $utility->struct;
-            $spec = self::resolveSpec($name, $testfile);
-            $clients = self::resolveClients($client, $spec, $store, $structUtils);
-            $subject = self::resolveSubject($name, $utility);
-
-            $runsetflags = function ($testspec, array $flags = [], $testsubject = null) use ($name, $client, $structUtils, &$subject, $clients) {
-                $subject = $testsubject ?? $subject;
-                $flags = self::resolveFlags($flags);
-                $testspecmap = self::fixJSON($testspec, $flags);
-                if (!isset($testspecmap['set']) || !is_array($testspecmap['set'])) {
-                    throw new Exception("Test specification 'set' is missing or not an array");
-                }
-                $testset = $testspecmap['set'];
-                foreach ($testset as &$entry) {
-                    try {
-                        $entry = self::resolveEntry($entry, $flags);
-                        $testpack = self::resolveTestPack($name, $entry, $subject, $client, $clients);
-                        $args = self::resolveArgs($entry, $testpack, $structUtils);
-                        $res = call_user_func_array($testpack['subject'], $args);
-                        $res = self::fixJSON($res, $flags);
-                        $entry['res'] = $res;
-                        self::checkResult($entry, $res, $structUtils);
-                    } catch (Exception $err) {
-                        self::handleError($entry, $err, $structUtils);
-                    }
-                }
-            };
-
-            $runset = function ($testspec, $testsubject = null) use ($runsetflags) {
-                $runsetflags($testspec, [], $testsubject);
-            };
-
-            return [
-                'spec'        => $spec,
-                'runset'      => $runset,
-                'runsetflags' => $runsetflags,
-                'subject'     => $subject,
-                'client'      => $client,
-            ];
-        };
-    }
-
-    private static function resolveSpec(string $name, string $testfile): array {
-        // If $testfile is an absolute path, use it as-is; otherwise, build a path relative to __DIR__
-        if (preg_match('/^(\/|[A-Za-z]:[\/\\\\])/', $testfile)) {
-            $path = $testfile;
-        } else {
-            $path = rtrim(__DIR__, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . $testfile;
-        }
-        $json = file_get_contents($path);
-        if ($json === false) {
-            throw new Exception("Unable to read test file at $path");
-        }
-        $alltests = json_decode($json, true);
-        if (isset($alltests['primary'][$name])) {
-            return $alltests['primary'][$name];
-        } elseif (isset($alltests[$name])) {
-            return $alltests[$name];
-        } else {
-            return $alltests;
-        }
-    }
-
-    private static function resolveClients($client, array $spec, $store, $structUtils): array {
-        $clients = [];
-        if (isset($spec['DEF']) && isset($spec['DEF']['client'])) {
-            foreach ($spec['DEF']['client'] as $cn => $cdef) {
-                $copts = $cdef['test']['options'] ?? [];
-                if (is_array($store) && method_exists($structUtils, 'inject')) {
-                    $structUtils->inject($copts, $store);
-                }
-                $clients[$cn] = $client->test($copts);
-            }
-        }
-        return $clients;
-    }
-
-    private static function resolveSubject(string $name, $container, $subject = null) {
-        return $subject ?? ($container->$name ?? null);
-    }
-
-    private static function resolveFlags($flags = null): array {
-        if ($flags === null) {
-            $flags = [];
-        }
-        $flags['null'] = $flags['null'] ?? true;
-        $flags['null'] = (bool)$flags['null'];
-        return $flags;
-    }
-
-    private static function resolveEntry($entry, array $flags) {
-        if (!isset($entry['out']) && $flags['null']) {
-            $entry['out'] = self::NULLMARK;
-        }
-        return $entry;
-    }
-
-    private static function checkResult(array $entry, $res, $structUtils) {
-        $matched = false;
-        if (isset($entry['match'])) {
-            $result = [
-                'in'  => $entry['in'] ?? null,
-                'out' => $entry['res'] ?? null,
-                'ctx' => $entry['ctx'] ?? null,
-            ];
-            self::match($entry['match'], $result, $structUtils);
-            $matched = true;
-        }
-        if (isset($entry['out']) && $entry['out'] === $res) {
-            return;
-        }
-        if ($matched && ($entry['out'] === self::NULLMARK || $entry['out'] === null)) {
-            return;
-        }
-        if (json_encode($res) !== json_encode($entry['out'])) {
-            throw new \AssertionError('Deep equality failed: expected ' .
-                $structUtils->stringify($entry['out']) . ' but got ' .
-                $structUtils->stringify($res));
-        }
-    }
-
-    private static function handleError(&$entry, \Exception $err, $structUtils) {
-        $entry['thrown'] = $err->getMessage();
-        if (isset($entry['err'])) {
-            if ($entry['err'] === true || self::matchval($entry['err'], $err->getMessage(), $structUtils)) {
-                if (isset($entry['match'])) {
-                    self::match(
-                        $entry['match'],
-                        [
-                            'in'  => $entry['in'] ?? null,
-                            'out' => $entry['res'] ?? null,
-                            'ctx' => $entry['ctx'] ?? null,
-                            'err' => $err->getMessage(),
-                        ],
-                        $structUtils
-                    );
-                }
-                return;
-            }
-            throw new \AssertionError('ERROR MATCH: [' . $structUtils->stringify($entry['err']) .
-                '] <=> [' . $err->getMessage() . ']');
-        } elseif ($err instanceof \AssertionError) {
-            throw new \AssertionError($err->getMessage() .
-                "\n\nENTRY: " . json_encode($entry, JSON_PRETTY_PRINT));
-        } else {
-            throw new Exception($err->getTraceAsString() .
-                "\n\nENTRY: " . json_encode($entry, JSON_PRETTY_PRINT));
-        }
-    }
-
-    private static function resolveArgs($entry, array $testpack, $structUtils): array {
-        $args = [];
-        if (isset($entry['in'])) {
-            $args[] = $structUtils->clone($entry['in']);
-        }
-        if (isset($entry['ctx'])) {
-            $args = [$entry['ctx']];
-        } elseif (isset($entry['args'])) {
-            $args = $entry['args'];
-        }
-        if ((isset($entry['ctx']) || isset($entry['args'])) && isset($args[0]) && is_array($args[0])) {
-            $first = $structUtils->clone($args[0]);
-            $first['client'] = $testpack['client'];
-            $first['utility'] = $testpack['utility'];
-            $args[0] = $first;
-            $entry['ctx'] = $first;
-        }
-        return $args;
-    }
-
-    private static function resolveTestPack(string $name, $entry, $subject, $client, array $clients): array {
-        $testpack = [
-            'client'  => $client,
-            'subject' => $subject,
-            'utility' => $client->utility(),
-        ];
-        if (isset($entry['client'])) {
-            $testpack['client'] = $clients[$entry['client']] ?? $client;
-            $testpack['utility'] = $testpack['client']->utility();
-            $testpack['subject'] = self::resolveSubject($name, $testpack['utility']);
-        }
-        return $testpack;
-    }
-
-    private static function match($check, $base, $structUtils): void {
-        $structUtils->walk($check, function ($key, $val, $parent, $path) use ($base, $structUtils) {
-            if (!is_array($val) && !is_object($val)) {
-                $baseval = $structUtils->getpath($base, $path);
-                if ($baseval === $val) {
-                    return;
-                }
-                if ($val === self::UNDEFMARK && $baseval === null) {
-                    return;
-                }
-                if (!self::matchval($val, $baseval, $structUtils)) {
-                    throw new \AssertionError(
-                        'MATCH: ' . implode('.', $path) .
-                        ': [' . $structUtils->stringify($val) .
-                        '] <=> [' . $structUtils->stringify($baseval) . ']'
-                    );
-                }
-            }
-        });
-    }
-
-    private static function matchval($check, $base, $structUtils): bool {
-        $pass = ($check === $base);
-        if (!$pass) {
-            if (is_string($check)) {
-                $basestr = $structUtils->stringify($base);
-                if (preg_match('/^\/(.+)\/$/', $check, $matches)) {
-                    $pass = preg_match('/' . $matches[1] . '/', $basestr) === 1;
-                } else {
-                    $pass = stripos($basestr, $structUtils->stringify($check)) !== false;
-                }
-            } elseif (is_callable($check)) {
-                $pass = true;
-            }
-        }
-        return $pass;
-    }
-
-    private static function fixJSON($val, array $flags) {
-        if ($val === null) {
-            return $flags['null'] ? self::NULLMARK : $val;
-        }
-        $replacer = function ($v) use ($flags, &$replacer) {
-            if ($v === null && $flags['null']) {
-                return self::NULLMARK;
-            }
-            if ($v instanceof \Exception) {
-                return array_merge(get_object_vars($v), [
-                    'name'    => get_class($v),
-                    'message' => $v->getMessage(),
-                ]);
-            }
-            if (is_array($v)) {
-                return array_map($replacer, $v);
-            }
-            if (is_object($v)) {
-                $arr = get_object_vars($v);
-                return array_map($replacer, $arr);
-            }
-            return $v;
-        };
-        $fixed = $replacer($val);
-        return json_decode(json_encode($fixed), true);
-    }
-
-    public static function nullModifier($val, $key, array &$parent) {
-        if ($val === self::NULLMARK) {
-            $parent[$key] = null;
-        } elseif (is_string($val)) {
-            $parent[$key] = str_replace('__NULL__', 'null', $val);
-        }
-    }
-}

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

@@ -1,411 +0,0 @@
-# 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 projectname_sdk.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',
-]