lockss-turtles 0.6.0.dev2__py3-none-any.whl → 0.6.0.dev4__py3-none-any.whl

lockss/turtles/plugin_set.py

@@ -33,102 +33,78 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-import importlib.resources as IR
 import os
-from pathlib import Path, PurePath
+from pathlib import Path
 import shlex
 import subprocess
 import sys
-from typing import List, Tuple, Union
+from typing import Annotated, Any, ClassVar, Literal, Optional, Union
 
-from lockss.pybasic.fileutil import path
+from pydantic import BaseModel, Field
 
-from . import resources as __resources__
-from .plugin import Plugin
-from .util import YamlT, load_and_validate
+from .plugin import Plugin, PluginIdentifier
+from .util import BaseModelWithRoot
 
 
-class PluginSetCatalog(object):
+PluginSetCatalogKind = Literal['PluginSetCatalog']
 
-    PLUGIN_SET_CATALOG_SCHEMA = 'plugin-set-catalog-schema.json'
 
-    def __init__(self, parsed: YamlT) -> None:
-        super().__init__()
-        self._parsed: YamlT = parsed
+class PluginSetCatalog(BaseModelWithRoot):
+    kind: PluginSetCatalogKind = Field(description="This object's kind")
+    plugin_set_files: list[str] = Field(min_length=1, description="A non-empty list of plugin set files", title='Plugin Set Files', alias='plugin-set-files')
 
-    def get_plugin_set_files(self) -> List[str]:
-        return self._parsed['plugin-set-files']
+    def get_plugin_set_files(self) -> list[Path]:
+        return [self.get_root().joinpath(p) for p in self.plugin_set_files]
 
-    @staticmethod
-    def from_path(plugin_set_catalog_path: Union[PurePath, str]) -> PluginSetCatalog:
-        plugin_set_catalog_path = path(plugin_set_catalog_path)
-        with IR.path(__resources__, PluginSetCatalog.PLUGIN_SET_CATALOG_SCHEMA) as plugin_set_catalog_schema_path:
-            parsed = load_and_validate(plugin_set_catalog_schema_path, plugin_set_catalog_path)
-            return PluginSetCatalog(parsed)
 
+PluginSetBuilderType = Literal['ant', 'maven']
 
-class PluginSet(ABC):
 
-    PLUGIN_SET_SCHEMA = 'plugin-set-schema.json'
-
-    def __init__(self, parsed: YamlT) -> None:
-        super().__init__()
-        self._parsed: YamlT = parsed
+class BasePluginSetBuilder(BaseModelWithRoot, ABC):
+    TYPE_FIELD: ClassVar[dict[str, str]] = dict(description='A plugin builder type', title='Plugin Builder Type')
+    MAIN_FIELD: ClassVar[dict[str, str]] = dict(description="The path to the plugins' source code, relative to the root of the project", title='Main Code Path')
+    TEST_FIELD: ClassVar[dict[str, str]] = dict(description="The path to the plugins' unit tests, relative to the root of the project", title='Test Code Path')
 
     @abstractmethod
-    def build_plugin(self, plugin_id, keystore_path, keystore_alias, keystore_password=None) -> Tuple[Path, Plugin]:
+    def build_plugin(self, plugin_id: PluginIdentifier, keystore_path: Path, keystore_alias: str, keystore_password=None) -> tuple[Path, Plugin]:
         pass
 
-    def get_builder_type(self) -> str:
-        return self._parsed['builder']['type']
-
-    def get_id(self) -> str:
-        return self._parsed['id']
+    def get_main(self) -> Path:
+        return self.get_root().joinpath(self._get_main())
 
-    def get_name(self) -> str:
-        return self._parsed['name']
+    def get_test(self) -> Path:
+        return self.get_root().joinpath(self._get_test())
 
-    @abstractmethod
-    def has_plugin(self, plugin_id: str) -> bool:
-        pass
+    def get_type(self) -> PluginSetBuilderType:
+        return getattr(self, 'type')
 
-    @abstractmethod
-    def make_plugin(self, plugin_id: str) -> Plugin:
-        pass
+    def has_plugin(self, plugin_id: PluginIdentifier) -> bool:
+        return self._plugin_path(plugin_id).is_file()
 
-    @staticmethod
-    def from_path(plugin_set_file_path) -> List[PluginSet]:
-        plugin_set_file_path = path(plugin_set_file_path)
-        with IR.path(__resources__, PluginSet.PLUGIN_SET_SCHEMA) as plugin_set_schema_path:
-            lst = load_and_validate(plugin_set_schema_path, plugin_set_file_path, multiple=True)
-            return [PluginSet._from_obj(parsed, plugin_set_file_path) for parsed in lst]
+    def make_plugin(self, plugin_id: PluginIdentifier) -> Plugin:
+        return Plugin.from_path(self._plugin_path(plugin_id))
 
-    @staticmethod
-    def _from_obj(parsed: YamlT, plugin_set_file_path: Path) -> PluginSet:
-        typ = parsed['builder']['type']
-        if typ == AntPluginSet.TYPE:
-            return AntPluginSet(parsed, plugin_set_file_path)
-        elif typ == MavenPluginSet.TYPE:
-            return MavenPluginSet(parsed, plugin_set_file_path)
-        else:
-            raise Exception(f'{plugin_set_file_path!s}: unknown builder type: {typ}')
+    def _get_main(self) -> str:
+        return getattr(self, 'main')
 
+    def _get_test(self) -> str:
+        return getattr(self, 'test')
 
-class AntPluginSet(PluginSet):
+    def _plugin_path(self, plugin_id: PluginIdentifier) -> Path:
+        return self.get_main_path().joinpath(Plugin.id_to_file(plugin_id))
 
-    TYPE = 'ant'
 
-    DEFAULT_MAIN = 'plugins/src'
+class AntPluginSetBuilder(BasePluginSetBuilder):
+    DEFAULT_MAIN: ClassVar[str] = 'plugins/src'
+    DEFAULT_TEST: ClassVar[str] = 'plugins/test/src'
 
-    DEFAULT_TEST = 'plugins/test/src'
+    type: Literal['ant'] = Field(**BasePluginSetBuilder.TYPE_FIELD)
+    main: Optional[str] = Field(DEFAULT_MAIN, **BasePluginSetBuilder.MAIN_FIELD)
+    test: Optional[str] = Field(DEFAULT_TEST, **BasePluginSetBuilder.TEST_FIELD)
 
-    def __init__(self, parsed: YamlT, fpath: Path) -> None:
-        super().__init__(parsed)
-        self._built: bool = False
-        self._root: Path = fpath.parent
+    _built: bool
 
-    # Returns (jar_path, plugin)
-    def build_plugin(self, plugin_id, keystore_path, keystore_alias, keystore_password=None) -> Tuple[Path, Plugin]:
+    def build_plugin(self, plugin_id: PluginIdentifier, keystore_path: Path, keystore_alias: str, keystore_password=None) -> tuple[Path, Plugin]:
         # Prerequisites
         if 'JAVA_HOME' not in os.environ:
             raise Exception('error: JAVA_HOME must be set in your environment')
@@ -137,39 +113,18 @@ class AntPluginSet(PluginSet):
         # Little build
         return self._little_build(plugin_id, keystore_path, keystore_alias, keystore_password=keystore_password)
 
-    def get_main(self) -> str:
-        return self._parsed.get('main', AntPluginSet.DEFAULT_MAIN)
-
-    def get_main_path(self) -> Path:
-        return self.get_root_path().joinpath(self.get_main())
-
-    def get_root(self) -> Path:
-        return self._root
-
-    def get_root_path(self) -> Path:
-        return self.get_root().expanduser().resolve()
-
-    def get_test(self) -> str:
-        return self._parsed.get('test', AntPluginSet.DEFAULT_TEST)
-
-    def get_test_path(self) -> Path:
-        return self.get_root_path().joinpath(self.get_test())
-
-    def has_plugin(self, plugin_id: str) -> bool:
-        return self._plugin_path(plugin_id).is_file()
-
-    def make_plugin(self, plugin_id: str) -> Plugin:
-        return Plugin.from_path(self._plugin_path(plugin_id))
+    def model_post_init(self, context: Any) -> None:
+        super().model_post_init(context)
+        self._built = False
 
     def _big_build(self) -> None:
         if not self._built:
             # Do build
             subprocess.run('ant load-plugins',
-                           shell=True, cwd=self.get_root_path(), check=True, stdout=sys.stdout, stderr=sys.stderr)
+                           shell=True, cwd=self.get_root(), check=True, stdout=sys.stdout, stderr=sys.stderr)
             self._built = True
 
-    # Returns (jar_path, plugin)
-    def _little_build(self, plugin_id: str, keystore_path: Path, keystore_alias: str, keystore_password: str=None) -> Tuple[Path, Plugin]:
+    def _little_build(self, plugin_id: PluginIdentifier, keystore_path: Path, keystore_alias: str, keystore_password: str=None) -> tuple[Path, Plugin]:
         orig_plugin = None
         cur_id = plugin_id
         # Get all directories for jarplugin -d
@@ -187,14 +142,14 @@ class AntPluginSet(PluginSet):
             cur_id = cur_plugin.get_parent_identifier()
         # Invoke jarplugin
         jar_fstr = Plugin.id_to_file(plugin_id)
-        jar_path = self.get_root_path().joinpath('plugins/jars', f'{plugin_id}.jar')
+        jar_path = self.get_root().joinpath('plugins/jars', f'{plugin_id}.jar')
         jar_path.parent.mkdir(parents=True, exist_ok=True)
         cmd = ['test/scripts/jarplugin',
                '-j', str(jar_path),
                '-p', str(jar_fstr)]
         for d in dirs:
             cmd.extend(['-d', d])
-        subprocess.run(cmd, cwd=self.get_root_path(), check=True, stdout=sys.stdout, stderr=sys.stderr)
+        subprocess.run(cmd, cwd=self.get_root(), check=True, stdout=sys.stdout, stderr=sys.stderr)
         # Invoke signplugin
         cmd = ['test/scripts/signplugin',
                '--jar', str(jar_path),
@@ -203,14 +158,14 @@ class AntPluginSet(PluginSet):
         if keystore_password is not None:
             cmd.extend(['--password', keystore_password])
         try:
-            subprocess.run(cmd, cwd=self.get_root_path(), check=True, stdout=sys.stdout, stderr=sys.stderr)
+            subprocess.run(cmd, cwd=self.get_root(), check=True, stdout=sys.stdout, stderr=sys.stderr)
         except subprocess.CalledProcessError as cpe:
             raise self._sanitize(cpe)
         if not jar_path.is_file():
             raise FileNotFoundError(str(jar_path))
         return jar_path, orig_plugin
 
-    def _plugin_path(self, plugin_id: str) -> Path:
+    def _plugin_path(self, plugin_id: PluginIdentifier) -> Path:
         return self.get_main_path().joinpath(Plugin.id_to_file(plugin_id))
 
     def _sanitize(self, called_process_error: subprocess.CalledProcessError) -> subprocess.CalledProcessError:
@@ -222,47 +177,23 @@ class AntPluginSet(PluginSet):
         return called_process_error
 
 
-class MavenPluginSet(PluginSet):
-
-    TYPE = 'maven'
-
-    DEFAULT_MAIN = 'src/main/java'
+class MavenPluginSetBuilder(BasePluginSetBuilder):
+    DEFAULT_MAIN: ClassVar[str] = 'src/main/java'
+    DEFAULT_TEST: ClassVar[str] = 'src/test/java'
 
-    DEFAULT_TEST = 'src/test/java'
+    type: Literal['maven'] = Field(**BasePluginSetBuilder.TYPE_FIELD)
+    main: Optional[str] = Field(DEFAULT_MAIN, **BasePluginSetBuilder.MAIN_FIELD)
+    test: Optional[str] = Field(DEFAULT_TEST, **BasePluginSetBuilder.TEST_FIELD)
 
-    def __init__(self, parsed: YamlT, root: Path) -> None:
-        super().__init__(parsed)
-        self._built: bool = False
-        self._root: Path = root.parent
+    _built: bool
 
-    # Returns (jar_path, plugin)
-    def build_plugin(self, plugin_id: str, keystore_path: Path, keystore_alias: str, keystore_password=None) -> Tuple[Path, Plugin]:
+    def build_plugin(self, plugin_id: PluginIdentifier, keystore_path: Path, keystore_alias: str, keystore_password=None) -> tuple[Path, Plugin]:
         self._big_build(keystore_path, keystore_alias, keystore_password=keystore_password)
         return self._little_build(plugin_id)
 
-    def get_main(self) -> str:
-        return self._parsed.get('main', MavenPluginSet.DEFAULT_MAIN)
-
-    def get_main_path(self) -> Path:
-        return self.get_root_path().joinpath(self.get_main())
-
-    def get_root(self) -> Path:
-        return self._root
-
-    def get_root_path(self) -> Path:
-        return self.get_root().expanduser().resolve()
-
-    def get_test(self) -> str:
-        return self._parsed.get('test', MavenPluginSet.DEFAULT_TEST)
-
-    def get_test_path(self) -> Path:
-        return self.get_root_path().joinpath(self.get_test())
-
-    def has_plugin(self, plugin_id) -> bool:
-        return self._plugin_path(plugin_id).is_file()
-
-    def make_plugin(self, plugin_id) -> Plugin:
-        return Plugin.from_path(self._plugin_path(plugin_id))
+    def model_post_init(self, context: Any) -> None:
+        super().model_post_init(context)
+        self._built = False
 
     def _big_build(self, keystore_path: Path, keystore_alias: str, keystore_password: str=None) -> None:
         if not self._built:
@@ -272,21 +203,17 @@ class MavenPluginSet(PluginSet):
                    f'-Dkeystore.alias={keystore_alias}',
                    f'-Dkeystore.password={keystore_password}']
             try:
-                subprocess.run(cmd, cwd=self.get_root_path(), check=True, stdout=sys.stdout, stderr=sys.stderr)
+                subprocess.run(cmd, cwd=self.get_root(), check=True, stdout=sys.stdout, stderr=sys.stderr)
             except subprocess.CalledProcessError as cpe:
                 raise self._sanitize(cpe)
             self._built = True
 
-    # Returns (jar_path, plugin)
-    def _little_build(self, plugin_id: str) -> Tuple[Path, Plugin]:
-        jar_path = self.get_root_path().joinpath('target', 'pluginjars', f'{plugin_id}.jar')
+    def _little_build(self, plugin_id: PluginIdentifier) -> tuple[Path, Plugin]:
+        jar_path = self.get_root().joinpath('target', 'pluginjars', f'{plugin_id}.jar')
         if not jar_path.is_file():
             raise Exception(f'{plugin_id}: built JAR not found: {jar_path!s}')
         return jar_path, Plugin.from_jar(jar_path)
 
-    def _plugin_path(self, plugin_id) -> Path:
-        return self.get_main_path().joinpath(Plugin.id_to_file(plugin_id))
-
     def _sanitize(self, called_process_error: subprocess.CalledProcessError) -> subprocess.CalledProcessError:
         cmd = called_process_error.cmd[:]
         for i in range(len(cmd)):
@@ -294,3 +221,41 @@ class MavenPluginSet(PluginSet):
                 cmd[i] = '-Dkeystore.password=<password>'
         called_process_error.cmd = ' '.join([shlex.quote(c) for c in cmd])
         return called_process_error
+
+
+PluginSetBuilder = Annotated[Union[AntPluginSetBuilder, MavenPluginSetBuilder], Field(discriminator='type')]
+
+
+PluginSetKind = Literal['PluginSet']
+
+
+PluginSetIdentifier = str
+
+
+class PluginSet(BaseModel):
+    kind: PluginSetKind = Field(description="This object's kind")
+    id: PluginSetIdentifier = Field(description='An identifier for the plugin set')
+    name: str = Field(description='A name for the plugin set')
+    builder: PluginSetBuilder = Field(description='A builder for the plugin set', title='Plugin Set Builder')
+
+    def build_plugin(self, plugin_id: PluginIdentifier, keystore_path: Path, keystore_alias: str, keystore_password=None) -> tuple[Path, Plugin]:
+        return self.builder.build_plugin(plugin_id, keystore_path, keystore_alias, keystore_password)
+
+    def get_builder(self) -> PluginSetBuilder:
+        return self.builder
+
+    def get_id(self) -> PluginSetIdentifier:
+        return self.id
+
+    def get_name(self) -> str:
+        return self.name
+
+    def has_plugin(self, plugin_id: PluginIdentifier) -> bool:
+        return self.get_builder().has_plugin(plugin_id)
+
+    def make_plugin(self, plugin_id: PluginIdentifier) -> Plugin:
+        return self.get_builder().make_plugin(plugin_id)
+
+    def _initialize(self, root: Path) -> PluginSet:
+        self.get_builder()._initialize(root)
+        return self

lockss/turtles/util.py

@@ -28,26 +28,37 @@
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 
-import json
+# Remove in Python 3.14
+# See https://stackoverflow.com/questions/33533148/how-do-i-type-hint-a-method-with-the-type-of-the-enclosing-class/33533514#33533514
+from __future__ import annotations
+
+from collections.abc import Iterable
 from pathlib import Path
-from typing import Any, List, TypeAlias, Union
+from typing import Any, Optional, Union
+
+from lockss.pybasic.fileutil import path
+from pydantic import BaseModel
+
+
+# Candidate for lockss-pybasic
+PathOrStr = Union[Path, str]
+
+
+class BaseModelWithRoot(BaseModel):
+    _root: Optional[Path]
 
-import jsonschema
-import jsonschema.exceptions
-import yaml
+    def model_post_init(self, context: Any) -> None:
+        self._root = None
 
+    def get_root(self) -> Path:
+        if self._root is None:
+            raise RuntimeError('Uninitialized root')
+        return self._root
 
-YamlT: TypeAlias = Any
+    def initialize(self, root: PathOrStr) -> BaseModelWithRoot:
+        self._root = path(root)
+        return self
 
 
-def load_and_validate(schema_path: Path, instance_path: Path, multiple: bool=False) -> Union[List[YamlT], YamlT]:
-    with schema_path.open('r') as f:
-        schema = json.load(f)
-    with instance_path.open('r') as f:
-        ret = list(yaml.safe_load_all(f)) if multiple else [yaml.safe_load(f)]
-    for instance in ret:
-        try:
-            jsonschema.validate(instance, schema)
-        except jsonschema.exceptions.ValidationError as validation_exception:
-            raise Exception(validation_exception.message) from validation_exception
-    return ret if multiple else ret[0]
+def file_or(paths: Iterable[Path]) -> str:
+    return ' or '.join(map(str, paths))

{lockss_turtles-0.6.0.dev2.dist-info → lockss_turtles-0.6.0.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lockss-turtles
-Version: 0.6.0.dev2
+Version: 0.6.0.dev4
 Summary: Library and command line tool to manage LOCKSS plugin sets and LOCKSS plugin registries
 License: BSD-3-Clause
 Author: Thib Guicherd-Callin
@@ -19,9 +19,8 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: System :: Archiving
 Classifier: Topic :: Utilities
 Requires-Dist: java-manifest (>=1.1.0,<1.2.0)
-Requires-Dist: jsonschema (>=4.24.0,<4.25.0)
 Requires-Dist: lockss-pybasic (>=0.1.0,<0.2.0)
-Requires-Dist: pydantic (>=2.11.7,<3.0.0)
+Requires-Dist: pydantic (>=2.11.0,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.0,<6.1.0)
 Requires-Dist: xdg (>=6.0.0,<6.1.0)
 Project-URL: Documentation, https://docs.lockss.org/en/latest/software/turtles

lockss_turtles-0.6.0.dev4.dist-info/RECORD

@@ -0,0 +1,15 @@
+lockss/turtles/__init__.py,sha256=Ts53KN-wrOJ3oRXXsPX3M75HTrGe7TthpeUrY47G6_E,1743
+lockss/turtles/__main__.py,sha256=825geLIwXS0LKRqxifJXlLaAZrY8nllXfHzw5ch5ysM,1624
+lockss/turtles/app.py,sha256=aMWuYsY88FV1YTjcnXDhKHoAYh47i819y9qa9nJMrFE,13312
+lockss/turtles/cli.py,sha256=pLZAG1hmYarCp0R4vHSJcTs3G1umk2esvaLhM5JX7rg,18435
+lockss/turtles/plugin.py,sha256=re44YVlzXVU8azDshxn7oHw1GdTQLLQgYwkvZlur-60,5384
+lockss/turtles/plugin_registry.py,sha256=pIQOzrastTxeJsny3CV2GhhYO0iQflPdJAxSIdxAiYY,11095
+lockss/turtles/plugin_set.py,sha256=Lueg3KcsJ1MEh8CFa48UbhFoO_7PB5KB6ynCpMCOI0M,11299
+lockss/turtles/util.py,sha256=wGCrw_YySvyqaCzT0PItzXpkLHOCMMC_DQHhGU7zudI,2500
+unittest/lockss/turtles/__init__.py,sha256=hrgWx4GaP-hhPBuRlbLndJnOQmZicKCLaP-dQTCu1sQ,3162
+unittest/lockss/turtles/test_plugin_set.py,sha256=i-VM8mvrPuW2KqUlh2HPVRtgh3-F7RhmRAwcvhwpoDA,3354
+lockss_turtles-0.6.0.dev4.dist-info/LICENSE,sha256=O9ONND4uDxY_jucI4jZDf2liAk05ScEJaYu-Al7EOdQ,1506
+lockss_turtles-0.6.0.dev4.dist-info/METADATA,sha256=ji_iWkIEQ2UHv3xbYDPvUwZrzun9IOeSpHRNnVae9bo,39610
+lockss_turtles-0.6.0.dev4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+lockss_turtles-0.6.0.dev4.dist-info/entry_points.txt,sha256=25BAVFSBRKWAWiXIGZgcr1ypt2mV7nj31Jl8WcNZZOk,51
+lockss_turtles-0.6.0.dev4.dist-info/RECORD,,

unittest/lockss/turtles/__init__.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2000-2025, Board of Trustees of Leland Stanford Jr. University
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+from collections.abc import Callable
+from pydantic import ValidationError
+from pydantic_core import ErrorDetails
+from typing import Any, Optional, Tuple, Union
+from unittest import TestCase
+
+
+Loc = Union[Tuple[str], str]
+
+
+class PydanticTestCase(TestCase):
+
+    def _assertPydanticValidationError(self,
+                                       func: Callable[[], Any],
+                                       matcher: Callable[[ErrorDetails], bool],
+                                       msg: Optional[str]=None):
+        with self.assertRaises(ValidationError) as cm:
+            func()
+            self.fail('Expected ValidationError but did not get one')
+        self.assertIsInstance(cm.exception, ValidationError)
+        ve: ValidationError = cm.exception
+        for e in ve.errors():
+            if matcher(e):
+                return
+        self.fail(msg or f'Did not get a matching ValidationError; got:\n{"\n".join([str(e) for e in ve.errors()])}\n{ve!s}')
+
+    def assertPydanticMissing(self, func: Callable[[], Any], loc: Loc, msg=None) -> None:
+        if isinstance(loc, str):
+            loc = (loc,)
+        self._assertPydanticValidationError(func, lambda e: e.get('type') == 'missing' and e.get('loc') == loc)
+
+    def assertPydanticLiteralError(self, func: Callable[[], Any], loc: Loc, expected: str, msg=None) -> None:
+        if isinstance(loc, str):
+            loc = (loc,)
+        self._assertPydanticValidationError(func, lambda e: e.get('type') == 'literal_error' and e.get('loc') == loc and (ctx := e.get('ctx')) and ctx.get('expected') == repr(expected))

unittest/lockss/turtles/test_plugin_set.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2000-2025, Board of Trustees of Leland Stanford Jr. University
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+from . import PydanticTestCase
+from lockss.turtles.plugin_set import AntPluginSetBuilder, MavenPluginSetBuilder, PluginSet, PluginSetBuilder
+
+
+class TestPluginSet(PydanticTestCase):
+
+    def setUp(self):
+        pass
+
+    def testPluginSet(self):
+        self.assertPydanticMissing(lambda: PluginSet(), 'kind')
+        self.assertPydanticLiteralError(lambda: PluginSet(kind='WrongKind'), 'kind', 'PluginSet')
+        self.assertPydanticMissing(lambda: PluginSet(kind='PluginSet'), 'id')
+        self.assertPydanticMissing(lambda: PluginSet(kind='PluginSet', id='myid'), 'name')
+        self.assertPydanticMissing(lambda: PluginSet(kind='PluginSet', id='myset', name='My Set'), 'builder')
+        PluginSet(kind='PluginSet', id='myset', name='My Set', builder=AntPluginSetBuilder(type='ant'))
+        PluginSet(kind='PluginSet', id='myset', name='My Set', builder=MavenPluginSetBuilder(type='maven'))
+
+class TestPluginSetBuilder(PydanticTestCase):
+
+    def doTestPluginSetBuilder(self, Pbsc: type(PluginSetBuilder), typ: str, def_main: str, def_test: str) -> None:
+        self.assertPydanticMissing(lambda: Pbsc(), 'type')
+        self.assertPydanticLiteralError(lambda: Pbsc(type='BADTYPE'), 'type', typ)
+        self.assertIsNone(Pbsc(type=typ)._root)
+        self.assertEqual(Pbsc(type=typ)._get_main(), def_main)
+        self.assertEqual(Pbsc(type=typ, main='mymain')._get_main(), 'mymain')
+        self.assertEqual(Pbsc(type=typ)._get_test(), def_test)
+        self.assertEqual(Pbsc(type=typ, test='mytest')._get_test(), 'mytest')
+
+    def testPluginSetBuilder(self):
+        self.doTestPluginSetBuilder(AntPluginSetBuilder, 'ant', 'plugins/src', 'plugins/test/src')
+        self.doTestPluginSetBuilder(MavenPluginSetBuilder, 'maven', 'src/main/java', 'src/test/java')

lockss/turtles/resources/__init__.py

@@ -1,29 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2000-2024, Board of Trustees of Leland Stanford Jr. University
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# 1. Redistributions of source code must retain the above copyright notice,
-# this list of conditions and the following disclaimer.
-#
-# 2. Redistributions in binary form must reproduce the above copyright notice,
-# this list of conditions and the following disclaimer in the documentation
-# and/or other materials provided with the distribution.
-#
-# 3. Neither the name of the copyright holder nor the names of its contributors
-# may be used to endorse or promote products derived from this software without
-# specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.

lockss/turtles/resources/plugin-registry-catalog-schema.json

@@ -1,27 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://assets.lockss.org/schemas/json/plugin-registry-catalog-schema.json",
-  "title": "Plugin Registry Catalog",
-  "description": "LOCKSS plugin registry catalog",
-  "type": "object",
-  "required": [
-    "kind",
-    "plugin-registry-files"
-  ],
-  "properties": {
-    "kind": {
-      "description": "This object's kind",
-      "type": "string",
-      "const": "PluginRegistryCatalog"
-    },
-    "plugin-registry-files": {
-      "description": "A list of plugin registry files",
-      "type": "array",
-      "minItems": 1,
-      "uniqueItems": true,
-      "items": {
-        "type": "string"
-      }
-    }
-  }
-}