lockss-turtles 0.6.0.dev24__py3-none-any.whl → 0.6.0.dev26__py3-none-any.whl

unittest/lockss/turtles/test_plugin_set.py

@@ -28,50 +28,247 @@
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 
+# 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 abc import ABC, abstractmethod
 from pathlib import Path
 
-from . import PydanticTestCase
-from lockss.turtles.plugin_set import AntPluginSetBuilder, MavenPluginSetBuilder, PluginSet, PluginSetBuilder, PluginSetBuilderType
+from . import PydanticTestCase, ROOT
+from lockss.turtles.plugin_set import AntPluginSetBuilder, BasePluginSetBuilder, MavenPluginSetBuilder, PluginSet, PluginSetBuilderType, PluginSetCatalog
 
 
-ROOT: Path = Path('.').absolute()
+class TestPluginSetCatalog(PydanticTestCase):
 
+    def setUp(self) -> None:
+        super().setUp()
+        self.valid_absolute = PluginSetCatalog(**{'kind': 'PluginSetCatalog',
+                                                  'plugin-set-files': [
+                                                      '/tmp/one.yaml'
+                                                  ]}).initialize(ROOT)
+        self.valid_relative = PluginSetCatalog(**{'kind': 'PluginSetCatalog',
+                                                  'plugin-set-files': [
+                                                      'one.yaml'
+                                                  ]}).initialize(ROOT)
+        self.valid = [self.valid_absolute, self.valid_relative]
 
-class TestPluginSet(PydanticTestCase):
+    def test_missing_kind(self) -> None:
+        self.assertPydanticMissing(lambda: PluginSetCatalog(),
+                                   'kind')
+
+    def test_null_kind(self) -> None:
+        self.assertPydanticLiteralError(lambda: PluginSetCatalog(kind=None),
+                                        'kind',
+                                        'PluginSetCatalog')
+
+    def test_wrong_kind(self) -> None:
+        self.assertPydanticLiteralError(lambda: PluginSetCatalog(kind='WrongKind'),
+                                        'kind',
+                                        'PluginSetCatalog')
+
+    def test_missing_plugin_registry_files(self) -> None:
+        self.assertPydanticMissing(lambda: PluginSetCatalog(),
+                                   'plugin-set-files')
+
+    def test_null_plugin_registry_files(self) -> None:
+        self.assertPydanticListType(lambda: PluginSetCatalog(**{'plugin-set-files': None}),
+                                    'plugin-set-files')
+
+    def test_empty_plugin_registry_files(self) -> None:
+        self.assertPydanticTooShort(lambda: PluginSetCatalog(**{'plugin-set-files': []}),
+                                    'plugin-set-files')
+
+    def test_uninitialized(self) -> None:
+        psc = PluginSetCatalog(**{'kind': 'PluginSetCatalog',
+                                  'plugin-set-files': ['whatever']})
+        self.assertRaises(ValueError, lambda: psc.get_root())
+        self.assertRaises(ValueError, lambda: psc.get_plugin_set_files())
 
-    def setUp(self):
+    def test_kind(self) -> None:
+        for valid in self.valid:
+            self.assertEqual(valid.kind, 'PluginSetCatalog')
+
+    def test_get_plugin_set_files(self) -> None:
+        self.assertListEqual(self.valid_absolute.get_plugin_set_files(),
+                             [Path('/tmp/one.yaml')])
+        self.assertListEqual(self.valid_relative.get_plugin_set_files(),
+                             [ROOT.joinpath('one.yaml')])
+
+
+# Important: see "del _BasePluginSetBuilderTestCase" at the end
+class _BasePluginSetBuilderTestCase(ABC, PydanticTestCase):
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.valid_absolute = self.instance(type=self.type(),
+                                            main='/tmp/maindir',
+                                            test='/tmp/testdir').initialize(ROOT)
+        self.valid_relative = self.instance(type=self.type(),
+                                            main='maindir',
+                                            test='testdir').initialize(ROOT)
+        self.valid = [self.valid_absolute, self.valid_relative]
+
+    @abstractmethod
+    def instance(self, **kwargs) -> BasePluginSetBuilder:
+        pass
+
+    @abstractmethod
+    def type(self) -> PluginSetBuilderType:
         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: PluginSetBuilderType, def_main: Path, def_test: Path) -> None:
-        self.assertPydanticMissing(lambda: Pbsc(), 'type')
-        self.assertPydanticLiteralError(lambda: Pbsc(type='BADTYPE'), 'type', typ)
-        self.assertIsNone(Pbsc(type=typ)._root)
-        with self.assertRaises(ValueError):
-            Pbsc(type=typ).get_root()
-        self.assertEqual(Pbsc(type=typ).initialize(ROOT).get_root(), ROOT)
-        with self.assertRaises(ValueError):
-            Pbsc(type=typ, main='anything').get_main()
-        self.assertEqual(Pbsc(type=typ).initialize(ROOT).get_main(), def_main)
-        self.assertEqual(Pbsc(type=typ, main='mymain').initialize(ROOT).get_main(), ROOT.joinpath('mymain'))
-        self.assertEqual(Pbsc(type=typ, main='/opt/main').initialize(ROOT).get_main(), Path('/opt/main'))
-        with self.assertRaises(ValueError):
-            Pbsc(type=typ, test='anything').get_test()
-        self.assertEqual(Pbsc(type=typ).initialize(ROOT).get_test(), def_test)
-        self.assertEqual(Pbsc(type=typ, test='mytest').initialize(ROOT).get_test(), ROOT.joinpath('mytest'))
-        self.assertEqual(Pbsc(type=typ, test='/opt/test').initialize(ROOT).get_test(), Path('/opt/test'))
-
-    def testPluginSetBuilder(self):
-        self.doTestPluginSetBuilder(AntPluginSetBuilder, 'ant', ROOT.joinpath('plugins/src'), ROOT.joinpath('plugins/test/src'))
-        self.doTestPluginSetBuilder(MavenPluginSetBuilder, 'maven', ROOT.joinpath('src/main/java'), ROOT.joinpath('src/test/java'))
+    @abstractmethod
+    def default_main(self) -> str:
+        pass
+
+    @abstractmethod
+    def default_test(self) -> str:
+        pass
+
+    def test_missing_type(self) -> None:
+        self.assertPydanticMissing(lambda: self.instance(),
+                                   'type')
+
+    def test_null_type(self) -> None:
+        self.assertPydanticLiteralError(lambda: self.instance(type=None),
+                                       'type',
+                                        self.type())
+
+    def test_default_main(self) -> None:
+        self.assertEqual(getattr(self.instance(type=self.type()), '_get_main')(),
+                         self.default_main())
+
+    def test_null_main(self) -> None:
+        self.assertPydanticStringType(lambda: self.instance(main=None),
+                                      'main')
+
+    def test_default_test(self) -> None:
+        self.assertEqual(getattr(self.instance(type=self.type()), '_get_test')(),
+                         self.default_test())
+
+    def test_null_test(self) -> None:
+        self.assertPydanticStringType(lambda: self.instance(test=None),
+                                      'test')
+
+    def test_uninitialized(self) -> None:
+        psb = self.instance(type=self.type(),
+                            main='mainpath',
+                            test='testpath')
+        self.assertRaises(ValueError, lambda: psb.get_root())
+        self.assertRaises(ValueError, lambda: psb.get_main())
+        self.assertRaises(ValueError, lambda: psb.get_test())
+
+    def test_get_type(self) -> None:
+        for valid in self.valid:
+            self.assertEqual(valid.get_type(), self.type())
+
+    def test_get_main(self) -> None:
+        self.assertEqual(self.valid_absolute.get_main(), Path('/tmp/maindir'))
+        self.assertEqual(self.valid_relative.get_main(), ROOT.joinpath('maindir'))
+
+    def test_get_test(self) -> None:
+        self.assertEqual(self.valid_absolute.get_test(), Path('/tmp/testdir'))
+        self.assertEqual(self.valid_relative.get_test(), ROOT.joinpath('testdir'))
+
+class TestMavenPluginSetBuilder(_BasePluginSetBuilderTestCase):
+
+    def instance(self, **kwargs) -> MavenPluginSetBuilder:
+        return MavenPluginSetBuilder(**kwargs)
+
+    def type(self) -> PluginSetBuilderType:
+        return 'maven'
+
+    def default_main(self) -> str:
+        return 'src/main/java'
+
+    def default_test(self) -> str:
+        return 'src/test/java'
+
+
+class TestAntPluginSetBuilder(_BasePluginSetBuilderTestCase):
+
+    def instance(self, **kwargs) -> AntPluginSetBuilder:
+        return AntPluginSetBuilder(**kwargs)
+
+    def type(self) -> PluginSetBuilderType:
+        return 'ant'
+
+    def default_main(self) -> str:
+        return 'plugins/src'
+
+    def default_test(self) -> str:
+        return 'plugins/test/src'
+
+
+class TestPluginSet(PydanticTestCase):
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.valid_builder = MavenPluginSetBuilder(type='maven')
+        self.valid = PluginSet(kind='PluginSet',
+                               id='myid',
+                               name='My Name',
+                               builder=self.valid_builder).initialize(ROOT)
+
+    def test_missing_kind(self) -> None:
+        self.assertPydanticMissing(lambda: PluginSet(),
+                                   'kind')
+
+    def test_null_kind(self) -> None:
+        self.assertPydanticLiteralError(lambda: PluginSet(kind=None),
+                                        'kind',
+                                        'PluginSet')
+
+    def test_wrong_kind(self) -> None:
+        self.assertPydanticLiteralError(lambda: PluginSet(kind='WrongKind'),
+                                        'kind',
+                                        'PluginSet')
+
+    def test_missing_identifier(self) -> None:
+        self.assertPydanticMissing(lambda: PluginSet(),
+                                   'id')
+
+    def test_null_identifier(self) -> None:
+        self.assertPydanticStringType(lambda: PluginSet(id=None),
+                                      'id')
+
+    def test_missing_name(self) -> None:
+        self.assertPydanticMissing(lambda: PluginSet(),
+                                   'name')
+
+    def test_null_name(self) -> None:
+        self.assertPydanticStringType(lambda: PluginSet(name=None),
+                                      'name')
+
+    def test_missing_builder(self) -> None:
+        self.assertPydanticMissing(lambda: PluginSet(),
+                                   'builder')
+
+    def test_null_builder(self) -> None:
+        self.assertPydanticModelAttributesType(lambda: PluginSet(builder=None),
+                                               'builder')
+
+    def test_uninitialized(self) -> None:
+        ps = PluginSet(kind='PluginSet',
+                       id='myid',
+                       name='My Name',
+                       builder=MavenPluginSetBuilder(type='maven'))
+        self.assertRaises(ValueError, lambda: ps.get_builder().get_root())
+
+    def test_kind(self) -> None:
+        self.assertEqual(self.valid.kind, 'PluginSet')
+
+    def test_get_id(self) -> None:
+        self.assertEqual(self.valid.get_id(), 'myid')
+
+    def test_get_name(self) -> None:
+        self.assertEqual(self.valid.get_name(), 'My Name')
+
+    def test_get_builder(self) -> None:
+        self.assertEqual(self.valid.get_builder(), self.valid_builder)
+
+
+#
+# See https://stackoverflow.com/a/43353680
+#
+del _BasePluginSetBuilderTestCase

unittest/lockss/turtles/test_plugin_signing_credentials.py

@@ -0,0 +1,102 @@
+#!/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.
+
+# 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 abc import ABC, abstractmethod
+from pathlib import Path
+
+from . import PydanticTestCase, ROOT
+from lockss.turtles.plugin_signing_credentials import PluginSigningCredentials
+
+class TestPluginSigningCredentials(PydanticTestCase):
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.valid_absolute = PluginSigningCredentials(**{'kind': 'PluginSigningCredentials',
+                                                          'plugin-signing-keystore': '/tmp/keystore.txt',
+                                                          'plugin-signing-alias': 'myalias'}).initialize(ROOT)
+        self.valid_relative = PluginSigningCredentials(**{'kind': 'PluginSigningCredentials',
+                                                          'plugin-signing-keystore': 'keystore.txt',
+                                                          'plugin-signing-alias': 'myalias'}).initialize(ROOT)
+        self.valid = [self.valid_absolute, self.valid_relative]
+
+    def test_missing_kind(self) -> None:
+        self.assertPydanticMissing(lambda: PluginSigningCredentials(),
+                                   'kind')
+
+    def test_null_kind(self) -> None:
+        self.assertPydanticLiteralError(lambda: PluginSigningCredentials(kind=None),
+                                        'kind',
+                                        'PluginSigningCredentials')
+
+    def test_wrong_kind(self) -> None:
+        self.assertPydanticLiteralError(lambda: PluginSigningCredentials(kind='WrongKind'),
+                                        'kind',
+                                        'PluginSigningCredentials')
+
+    def test_missing_plugin_signing_alias(self) -> None:
+        self.assertPydanticMissing(lambda: PluginSigningCredentials(),
+                                   'plugin-signing-alias')
+
+    def test_null_plugin_signing_alias(self) -> None:
+        self.assertPydanticStringType(lambda: PluginSigningCredentials(**{'plugin-signing-alias': None}),
+                                      'plugin-signing-alias')
+
+    def test_missing_plugin_signing_keystore(self) -> None:
+        self.assertPydanticMissing(lambda: PluginSigningCredentials(),
+                                   'plugin-signing-keystore')
+
+    def test_null_plugin_signing_keystore(self) -> None:
+        self.assertPydanticStringType(lambda: PluginSigningCredentials(**{'plugin-signing-keystore': None}),
+                                      'plugin-signing-keystore')
+
+    def test_uninitialized(self) -> None:
+        psc = PluginSigningCredentials(**{'kind': 'PluginSigningCredentials',
+                                          'plugin-signing-keystore': '/tmp/keystore.txt',
+                                          'plugin-signing-alias': 'myalias'})
+        self.assertRaises(ValueError, lambda: psc.get_root())
+        self.assertRaises(ValueError, lambda: psc.get_plugin_signing_keystore())
+
+    def test_kind(self) -> None:
+        for valid in self.valid:
+            self.assertEqual(valid.kind, 'PluginSigningCredentials')
+
+    def test_get_plugin_signing_alias(self) -> None:
+        for valid in self.valid:
+            self.assertEqual(valid.get_plugin_signing_alias(), 'myalias')
+
+    def test_get_plugin_signing_keystore(self) -> None:
+        self.assertEqual(self.valid_absolute.get_plugin_signing_keystore(),
+                         Path('/tmp/keystore.txt'))
+        self.assertEqual(self.valid_relative.get_plugin_signing_keystore(),
+                         ROOT.joinpath('keystore.txt'))

lockss_turtles-0.6.0.dev24.dist-info/RECORD

@@ -1,15 +0,0 @@
-lockss/turtles/__init__.py,sha256=h2gkVQIPx7M4cQT_0ZSSioskUq00IUryPyduZ6g5sV8,1827
-lockss/turtles/__main__.py,sha256=BqRTG3dejCgLh87UJ1Os9DD9unxnQkOdUQM6eqWS3Sg,1680
-lockss/turtles/app.py,sha256=Rxbsq10A830D1r99a5tqLVYWM3bJZ2Org-JKjXD-2Mk,16689
-lockss/turtles/cli.py,sha256=Pgd0GSThxDfnPWKwwujo6ZocfKePoe-aiHJ9qYpm9BQ,21019
-lockss/turtles/plugin.py,sha256=HT01Er9-odvJ4lF8DNC7TV4uxSqTw44UBe02Jgj5xMs,11065
-lockss/turtles/plugin_registry.py,sha256=UlB9faNH8fEh9mfdj6byMcRcZ7axi0DzUP2qdyj9ANk,26935
-lockss/turtles/plugin_set.py,sha256=PuzSWl2k7ikbkKtxStQRJhcXi1JXuSBl9jXz4dzp7Ts,24550
-lockss/turtles/util.py,sha256=P-f-Uc4hdrjvaKnyVozwCO8oVpUWJ_YXaxeFDBxwHWM,3658
-unittest/lockss/turtles/__init__.py,sha256=hrgWx4GaP-hhPBuRlbLndJnOQmZicKCLaP-dQTCu1sQ,3162
-unittest/lockss/turtles/test_plugin_set.py,sha256=q6JmooDR-wijAQ8x9DWKTNB6Of4EOr3Dgq8oaX0LTpQ,4179
-lockss_turtles-0.6.0.dev24.dist-info/LICENSE,sha256=O9ONND4uDxY_jucI4jZDf2liAk05ScEJaYu-Al7EOdQ,1506
-lockss_turtles-0.6.0.dev24.dist-info/METADATA,sha256=IQceC6i6VxnjA6Dgv4SVYj9BIsdbHQfWrmROxDaeMZg,2340
-lockss_turtles-0.6.0.dev24.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-lockss_turtles-0.6.0.dev24.dist-info/entry_points.txt,sha256=25BAVFSBRKWAWiXIGZgcr1ypt2mV7nj31Jl8WcNZZOk,51
-lockss_turtles-0.6.0.dev24.dist-info/RECORD,,