PHPUnit: Doing assertions on non-public variables

Suppose I have a class with a private property and associated public getter and setter. I want to test with PHPUnit that the property gets the correct value after the setter has been used or that the getter returns the correct property.

Of course I can test the setter by using the getter to see that the object is storing the correct value, and vice versa for testing the getter. However, this doesn’t guarantee that the private property is the one being set.

Say I had the following class. I created a property, getter and setter. But I made a typo in the property name, so the getter and the setter don’t actually manipulate the property they’re meant to manipulate

class SomeClass
        $mane = NULL; // Was supposed to be $name but got fat-fingered!

    public function getName ()
        return ($this -> name);

    public function setName ($newName)
        $this -> name = $newName;
        return ($this);

If I run the following test

public function testSetName ()
    $this -> object -> setName ('Gerald');
    $this -> assertTrue ($this -> object -> getName () == 'Gerald');

I would get a pass. However, something very bad has actually happened that I don’t want. When setName() is called, it actually creates a new property in the class with the name I thought my private property had, only the one that the setter creates is public! I can demonstrate that with the following code:

$a  = new SomeClass;

$a -> setName('gerald');
var_dump ($a -> getName ());
var_dump ($a -> name);

It would output:

string(6) "gerald"

string(6) "gerald"

Is there any way I can access the private properties from PHPUnit so I can write tests that make sure that the properties I think are being get and set actually really are being get and set?

Or is there some other thing I should be doing in a test to catch problems like this without trying to get access to the private state of the object under test?

Here is Solutions:

We have many solutions to this problem, But we recommend you to use the first solution because it is tested & true solution that will 100% work for you.

Solution 1

You can also use Assert::assertAttributeEquals('value', 'propertyName', $object).


Solution 2

For testing properties, I’d make the same arguments I make then talking about testing private methods.

You usually don't want to do this.

It’s about testing observable behavior.

If you rename all your properties or decide to store them into an array you should not need to adapt your tests at all. You want your tests to tell you that everything still works! When you need to change the tests to make sure everything still works you lose all the benefits as you also could make an error changing the tests.

So, all in all, you lose the value of you test suite!

Just testing the get/set combinations would be ok enough but usually not every setter should have a getter and just creating them for testing is not a nice thing ether.

Usually, you set some stuff and then tell the method to DO (behavior) something. Testing for that (that the class does what is should do) is the best option for testing and should make testing the properties superfluous.

If you really want to do that there is the setAccessible functionality in PHP reflections API but I can’t make up an example where I find this desirable

Finding unused properties to catch bugs / issues like this one:

The PHP Mess Detector As a UnusedPrivateField Rule

class Something
    private static $FOO = 2; // Unused
    private $i = 5; // Unused
    private $j = 6;
    public function addOne()
        return $this->j++;

This will generate two warnings for you because the variables are never accessed

Solution 3

I just want to point out one thing. Let’s forget about private fields for a moment and focus on what client of your class cares about. Your class exposes a contract, in this case – ability to alter and retrieve name (via getter and setter). Expected functionality is simple:

  • when I set name with setName to "Gerald", I expect to get "Gerald" when I call getName

That’s all. Client won’t (well, shouldn’t!) care about internal implementation. Whether you used private field name, hashset or called web service via dynamically generated code – doesn’t matter for client. The bug you are currently experiencing, from user point of view – is not a bug at all.

Whether PHPUnit allows you to test private variables – I don’t know. But from unit-testing perspective, you shouldn’t do that.

Edit (in response to comment):

I understand your concerns about possible exposure of internal state, however I don’t think unit testing is the right tool to deal with that. You can come up with a lot of possible scenarios how something might do something else which wasn’t planned. Unit tests are by no means cure for all and shouldn’t be used as such.

Solution 4

I agree with the others that in general you want to avoid accessing privates in your tests, but for the cases where you need to, you can use reflection to read and write the property.

Note: Use and implement solution 1 because this method fully tested our system.
Thank you 🙂

All methods was sourced from or, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0

Leave a Reply