In a recent post Nate Krantz has shared some of his own methods around writing functional and unit tests.

So...testing. That thing that everyone says is so important but you don't really learn about it in school. I've had some trials and tribulations with testing so I'm going to just dump out some thoughts here.

He starts with a bit of background on his own experiences in development and how he finally decided that testing would "solve everything". He started with unit tests (for a CodeIgniter application) and how he got them up and running. He talks about issues he found around dependencies (and static methods) and how he made use of mocks to reduce some of the issues with dynamic loading, at least how CodeIgniter does it. Unfortunately, this didn't work out as planned so he fell back to a test database and create more effective and simpler functional tests. Code examples are sprinkled through out the post to show how he was trying to solve the problem at different points in the process.

On NetTuts.com today they've made an announcement about a new PHP testing course they're making available for free. The course is an introduction to testing your PHP applications and is taught by Andrew Perkins.

In this course, Andrew Perkins will teach you the very basics of testing in the PHP language. Learn what is needed to test PHP applications and why testing is important. Explore the differences between regular testing, test-driven development (TDD) and behavior-driven development (BDD). Along the way, take a look at the various frameworks that are available, to make sure your PHP websites run just as you expected. And lastly, compare and contrast the different types of tests that you can run such as unit, functional, and acceptance tests.

The training course covers a lot of the basics behind testing and several of the tools you can use along the way including PHPUnit, Codeception and Behat. It's a pretty quick overview, so don't expect too much in-depth coding and testing examples. The course with all videos included comes in at just a bit over an hour of content. You can find out more and sign up to have access to the training here.

In this new post on thePHP.cc blog today Sebastian Bergmann relates the unfortunate disintegration of the Mars Climate Orbiter (back in 1999) back to a lesson on software testing and errors.

One of the most important tasks in software testing is to find the smallest scope in which a test case can be implemented. The smaller the scope in which a test is run, the faster it can be executed and the more precise its result. Unit Tests exercise one unit of code in isolation from all collaborators. Integration Tests verify the interaction of two or more collaborators in isolation from the rest of the system. Edge-to-Edge Tests run the software as end-to-end as possible in a single process (and without using a web browser or a web server). End-to-End Tests, or System Tests, look at the whole system and in the case of a web application send a HTTP request from a web browser to a web server running the software to inspect the HTTP response that is sent back.

He talks some about the difference between unit tests and acceptance tests and how "easy and seductive" functional tests can be over unit testing. He points out how fragile (and sometimes slow) this can be though, and how their failure only shows a problem and not where it is.

The promise of being able to develop both the business model as well as the software that implements it in an agile fashion should be reason enough for enterprises to invest in a modern, highly decoupled software architecture. And when the members of the software development team communicate well, both among themselves and with the other stakeholders, then there is not much that can really impede the success of the project.

On PHPMaster.com today there's a new article with some thoughts of a pragmatic tester - some thoughts from Michael Bodnarchuk about both unit and functional testing.

Here’s how it usually plays out: the developer thinks, “I need to do unit tests, and I should use PHPUnit because it’s a standard. I don’t know much about it, though.” Then he visits the PHPUnit site and reads the first chapter of the documentation, then the second, then the third… and is left scratching his head.

[...] Maybe something similar happened to you. Maybe not. But you really should know what to test and how to test it. Such knowledge comes from experience, so in this article I’ll share some of my experience with unit testing.

The article's not so much an introduction to unit testing as it is some of the experiences he's had around testing his applications both at the code level and from a functional perspective. He also mentions some alternatives to the standard PHPUnit testing like Atoum and EnhancePHP.