mirror of
https://github.com/LorenEteval/Furious.git
synced 2026-09-27 09:27:55 +03:00
518 lines
17 KiB
Python
518 lines
17 KiB
Python
# Copyright (C) 2024–present Loren Eteval & contributors <loren.eteval@proton.me>
|
||
#
|
||
# This file is part of Furious.
|
||
#
|
||
# This program is free software: you can redistribute it and/or modify
|
||
# it under the terms of the GNU General Public License as published by
|
||
# the Free Software Foundation, either version 3 of the License, or
|
||
# (at your option) any later version.
|
||
#
|
||
# This program is distributed in the hope that it will be useful,
|
||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
# GNU General Public License for more details.
|
||
#
|
||
# You should have received a copy of the GNU General Public License
|
||
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||
|
||
"""Verify plugin capability discovery, factories, rollback, and shutdown."""
|
||
|
||
from __future__ import annotations
|
||
|
||
from Furious.Models import ConfigFactory
|
||
from Furious.Plugins.API import (
|
||
CapabilityKind,
|
||
FuriousPlugin,
|
||
KernelFactory,
|
||
KernelLaunch,
|
||
KernelRequest,
|
||
PluginMetadata,
|
||
ProtocolDescriptor,
|
||
ProtocolEditorProvider,
|
||
ProtocolHandler,
|
||
ProtocolParseResult,
|
||
SubscriptionDecoder,
|
||
SubscriptionItem,
|
||
SubscriptionResult,
|
||
)
|
||
from Furious.Plugins.Registry import PluginRegistry
|
||
from Furious.Service.SubscriptionImporter import (
|
||
SubscriptionImportService,
|
||
SubscriptionSource,
|
||
)
|
||
|
||
from PySide6 import QtCore, QtWidgets
|
||
|
||
from tests.support import application, collectAtBoundary, waitFor
|
||
|
||
import unittest
|
||
import weakref
|
||
|
||
|
||
class FixtureConfiguration(ConfigFactory):
|
||
"""Represent one deterministic plugin-owned connection document."""
|
||
|
||
@property
|
||
def itemProtocol(self):
|
||
"""Return the protocol ID used by display and dispatch code."""
|
||
return 'FIXTURE'
|
||
|
||
def httpProxy(self) -> str:
|
||
"""Return the local HTTP endpoint used by controller fixtures."""
|
||
return '127.0.0.1:18080'
|
||
|
||
|
||
class FixtureProtocolHandler(ProtocolHandler):
|
||
"""Parse and export a minimal fixture:// URI."""
|
||
|
||
descriptor = ProtocolDescriptor(
|
||
'FIXTURE',
|
||
'Fixture',
|
||
'Add Fixture...',
|
||
subscriptionImportable=True,
|
||
)
|
||
schemes = ('fixture',)
|
||
|
||
def supports(self, configuration) -> bool:
|
||
"""Return whether this handler owns *configuration*."""
|
||
return isinstance(
|
||
getattr(configuration, 'connection', configuration),
|
||
FixtureConfiguration,
|
||
)
|
||
|
||
def parse(self, uri: str, **kwargs):
|
||
"""Parse one fixture endpoint or decline another scheme."""
|
||
if not uri.casefold().startswith('fixture://'):
|
||
return None
|
||
|
||
value = uri.split('://', 1)[1]
|
||
|
||
if not value:
|
||
return None
|
||
|
||
return ProtocolParseResult(
|
||
FixtureConfiguration({'type': 'fixture', 'value': value}),
|
||
{'displayName': value},
|
||
)
|
||
|
||
def fromMapping(self, configuration, **kwargs):
|
||
"""Recognize normalized fixture mappings."""
|
||
if configuration.get('type') == 'fixture':
|
||
return FixtureConfiguration(dict(configuration))
|
||
|
||
return None
|
||
|
||
def blank(self, **kwargs):
|
||
"""Create one valid blank fixture configuration."""
|
||
return FixtureConfiguration({'type': 'fixture', 'value': 'blank'})
|
||
|
||
def export(self, configuration, remark: str = '') -> str:
|
||
"""Export a fixture URI."""
|
||
connection = getattr(configuration, 'connection', configuration)
|
||
|
||
return f"fixture://{connection.get('value', '')}"
|
||
|
||
def validate(self, configuration):
|
||
"""Require a non-empty fixture value."""
|
||
connection = getattr(configuration, 'connection', configuration)
|
||
|
||
return tuple() if connection.get('value') else ('missing fixture value',)
|
||
|
||
|
||
class FixtureEditorProvider(ProtocolEditorProvider):
|
||
"""Create a sentinel editor without retaining it in the registry."""
|
||
|
||
editorId = 'fixture.editor'
|
||
protocolIds = ('FIXTURE',)
|
||
|
||
def createEditor(self, protocolId: str, parent=None, **kwargs):
|
||
"""Return a fresh sentinel editor for the exact protocol."""
|
||
return {'protocol': protocolId, 'parent': parent, **kwargs}
|
||
|
||
|
||
class FixtureKernel:
|
||
"""Record start calls made through KernelLaunch."""
|
||
|
||
def __init__(self):
|
||
"""Initialize an empty call history."""
|
||
self.calls = []
|
||
|
||
def start(self, configuration, *args, **kwargs):
|
||
"""Record prepared launch values and report success."""
|
||
self.calls.append((configuration, args, kwargs))
|
||
|
||
return True
|
||
|
||
|
||
class FixtureKernelFactory(KernelFactory):
|
||
"""Create a deterministic in-process runtime kernel."""
|
||
|
||
factoryId = 'fixture.kernel'
|
||
configurationTypes = (FixtureConfiguration,)
|
||
kernelTypes = (FixtureKernel,)
|
||
|
||
def create(self, request: KernelRequest):
|
||
"""Build one prepared launch for a fixture configuration."""
|
||
if not isinstance(request.configuration, FixtureConfiguration):
|
||
return None
|
||
|
||
return KernelLaunch(
|
||
FixtureKernel(),
|
||
request.configuration,
|
||
('prepared',),
|
||
{'routing': request.routing},
|
||
)
|
||
|
||
|
||
class FixtureDecoder(SubscriptionDecoder):
|
||
"""Decode a deterministic fixture payload."""
|
||
|
||
decoderId = 'fixture-decoder'
|
||
displayName = 'Fixture Decoder'
|
||
priority = 100
|
||
|
||
def decode(self, data: bytes):
|
||
"""Decode the exact fixture marker."""
|
||
if data != b'fixture':
|
||
return None
|
||
|
||
return SubscriptionResult(
|
||
self.decoderId,
|
||
(
|
||
SubscriptionItem(uri='fixture://one', upstreamId='one'),
|
||
SubscriptionItem(uri='fixture://two', upstreamId='two'),
|
||
),
|
||
)
|
||
|
||
|
||
class FixturePlugin(FuriousPlugin):
|
||
"""Bundle representative capabilities for registry tests."""
|
||
|
||
metadata = PluginMetadata('tests.fixture', 'Fixture Plugin')
|
||
capabilities = (
|
||
FixtureProtocolHandler(),
|
||
FixtureEditorProvider(),
|
||
FixtureKernelFactory(),
|
||
FixtureDecoder(),
|
||
)
|
||
|
||
def __init__(self):
|
||
"""Initialize lifecycle counters."""
|
||
self.initialized = 0
|
||
self.stopped = 0
|
||
self.context = None
|
||
|
||
def initialize(self, context):
|
||
"""Record one successful initialization."""
|
||
self.initialized += 1
|
||
self.context = context
|
||
|
||
def shutdown(self):
|
||
"""Record one registry-owned shutdown."""
|
||
self.stopped += 1
|
||
|
||
|
||
class PluginRegistryTest(unittest.TestCase):
|
||
"""Exercise capability dispatch without the process-wide registry."""
|
||
|
||
def setUp(self):
|
||
"""Create one isolated registry and fixture plugin."""
|
||
self.registry = PluginRegistry()
|
||
self.plugin = FixturePlugin()
|
||
self.registry.register(self.plugin)
|
||
|
||
def tearDown(self):
|
||
"""Release only plugins owned by this test."""
|
||
self.registry.shutdown()
|
||
|
||
def testCapabilityDiscoveryAndMetadata(self):
|
||
"""Query capabilities without assuming every plugin is a core."""
|
||
self.assertEqual(self.plugin.initialized, 1)
|
||
self.assertIs(self.plugin.context.registry, self.registry)
|
||
self.assertEqual(
|
||
self.registry.metadataFor('tests.fixture'),
|
||
self.plugin.metadata,
|
||
)
|
||
self.assertEqual(
|
||
len(self.registry.capabilities(plugin=self.plugin)),
|
||
4,
|
||
)
|
||
self.assertIs(
|
||
self.registry.capability(CapabilityKind.Protocol, 'FIXTURE'),
|
||
self.plugin.capabilities[0],
|
||
)
|
||
self.assertEqual(
|
||
self.registry.pluginsWithCapability(CapabilityKind.KernelFactory),
|
||
(self.plugin,),
|
||
)
|
||
|
||
def testProtocolParseExportValidationAndEditorFactory(self):
|
||
"""Dispatch URI and editor operations through registered capabilities."""
|
||
parsed = self.registry.parseURI('FiXtUrE://server')
|
||
|
||
self.assertIsInstance(parsed.configuration, FixtureConfiguration)
|
||
self.assertEqual(parsed.metadata['displayName'], 'server')
|
||
self.assertEqual(
|
||
self.registry.exportConfig(parsed.configuration),
|
||
'fixture://server',
|
||
)
|
||
self.assertEqual(self.registry.validateConfig(parsed.configuration), tuple())
|
||
self.assertEqual(
|
||
self.registry.createEditorForConfig(parsed.configuration, marker=7),
|
||
{'protocol': 'fixture', 'parent': None, 'marker': 7},
|
||
)
|
||
|
||
def testConfigurationAndKernelFactories(self):
|
||
"""Build normalized configurations and start one prepared runtime."""
|
||
config = self.registry.configFromDict({'type': 'fixture', 'value': 'node'})
|
||
launch = self.registry.createKernel(config, 'direct')
|
||
|
||
self.assertIsInstance(config, FixtureConfiguration)
|
||
self.assertIsInstance(launch.kernel, FixtureKernel)
|
||
self.assertTrue(launch.start())
|
||
self.assertEqual(
|
||
launch.kernel.calls,
|
||
[(config, ('prepared',), {'routing': 'direct'})],
|
||
)
|
||
|
||
def testSubscriptionImportSeparatesMetadataAndConnection(self):
|
||
"""Convert decoder items into managed profiles with stable identities."""
|
||
result = SubscriptionImportService(self.registry).importPayload(
|
||
b'fixture',
|
||
SubscriptionSource('source-id', displayName='Fixture source'),
|
||
)
|
||
|
||
self.assertEqual(result.decoderId, 'fixture-decoder')
|
||
self.assertEqual(result.rejectedItems, 0)
|
||
self.assertEqual(len(result.profiles), 2)
|
||
self.assertEqual(
|
||
tuple(profile.itemRemark for profile in result.profiles),
|
||
('one', 'two'),
|
||
)
|
||
self.assertTrue(
|
||
all(profile.metadata.subscriptionManaged for profile in result.profiles)
|
||
)
|
||
self.assertEqual(
|
||
tuple(
|
||
profile.metadata.subscriptionProfileKey for profile in result.profiles
|
||
),
|
||
('upstream:one', 'upstream:two'),
|
||
)
|
||
|
||
def testShutdownRunsOnceInReverseRegistryLifetime(self):
|
||
"""Make shutdown idempotent and reject use of a closed registry."""
|
||
self.registry.shutdown()
|
||
self.registry.shutdown()
|
||
|
||
self.assertEqual(self.plugin.stopped, 1)
|
||
|
||
with self.assertRaises(RuntimeError):
|
||
self.registry.register(FixturePlugin())
|
||
|
||
|
||
class PluginRollbackTest(unittest.TestCase):
|
||
"""Verify failed plugins leave no capabilities or live lifecycle state."""
|
||
|
||
def testInitializationFailureRollsBackEveryIndex(self):
|
||
"""Remove a failed plugin from all capability lookup structures."""
|
||
|
||
class FailingPlugin(FixturePlugin):
|
||
"""Raise after capabilities have been indexed."""
|
||
|
||
metadata = PluginMetadata('tests.failure', 'Failing Plugin')
|
||
|
||
def initialize(self, context):
|
||
"""Simulate plugin initialization failure."""
|
||
raise RuntimeError('fixture failure')
|
||
|
||
registry = PluginRegistry()
|
||
plugin = FailingPlugin()
|
||
|
||
with self.assertRaisesRegex(RuntimeError, 'fixture failure'):
|
||
registry.register(plugin)
|
||
|
||
self.assertEqual(plugin.stopped, 1)
|
||
self.assertEqual(registry.plugins(), tuple())
|
||
self.assertEqual(registry.capabilities(), tuple())
|
||
self.assertIsNone(registry.parseURI('fixture://node'))
|
||
|
||
registry.shutdown()
|
||
|
||
def testDuplicateSchemeDoesNotPartiallyRegisterSecondPlugin(self):
|
||
"""Reject conflicting protocol ownership atomically."""
|
||
|
||
class ConflictingPlugin(FuriousPlugin):
|
||
"""Claim an existing URI scheme under another protocol ID."""
|
||
|
||
metadata = PluginMetadata('tests.conflict', 'Conflict')
|
||
|
||
class Handler(FixtureProtocolHandler):
|
||
"""Use a distinct protocol ID with the same scheme."""
|
||
|
||
descriptor = ProtocolDescriptor('OTHER', 'Other', 'Add Other')
|
||
|
||
capabilities = (Handler(),)
|
||
|
||
first = FixturePlugin()
|
||
|
||
registry = PluginRegistry()
|
||
registry.register(first)
|
||
|
||
try:
|
||
with self.assertRaises(ValueError):
|
||
registry.register(ConflictingPlugin())
|
||
|
||
self.assertEqual(registry.plugins(), (first,))
|
||
self.assertIsNotNone(registry.parseURI('fixture://node'))
|
||
finally:
|
||
registry.shutdown()
|
||
|
||
|
||
class PluginFailureIsolationTest(unittest.TestCase):
|
||
"""Keep optional plugin failures bounded to the owning capability."""
|
||
|
||
@classmethod
|
||
def setUpClass(cls):
|
||
"""Create Qt before exercising a plugin-provided editor widget."""
|
||
application()
|
||
|
||
def tearDown(self):
|
||
"""Drain deferred deletes after plugin UI tests."""
|
||
collectAtBoundary()
|
||
|
||
def testDecoderExceptionFallsThroughToNextCandidate(self):
|
||
"""Allow one broken decoder without blocking later valid decoders."""
|
||
|
||
class RaisingDecoder(SubscriptionDecoder):
|
||
decoderId = 'raising-decoder'
|
||
displayName = 'Raising decoder'
|
||
priority = 200
|
||
|
||
def decode(self, data: bytes):
|
||
raise RuntimeError('decoder fixture')
|
||
|
||
class RaisingPlugin(FuriousPlugin):
|
||
metadata = PluginMetadata('tests.raising-decoder', 'Raising decoder')
|
||
capabilities = (RaisingDecoder(),)
|
||
|
||
registry = PluginRegistry()
|
||
registry.register(RaisingPlugin())
|
||
registry.register(FixturePlugin())
|
||
|
||
try:
|
||
result = registry.decodeSubscription(b'fixture')
|
||
|
||
self.assertIsNotNone(result)
|
||
self.assertEqual(result.decoderId, 'fixture-decoder')
|
||
finally:
|
||
registry.shutdown()
|
||
|
||
def testKernelFactoryExceptionReturnsControlledStartFailure(self):
|
||
"""Translate construction failure into a false runtime result."""
|
||
|
||
class RaisingFactory(KernelFactory):
|
||
factoryId = 'raising-factory'
|
||
configurationTypes = (FixtureConfiguration,)
|
||
kernelTypes = (FixtureKernel,)
|
||
|
||
def create(self, request: KernelRequest):
|
||
raise RuntimeError('factory fixture')
|
||
|
||
class RaisingPlugin(FuriousPlugin):
|
||
metadata = PluginMetadata('tests.raising-factory', 'Raising factory')
|
||
capabilities = (RaisingFactory(),)
|
||
|
||
registry = PluginRegistry()
|
||
registry.register(RaisingPlugin())
|
||
|
||
try:
|
||
kernel, success = registry.startKernel(
|
||
FixtureConfiguration({'type': 'fixture'}),
|
||
'direct',
|
||
)
|
||
|
||
self.assertIsNone(kernel)
|
||
self.assertFalse(success)
|
||
finally:
|
||
registry.shutdown()
|
||
|
||
def testShutdownExceptionDoesNotBlockOtherPlugins(self):
|
||
"""Run every shutdown hook once even when one hook raises."""
|
||
stopped = []
|
||
|
||
class OrderedPlugin(FuriousPlugin):
|
||
capabilities = tuple()
|
||
|
||
def __init__(self, identifier: str, *, raises=False):
|
||
self.metadata = PluginMetadata(identifier, identifier)
|
||
self.raises = raises
|
||
|
||
def shutdown(self):
|
||
stopped.append(self.metadata.id)
|
||
|
||
if self.raises:
|
||
raise RuntimeError('shutdown fixture')
|
||
|
||
registry = PluginRegistry()
|
||
registry.register(OrderedPlugin('tests.shutdown.first'))
|
||
registry.register(OrderedPlugin('tests.shutdown.second', raises=True))
|
||
registry.register(OrderedPlugin('tests.shutdown.third'))
|
||
|
||
registry.shutdown()
|
||
registry.shutdown()
|
||
|
||
self.assertEqual(
|
||
stopped,
|
||
[
|
||
'tests.shutdown.third',
|
||
'tests.shutdown.second',
|
||
'tests.shutdown.first',
|
||
],
|
||
)
|
||
|
||
def testRegistryStoresEditorFactoryButNotTransientEditorInstance(self):
|
||
"""Destroy a plugin editor while its provider remains registered."""
|
||
|
||
class WidgetEditorProvider(ProtocolEditorProvider):
|
||
editorId = 'fixture.widget-editor'
|
||
protocolIds = ('FIXTURE',)
|
||
|
||
def createEditor(self, protocolId: str, parent=None, **kwargs):
|
||
editor = QtWidgets.QDialog(parent)
|
||
editor.setAttribute(QtCore.Qt.WidgetAttribute.WA_DeleteOnClose, True)
|
||
|
||
return editor
|
||
|
||
class WidgetPlugin(FuriousPlugin):
|
||
metadata = PluginMetadata('tests.widget-editor', 'Widget editor')
|
||
capabilities = (
|
||
FixtureProtocolHandler(),
|
||
WidgetEditorProvider(),
|
||
)
|
||
|
||
registry = PluginRegistry()
|
||
registry.register(WidgetPlugin())
|
||
|
||
try:
|
||
editor = registry.createEditorForConfig(
|
||
FixtureConfiguration({'type': 'fixture', 'value': 'node'})
|
||
)
|
||
editorReference = weakref.ref(editor)
|
||
editor.show()
|
||
editor.close()
|
||
editor = None
|
||
|
||
self.assertTrue(waitFor(lambda: editorReference() is None))
|
||
self.assertIsNotNone(
|
||
registry.capability(
|
||
CapabilityKind.ProtocolEditor,
|
||
'fixture.widget-editor',
|
||
)
|
||
)
|
||
finally:
|
||
registry.shutdown()
|
||
|
||
|
||
if __name__ == '__main__':
|
||
unittest.main()
|