# -*- coding: utf-8 -*-
import unittest
from main import (PluginContainer, DocumentContext, InitContext, 
                  MessageContext, DocumentPlugin, InitPlugin, 
                  MessagePlugin)

class TestSudsPlugins(unittest.TestCase):
    
    class MyDocumentPlugin(DocumentPlugin):
        """Local 'document' plugin class used in the tests in this module."""
        pass

    class MyInitPlugin(InitPlugin):
        """Local 'init' plugin class used in the tests in this module."""
        pass

    class MyMessagePlugin(MessagePlugin):
        """Local 'message' plugin class used in the tests in this module."""
        pass

    def test_collecting_plugins_and_context_per_empty_domain(self):
        plugin_domain_pairs = [
            ("document", DocumentContext),
            ("init", InitContext),
            ("message", MessageContext)
        ]
        for domain, expected_context in plugin_domain_pairs:
            container = PluginContainer([])
            result = getattr(container, domain)
            self.assertIsInstance(result, PluginDomain)
            self.assertEqual(result.ctx, expected_context)
            self.assertEqual(result.plugins, [])

    def test_collecting_plugins_per_domain(self):
        domain_plugin_pairs = [
            ("document", DocumentPlugin),
            ("init", InitPlugin),
            ("message", MessagePlugin)
        ]
        
        plugins = [
            self.MyDocumentPlugin(),
            self.MyDocumentPlugin(),
            self.MyMessagePlugin(),
            self.MyDocumentPlugin(),
            self.MyInitPlugin(),
            self.MyInitPlugin(),
            self.MyMessagePlugin(),
            InitPlugin(),
            self.MyMessagePlugin(),
            self.MyMessagePlugin(),
            None,
            MessagePlugin(),
            DocumentPlugin(),
            self.MyMessagePlugin(),
            self.MyDocumentPlugin(),
            InitPlugin(),
            InitPlugin(),
            self.MyInitPlugin(),
            self.MyInitPlugin(),
            None,
            self.MyDocumentPlugin(),
            DocumentPlugin(),
            MessagePlugin(),
            DocumentPlugin(),
            MessagePlugin(),
            DocumentPlugin(),
            InitPlugin(),
            MessagePlugin(),
            object(),
            DocumentPlugin(),
            MessagePlugin(),
            object(),
            InitPlugin(),
            Plugin(),
            Plugin(),
            self.MyInitPlugin()
        ]

        for domain, plugin_class in domain_plugin_pairs:
            container = PluginContainer(plugins)
            expected_plugins = [p for p in plugins if isinstance(p, plugin_class)]
            result = getattr(container, domain).plugins
            self.assertEqual(result, expected_plugins)

    def test_exception_passing(self):
        class FailingPluginException(Exception):
            pass

        class FailingPlugin(MessagePlugin):
            def marshalled(self, context):
                raise FailingPluginException

        container = PluginContainer([FailingPlugin()])
        with self.assertRaises(FailingPluginException):
            container.message.marshalled(None)

    def test_invalid_plugin_domain(self):
        container = PluginContainer([])
        domain = "invalid_domain_name"
        with self.assertRaises(Exception) as cm:
            getattr(container, domain)
        self.assertIsInstance(cm.exception, Exception)
        self.assertEqual(str(cm.exception), f"plugin domain ({domain}), invalid")

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