Skip to content

armgit / ODS

Public Imported from GitHub
0

ODS V3 Pre-Release: Public testing and refinement ahead of the official V3 launch. Turn your PC, Mac, or Linux box into a private AI server.

13.4 KB
Raw Blame
"""Exercise provider selection and immutable provisioning without contacting npm."""

import sys
if sys.platform == "win32":
    from unittest import SkipTest
    raise SkipTest("Requires POSIX host ownership, file locks, or Unix sockets; run under Linux/WSL")

import base64
import hashlib
import importlib.util
import io
import json
import os
import subprocess
from pathlib import Path
import tarfile
import tempfile
import unittest
from unittest.mock import patch, Mock

spec = importlib.util.spec_from_file_location(
    "native_search", Path(__file__).resolve().parents[1]
    / "extensions/services/pixel-agent/host/native_search.py")
ns = importlib.util.module_from_spec(spec)
spec.loader.exec_module(ns)


def archive(overrides=None, extra=()):
    files = {
        "package/package.json": json.dumps({"name": ns.PACKAGE, "version": ns.VERSION}).encode(),
        "package/openclaw.plugin.json": json.dumps({
            "id": "parallel", "contracts": {"webSearchProviders": ["parallel-free"]}}).encode(),
        "package/dist/index.js": b"// inert fixture\n",
    }
    files.update(overrides or {})
    out = io.BytesIO()
    with tarfile.open(fileobj=out, mode="w:gz") as bundle:
        for name, content in files.items():
            if content is None:
                continue
            entry = tarfile.TarInfo(name)
            entry.size = len(content)
            bundle.addfile(entry, io.BytesIO(content))
        for entry, content in extra:
            bundle.addfile(entry, io.BytesIO(content))
    return out.getvalue()


class NativeSearchTests(unittest.TestCase):
    def setUp(self):
        temp = tempfile.TemporaryDirectory()
        self.addCleanup(temp.cleanup)
        self.root = Path(temp.name)
        self.data = archive()
        # A valid baseline is required before each negative mutation.
        self.assertEqual(set(ns.archive_files(self.data)),
                         {"package.json", "openclaw.plugin.json", "dist/index.js"})

    def test_provider_choices_and_legacy_preservation(self):
        answers = self.root / "answers.json"
        self.assertEqual(ns.select_provider(answers), "parallel-free")
        for document, expected in [({}, "searxng"),
                                   ({"webSearchProvider": "searxng"}, "searxng"),
                                   ({"webSearchProvider": "parallel-free"}, "parallel-free")]:
            answers.write_text(json.dumps(document))
            answers.chmod(0o600)
            self.assertEqual(ns.select_provider(answers), expected)
            for explicit in ["searxng", "parallel-free"]:
                self.assertEqual(ns.select_provider(answers, explicit), explicit)
        for value in ["parallel", "unknown", None, 3, [], {}]:
            answers.write_text(json.dumps({"webSearchProvider": value}))
            with self.subTest(value=value), self.assertRaisesRegex(ValueError, "search provider"):
                ns.select_provider(answers)

    def test_download_recovers_interrupted_tls_and_partial_read(self):
        partial = Mock()
        partial.__enter__ = Mock(return_value=partial)
        partial.__exit__ = Mock(return_value=False)
        partial.read.side_effect = ns.http.client.IncompleteRead(b'partial')
        opener = Mock()
        opener.open.side_effect = [ns.urllib.error.URLError(ns.ssl.SSLEOFError('EOF')),
                                   partial, io.BytesIO(self.data)]
        integrity = base64.b64encode(hashlib.sha512(self.data).digest()).decode()
        with patch.object(ns.urllib.request, 'build_opener', return_value=opener), \
                patch.object(ns.time, 'sleep') as sleep, patch.object(ns, 'INTEGRITY', integrity):
            receipt = ns.prepare(self.root / 'recovered')
        self.assertTrue(receipt['changed'])
        self.assertEqual((self.root / 'recovered' / f'parallel-{ns.VERSION}.tgz').read_bytes(), self.data)
        self.assertEqual(opener.open.call_count, 3)
        self.assertEqual([call.args for call in sleep.call_args_list], [(1,), (2,)])
        for call in opener.open.call_args_list:
            self.assertEqual(call.args, (ns.URL,))
            self.assertEqual(call.kwargs, {'timeout': 30})

    def test_download_transient_failures_are_bounded_and_leave_no_cache(self):
        for error in [TimeoutError('timeout'), ConnectionResetError('reset'),
                      ns.urllib.error.HTTPError(ns.URL, 503, 'unavailable', {}, None)]:
            with self.subTest(error=type(error).__name__), tempfile.TemporaryDirectory() as tmp:
                opener = Mock()
                opener.open.side_effect = error
                with patch.object(ns.urllib.request, 'build_opener', return_value=opener), \
                        patch.object(ns.time, 'sleep') as sleep, self.assertRaises(type(error)):
                    ns.prepare(Path(tmp) / 'failed')
                self.assertEqual(opener.open.call_count, 3)
                self.assertEqual(sleep.call_count, 2)
                self.assertEqual([p.name for p in (Path(tmp) / 'failed').iterdir()], ['.install.lock'])

    def test_download_does_not_retry_certificate_http_or_integrity_refusals(self):
        for error in [ns.urllib.error.URLError(ns.ssl.SSLCertVerificationError('certificate')),
                      ns.urllib.error.HTTPError(ns.URL, 404, 'missing', {}, None),
                      ValueError('unexpected redirect')]:
            with self.subTest(error=str(error)):
                opener = Mock()
                opener.open.side_effect = error
                with patch.object(ns.urllib.request, 'build_opener', return_value=opener), \
                        patch.object(ns.time, 'sleep') as sleep, self.assertRaises(type(error)):
                    ns.download_archive()
                self.assertEqual(opener.open.call_count, 1)
                sleep.assert_not_called()
        opener = Mock()
        opener.open.return_value = io.BytesIO(b'untrusted partial archive')
        with patch.object(ns.urllib.request, 'build_opener', return_value=opener), \
                patch.object(ns.time, 'sleep') as sleep, self.assertRaisesRegex(ValueError, 'pinned release'):
            ns.download_archive()
        self.assertEqual(opener.open.call_count, 1)
        sleep.assert_not_called()

    def test_onboarding_requires_private_regular_file(self):
        answers = self.root / "answers.json"
        answers.write_text('{}')
        for mode in [0o640, 0o620, 0o602]:
            answers.chmod(mode)
            with self.subTest(mode=mode), self.assertRaisesRegex(ValueError, "owner-private"):
                ns.select_provider(answers)
        answers.chmod(0o600)
        link = self.root / "link"
        link.symlink_to(answers)
        with self.assertRaises(OSError):
            ns.select_provider(link)
        self.assertEqual(answers.read_text(), '{}')

    def test_cli_rejects_fifo_answers_and_cache_without_waiting_for_a_writer(self):
        for mode in ("answers", "cache"):
            with self.subTest(mode=mode):
                base = self.root / mode
                base.mkdir(mode=0o700)
                special = base / ("answers.json" if mode == "answers" else f"parallel-{ns.VERSION}.tgz")
                os.mkfifo(special, 0o600)
                before = special.lstat()
                args = ["--answers-file", str(special)] if mode == "answers" else ["--base-dir", str(base)]
                try:
                    result = subprocess.run([sys.executable, ns.__file__, *args],
                                            capture_output=True, text=True, timeout=3)
                except subprocess.TimeoutExpired:
                    self.fail("native search CLI blocked opening a FIFO before checking its type")
                self.assertEqual(result.returncode, 1)
                self.assertIn("owner-private regular file", result.stderr)
                self.assertNotIn("Traceback", result.stderr)
                self.assertEqual(result.stdout, "")
                self.assertEqual(special.lstat().st_ino, before.st_ino)
                self.assertFalse((base / f"parallel-{ns.VERSION}").exists())

        answers = self.root / "regular.json"
        answers.write_text('{"webSearchProvider":"parallel-free"}')
        answers.chmod(0o600)
        result = subprocess.run([sys.executable, ns.__file__, "--answers-file", str(answers)],
                                capture_output=True, text=True, timeout=3, check=True)
        self.assertEqual(result.stdout, "parallel-free\n")

    def test_archive_rejects_unsafe_names_and_duplicates(self):
        for name in ["package/../escape", "/escape", "package//empty", "package/./dot",
                     "package/a\\b", "package/a\nb", "package/a\x7fb", "package/dist/index.js"]:
            entry = tarfile.TarInfo(name)
            entry.size = 1
            with self.subTest(name=name), self.assertRaisesRegex(ValueError, "invalid search plugin archive entry"):
                ns.archive_files(archive(extra=[(entry, b'x')]))

    def test_archive_rejects_links_and_special_files(self):
        for kind in [tarfile.SYMTYPE, tarfile.LNKTYPE, tarfile.FIFOTYPE, tarfile.CHRTYPE, tarfile.BLKTYPE]:
            entry = tarfile.TarInfo("package/dist/extra")
            entry.type = kind
            entry.linkname = "outside"
            with self.subTest(kind=kind), self.assertRaisesRegex(ValueError, "invalid search plugin archive entry"):
                ns.archive_files(archive(extra=[(entry, b'')]))

    def test_archive_metadata_and_dependency_boundaries(self):
        for path, content in [
            ("package/package.json", b'{"name":"wrong","version":"2026.6.33"}'),
            ("package/package.json", b'{"name":"@openclaw/parallel-plugin","version":"0"}'),
            ("package/openclaw.plugin.json", b'{"id":"parallel","contracts":{"webSearchProviders":["parallel"]}}'),
            ("package/openclaw.plugin.json", None),
        ]:
            with self.subTest(path=path, content=content), self.assertRaisesRegex(ValueError, "identity or keyless provider contract"):
                ns.archive_files(archive({path: content}))
        with self.assertRaisesRegex(ValueError, "node_modules"):
            ns.archive_files(archive({"package/node_modules/x.js": b'x'}))

    def test_archive_size_and_entry_limits(self):
        with self.assertRaisesRegex(ValueError, "size limit"):
            ns.archive_files(b'x' * (ns.MAX_ARCHIVE + 1))
        with self.assertRaisesRegex(ValueError, "content exceeds"):
            ns.archive_files(archive({"package/huge": b'x' * (ns.MAX_ARCHIVE + 1)}))
        with self.assertRaisesRegex(ValueError, "content exceeds"):
            ns.archive_files(archive({f"package/big-{i}": b'x' * ns.MAX_ARCHIVE for i in range(5)}))
        with self.assertRaisesRegex(ValueError, "invalid search plugin archive entry"):
            ns.archive_files(archive({f"package/extra-{i}": b'' for i in range(65)}))

    def seeded(self, name="base"):
        base = self.root / name
        base.mkdir(mode=0o755)
        cache = base / f"parallel-{ns.VERSION}.tgz"
        cache.write_bytes(self.data)
        cache.chmod(0o600)
        return base, cache

    def prepare(self, base):
        integrity = base64.b64encode(hashlib.sha512(self.data).digest()).decode()
        with patch.object(ns, "INTEGRITY", integrity), patch.object(
                ns.urllib.request, "build_opener", side_effect=AssertionError("unexpected network")):
            return ns.prepare(base)

    def test_provision_and_reuse_preserve_exact_tree(self):
        base, _ = self.seeded()
        first = self.prepare(base)
        self.assertTrue(first["changed"])
        self.assertEqual(Path(first["path"], "dist/index.js").read_bytes(), b'// inert fixture\n')
        self.assertFalse(self.prepare(base)["changed"])

    def test_changed_installed_tree_is_retained_and_rejected(self):
        for change in ["modified", "missing", "extra-directory"]:
            with self.subTest(change=change):
                base, _ = self.seeded(change)
                target = Path(self.prepare(base)["path"])
                entry = target / "dist/index.js"
                if change == "modified":
                    entry.write_bytes(b'owner change')
                elif change == "missing":
                    entry.unlink()
                else:
                    (target / "extra").mkdir(mode=0o755)
                with self.assertRaisesRegex(ValueError, "immutable directory was retained"):
                    self.prepare(base)
                self.assertEqual(entry.exists(), change != "missing")
                if change == "modified":
                    self.assertEqual(entry.read_bytes(), b'owner change')
                if change == "extra-directory":
                    self.assertTrue((target / "extra").is_dir())

    def test_corrupt_cache_does_not_publish_or_overwrite(self):
        base, cache = self.seeded()
        cache.write_bytes(b'corrupt')
        with self.assertRaisesRegex(ValueError, "pinned release"):
            self.prepare(base)
        self.assertEqual(cache.read_bytes(), b'corrupt')
        self.assertFalse((base / f"parallel-{ns.VERSION}").exists())

    def test_symlink_base_and_cache_reject_without_external_change(self):
        base, cache = self.seeded()
        link = self.root / "link"
        link.symlink_to(base)
        with self.assertRaisesRegex(ValueError, "symbolic links"):
            self.prepare(link)
        outside = self.root / "outside"
        cache.rename(outside)
        cache.symlink_to(outside)
        with self.assertRaises(OSError):
            self.prepare(base)
        self.assertEqual(outside.read_bytes(), self.data)


if __name__ == "__main__":
    unittest.main()