public interface CountFishInterface {
    public void one();
    public void two();
}

public class OurFish implements CountFishInterface {
    public void one() { ... }
    public void two() { ... }
}

class CountFishInterface(object):
    def one(self, *args, **kwargs):
        raise NotImplementedError

    def two(self, *args, **kwargs):
        raise NotImplementedError

class OurFish(CountFishInterface):
    def one(self):
        return 1

    def two(self):
        return 2

class OurFishImplementsCountFishInterface(TestCase):
    def setUp(self):
        self.obj = OurFish()

    def test_one(self):
        try:
            self.obj.one()
        except NotImplementedError:
            self.fail("OurFish does not implement one")

    ...

class AbstractTestCountFishInterface(object):
    def test_one(self):
        try:
            self.obj.one()
        except NotImplementedError:
            self.fail(str(type(self.obj)) + "does not implement one")

    ...


class TestOurFish(AbstractTestCountFishInterface, ..., TestCase):
    def setUp(self):
        self.obj = OurFish()

class A(B, C):
    an_attribute = 1

    def a_method():
        return 2

A = type("A", (B, C), {"an_attribute": 1, "a_method": lambda: 2})

def Interface(interface_name, method_names):
    def interface_helper(*args, **kwargs):
        raise NotImplementedError

    methods = {method_name: interface_helper for method_name in method_names}
    return type(interface_name, (object,), methods)

def AbstractInterfaceTest(test_name, method_names):
    def abstract_interface_test_helper(method_name):
        def test_method(self):
            try:
                getattr(self.obj, method_name)()
            except NotImplementedError:
                self.fail(
                    type(self.obj).__name__ + " does not implement " + method_name
                )

        return test_method

    methods = {
        "test_" + method_name: abstract_interface_test_helper(method_name)
        for method_name in method_names
    }
    return type(test_name, (object,), methods)

interfaces = {"CountFish": ["one", "two"], "ColorFish": ["red", "blue"]}

for interface_name, methods in interfaces.iteritems():
    interface_name += "Interface"
    globals()[interface_name] = Interface(interface_name, methods)
    test_name = "AbstractTest" + interface_name
    globals()[test_name] = AbstractInterfaceTest(test_name, methods)