Some minor changes have been done to update the project and adapt it
to some depencencies updates.

The AuthorizationFilter is used by the test to simulate the HTTP basic
authentication. It was initially programmed to just allow access to the
"people" path.

This commit modifies this filter so that now it is easier to include
more paths accessible by the administrator.

The PeopleResourceTests now include security tests to verify that normal
users can't access people data.

The user authentication was currently done using a cookie and following
the same style of token as the HTTP Basic authentication (i.e. a
concatenation of user and password joined with a ':' encoded with
base64).

This authentication has been replaced by a standard HTTP Basic
authentication.

The message showed currently by the HasHttpStatus when de expected
status didn't match the actual status was not very informative, as
the actual status was not shown in the message.

This commit modifies this behaviour to show both status (expected and
actual) in the message.

Commit 9ef1c405 redesigned the user interface by introducing Bootstrap.
Although the structure changes where minimal, the changes on class types
caused the page object classes' selectors to fail.

This commit fixes this error and, in addition, fixes an unexpected error
on person deletion. This error was caused due to a missing wait for an
AJAX request response.

The EqualsVerifier library has been added to test the equals and hashCode
methods and it has been used to test the Person entity.

The login token was incorrectly set to "admin:admin" instead of
"admin:adminpass". This commit fixes this and sets the valid token
value.

This commit adds the new resource UsersResource (/users) with a simple
functionality: retrieving the data of an user. This functionality
requires knowing the login of the user that is performing the request.
In this regard, this commit is an example of how this information can be
retrieved and how to test a resource that requires knowing the login of
an user.

This test was unintentionally leaved out when creating the test case.

The tests classes have been simplified by delegating some of the
functions in the test classes to external utility classes. For example,
a PeopleDataset has been added to manage the dataset or the
IsEqualToEntity Hamcrest matcher has been added to simplify entity
comparisons.

In addition, a PersonUnitTest class has been added to test the Person
entity.

A big refactorization has been done in this commit, focused on
simplifying the testing and execution process. The Spring-DbUnit library
has been added to allow the use of DbUnit through annotations in the
test classes. This change has been complemented with two new test
listeners that allow the creation of custom initial contexts and the use
of custom SQL scripts to create and destroy the database tables before
and after the test execution, respectively. In addition, all the tests
are executed now using a HSQLDB database.

The datasource configuration has been pulled out of the project, and now
it must be provided by the container.

The sample classes have been reviewed, refactorized and documented with
JavaDoc.

The POM file has been reworked to ease test and application execution
using maven. The new execution modes are:
	- The default execution includes unit, integration and acceptance (with
Selenium) test execution.
	- No acceptance tests: mvn -P -acceptance-tests-cargo <phase>
	- Run server for manual acceptance tests: mvn
-Dcargo.tomcat.start.skip=true -Dcargo.tomcat.run.skip=false
-DskipTests=true pre-integration-test 
	- Run server with MySQL database: mvn -P
run-tomcat-mysql,-acceptance-tests-cargo -DskipTests=true package
cargo:run

DatabaseQueryUnitTest mocks the database and there is no need to create
a testing database. Therefore, the TestUtils method calls to initialize
and clear the testing database where removed.

Several testing improvement have been done:
	- Cobertura plugin was replaced by JaCoCo plugin that supports Java 8
syntax.
	- Unit tests with a controller fixtured using EasyMock were added for
PeopleDAO and PeopleResource.
	- POM was reviewed, reordered and reformatted.
	- Test classes naming was reviewed and standarized.
	- Three test suites were added to group the unit, integration, and
acceptance tests.
	- Naming context management done in TestUtils was improved. 

Web configuration for REST services and login filter was moved from the
web.xml file to code annotations.

POM was reviewed to update the dependencies of the project to the last
version and to improve the test execution.

Now it is possible to run the project with the testing database in a
Tomcat Server v7.0 using the mvn tomcat7:run goal. In addition, Selenium
tests now are executed as integration tests, starting the web server
before the test execution and stoping it after the tests end. Finally,
support for generating regular and cobertura test reports in HTML format
was also added.

The project was also cleaned by removing the MANIFEST.MF files and by
reallocating the SQL files.

Sunfire report generation plugin added to pom.xml.

Minor code cleaning in pom.xml and PeopleWebTest class.

New login method based in HTTP's Basic Authentication used. This new
method eliminates the need of the database supporting the SHA256
algorithm and facilitates the future use of Basic Authentication.

Tests were updated to use the new token encoding.

DAO class modified to support and alternative JNDI for the data source
through the "db.jndi" system property. A new testing database resource
was added to the Context.xml file.

DAO tests use the "spring-test" library to create a JNDI context, as
JUnit doesn't create any context. Additionaly, a custom DataSource is
created using the "commons-dbcp" library and injected into the context.
Testing database creation scripts are provided in the mysql-tests.sql
file.

REST API is tested in the server side using the
"jersey-test-framework-provider-grizzly2" library. These tests also use
the "spring-test" and "commons-dbcp" libraries to create a context and
inject a custom data source.

REST API is tested in the client side using the "Selenium IDE" and
"RESTClient" plugins for Firefox. Manual database reset is required
before launching the test suite.

Web interface is tested using the "Selenium IDE" plugin for Firefox and
using the "Selenium WebDrive" in JUnit tests. Same tests are implemented
in both cases. Selenium IDE tests require a manual database reset before
launching the test suite. JUnit test require the server to be started
using the testing database.