The purpose of this project was to build a simple blogging tool with the principles of test driven development (TDD), and domain driven design (DDD).

This project is designed to be a good showcase of TDD and DDD. It has a comprehensive test suite, and a layered architecture that should encourage easy extension.

This project was built using PHP 5.4, and it uses composer to manage dependencies.

The dependencies needed for this application are listed in the composer.json file. To install them simply run the following at the command line:

php composer.phar install

PHPUnit was installed using PEAR, and it is necessary for running tests.

This application relies on pdo_sqlite for the test suite, and pdo_mysql for production. These are utilized by the Doctrine2 ORM. Several tests will fail if APC is not installed, but the application can run without it. This of course means you need sqlite and mysql installed as well.

Once all the dependencies are taken care of, you can run the full test suite by running the following shell script in from the bin directory

bin/runtests

This script was built using the default Ubuntu bin/bash, and is just a helper for running all tests in the src/Test directory.

If you have guard and guard-phpunit installed, you can run the guard command from the terminal for live feedback during development

The application relies on mysql. The credentials used to connect are stored in src/Infrastructure/Persistence/Doctrine/doctrine.cfg.json. Keep in mind, you will need to create a database for the application to run.

This repo comes with a Doctrine console in the bin directory so you can generate the schema. Run the following command to create the schema for the app:

bin/doctrine orm:schema-tool:create

If you need to regenerate the proxies (recommended) for the domain entities, run the following:

bin/doctrine orm:generate-proxies

The application can be run out of the box using PHP 5.4's built in web server. Running the following command will start a web server on port 8000.

bin/runapp

All source for the application is contained in the src directory. The lib directory is where dependencies are installed to via composer.

The domain layer is the application core. The Domain\Entities namespace contains the models used for this application, that is User, Post, and Comment.

Domain\Repositories contains the interfaces for the each entity's repository. These interfaces are realized in the Infrastructure layer.

The root Domain namespace contains any value objects and services that are used throughout the application.

All repositories in this layer rely on Doctrine2, and are held within the Infrastructure\Persistence\Doctrine namespace. This layer also contains a UnitOfWork

The ConfigurationFactory can be used to tweak development and production environments for Doctrine2

The presentation layer is built using the Slim framework. The framework was chosen specifically to stay away from an MVC approach. This may better illustrate using the underlying services of the Domain and Infrastructure packages.

The Twig templating engine was used to generate markup, and Twitter bootstrap was used to give some generic style and structure to the interface.

Fuel Validation powers the input models in this layer.

Slim form based authentication is accomplished using several domain and infrastructure services via the Presentation\SlimAuthenticationService service.

Tests are broken into unit and integration tests. Both are constructed using PHPUnit, and were used to drive the implementations for this application.

Objects used throughout different tests can be found in the Test\Fixtures namespace.

This file loads the composer autoloader, and adds additional classes to the path. It is included in the Presentation and Test packages.