14

I am writing a class that will inherit an interface. The client code will be written for that interface, and the class written to support it. The idea is that I will later write other classes for that interface, and objects of those two different classes should be completely interchangeable. Rather than writing a test class for that first class, I want to write one for the interface.

My plan was to write a test class that would take a factory object for the constructor (dependency injection), and use the factory to create new instances of the class under test.

That way, if I wanted to test ClassA, I could pass a ClassAFactory object to the constructor of the test class, and if I wanted to test ClassB, I would pass a ClassBFactory object. Both classes are designed to be interchangeable, and since only public methods are supposed to be tested, this seems ideal.

But what about testing the constructor? Would I be better writing an abstract test class and implmenting constructor tests in classes that inherit the abstract test class (different classes may be instantiated differently)?

If I did use the first idea, I guess I would have a test class for each class being tested, like:

class ClassATest extends [PHPUnit test case]
{
    $myFactory = new ClassAFactory();
    $myTest = new ClassTest($myFactory);

    $myTest->test1();
    $myTest->test2();
    //etc.
}

What's the best way to go about this? I want to have a general test, so that when I write new classes to implement the common interface, I can just put an object of the same tests as used for the others. But, seeing as the different classes would have different constructors, perhaps writing an abstract test class and extending it for each new object would be better? What do you think?

Improve this question

2 Answers 2

Reset to default
10

I think you need to reconsider your plan. You can't test an interface and there's a good reason why - interfaces just define the API and not functionality, tests test functionality. Let me give you an example that might help. Say you have a "messaging" interface. So you implement an EmailMessager and an SMSMessager. Now you need to test these separately as with the EmailMessager you need to make sure it is doing its stuff, maybe validating the recipient (an email address) and possibly delegating the sending to an email class etc. Obviously an SMS message would be different.

Improve this answer
Sign up to request clarification or add additional context in comments.

8 Comments

In this specific example, the classes will represent recipients for a mailing list. Though they'll have different ways of doing their job, they'll take the same data from a client, and return the same results - completely interchangeable. It seems to me that if objects from different classes that use that interface are interchangeable within the client code, they should be interchangeable within the test code too. So when I say I want to test the interface, what I mean is, I want to write a test to that interface, in order to test a class that uses that interface. Does that make sense to you?
No it still doesn't make sense. That's not how I understand an interface to work. You may be wanting an Abstract base class rather than an interface to implement the common code. I'm not sure what is different about your classes other than data.
Let's say on class, MailChimpRecipient uses the MailingListRecipient interface: the client coded adds someone to the list by setting the email address and name properties of the recipient object, and then calling a method to add them. Now, that method for the MailChimp class will use the MailChimp API to add them. Say in the future, I want to host my own mailing list or use another provider, I could switch the class with another class that uses the MailingListRecipient interface. That class might do something completely different in order to add the recipient, but it still takes the same data.
That's basically my point. The methods for adding the email address and name properties are common to all mailing lists so they would sit nicely in an abstract base class. The method for adding the recipient object to whatever mailing list provider you are using would suit an interface but as you point out the functionality of that method would depend on which mailing list you were using and hence would need to be tested separately.
I think you're getting confused between two slightly different meanings of the word interface. Interface (as in API) are the public methods a class and therefore and object exposes. It is often said that this is what you should test, although you are actually testing the functionality behind each method. There are ways of testing protected and private methods and there is some benefit in testing these too. The other sense of the word Interface is the PHP structure which defines a common set of methods that classes that implement the Interface have to implement.
|
7

You can create an abstract test case with all of the test methods using a property that each subclass will set without requiring a factory. It can test the fixed qualities that all implementations must posess.

abstract class IAdderTestCase extends PFTC
{
    function testAdd() {
        self::assertEquals(5, $this->fixture->add(2, 3));
    }
    ...
}

class BasicAdderTest extends IAdderTestCase
{
    function setUp() {
        $this->fixture = new BasicAdder();
    }
}

PHPUnit will call setUp() before each test method. It should call all inherited test methods for each concrete subclass plus any additional ones, e.g. to test the constructors.

Improve this answer

1 Comment

Thanks for that! That seems the best way to go, as I can then change the setUp method for each different subsclass.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.