Best practices to test protected methods with PHPUnit

Question

I found the discussion on Do you test private method informative   I have decided  that in some classes  I want to have protected methods  but test them  Some of these methods are static and short  Because most of the public methods make use of them  I will probably be able to safely remove the tests later  But for starting with a TDD approach and avoid debugging  I really want to test them   I thought of the following    Method Object as adviced in an answer seems to be overkill for this  Start with public methods and when code coverage is given by higher level tests  turn them protected and remove the tests  Inherit a class with a testable interface making protected methods public   Which is best practice  Is there anything else   It seems  that JUnit automatically changes protected methods to be public  but I did not have a deeper look at it  PHP does not allow this via reflection

User · Answer

I suggest following workaround for  Henrik Paul  s workaround idea     You know names of private methods of your class  For example they are like  add     edit     delete   etc   Hence when you want to test it from aspect of unit-testing  just call private methods by prefixing and or suffixing some common word  for example  addPhpunit  so that when   call   method is called  since method  addPhpunit   doesn t exist  of owner class  you just put necessary code in   call   method to remove prefixed suffixed word s  Phpunit  and then to call that deduced private method from there  This is another good use of magic methods   Try it out

User · Answer

I think troelskn is close  I would do this instead   class ClassToTest      protected function testThisMethod                Implement stuff here          Then  implement something like this   class TestClassToTest extends ClassToTest     public function testThisMethod           return parent  testThisMethod            You then run your tests against TestClassToTest   It should be possible to automatically generate such extension classes by parsing the code  I wouldn t be surprised if PHPUnit already offers such a mechanism  though I haven t checked

User · Answer

You can indeed use   call   in a generic fashion to access protected methods  To be able to test this class  class Example       protected function getMessage             return  hello             you create a subclass in ExampleTest php   class ExampleExposed extends Example       public function   call  method  array  args   array              if   method exists  this   method               throw new BadMethodCallException  method   method  does not exist            return call user func array array  this   method    args             Note that the   call   method does not reference the class in any way so you can copy the above for each class with protected methods you want to test and just change the class declaration  You may be able to place this function in a common base class  but I haven t tried it   Now the test case itself only differs in where you construct the object to be tested  swapping in ExampleExposed for Example   class ExampleTest extends PHPUnit Framework TestCase       function testGetMessage              fixture   new ExampleExposed            self  assertEquals  hello    fixture- gt getMessage               I believe PHP 5 3 allows you to use reflection to change the accessibility of methods directly  but I assume you d have to do so for each method individually

User · Answer

teastburn has the right approach  Even simpler is to call the method directly and return the answer   class PHPUnitUtil     public static function callMethod  obj   name  array  args             class   new  ReflectionClass  obj            method    class- gt getMethod  name            method- gt setAccessible true           return  method- gt invokeArgs  obj   args             You can call this simply in your tests by    returnVal   PHPUnitUtil  callMethod                   this- gt object                    nameOfProtectedMethod                    array  arg1   arg2

User · Answer

I m going to throw my hat into the ring here   I ve used the   call hack with mixed degrees of success   The alternative I came up with was to use the Visitor pattern   1  generate a stdClass or custom class  to enforce type   2  prime that with the required method and arguments  3  ensure that your SUT has an acceptVisitor method which will execute the method with the arguments specified in the visiting class  4  inject it into the class you wish to test  5  SUT injects the result of operation into the visitor  6  apply your test conditions to the Visitor s result attribute

User · Answer

I think troelskn is close  I would do this instead   class ClassToTest      protected function testThisMethod                Implement stuff here          Then  implement something like this   class TestClassToTest extends ClassToTest     public function testThisMethod           return parent  testThisMethod            You then run your tests against TestClassToTest   It should be possible to automatically generate such extension classes by parsing the code  I wouldn t be surprised if PHPUnit already offers such a mechanism  though I haven t checked

User · Answer

teastburn has the right approach  Even simpler is to call the method directly and return the answer   class PHPUnitUtil     public static function callMethod  obj   name  array  args             class   new  ReflectionClass  obj            method    class- gt getMethod  name            method- gt setAccessible true           return  method- gt invokeArgs  obj   args             You can call this simply in your tests by    returnVal   PHPUnitUtil  callMethod                   this- gt object                    nameOfProtectedMethod                    array  arg1   arg2

User · Answer

I m going to throw my hat into the ring here   I ve used the   call hack with mixed degrees of success   The alternative I came up with was to use the Visitor pattern   1  generate a stdClass or custom class  to enforce type   2  prime that with the required method and arguments  3  ensure that your SUT has an acceptVisitor method which will execute the method with the arguments specified in the visiting class  4  inject it into the class you wish to test  5  SUT injects the result of operation into the visitor  6  apply your test conditions to the Visitor s result attribute

User · Answer

You seem to be aware already  but I ll just restate it anyway  It s a bad sign  if you need to test protected methods  The aim of a unit test  is to test the interface of a class  and protected methods are implementation details  That said  there are cases where it makes sense  If you use inheritance  you can see a superclass as providing an interface for the subclass  So here  you would have to test the protected method  But never a private one   The solution to this  is to create a subclass for testing purpose  and use this to expose the methods  Eg    class Foo     protected function stuff            secret stuff  you want to test        class SubFoo extends Foo     public function exposedStuff         return  this- gt stuff            Note that you can always replace inheritance with composition  When testing code  it s usually a lot easier to deal with code that uses this pattern  so you may want to consider that option

User · Answer

You seem to be aware already  but I ll just restate it anyway  It s a bad sign  if you need to test protected methods  The aim of a unit test  is to test the interface of a class  and protected methods are implementation details  That said  there are cases where it makes sense  If you use inheritance  you can see a superclass as providing an interface for the subclass  So here  you would have to test the protected method  But never a private one   The solution to this  is to create a subclass for testing purpose  and use this to expose the methods  Eg    class Foo     protected function stuff            secret stuff  you want to test        class SubFoo extends Foo     public function exposedStuff         return  this- gt stuff            Note that you can always replace inheritance with composition  When testing code  it s usually a lot easier to deal with code that uses this pattern  so you may want to consider that option

User · Answer

I think troelskn is close  I would do this instead   class ClassToTest      protected function testThisMethod                Implement stuff here          Then  implement something like this   class TestClassToTest extends ClassToTest     public function testThisMethod           return parent  testThisMethod            You then run your tests against TestClassToTest   It should be possible to automatically generate such extension classes by parsing the code  I wouldn t be surprised if PHPUnit already offers such a mechanism  though I haven t checked

User · Answer

I think troelskn is close  I would do this instead   class ClassToTest      protected function testThisMethod                Implement stuff here          Then  implement something like this   class TestClassToTest extends ClassToTest     public function testThisMethod           return parent  testThisMethod            You then run your tests against TestClassToTest   It should be possible to automatically generate such extension classes by parsing the code  I wouldn t be surprised if PHPUnit already offers such a mechanism  though I haven t checked

User · Answer

I suggest following workaround for  Henrik Paul  s workaround idea     You know names of private methods of your class  For example they are like  add     edit     delete   etc   Hence when you want to test it from aspect of unit-testing  just call private methods by prefixing and or suffixing some common word  for example  addPhpunit  so that when   call   method is called  since method  addPhpunit   doesn t exist  of owner class  you just put necessary code in   call   method to remove prefixed suffixed word s  Phpunit  and then to call that deduced private method from there  This is another good use of magic methods   Try it out

User · Answer

You seem to be aware already  but I ll just restate it anyway  It s a bad sign  if you need to test protected methods  The aim of a unit test  is to test the interface of a class  and protected methods are implementation details  That said  there are cases where it makes sense  If you use inheritance  you can see a superclass as providing an interface for the subclass  So here  you would have to test the protected method  But never a private one   The solution to this  is to create a subclass for testing purpose  and use this to expose the methods  Eg    class Foo     protected function stuff            secret stuff  you want to test        class SubFoo extends Foo     public function exposedStuff         return  this- gt stuff            Note that you can always replace inheritance with composition  When testing code  it s usually a lot easier to deal with code that uses this pattern  so you may want to consider that option

User · Answer

You can indeed use   call   in a generic fashion to access protected methods  To be able to test this class  class Example       protected function getMessage             return  hello             you create a subclass in ExampleTest php   class ExampleExposed extends Example       public function   call  method  array  args   array              if   method exists  this   method               throw new BadMethodCallException  method   method  does not exist            return call user func array array  this   method    args             Note that the   call   method does not reference the class in any way so you can copy the above for each class with protected methods you want to test and just change the class declaration  You may be able to place this function in a common base class  but I haven t tried it   Now the test case itself only differs in where you construct the object to be tested  swapping in ExampleExposed for Example   class ExampleTest extends PHPUnit Framework TestCase       function testGetMessage              fixture   new ExampleExposed            self  assertEquals  hello    fixture- gt getMessage               I believe PHP 5 3 allows you to use reflection to change the accessibility of methods directly  but I assume you d have to do so for each method individually

User · Answer

You seem to be aware already  but I ll just restate it anyway  It s a bad sign  if you need to test protected methods  The aim of a unit test  is to test the interface of a class  and protected methods are implementation details  That said  there are cases where it makes sense  If you use inheritance  you can see a superclass as providing an interface for the subclass  So here  you would have to test the protected method  But never a private one   The solution to this  is to create a subclass for testing purpose  and use this to expose the methods  Eg    class Foo     protected function stuff            secret stuff  you want to test        class SubFoo extends Foo     public function exposedStuff         return  this- gt stuff            Note that you can always replace inheritance with composition  When testing code  it s usually a lot easier to deal with code that uses this pattern  so you may want to consider that option

User · Answer

I d like to propose a slight variation to getMethod   defined in uckelman s answer  This version changes getMethod   by removing hard-coded values and simplifying usage a little  I recommend adding it to your PHPUnitUtil class as in the example below or to your PHPUnit Framework TestCase-extending class  or  I suppose  globally to your PHPUnitUtil file   Since MyClass is being instantiated anyways and ReflectionClass can take a string or an object    class PHPUnitUtil                  Get a private or protected method for testing documentation purposes         How to use for MyClass- gt foo                 cls   new MyClass                 foo   PHPUnitUtil  getPrivateMethod  cls   foo                 foo- gt invoke  cls                 param object  obj The instantiated instance of your class         param string  name The name of your private protected method         return ReflectionMethod The method you asked for             public static function getPrivateMethod  obj   name           class   new ReflectionClass  obj          method    class- gt getMethod  name          method- gt setAccessible true         return  method                   some other functions    I also created an alias function getProtectedMethod   to be explicit what is expected  but that one s up to you

User · Answer

If you re using PHP5     5 3 2  with PHPUnit  you can test your private and protected methods by using reflection to set them to be public prior to running your tests   protected static function getMethod  name       class   new ReflectionClass  MyClass       method    class- gt getMethod  name      method- gt setAccessible true     return  method     public function testFoo        foo   self  getMethod  foo       obj   new MyClass       foo- gt invokeArgs  obj  array

User · Answer

If you re using PHP5     5 3 2  with PHPUnit  you can test your private and protected methods by using reflection to set them to be public prior to running your tests   protected static function getMethod  name       class   new ReflectionClass  MyClass       method    class- gt getMethod  name      method- gt setAccessible true     return  method     public function testFoo        foo   self  getMethod  foo       obj   new MyClass       foo- gt invokeArgs  obj  array

User · Answer

I d like to propose a slight variation to getMethod   defined in uckelman s answer  This version changes getMethod   by removing hard-coded values and simplifying usage a little  I recommend adding it to your PHPUnitUtil class as in the example below or to your PHPUnit Framework TestCase-extending class  or  I suppose  globally to your PHPUnitUtil file   Since MyClass is being instantiated anyways and ReflectionClass can take a string or an object    class PHPUnitUtil                  Get a private or protected method for testing documentation purposes         How to use for MyClass- gt foo                 cls   new MyClass                 foo   PHPUnitUtil  getPrivateMethod  cls   foo                 foo- gt invoke  cls                 param object  obj The instantiated instance of your class         param string  name The name of your private protected method         return ReflectionMethod The method you asked for             public static function getPrivateMethod  obj   name           class   new ReflectionClass  obj          method    class- gt getMethod  name          method- gt setAccessible true         return  method                   some other functions    I also created an alias function getProtectedMethod   to be explicit what is expected  but that one s up to you

[php] Best practices to test protected methods with PHPUnit

Examples related to php

Examples related to unit-testing

Examples related to phpunit