Sebastian Bergmann has two recent posts dealing with some of the more difficult topics in unit testing. One looks at sharing fixtures between tests and the other talks about stubbing and mocking static methods in your tests.

From the first of the two tutorials:

A good example of a fixture that makes sense to share across several tests is a database connection: you log into the database once and reuse the database connection instead of creating a new connection for each test. This makes your tests run faster.

This fixture sharing example uses the setUpBeforeClass and tearDownAfterClass methods to create and destroy the connection.

In the second article Sebastian shows how to mock up a sample static function and mock it with the "staticExpects" helper.

In this recent post to his blog Johannes Schluter talks about a method he's suggested for testing objects in unit tests - overriding the "new" operator to replace specific classes with mocks.

Two years ago at some conference I had a conversation with Sebastian about the need for a way to overload the new operator in PHP so, probably, bad designed code can be tested more easily by replacing specific classes with mocks. [...] Sebastian then pushed the code as part of a new test_helpers extension with some documentation to github and I fixed some bugs in it. The aim of the extension is to collect functionality which might be beneficial for phpUnit and other test scenarios but which should never reach a production environment.

He includes some sample code to show it in action - defining the mock class, using the set_new_overload function to define it as what should be called when the "new" operator is used and a dump of the result.

In this new post to his blog today Federico Cargnelutti shows you how to use mock objects to unit test controllers in your Zend Framework application.

In this post I'll demonstrate a unit test technique for testing Zend Framework Action Controllers using Mock Objects. Unit testing controllers independently has a number of advantages: you can develop controllers test-first (TDD), develop and test all of your controller code before developing any of the view scripts and helps you quickly identify problems in the controller, rather than problems in one of the combination of Model, View and Controller.

He sets up a sample user controller and a test case to go along with it. Drop in a test for the user controller class that uses a "getMock" method to define a mock controller object for the "render" method. He also points out a few issues with this sort of testing in the Zend Framework - the return value of the Zend_Test_PHPUnit_ControllerTestCase, issues throwing exceptions with the Front Controller and a problem with the dispatcher's storage of the Action Controller.

Jani Hartikainen has posted the fourth part of his unit testing series looking at using mock objects when testing database interfaces.

When testing a class which needs an instance of another class to work, you do not want to depend on the other class too much. This is where mock objects come in - a mock object is a "clone" of an object, which we can use to simplify our tests, by having the mock object perform assertions or by replacing some functionality of the mock with our custom functionality.

He introduces some of the basics of mocking objects and how to create mock objects with PHPUnit. He takes it up to the next level with a mock database example based on grabbing event details to return "fake" results from a sample dataset.

The Content with Style blog has continued their series looking at unit testing with the Zend Framework (see this previous post) with this look at testing services based models.

However, unit testing models that talk to web services presents us with a different set of problem. Usually our application runs requests against something that is not in our control. Unless the service provider gives us some kind of test mode, we're operating with dynamic live data which shouldn't be used for testing, since it's harder to test in the first place, but also could be harmful to be manipulated.

They present two method you can use to test the models: creating mock objects to handle and return correctly formatted data and intercepting the HTTP request to either send it to a Zend_HTTP adapter or a different endpoint (service location).

Benjamin Eberlei has a suggestion for testing your application without having to mess around with creating new resources just for testing - use mocks.

Much talking is going on about Unit testing, Mocks and TDD in the PHP world. For the most this discussions surround object-oriented PHP code, frameworks and applications. Yet I would assert that the reality for PHP developers (me included) is dealing with PHP 4, PHP 5 migrated, or non-object oriented legacy applications which are near to impossible to bring under test.

He includes a "proof of concept" for a replacement mysql_query function (as created inside of Runkit) that sets up a "mocker" object that returns a "hello world" message when the mysql_query function is called.

In a new post today, Padraic Brady talks about some of his experience with unit testing in PHP - specifically with two of the more popular testing applications - SimpleTest and PHPUnit.

The word is that SimpleTest is moving towards PHP5 in the near future which is great news for all Mockists in PHP. When I moved to PHP, SimpleTest became the main ingredient in many a coding session up to 2 in the morning but once PHP5 gained traction and I was seduced into leaving PHP4 behind I found myself relying more heavily on PHPUnit. Not that SimpleTest is anti-PHP5 in any way (only some small things and obviously E_STRICT giving it a heart attack), but more projects I didn't control leaned heavily towards PHPUnit once PHP5 took off.

He goes on to talk about some of the differences between the two pieces of software (including Mock Object support and Stubs) and his personal feelings on how each of them works in his development experience. His interest has leaned more towards needing the Mock objects, though, so he favors SimpleTest for doing just what he needs.

PHPUnit fans can finally rejoice that the latest version of their much loved PHP unit testing utility - PHPUnit3 - has finally been released as a stable download.

Sebastian Bergmann and his contributors are proud to announce the immediate availability of PHPUnit 3. This release is a major improvement to the popular open source testing solution for PHP applications. It includes new features and bug fixes. Further details about this release can be found in the ChangeLog.

In his newest blog post, Sebastian lists some of the main new features this release offers - mock objects, selenium integration, and code-coverage support. There's even a brief installation howto and some on how to upgrade from the previous PHPUnit 2.3 to the latest.

On the Zend Developer Zone site today, Cal Evans had a chance to talk with Sebastian Bergmann, the lead coder on the PHPUnit unit testing project for an interview:

Sebastian Bergmann works at eZ systems. In his spare time he wrote and maintains the PHPUnit project. (He's worked on other project but since that's what he's talking about at ZendCon, that's what we'll talk about)

The interview is only a few questions long, but it's interesting to see how Sebastian's talk will be heading. There'll be talk of PHPUnit 3 (still in beta), mock objects, and its integration with CruiseControl. Check out the post for more of the questions.

Joseph Crawford has posted some of his thoughts on the mock testing that the folks over at php|architect are offering to help people prepare for Zend's PHP 5 Certification Exam.

So are you getting prepared to take the new PHP 5 Certification Exam offered by Zend? I have yet to see any books released for the preparation like i did with the PHP 4 exam, however there is something new and very cool. php|architect offers a Mock Tesing Environment which is powered by Vulcan Web Testing System.

Joseph talks about his experience, noting how he took the test and some of the topics that it covered. He definitely suggests taking it, too, as it provides a good glimpse into what you can expect come exam day.