Sebastian Göttschkes has a new post to his blog about a set of abstract base testing classes he's developed to help with the functional, unit and validation testing of his Symfony2-based applications.

So, when developing with symfony2, I rely on my tests. They are my safety net and without them, I get a little nervous after every change. Does everything work? Did I forget anything? So I developed some classes which I extend. They work on top of PHPUnit and the symfony2 WebTestCase. The classes are used by my different types of Tests: UnitTests, ValidationTests, FunctionalTests (as well as IntegrationTests).

Code for each type of testing base class is included in the post showing how he extends the based PHPUnit test case for unit testing and the Symfony WebTestCase for validation and functional testing. Each one of the classes are ready to use and give you some handy helper methods too.

In this new post to his blog Chris Hartjes offers up a few of his own thoughts about testing APIs and some of the issues/concerns he's come across in his own testing (via Behat).

I have been asked a few times on Twitter for some advice on how to use testing tools in order to test APIs. It just so happens that I am writing a bunch of tests for an API at work so perhaps this is a very timely blog post. [...] When you are testing an API you main concern is your ability to reproduce the results of a specific API call. If your API is such that repeating a call several times will give you different results, you do have some challenges on your hands.

He talks about functional testing, the "moving parts" they involve, using only known data sources and the creation of integration tests. He also mentions the testing of your local application to ensure it's handling (or transforming) the results of the API calls into something useful.

In the end, it doesn't really matter what tools you are using to test either your own APIs or ones that your application depends on. Be clear in your mind about what it is you are actually trying to accomplish and don't get create tests that provide very little value to your application.

On the Codeception blog there's an introduction to the Codeception tool, a behavior-driven framework written in PHP (in the spirit of Behat).

How often do you see PHP projects with no line of test written? From my experience, this situation happens quite often. We should state the unpleasant fact that tests are not so popular around the PHP world. Surely, the advanced developers with 5+ years of experience in PHP and other programming languages understand importance of testing and PHPUnit usage. But juniors and seniors are just skipping testing and, therefore, produce unstable web applications.

A code example of the framework in use is included in the post - a test on a class using methods like "wantTo", "amOnPage", "fillField" and "click". The installation is pretty simple and it gives you a quick way to start working on acceptance, functional and unit tests. In BDD fashion, the tests are written in a more "natural language" than traditional unit tests making them easier for the non-developers (like QA) to write. Their example loads a page, fills in some form fields and submits the form to check the result.

In a new post to his blog Sameer Borate looks at using the Underscore.php library to do a little functional programming in PHP. Underscrore.phpis a PHP port of Underscrore.js.

Underscore.php provides a utility library for PHP that provides a lot of the functional programming support that a programmer would expect in Ruby, but without adding much overhead during execution. The only caveat is that underscore.php requires PHP 5.3 or greater. Although you could accomplish some of the things using PHP's built in functions, the functional approach looks intuitive and easy to work with.

He gives a few simple code examples - one using the "pluck" method to pull certain values out of an array, the "map" method to apply a transformation to each item in an array and some OOP examples showing the use of the "max" and "template" methods.

Juozas Kaziukenas has a new post to his Web Species blog about using "lazy evaluation" in PHP - loading the resources you need for execution and evaluation only as you need them, not all up front.

Recently I needed to process a huge array of data and because of PHP's somewhat inefficient variables and especially arrays that was resulting in "out of memory" errors. However, I couldn't use any other tools than PHP so was forced to come up with a solution implementation in it. Here is how I solved it using principles from functional languages.

He gives an example using Haskell to generate a Fibonacci sequence using its built-in lazy evaluation abilities. Unfortunately, PHP doesn't have such a thing built in, so he tries the next best thing - Iterators. He caries the idea over to the database side too, recommending fetch() in a loop over fetchAll() and some effective joins.

On PHPBuilder.com today there's a new tutorial from Jason Gilmore about working with Zend Framework applications and how to test its functionality with the help of a library he's created.

Thankfully, the software community has put a great deal of time and effort into developing automated testing approaches. In fact, most Web frameworks incorporate a native testing solution that can be used to test a wide variety of website attributes and behaviors. One such framework, the Zend Framework, integrates the de facto PHP testing solution PHPUnit (introduced in an earlier PHPBuilder.com article).

He shows some first steps of testing an "About" controller and that you end up on the right action - "index". After that he gets a bit more complex with a test on a form complete with POST information to ensure that the user is either redirected to the user's profile page or back to the login form.

In a new post to the test.ical.ly blog Christian looks at how to wrap Symfony functional tests inside of a PHPUnit test case to unify them with your already-existing unit tests.

Yesterday I wrote a lot of functional tests for a symfony plugin that provides and XML web service interface. Using symfonys functional testing classes this is actually quite easy to do. But wouldn't it be cool if you could integrate these tests into your continuous integration service just like PHPUnit tests? Wouldn't it be cool to be able to generate PHPUnit coverage reports?

He created a simple PHPUnit test whose job it is to run all of the Lime tests (with a standard naming convention) and pull the results back into the test to be evaluated. An assertEquals checks the result to be sure the string "ok" is returned as the first thing on the line. If any of the functional tests fail, the whole test case will fail. It could be modified a bit to record which case it was that actually failed and report that back in the failure information.

On the Quality Assurance in PHP Projects site, Mike Lively has written up a few thoughts on how developers and development environments should work with testing databases as resources (case study).

Proper interaction with relational databases is incredibly important in most pieces of software. The importance of this interaction is underscored by the fact that many software architectures have at least one entire layer or system devoted to data persistence and data loading. When dealing with critical data in enterprise level applications it becomes even more important to make sure your data is being stored and retrieved correctly.

He talks about a case study on the topic (still in development) that will talk about testing techniques, functionality and how to create the tests needed to ensure your development environment can correctly use the database resource via unit tests and functional tests.

In this new article from Noupe.com they link to several resources that can help you make your site's forms a bit "more beautiful" by combining PHP and Ajax (and Javascript).

Forms needs a solid visual structure, a profound hierarchy of form elements (Fields and Labels), powerful techniques and Functionality (AJAX) to make the form look and work creatively. [...] Today we wanted to share with you some great steps to get the perfect form: we will go through designing and usability you need to keep in mind, styling your form, spicing it up with some nice javascript effects, validating user's input and finally getting it to work using PHP and Ajax.

Some of the links include:

• Web Form Design Patterns: Sign-Up Forms
• Justify elements using jQuery and CSS
• XHTML/CSS web forms: 5 simple techniques
• Using ProtoForm
• Autosuggest / Autocomplete with Ajax

Most of the article links also include links to demos of the tutorial/application in action.

In this new blog entry, Sebastian Bergmann talks about two bits of functionality that PHP has that bring it a bit closer to a full functional language - array_map and array_reduce.

Just like Python, PHP is not a full-fledged functional language, but it supports some very useful functional idioms such as map and reduce. A blog posting by Scott Moonen on Functional Python prompted me to write this posting on PHP's array_map() and array_reduce() functions that apply callback functions to arrays.

He includes examples of each (in the functional context) showing how you can map callbacks to the array values, one that adds one to each number in the array and the other that combines the values and returns the sum.