import pytest
from abc import abstractmethod
from slic.utils.metaclasses import combine_classes, RegistryABC
from slic.utils.registry import instances

# Test combine two simple classes with unique methods
class A:
    def method_a(self):
        return "A"

class B:
    def method_b(self):
        return "B"

def test_combine_classes_combines_methods():
    # Dynamically combine A and B using combine_classes
    Combined = combine_classes(A, B)
    obj = Combined()

    # Check that both methods are available
    assert obj.method_a() == "A"
    assert obj.method_b() == "B"


# Test validate that RegistryABC correctly inherits from ABCMeta and RegistryMeta
def test_registryabc_combines_registrymeta_and_abcmeta():
    # Define an abstract class using RegistryABC
    class AbstractThing(RegistryABC):
        @abstractmethod
        def doit(self):
            pass

    # Cannot instantiate abstract class without implementing abstract methods
    with pytest.raises(TypeError):
        AbstractThing()

    # Define a concrete subclass that implements the abstract method
    class ConcreteThing(AbstractThing):
        def doit(self):
            return "yes"

    obj = ConcreteThing()

    # ABCMeta behavior: abstract method works
    assert obj.doit() == "yes"

    # RegistryMeta behavior: instance is automatically registered
    assert obj in instances(AbstractThing)