Invariant Properties » 2013

Project Student: Maintenance Webapp (read-only)

Bear Giles | December 30, 2013

This is part of Project Student. Other posts are Webservice Client With Jersey, Webservice Server with Jersey, Business Layer, Persistence with Spring Data, Sharding Integration Test Data, Webservice Integration and JPA Criteria Queries.

When I started this project I had four goals. In no particular order they were to:

learn about jQuery and other AJAX technologies. For that I needed a REST server I understood,
capture recently acquired knowledge about jersey and tapestry,
create a framework I could use to learn about other technologies (e.g., spring MVC, restlet, netty), and
have something to discuss in job interviews

If it was useful to others – great! That’s why it’s available under the Apache license.

(It should go without saying that acceptable uses does not include turning “Project Student” into a student project without proper attribution!)

The problem with learning AJAX is that I’ll initially be uncertain where the problem lies. Is it bad jQuery? A bad REST service? Something else? The extensive unit and integration tests are a good start but there will always be some uncertainty.

The other consideration is that in the real world we’ll often need a basic view into the database. It won’t be for public consumption – it’s for internal use when we hit a WTF moment. It can also be used to maintain information that we don’t want to manage via a public interface, e.g., values in pulldown menus.

A small twist on this can be used to provide a modest level of scalability. Use hefty servers for your database and REST service, then have N front-end servers that run conventional webapps that act as an intermediary between the user and the REST service. The front-end servers can be fairly lightweight and spun up on an as-needed basis. Bonus points for putting a caching server between the front ends and the REST server since the overwhelming fraction of hits will be reads.

This approach won’t scale to Amazon or Facebook scales but it will be good enough for many sites.

Maintenance Webapp

This brings us to the optional layers of the webapp onion – a conventional webapp that acts as a frontend to the REST service. For various reasons I’m using Tapestry 5 for the application but it’s an arbitrary decision and I won’t spend much time delving into Tapestry-specific code.

You can create a new tapestry project with

$ mvn archetype:generate -DarchetypeCatalog=http://tapestry.apache.org

$ mvn archetype:generate -DarchetypeCatalog=http://tapestry.apache.org

I’ve found the examples at http://jumpstart.doublenegative.com.au/jumpstart/examples/ invaluable. I’ve kept in attribution where appropriate.

Later I will also create the second optional layer of the webapp – functional and regression tests with Selenium and WebDriver (that is, Selenium 2.0).

Limitations

Read-only – spinning up the webapp takes a lot of work so the initial version will only provide read-only access of simple tables. No updates, no one-to-many mappings.

User Authentication – no effort has been made to authenticate users.

Encryption – no effort has been made to encrypt communications.

Database Locks – we’re using opportunistic locking with hibernate versions instead of explicit database locks. Security note: under the principle of least disclosure we don’t want to make the version visible unless it’s required. A good rule is that you’ll see if it you request a specific object but not see it in lists.

REST Client – the default GET handler for each type is very crude – it just returns a list of objects. We need a more sophisticated response (e.g., the number of records, the start- and end-index, a status code, etc.) and will let the UI drive it. For now the only thing we really need is a count and we can just request the list and count the number of elements.

Goal

We want a page that lists all courses in the database. It does not need to worry about pagination, sorting, etc. It should have links (possibly inactive) for editing and deleting a record. It does not need to have a link to add a new course.

The page should look something like this:

Course template

The Tapestry page listing courses is straightforward – it’s basically just a decorated grid of values.

(See the tapestry archetype for Layout.tml, etc.)

<html t:type="layout" title="Course List"
t:sidebarTitle="Framework Version"
xmlns:t="http://tapestry.apache.org/schema/tapestry_5_3.xsd"
xmlns:p="tapestry:parameter">
<t:zone t:id="zone">
"Course" page
<t:grid source="courses" row="course" include="uuid,name,creationdate" add="edit,delete">
<p:name>
<t:pagelink page="CourseEditor" context="course.uuid">${course.name}</t:pagelink>
</p:name>
<p:editcell>
<t:actionlink t:id="edit" context="course.uuid">Edit</t:actionlink>
</p:editcell>
<p:deletecell>
<t:actionlink t:id="delete" context="course.uuid">Delete</t:actionlink>
</p:deletecell>
<p:empty>
There are no courses to display; you can <t:pagelink page="Course/Editor" parameters="{ 'mode':'create', 'courseUuid':null }">add some</t:pagelink>.
</p:empty>
</t:grid>
</t:zone>
<p:sidebar>
[
<t:pagelink page="Index">Index</t:pagelink>
]
[
<t:pagelink page="Course/List">Courses</t:pagelink>
]
</p:sidebar>
</html>

<html t:type="layout" title="Course List"
      t:sidebarTitle="Framework Version"
      xmlns:t="http://tapestry.apache.org/schema/tapestry_5_3.xsd"
      xmlns:p="tapestry:parameter">
        <!-- Most of the page content, including <head>, <body>, etc. tags, comes from Layout.tml -->

    <t:zone t:id="zone">   
        <p>
            "Course" page
        </p>
   
        <t:grid source="courses" row="course" include="uuid,name,creationdate" add="edit,delete">
            <p:name>
                <t:pagelink page="CourseEditor" context="course.uuid">${course.name}</t:pagelink>
            </p:name>
            <p:editcell>
                <t:actionlink t:id="edit" context="course.uuid">Edit</t:actionlink>
            </p:editcell>
            <p:deletecell>
                <t:actionlink t:id="delete" context="course.uuid">Delete</t:actionlink>
            </p:deletecell>
            <p:empty>
              <p>There are no courses to display; you can <t:pagelink page="Course/Editor" parameters="{ 'mode':'create', 'courseUuid':null }">add some</t:pagelink>.</p>
            </p:empty>
        </t:grid>
    </t:zone>

    <p:sidebar>
        <p>
            [
            <t:pagelink page="Index">Index</t:pagelink>
            ]<br/>
            [
            <t:pagelink page="Course/List">Courses</t:pagelink>
            ]
        </p>
    </p:sidebar>
</html>

with a properties file of

title=Courses
delete-course=Delete course?

title=Courses
delete-course=Delete course?

I’ve included the actionlinks for edit and delete but they’re nonfunctional.

GridDataSources

Our page needs a source for the values to display. This requires two classes. The first defines the courses property used above.

package com.invariantproperties.sandbox.student.maintenance.web.tables;
import com.invariantproperties.sandbox.student.business.CourseFinderService;
public class GridDataSources {
// Screen fields
@Property
private GridDataSource courses;
// Generally useful bits and pieces
@Inject
private CourseFinderService courseFinderService;
@InjectComponent
private Grid grid;
// The code
void setupRender() {
courses = new CoursePagedDataSource(courseFinderService);
}
}

package com.invariantproperties.sandbox.student.maintenance.web.tables;

import com.invariantproperties.sandbox.student.business.CourseFinderService;

public class GridDataSources {
    // Screen fields

    @Property
    private GridDataSource courses;

    // Generally useful bits and pieces

    @Inject
    private CourseFinderService courseFinderService;

    @InjectComponent
    private Grid grid;

    // The code

    void setupRender() {
        courses = new CoursePagedDataSource(courseFinderService);
    }
}

and the actual implementation is

package com.invariantproperties.sandbox.student.maintenance.web.tables;
import com.invariantproperties.sandbox.student.business.CourseFinderService;
import com.invariantproperties.sandbox.student.domain.Course;
import com.invariantproperties.sandbox.student.maintenance.query.SortCriterion;
import com.invariantproperties.sandbox.student.maintenance.query.SortDirection;
public class CoursePagedDataSource implements GridDataSource {
private int startIndex;
private List<Course> preparedResults;
private final CourseFinderService courseFinderService;
public CoursePagedDataSource(CourseFinderService courseFinderService) {
this.courseFinderService = courseFinderService;
}
@Override
public int getAvailableRows() {
long count = courseFinderService.count();
return (int) count;
}
@Override
public void prepare(final int startIndex, final int endIndex, final List<SortConstraint> sortConstraints) {
// Get a page of courses - ask business service to find them (from the
// database)
// List<SortCriterion> sortCriteria = toSortCriteria(sortConstraints);
// preparedResults = courseFinderService.findCourses(startIndex,
// endIndex - startIndex + 1, sortCriteria);
preparedResults = courseFinderService.findAllCourses();
this.startIndex = startIndex;
}
@Override
public Object getRowValue(final int index) {
return preparedResults.get(index - startIndex);
}
@Override
public Class<Course> getRowType() {
return Course.class;
}
/**
* Converts a list of Tapestry's SortConstraint to a list of our business
* tier's SortCriterion. The business tier does not use SortConstraint
* because that would create a dependency on Tapestry.
*/
private List<SortCriterion> toSortCriteria(List<SortConstraint> sortConstraints) {
List<SortCriterion> sortCriteria = new ArrayList<>();
for (SortConstraint sortConstraint : sortConstraints) {
String propertyName = sortConstraint.getPropertyModel().getPropertyName();
SortDirection sortDirection = SortDirection.UNSORTED;
switch (sortConstraint.getColumnSort()) {
case ASCENDING:
sortDirection = SortDirection.ASCENDING;
break;
case DESCENDING:
sortDirection = SortDirection.DESCENDING;
break;
default:
}
SortCriterion sortCriterion = new SortCriterion(propertyName, sortDirection);
sortCriteria.add(sortCriterion);
}
return sortCriteria;
}
}

package com.invariantproperties.sandbox.student.maintenance.web.tables;

import com.invariantproperties.sandbox.student.business.CourseFinderService;
import com.invariantproperties.sandbox.student.domain.Course;
import com.invariantproperties.sandbox.student.maintenance.query.SortCriterion;
import com.invariantproperties.sandbox.student.maintenance.query.SortDirection;

public class CoursePagedDataSource implements GridDataSource {

    private int startIndex;
    private List<Course> preparedResults;

    private final CourseFinderService courseFinderService;

    public CoursePagedDataSource(CourseFinderService courseFinderService) {
        this.courseFinderService = courseFinderService;
    }

    @Override
    public int getAvailableRows() {
        long count = courseFinderService.count();
        return (int) count;
    }

    @Override
    public void prepare(final int startIndex, final int endIndex, final List<SortConstraint> sortConstraints) {

        // Get a page of courses - ask business service to find them (from the
        // database)
        // List<SortCriterion> sortCriteria = toSortCriteria(sortConstraints);
        // preparedResults = courseFinderService.findCourses(startIndex,
        // endIndex - startIndex + 1, sortCriteria);
        preparedResults = courseFinderService.findAllCourses();

        this.startIndex = startIndex;
    }

    @Override
    public Object getRowValue(final int index) {
        return preparedResults.get(index - startIndex);
    }

    @Override
    public Class<Course> getRowType() {
        return Course.class;
    }

    /**
     * Converts a list of Tapestry's SortConstraint to a list of our business
     * tier's SortCriterion. The business tier does not use SortConstraint
     * because that would create a dependency on Tapestry.
     */
    private List<SortCriterion> toSortCriteria(List<SortConstraint> sortConstraints) {
        List<SortCriterion> sortCriteria = new ArrayList<>();

        for (SortConstraint sortConstraint : sortConstraints) {

            String propertyName = sortConstraint.getPropertyModel().getPropertyName();
            SortDirection sortDirection = SortDirection.UNSORTED;

            switch (sortConstraint.getColumnSort()) {
            case ASCENDING:
                sortDirection = SortDirection.ASCENDING;
                break;
            case DESCENDING:
                sortDirection = SortDirection.DESCENDING;
                break;
            default:
            }

            SortCriterion sortCriterion = new SortCriterion(propertyName, sortDirection);
            sortCriteria.add(sortCriterion);
        }

        return sortCriteria;
    }
}

AppModule

Now that we have a GridDataSource we can see what it needs – a CourseFinderService. While there is a Tapestry-Spring integration we want to keep the maintenance webapp as thin as possible so for now we use standard Tapestry injection.

package com.invariantproperties.sandbox.student.maintenance.web.services;
import com.invariantproperties.sandbox.student.business.CourseFinderService;
import com.invariantproperties.sandbox.student.business.CourseManagerService;
import com.invariantproperties.sandbox.student.maintenance.service.impl.CourseFinderServiceTapestryImpl;
import com.invariantproperties.sandbox.student.maintenance.service.impl.CourseManagerServiceTapestryImpl;
/**
* This module is automatically included as part of the Tapestry IoC Registry,
* it's a good place to configure and extend Tapestry, or to place your own
* service definitions.
*/
public class AppModule {
public static void bind(ServiceBinder binder) {
binder.bind(CourseFinderService.class, CourseFinderServiceTapestryImpl.class);
binder.bind(CourseManagerService.class, CourseManagerServiceTapestryImpl.class);
}
....
}

package com.invariantproperties.sandbox.student.maintenance.web.services;

import com.invariantproperties.sandbox.student.business.CourseFinderService;
import com.invariantproperties.sandbox.student.business.CourseManagerService;
import com.invariantproperties.sandbox.student.maintenance.service.impl.CourseFinderServiceTapestryImpl;
import com.invariantproperties.sandbox.student.maintenance.service.impl.CourseManagerServiceTapestryImpl;

/**
 * This module is automatically included as part of the Tapestry IoC Registry,
 * it's a good place to configure and extend Tapestry, or to place your own
 * service definitions.
 */
public class AppModule {
    public static void bind(ServiceBinder binder) {
        binder.bind(CourseFinderService.class, CourseFinderServiceTapestryImpl.class);
        binder.bind(CourseManagerService.class, CourseManagerServiceTapestryImpl.class);
    }

    ....
}

Note that we’re using the standard CourseFinderService interface with the tapestry-specific implementation. This means we can use the standard implementation directly with nothing more than a small change to the configuration files!

CourseFinderServiceTapestryImpl

The local implementation of the CourseFinderService interface must use the REST client instead of the Spring Data implementation. Using the outside-in approach used earlier the needs of the Tapestry template should drive the needs of the Service implementation and that, in turn, drives the needs of the REST client and server.

package com.invariantproperties.sandbox.student.maintenance.service.impl;
public class CourseFinderServiceTapestryImpl implements CourseFinderService {
private final CourseFinderRestClient finder;
public CourseFinderServiceTapestryImpl() {
// resource should be loaded as tapestry resource
final String resource = "http://localhost:8080/student-ws-webapp/rest/course/";
finder = new CourseFinderRestClientImpl(resource);
// load some initial data
initCache(new CourseManagerRestClientImpl(resource));
}
@Override
public long count() {
// FIXME: grossly inefficient but good enough for now.
return finder.getAllCourses().length;
}
@Override
public long countByTestRun(TestRun testRun) {
// FIXME: grossly inefficient but good enough for now.
return finder.getAllCourses().length;
}
@Override
public Course findCourseById(Integer id) {
// unsupported operation!
throw new ObjectNotFoundException(id);
}
@Override
public Course findCourseByUuid(String uuid) {
return finder.getCourse(uuid);
}
@Override
public List<Course> findAllCourses() {
return Arrays.asList(finder.getAllCourses());
}
@Override
public List<Course> findCoursesByTestRun(TestRun testRun) {
return Collections.emptyList();
}
// method to load some test data into the database.
private void initCache(CourseManagerRestClient manager) {
manager.createCourse("physics 101");
manager.createCourse("physics 201");
manager.createCourse("physics 202");
}
}

package com.invariantproperties.sandbox.student.maintenance.service.impl;

public class CourseFinderServiceTapestryImpl implements CourseFinderService {
    private final CourseFinderRestClient finder;

    public CourseFinderServiceTapestryImpl() {
        // resource should be loaded as tapestry resource
        final String resource = "http://localhost:8080/student-ws-webapp/rest/course/";
        finder = new CourseFinderRestClientImpl(resource);

        // load some initial data
        initCache(new CourseManagerRestClientImpl(resource));
    }

    @Override
    public long count() {
        // FIXME: grossly inefficient but good enough for now.
        return finder.getAllCourses().length;
    }

    @Override
    public long countByTestRun(TestRun testRun) {
        // FIXME: grossly inefficient but good enough for now.
        return finder.getAllCourses().length;
    }

    @Override
    public Course findCourseById(Integer id) {
        // unsupported operation!
        throw new ObjectNotFoundException(id);
    }

    @Override
    public Course findCourseByUuid(String uuid) {
        return finder.getCourse(uuid);
    }

    @Override
    public List<Course> findAllCourses() {
        return Arrays.asList(finder.getAllCourses());
    }

    @Override
    public List<Course> findCoursesByTestRun(TestRun testRun) {
        return Collections.emptyList();
    }

    // method to load some test data into the database.
    private void initCache(CourseManagerRestClient manager) {
        manager.createCourse("physics 101");
        manager.createCourse("physics 201");
        manager.createCourse("physics 202");
    }
}

Our JPA Criteria query can give us a quick count but our REST client doesn’t support that yet.

Wrapping up

After we finish the grunt work we’ll have a maintenance .war file. We can deploy it with the webservice .war on our appserver – or not. There’s no reason the two .war files have to be on the same system other than the temporarily hardcoded URL for the webservice.

We should first go to http://localhost:8080/student-maintenance-webapp/course/list. We should see a short list of courses as shown above. (In that case I had restarted the webapp three times so each entry is duplicated three-fold.)

Now we should go to our webservice webapp at http://localhost:8080/student-ws-webapp/rest/course and verify that we can get data via the browser there as well. After a bit of cleanup we should see:

{"course":
[
{
"creationDate":"2013-12-28T14:40:21.369-07:00",
"uuid":"500069e4-444d-49bc-80f0-4894c2d13f6a",
"version":"0",
"name":"physics 101"
},
{
"creationDate":"2013-12-28T14:40:21.777-07:00",
"uuid":"54001b2a-abbb-4a75-a289-e1f09173fa04",
"version":"0",
"name":"physics 201"
},
{
"creationDate":"2013-12-28T14:40:21.938-07:00",
"uuid":"cfaf892b-7ead-4d64-8659-8f87756bed62",
"version":"0",
"name":"physics 202"
},
{
"creationDate":"2013-12-28T16:17:54.608-07:00",
"uuid":"d29735ff-f614-4979-a0de-e1d134e859f4",
"version":"0",
"name":"physics 101"
},
....
]
}

{"course":
 [
   {
     "creationDate":"2013-12-28T14:40:21.369-07:00",
     "uuid":"500069e4-444d-49bc-80f0-4894c2d13f6a",
     "version":"0",
     "name":"physics 101"
   },
   {
     "creationDate":"2013-12-28T14:40:21.777-07:00",
     "uuid":"54001b2a-abbb-4a75-a289-e1f09173fa04",
     "version":"0",
     "name":"physics 201"
   },
   {
     "creationDate":"2013-12-28T14:40:21.938-07:00",
     "uuid":"cfaf892b-7ead-4d64-8659-8f87756bed62",
     "version":"0",
     "name":"physics 202"
   },
   {
     "creationDate":"2013-12-28T16:17:54.608-07:00",
     "uuid":"d29735ff-f614-4979-a0de-e1d134e859f4",
     "version":"0",
     "name":"physics 101"
   },
   ....
 ]
}

Source Code

The source code is at https://github.com/beargiles/project-student [github] and http://beargiles.github.io/project-student/ [github pages].

Comments: No Comments »
Categories: java
Comments rss
Trackback

Project Student: JPA Criteria Queries

Bear Giles | December 29, 2013

We’ve covered basic CRUD operations but that doesn’t take us very far. Spring Data makes it easy to include basic searches but it’s important to have other standard options. One of the most important is JPA criteria queries.

A good introduction to this material is Spring Data JPA tutorial – JPA Criteria Queries [http://www.petrikainulainen.net].

Design Decisions

JPA criteria – I’m using JPA criteria searches instead of querydsl. I’ll come back to querydsl later.

Limitations

Violation of Encapsulation – this design requires breaking the architectural goal of making each layer completely unaware of the implementation details of the other layers. This is a very small violation – only the JPA specifications – and we still have to deal with pagination. Put those together and I feel it’s premature optimization to worry about this too much at this time.

Webservices – the webservice client and server are not updated. Again we still have to deal with pagination and anything we do now will have to be changed anyway.

Refactoring Prior Work

I have three changes to prior work.

findCoursesByTestRun()

I had defined the method

List findCoursesByTestRun(TestRun testRun);

List findCoursesByTestRun(TestRun testRun);

in the Course repository. That doesn’t have the intended effect. What I needed was

List findCoursesByTestRun_Uuid(String uuid);

List findCoursesByTestRun_Uuid(String uuid);

with the appropriate changes to the calling code. Or you can just use the JPA criteria query discussed below.

FinderService and ManagerService

This comes from research on the Jumpstart site. The author splits the standard service interface into two pieces:

FinderService – read-only operations (searches)
ManagerService – read-write operations (create, update, delete)

This makes a lot of sense, e.g., it will be a lot easier to add behavior via AOP when we can operate at the class vs. method level. I’ve made the appropriate changes in the existing code.

FindBugs

I’ve fixed a number of issues identified by FindBugs.

Metadata

We begin by enabling access to metadata access to our persistent objects. This allows us to create queries that can be optimized by the JPA implementation.

import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.StaticMetamodel;
@StaticMetamodel(Course.class)
public class Course_ {
public static volatile SingularAttribute<Course, TestRun> testRun;
}

import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.StaticMetamodel;

@StaticMetamodel(Course.class)
public class Course_ {
    public static volatile SingularAttribute<Course, TestRun> testRun;
}

and

@StaticMetamodel(TestRun.class)
public class TestRun_ {
public static volatile SingularAttribute<TestRun, String> uuid;
}

@StaticMetamodel(TestRun.class)
public class TestRun_ {
    public static volatile SingularAttribute<TestRun, String> uuid;
}

The name of the class is required due to convention over configuration.

For a discussion of this feature see Static metadata [jboss.org].

Specifications

We can now create the query specification using the metadata now available. This is a slightly more complex query since we need to drill into the structure. (This shouldn’t require an actual join since the testrun uuid is used as the foreign key.)

public class CourseSpecifications {
/**
* Creates a specification used to find courses with the specified testUuid.
*
* @param testRun
* @return
*/
public static Specification<Course> testRunIs(final TestRun testRun) {
return new Specification<Course>() {
@Override
public Predicate toPredicate(Root<Course> courseRoot, CriteriaQuery<?> query, CriteriaBuilder cb) {
Predicate p = null;
if (testRun == null || testRun.getUuid() == null) {
p = cb.isNull(courseRoot.<Course_> get("testRun"));
} else {
p = cb.equal(courseRoot.<Course_> get("testRun").<TestRun_> get("uuid"), testRun.getUuid());
}
return p;
}
};
}
}

public class CourseSpecifications {

    /**
     * Creates a specification used to find courses with the specified testUuid.
     * 
     * @param testRun
     * @return
     */
    public static Specification<Course> testRunIs(final TestRun testRun) {

        return new Specification<Course>() {
            @Override
            public Predicate toPredicate(Root<Course> courseRoot, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Predicate p = null;
                if (testRun == null || testRun.getUuid() == null) {
                    p = cb.isNull(courseRoot.<Course_> get("testRun"));
                } else {
                    p = cb.equal(courseRoot.<Course_> get("testRun").<TestRun_> get("uuid"), testRun.getUuid());
                }
                return p;
            }
        };
    }
}

Some documentation suggests I could use get(Course_.testRun) instead of get(“testRun”) but eclipse was flagging it as a type violation on the get() method. Your mileage may vary.

Spring Data Repository

We must tell Spring Data that we’re using JPA Criteria queries. This is done by extending the JpaSpecificationExecutor interface.

@Repository
public interface CourseRepository extends JpaRepository<Course, Integer>,
JpaSpecificationExecutor<Course> {
Course findCourseByUuid(String uuid);
List findCoursesByTestRunUuid(String uuid);
}

@Repository
public interface CourseRepository extends JpaRepository<Course, Integer>,
        JpaSpecificationExecutor<Course> {
    
    Course findCourseByUuid(String uuid);

    List findCoursesByTestRunUuid(String uuid);
}

FinderService Implementation

We can now use the JPA specification in our service implementations. As mentioned above using the JPA Criteria Specification violates encapsulation.

import static com.invariantproperties.sandbox.student.specification.CourseSpecifications.testRunIs;
@Service
public class CourseFinderServiceImpl implements CourseFinderService {
@Resource
private CourseRepository courseRepository;
/**
* @see com.invariantproperties.sandbox.student.business.FinderService#
* count()
*/
@Transactional(readOnly = true)
@Override
public long count() {
return countByTestRun(null);
}
/**
* @see com.invariantproperties.sandbox.student.business.FinderService#
* countByTestRun(com.invariantproperties.sandbox.student.domain.TestRun)
*/
@Transactional(readOnly = true)
@Override
public long countByTestRun(TestRun testRun) {
long count = 0;
try {
count = courseRepository.count(testRunIs(testRun));
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("internal error retrieving classroom count by " + testRun, e);
}
throw new PersistenceException("unable to count classrooms by " + testRun, e, 0);
}
return count;
}
/**
* @see com.invariantproperties.sandbox.student.business.CourseFinderService#
* findAllCourses()
*/
@Transactional(readOnly = true)
@Override
public List<Course> findAllCourses() {
return findCoursesByTestRun(null);
}
/**
* @see com.invariantproperties.sandbox.student.business.CourseFinderService#
* findCoursesByTestRun(java.lang.String)
*/
@Transactional(readOnly = true)
@Override
public List<Course> findCoursesByTestRun(TestRun testRun) {
List<Course> courses = null;
try {
courses = courseRepository.findAll(testRunIs(testRun));
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("error loading list of courses: " + e.getMessage(), e);
}
throw new PersistenceException("unable to get list of courses.", e);
}
return courses;
}
....
}

import static com.invariantproperties.sandbox.student.specification.CourseSpecifications.testRunIs;

@Service
public class CourseFinderServiceImpl implements CourseFinderService {
    @Resource
    private CourseRepository courseRepository;

    /**
     * @see com.invariantproperties.sandbox.student.business.FinderService#
     *      count()
     */
    @Transactional(readOnly = true)
    @Override
    public long count() {
        return countByTestRun(null);
    }

    /**
     * @see com.invariantproperties.sandbox.student.business.FinderService#
     *      countByTestRun(com.invariantproperties.sandbox.student.domain.TestRun)
     */
    @Transactional(readOnly = true)
    @Override
    public long countByTestRun(TestRun testRun) {
        long count = 0;
        try {
            count = courseRepository.count(testRunIs(testRun));
        } catch (DataAccessException e) {
            if (!(e instanceof UnitTestException)) {
                log.info("internal error retrieving classroom count by " + testRun, e);
            }
            throw new PersistenceException("unable to count classrooms by " + testRun, e, 0);
        }

        return count;
    }

    /**
     * @see com.invariantproperties.sandbox.student.business.CourseFinderService#
     *      findAllCourses()
     */
    @Transactional(readOnly = true)
    @Override
    public List<Course> findAllCourses() {
        return findCoursesByTestRun(null);
    }

    /**
     * @see com.invariantproperties.sandbox.student.business.CourseFinderService#
     *      findCoursesByTestRun(java.lang.String)
     */
    @Transactional(readOnly = true)
    @Override
    public List<Course> findCoursesByTestRun(TestRun testRun) {
        List<Course> courses = null;

        try {
            courses = courseRepository.findAll(testRunIs(testRun));
        } catch (DataAccessException e) {
            if (!(e instanceof UnitTestException)) {
                log.info("error loading list of courses: " + e.getMessage(), e);
            }
            throw new PersistenceException("unable to get list of courses.", e);
        }

        return courses;
    }

    ....
}

Unit Testing

Our unit tests require a small change to use a Specification.

public class CourseFinderServiceImplTest {
private final Class<Specification<Course>> sClass = null;
@Test
public void testCount() {
final long expected = 3;
final CourseRepository repository = Mockito.mock(CourseRepository.class);
when(repository.count(any(sClass))).thenReturn(expected);
final CourseFinderService service = new CourseFinderServiceImpl(repository);
final long actual = service.count();
assertEquals(expected, actual);
}
@Test
public void testCountByTestRun() {
final long expected = 3;
final TestRun testRun = new TestRun();
final CourseRepository repository = Mockito.mock(CourseRepository.class);
when(repository.count(any(sClass))).thenReturn(expected);
final CourseFinderService service = new CourseFinderServiceImpl(repository);
final long actual = service.countByTestRun(testRun);
assertEquals(expected, actual);
}
@Test(expected = PersistenceException.class)
public void testCountError() {
final CourseRepository repository = Mockito.mock(CourseRepository.class);
when(repository.count(any(sClass))).thenThrow(new UnitTestException());
final CourseFinderService service = new CourseFinderServiceImpl(repository);
service.count();
}
@Test
public void testFindAllCourses() {
final List<Course> expected = Collections.emptyList();
final CourseRepository repository = Mockito.mock(CourseRepository.class);
when(repository.findAll(any(sClass))).thenReturn(expected);
final CourseFinderService service = new CourseFinderServiceImpl(repository);
final List<Course> actual = service.findAllCourses();
assertEquals(expected, actual);
}
@Test(expected = PersistenceException.class)
public void testFindAllCoursesError() {
final CourseRepository repository = Mockito.mock(CourseRepository.class);
final Class<Specification<Course>> sClass = null;
when(repository.findAll(any(sClass))).thenThrow(new UnitTestException());
final CourseFinderService service = new CourseFinderServiceImpl(repository);
service.findAllCourses();
}
@Test
public void testFindCourseByTestUuid() {
final TestRun testRun = new TestRun();
final Course course = new Course();
final List<Course> expected = Collections.singletonList(course);
final CourseRepository repository = Mockito.mock(CourseRepository.class);
when(repository.findAll(any(sClass))).thenReturn(expected);
final CourseFinderService service = new CourseFinderServiceImpl(repository);
final List actual = service.findCoursesByTestRun(testRun);
assertEquals(expected, actual);
}
@Test(expected = PersistenceException.class)
public void testFindCourseByTestUuidError() {
final TestRun testRun = new TestRun();
final CourseRepository repository = Mockito.mock(CourseRepository.class);
when(repository.findAll(any(sClass))).thenThrow(new UnitTestException());
final CourseFinderService service = new CourseFinderServiceImpl(repository);
service.findCoursesByTestRun(testRun);
}
@Test
public void testFindCoursesByTestUuid() {
final TestRun testRun = new TestRun();
final Course course = new Course();
final List<Course> expected = Collections.singletonList(course);
final CourseRepository repository = Mockito.mock(CourseRepository.class);
when(repository.findAll(any(sClass))).thenReturn(expected);
final CourseFinderService service = new CourseFinderServiceImpl(repository);
final List<Course> actual = service.findCoursesByTestRun(testRun);
assertEquals(expected, actual);
}
@Test(expected = PersistenceException.class)
public void testFindCoursesByTestUuidError() {
final TestRun testRun = new TestRun();
final CourseRepository repository = Mockito.mock(CourseRepository.class);
when(repository.findAll(any(sClass))).thenThrow(new UnitTestException());
final CourseFinderService service = new CourseFinderServiceImpl(repository);
service.findCoursesByTestRun(testRun);
}
....
}

public class CourseFinderServiceImplTest {
    private final Class<Specification<Course>> sClass = null;

    @Test
    public void testCount() {
        final long expected = 3;

        final CourseRepository repository = Mockito.mock(CourseRepository.class);
        when(repository.count(any(sClass))).thenReturn(expected);

        final CourseFinderService service = new CourseFinderServiceImpl(repository);
        final long actual = service.count();

        assertEquals(expected, actual);
    }

    @Test
    public void testCountByTestRun() {
        final long expected = 3;
        final TestRun testRun = new TestRun();

        final CourseRepository repository = Mockito.mock(CourseRepository.class);
        when(repository.count(any(sClass))).thenReturn(expected);

        final CourseFinderService service = new CourseFinderServiceImpl(repository);
        final long actual = service.countByTestRun(testRun);

        assertEquals(expected, actual);
    }

    @Test(expected = PersistenceException.class)
    public void testCountError() {
        final CourseRepository repository = Mockito.mock(CourseRepository.class);
        when(repository.count(any(sClass))).thenThrow(new UnitTestException());

        final CourseFinderService service = new CourseFinderServiceImpl(repository);
        service.count();
    }

    @Test
    public void testFindAllCourses() {
        final List<Course> expected = Collections.emptyList();

        final CourseRepository repository = Mockito.mock(CourseRepository.class);
        when(repository.findAll(any(sClass))).thenReturn(expected);

        final CourseFinderService service = new CourseFinderServiceImpl(repository);
        final List<Course> actual = service.findAllCourses();

        assertEquals(expected, actual);
    }

    @Test(expected = PersistenceException.class)
    public void testFindAllCoursesError() {
        final CourseRepository repository = Mockito.mock(CourseRepository.class);
        final Class<Specification<Course>> sClass = null;
        when(repository.findAll(any(sClass))).thenThrow(new UnitTestException());

        final CourseFinderService service = new CourseFinderServiceImpl(repository);
        service.findAllCourses();
    }
 
    @Test
    public void testFindCourseByTestUuid() {
        final TestRun testRun = new TestRun();
        final Course course = new Course();
        final List<Course> expected = Collections.singletonList(course);

        final CourseRepository repository = Mockito.mock(CourseRepository.class);
        when(repository.findAll(any(sClass))).thenReturn(expected);

        final CourseFinderService service = new CourseFinderServiceImpl(repository);
        final List actual = service.findCoursesByTestRun(testRun);

        assertEquals(expected, actual);
    }

    @Test(expected = PersistenceException.class)
    public void testFindCourseByTestUuidError() {
        final TestRun testRun = new TestRun();

        final CourseRepository repository = Mockito.mock(CourseRepository.class);
        when(repository.findAll(any(sClass))).thenThrow(new UnitTestException());

        final CourseFinderService service = new CourseFinderServiceImpl(repository);
        service.findCoursesByTestRun(testRun);
    }

    @Test
    public void testFindCoursesByTestUuid() {
        final TestRun testRun = new TestRun();
        final Course course = new Course();
        final List<Course> expected = Collections.singletonList(course);

        final CourseRepository repository = Mockito.mock(CourseRepository.class);
        when(repository.findAll(any(sClass))).thenReturn(expected);

        final CourseFinderService service = new CourseFinderServiceImpl(repository);
        final List<Course> actual = service.findCoursesByTestRun(testRun);

        assertEquals(expected, actual);
    }

    @Test(expected = PersistenceException.class)
    public void testFindCoursesByTestUuidError() {
        final TestRun testRun = new TestRun();

        final CourseRepository repository = Mockito.mock(CourseRepository.class);
        when(repository.findAll(any(sClass))).thenThrow(new UnitTestException());

        final CourseFinderService service = new CourseFinderServiceImpl(repository);
        service.findCoursesByTestRun(testRun);
    }

    ....
}

I could eliminate a lot of duplicate code by using a @Begin method but decided against it to support parallel testing.

Integration Testing

We finally come to our integration tests. We know we did something right because the only is one line to test additional functionality – counting the number of courses in the database.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { BusinessApplicationContext.class, TestBusinessApplicationContext.class,
TestPersistenceJpaConfig.class })
@Transactional
@TransactionConfiguration(defaultRollback = true)
public class CourseServiceIntegrationTest {
@Resource
private CourseFinderService fdao;
@Resource
private CourseManagerService mdao;
@Resource
private TestRunService testService;
@Test
public void testCourseLifecycle() throws Exception {
final TestRun testRun = testService.createTestRun();
final String name = "Calculus 101 : " + testRun.getUuid();
final Course expected = new Course();
expected.setName(name);
assertNull(expected.getId());
// create course
Course actual = mdao.createCourseForTesting(name, testRun);
expected.setId(actual.getId());
expected.setUuid(actual.getUuid());
expected.setCreationDate(actual.getCreationDate());
assertThat(expected, equalTo(actual));
assertNotNull(actual.getUuid());
assertNotNull(actual.getCreationDate());
// get course by id
actual = fdao.findCourseById(expected.getId());
assertThat(expected, equalTo(actual));
// get course by uuid
actual = fdao.findCourseByUuid(expected.getUuid());
assertThat(expected, equalTo(actual));
// get all courses
final List<Course> courses = fdao.findCoursesByTestRun(testRun);
assertTrue(courses.contains(actual));
// count courses
final long count = fdao.countByTestRun(testRun);
assertTrue(count > 0);
// update course
expected.setName("Calculus 102 : " + testRun.getUuid());
actual = mdao.updateCourse(actual, expected.getName());
assertThat(expected, equalTo(actual));
// delete Course
mdao.deleteCourse(expected.getUuid(), 0);
try {
fdao.findCourseByUuid(expected.getUuid());
fail("exception expected");
} catch (ObjectNotFoundException e) {
// expected
}
testService.deleteTestRun(testRun.getUuid());
}
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { BusinessApplicationContext.class, TestBusinessApplicationContext.class,
        TestPersistenceJpaConfig.class })
@Transactional
@TransactionConfiguration(defaultRollback = true)
public class CourseServiceIntegrationTest {

    @Resource
    private CourseFinderService fdao;

    @Resource
    private CourseManagerService mdao;

    @Resource
    private TestRunService testService;

    @Test
    public void testCourseLifecycle() throws Exception {
        final TestRun testRun = testService.createTestRun();

        final String name = "Calculus 101 : " + testRun.getUuid();

        final Course expected = new Course();
        expected.setName(name);

        assertNull(expected.getId());

        // create course
        Course actual = mdao.createCourseForTesting(name, testRun);
        expected.setId(actual.getId());
        expected.setUuid(actual.getUuid());
        expected.setCreationDate(actual.getCreationDate());

        assertThat(expected, equalTo(actual));
        assertNotNull(actual.getUuid());
        assertNotNull(actual.getCreationDate());

        // get course by id
        actual = fdao.findCourseById(expected.getId());
        assertThat(expected, equalTo(actual));

        // get course by uuid
        actual = fdao.findCourseByUuid(expected.getUuid());
        assertThat(expected, equalTo(actual));

        // get all courses
        final List<Course> courses = fdao.findCoursesByTestRun(testRun);
        assertTrue(courses.contains(actual));

        // count courses
        final long count = fdao.countByTestRun(testRun);
        assertTrue(count > 0);

        // update course
        expected.setName("Calculus 102 : " + testRun.getUuid());
        actual = mdao.updateCourse(actual, expected.getName());
        assertThat(expected, equalTo(actual));

        // delete Course
        mdao.deleteCourse(expected.getUuid(), 0);
        try {
            fdao.findCourseByUuid(expected.getUuid());
            fail("exception expected");
        } catch (ObjectNotFoundException e) {
            // expected
        }

        testService.deleteTestRun(testRun.getUuid());
    }
}

Source Code

The source code is at https://github.com/beargiles/project-student [github] and http://beargiles.github.io/project-student/ [github pages].

Comments: No Comments »
Categories: java
Comments rss
Trackback

How Many Lines Of Code Do You Write Every Day?

Bear Giles | December 27, 2013

I was recently asked a bizarre question in an interview – “how many lines of code do you write every day?”

I’ve been thinking about that question for a week and realized that it makes sense since she was a C person before migrating to other work a few years ago, not a contemporary java person.

To explain, I can fold my career into three major stages.

Ancient – computers were resource-limited (memory < 1 MB) and no third-party libraries to speak of. Our "internet" was journals (esp. "Programming Pearls"), magazines (e.g., "Dr. Dobbs") and books. You wrote everything you used and you needed to use efficient algorithms and data structures if you didn’t want it to crawl. SLOC could be considered a fair measure of productivity, subject to various well-known limitations. (E.g., you needed to be comparing comparable work using the same definition of SLOC, etc.)

(Sidenote: on several occasions I improved performance of existing code by several orders of magnitude – literally hours to minutes or minutes to seconds – by simply recognizing that the code was now running on computers with more memory and I could cache values instead of constantly rereading files or the database, recomputing values, etc.)

Mature C – computers had decent resources (memory < 100 MB) and a wide variety of quality third-party libraries. We could get those libraries via the internet but it was years before Google or blogs and we still depended on journals, magazines and books. SLOC was starting to lose its value since you could have one person who still wrote everything himself (including bugs) and another person who took less time and wrote fewer SLOC but had better results since he used a third-party library. Knowing good third-party libraries was important but not critical and you still spent most of your time writing code (excluding meetings, etc.).

Mature Java – computers have ample resources (memory > 4 GB, multicore processors) and a number of quality deep libraries. The standard API, Apache, Spring Framework, etc. We can get libraries by adding a few lines of text to a configuration file and we can learn about them by reading blogs and Google searches. We’re often more productive with a day of research than a week of coding.

There is no “right answer” here since it depends on the ecosystem. Some languages have deeper third-party libraries than others. Some shops require highly specialized needs that they must write themselves. But it really struck me just how different my world has become over the last few years when she asked that question and my first thought was how much time I spent in research vs. coding and how that affects the raw SLOC numbers.

Comments: No Comments »
Categories: java
Comments rss
Trackback

Project Student: Webservice Integration

Bear Giles | December 25, 2013

This is part of Project Student. Other posts are Webservice Client With Jersey, Webservice Server with Jersey, Business Layer, Persistence with Spring Data and Sharding Integration Test Data.

Earlier we successfully ran integration tests for both the persistence/business layer (using an embedded H2 database) and the REST server/client layers (using a Jetty server). It’s time to knit everything together.

Fortunately we already have all of our code in place and tested. All we need to do now is create some configuration file magic.

Limitations

User authentication – no effort has been made to authenticate users.

Encryption – no effort has been made to encrypt communications.

Container-Managed Datasource and JNDI

Container-managed datasources have a bad reputation for many developers and I’m not sure why. Confusion with Container-Managed Persistence (CMP), perhaps?

In any case the idea behind a container-managed datasource is simple. You don’t need to figure out how to maintain database connection parameters in a deployed system – no need to modify a deployed webapp (which is insecure) or read a file from the filesystem (which you may not be able to access), etc. You just hand the problem to the person maintaining the webserver/appserver and retrieve the value via JNDI.

Tomcat and Jetty require manual configuration in an XML file. More advanced appservers like JBoss and GlassFish allow you to configure datasources via a nice GUI. It doesn’t really matter since you only have to do it once. Instructions for Tomcat 7 and Jetty.

The key points for Tomcat are that the server library is under $CATALINA_HOME/lib and that might not be where you expect. E.g., in Ubuntu it’s /usr/share/tomcat7/lib, not /var/lib/tomcat7/lib. Second, if the META-INF/context.xml file isn’t picked up from the .war file you must place it under conf/Catalina/localhost/student-ws-webapp.xml (or whatever you have named your .war file). The latter overrides the former so it’s common to set up the .war file to run in the development environment and then override the configuration in the test and production environments.

META-INF/context.xml (Tomcat)

<?xml version="1.0" encoding="UTF-8"?>
<Context>
<Resource name="jdbc/studentDS"
auth="Container"
type="javax.sql.DataSource"
driverClassName="org.postgresql.Driver"
url="jdbc:postgresql:student"
username="student"
password="student"
maxActive="20"
maxIdle="10"
maxWait="-1"
factory="org.apache.commons.dbcp.BasicDataSourceFactory" />
</Context>

<?xml version="1.0" encoding="UTF-8"?>
<Context>

    <Resource name="jdbc/studentDS"
        auth="Container"
        type="javax.sql.DataSource"
        driverClassName="org.postgresql.Driver"
        url="jdbc:postgresql:student"
        username="student"
        password="student"
        maxActive="20"
        maxIdle="10"
        maxWait="-1"
        factory="org.apache.commons.dbcp.BasicDataSourceFactory" />
        
</Context>

It’s worth noting that it’s trivial to pass an encryption key via JNDI (as a java.lang.String). This has the same benefits as discussed earlier with regards to the need to modify a deployed webapp or access the server’s filesystem.

(The implementation is a little more complex since you want your actual encryption key to require both the JNDI key AND a filesystem-based salt but this is easy to handle during initial deployment of the webapp.)

JPA Configuration

Our persistence.xml file is extremely minimal. We’ll typically want two persistence units, one for JTA transactions (production) and one for non-JTA transactions (development and testing).

META-INF/persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
version="1.0">
<persistence-unit name="studentPU-local"
transaction-type="RESOURCE_LOCAL">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<non-jta-data-source>jdbc/studentDS</non-jta-data-source>
</persistence-unit>
</persistence>

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
   http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
	version="1.0">

	<persistence-unit name="studentPU-local"
		transaction-type="RESOURCE_LOCAL">
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
		<non-jta-data-source>jdbc/studentDS</non-jta-data-source>
	</persistence-unit>
</persistence>

Web Configuration

The web.xml file is nearly identical to the one used in integration testing. The key difference is that it pulls in a resource reference for the container-provided datasource.

WEB-INF/web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name>Project Student Webservice</display-name>
<context-param>
<param-name>contextClass</param-name>
<param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
</context-param>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
com.invariantproperties.sandbox.student.config.PersistenceJpaConfig
com.invariantproperties.sandbox.student.config.BusinessApplicationContext
com.invariantproperties.sandbox.student.webservice.config.RestApplicationContext
</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>REST dispatcher</servlet-name>
<servlet-class>com.sun.jersey.spi.spring.container.servlet.SpringServlet</servlet-class>
<init-param>
<param-name>spring.profiles.active</param-name>
<param-value>test</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>REST dispatcher</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>
<resource-ref>
<description>Student Datasource</description>
<res-ref-name>jdbc/studentDS</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
</web-app>

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    <display-name>Project Student Webservice</display-name>
    
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
    </context-param>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            com.invariantproperties.sandbox.student.config.PersistenceJpaConfig
            com.invariantproperties.sandbox.student.config.BusinessApplicationContext
            com.invariantproperties.sandbox.student.webservice.config.RestApplicationContext
        </param-value>
    </context-param>

    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>

    <servlet>
        <servlet-name>REST dispatcher</servlet-name>
        <servlet-class>com.sun.jersey.spi.spring.container.servlet.SpringServlet</servlet-class>
        <init-param>
            <param-name>spring.profiles.active</param-name>
            <param-value>test</param-value>
        </init-param>
    </servlet>

    <servlet-mapping>
        <servlet-name>REST dispatcher</servlet-name>
        <url-pattern>/rest/*</url-pattern>
    </servlet-mapping>
    
    <resource-ref>
        <description>Student Datasource</description>
        <res-ref-name>jdbc/studentDS</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
    </resource-ref>
</web-app>

Spring Configuration

The Spring configuration for the persistence layer is dramatically different from before because of two changes. Stylistically, we can use a standard configuration file instead of a configuration class since we no longer have to deal with an embedded database.

The more important change is that we’ve moved all of the datasource configuration to the container and we can eliminate it from our spring configuration. We need to point to the right datasource and persistence unit and that’s about it!

applicationContext-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
http://www.springframework.org/schema/jee
http://www.springframework.org/schema/jee/spring-jee-3.0.xsd">
<context:property-placeholder location="WEB-INF/database.properties" />
<context:annotation-config />
<jee:jndi-lookup id="dataSource" jndi-name="${persistence.unit.dataSource}"
expected-type="javax.sql.DataSource" />
<bean name="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="persistenceUnitName" value="${persistence.unit.name}" />
<property name="packagesToScan" value="${entitymanager.packages.to.scan}" />
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
</property>
</bean>
<bean name="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager" />
<bean name="exceptionTranslation"
class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />
<tx:annotation-driven transaction-manager="transactionManager"
proxy-target-class="false" />
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-3.2.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
       http://www.springframework.org/schema/data/jpa
       http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
       http://www.springframework.org/schema/jee
       http://www.springframework.org/schema/jee/spring-jee-3.0.xsd">

    <context:property-placeholder location="WEB-INF/database.properties" />

    <context:annotation-config />

    <!-- we use container-based datasource -->
    <jee:jndi-lookup id="dataSource" jndi-name="${persistence.unit.dataSource}"
        expected-type="javax.sql.DataSource" />

    <bean name="entityManagerFactory"
        class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="persistenceUnitName" value="${persistence.unit.name}" />
        <property name="packagesToScan" value="${entitymanager.packages.to.scan}" />
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
        </property>
    </bean>

    <bean name="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager" />

    <bean name="exceptionTranslation"
        class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />

    <tx:annotation-driven transaction-manager="transactionManager"
        proxy-target-class="false" />

</beans>

Our properties file just contains the name of the datasource, the persistence unit name, and the list of packages to scan that contain JPA annotations.

WEB-INF/database.properties

# jpa configuration
entitymanager.packages.to.scan=com.invariantproperties.sandbox.student.domain
persistence.unit.dataSource=java:comp/env/jdbc/studentDS
persistence.unit.name=studentPU-local

# jpa configuration
entitymanager.packages.to.scan=com.invariantproperties.sandbox.student.domain
persistence.unit.dataSource=java:comp/env/jdbc/studentDS
persistence.unit.name=studentPU-local

Database Schema and Security

Finally the integration tests can use Hibernate auto-creation but we should always explicitly maintain our schemas in a development and production environment. This allows us to maintain infrastructure values in addition to avoiding potential problems from automated tools acting in an unexpected manner.

It’s important to write and test both upgrade and downgrade scripts before going into production. We always need a way to recover gracefully if there’s a problem.

More importantly our database schema should always be owned by a different user than the webapp. E.g., the webapp may use ‘student-user’ for the tables created by ‘student-owner’. This will prevent an attacker using SQL injection from deleting or modifying tables.

--
-- for security this must run as student-owner, not student-user!
--
--
-- create an idempotent stored procedure that creates the initial database schema.
--
create or replace function create_schema_0_0_2() returns void as $$
declare
schema_version_rec record;
schema_count int;
begin
create table if not exists schema_version (
schema_version varchar(20) not null
);
select count(*) into schema_count from schema_version;
case schema_count
when 0 then
-- we just created table
insert into schema_version(schema_version) values('0.0.2');
when 1 then
-- this is 'create' so we only need to make sure it's current version
-- normally we accept either current version or immediately prior version.
select * into strict schema_version_rec from schema_version;
if schema_version_rec.schema_version '0.0.2' then
raise notice 'Unwilling to run updates - check prior version';
exit;
end if;
else
raise notice 'Bad database - more than one schema versions defined!';
exit;
end case;
-- create tables!
create table if not exists test_run (
test_run_pkey int primary key,
uuid varchar(40) unique not null,
creation_date timestamp not null,
name varchar(80) not null,
test_date timestamp not null,
username varchar(40) not null
);
create table if not exists classroom (
classroom_pkey int primary key,
uuid varchar(40) unique not null,
creation_date timestamp not null,
test_run_pkey int references test_run(test_run_pkey),
name varchar(80) not null
);
create table if not exists course (
course_pkey int primary key,
uuid varchar(40) unique not null,
creation_date timestamp not null,
test_run_pkey int references test_run(test_run_pkey),
name varchar(80) not null
);
create table if not exists instructor (
instructor_pkey int primary key,
uuid varchar(40) unique not null,
creation_date timestamp not null,
test_run_pkey int references test_run(test_run_pkey),
name varchar(80) not null,
email varchar(200) unique not null
);
create table if not exists section (
section_pkey int primary key,
uuid varchar(40) unique not null,
creation_date timestamp not null,
test_run_pkey int references test_run(test_run_pkey),
name varchar(80) not null
);
create table if not exists student (
student_pkey int primary key,
uuid varchar(40) unique not null,
creation_date timestamp not null,
test_run_pkey int references test_run(test_run_pkey),
name varchar(80) not null,
email varchar(200) unique not null
);
create table if not exists term (
term_pkey int primary key,
uuid varchar(40) unique not null,
creation_date timestamp not null,
test_run_pkey int references test_run(test_run_pkey),
name varchar(80) not null
);
-- correction: need to define this!
create sequence hibernate_sequence;
-- make sure nobody can truncate our tables
revoke truncate on classroom, course, instructor, section, student, term, test_run from public;
-- grant CRUD privileges to student-user.
grant select, insert, update, delete on classroom, course, instructor, section, student, term, test_run to student;
grant usage on hibernate_sequence to student;
return;
end;
$$ language plpgsql;
-- create database schema
select create_schema_0_0_2() is null;
-- clean up
drop function create_schema_0_0_2();

--
-- for security this must run as student-owner, not student-user!
--

--
-- create an idempotent stored procedure that creates the initial database schema.
--
create or replace function create_schema_0_0_2() returns void as $$
declare
    schema_version_rec record;
    schema_count int;
begin
    create table if not exists schema_version (
        schema_version varchar(20) not null
    );

    select count(*) into schema_count from schema_version;

    case schema_count
        when 0 then
            -- we just created table
            insert into schema_version(schema_version) values('0.0.2');
        when 1 then
            -- this is 'create' so we only need to make sure it's current version
            -- normally we accept either current version or immediately prior version.
            select * into strict schema_version_rec from schema_version;
            if schema_version_rec.schema_version  '0.0.2' then
                raise notice 'Unwilling to run updates - check prior version';
                exit;
            end if;      
        else
            raise notice 'Bad database - more than one schema versions defined!';
            exit;
    end case;

    -- create tables!

    create table if not exists test_run (
        test_run_pkey int primary key,
        uuid varchar(40) unique not null,
        creation_date timestamp not null,
        name varchar(80) not null,
        test_date timestamp not null,
        username varchar(40) not null
    );

    create table if not exists classroom (
        classroom_pkey int primary key,
        uuid varchar(40) unique not null,
        creation_date timestamp not null,
        test_run_pkey int references test_run(test_run_pkey),
        name varchar(80) not null
    );

    create table if not exists course (
        course_pkey int primary key,
        uuid varchar(40) unique not null,
        creation_date timestamp not null,
        test_run_pkey int references test_run(test_run_pkey),
        name varchar(80) not null
    );

    create table if not exists instructor (
        instructor_pkey int primary key,
        uuid varchar(40) unique not null,
        creation_date timestamp not null,
        test_run_pkey int references test_run(test_run_pkey),
        name varchar(80) not null,
        email varchar(200) unique not null
    );

    create table if not exists section (
        section_pkey int primary key,
        uuid varchar(40) unique not null,
        creation_date timestamp not null,
        test_run_pkey int references test_run(test_run_pkey),
        name varchar(80) not null
    );

    create table if not exists student (
        student_pkey int primary key,
        uuid varchar(40) unique not null,
        creation_date timestamp not null,
        test_run_pkey int references test_run(test_run_pkey),
        name varchar(80) not null,
        email varchar(200) unique not null
    );

    create table if not exists term (
        term_pkey int primary key,
        uuid varchar(40) unique not null,
        creation_date timestamp not null,
        test_run_pkey int references test_run(test_run_pkey),
        name varchar(80) not null
    );

    -- correction: need to define this!
    create sequence hibernate_sequence;

    -- make sure nobody can truncate our tables
    revoke truncate on classroom, course, instructor, section, student, term, test_run from public;

    -- grant CRUD privileges to student-user.
    grant select, insert, update, delete on classroom, course, instructor, section, student, term, test_run to student;

    grant usage on hibernate_sequence to student;

    return;
end;
$$ language plpgsql;

-- create database schema
select create_schema_0_0_2() is null;

-- clean up
drop function create_schema_0_0_2();

Integration Testing

We can reuse the integration tests from the webservice service but I haven’t copied them to this project since 1) I hate duplicating code and it would be better to pull the integration tests into a separate project used by both server and webapp and 2) it’s easy to configure Jetty to supply JNDI values but for some reason the documented class is throwing an exception and it’s not important enough (at this time) to spend more than a few hours researching.

Source Code

The source code is at https://github.com/beargiles/project-student [github] and http://beargiles.github.io/project-student/ [github pages].

Correction

The schema provided overlooked the ‘hibernate_sequence’ required to create new objects. It must be defined and readable by the ‘student’ user.

Comments: No Comments »
Categories: java, linux
Comments rss
Trackback

Project Student: Sharding Integration Test Data

Bear Giles | December 23, 2013

This is part of Project Student. Other posts are Webservice Client With Jersey, Webservice Server with Jersey, Business Layer and Persistence with Spring Data.

All of the integration tests until now have used an in-memory embedded database that did not retain information from run to run. This changes when we fully integrate the REST server with a “real” database server – leftover test data will pollute our development or test database. This can be a real headache once we have continuous integration that runs integration tests code is checked in.

One solution is to ‘shard’ our integration test data in a way that allows our tests to use the shared development database without polluting it or other tests. The easiest approach is to add a TestRun field to all of our objects. “Test” data will have a value that indicates the specific test run, “live” data will have a null value.

The exact timeline is

create and persist a TestRun object
create test objects with appropriate TestRun value
perform the integration tests
delete the test objects
delete the TestRun object

Any entry in the TestRun table will either be 1) active integration tests or 2) failed integration tests that threw an unhandled exception (depending upon the transaction manager, of course). It’s important to note that we can also capture the database state after an unexpected exception is thrown even if the transaction manager performs a rollback – it’s a simple extension to the junit test runner.

Timestamp and user fields make it easy to delete stale test data according to its age (e.g., any test more than 7 days old) or the person who ran the test.

TestablePersistentObject abstract base class

This change starts at the persistence level so we should start there and work our way outwards.

We first extend our PersistentObject abstract base class with a test run value.

@MappedSuperclass
public abstract class TestablePersistentObject extends PersistentObject {
private static final long serialVersionUID = 1L;
private TestRun testRun;
/**
* Fetch testRun object. We use lazy fetching since we rarely care about the
* contents of this object - we just want to ensure referential integrity to
* an existing testRun object when persisting a TPO.
*
* @return
*/
@ManyToOne(fetch = FetchType.LAZY, optional = true)
public TestRun getTestRun() {
return testRun;
}
public void setTestRun(TestRun testRun) {
this.testRun = testRun;
}
@Transient
public boolean isTestData() {
return testRun != null;
}
}

@MappedSuperclass
public abstract class TestablePersistentObject extends PersistentObject {
    private static final long serialVersionUID = 1L;
    private TestRun testRun;

    /**
     * Fetch testRun object. We use lazy fetching since we rarely care about the
     * contents of this object - we just want to ensure referential integrity to
     * an existing testRun object when persisting a TPO.
     * 
     * @return
     */
    @ManyToOne(fetch = FetchType.LAZY, optional = true)
    public TestRun getTestRun() {
        return testRun;
    }

    public void setTestRun(TestRun testRun) {
        this.testRun = testRun;
    }

    @Transient
    public boolean isTestData() {
        return testRun != null;
    }
}

TestRun class

The TestRun class contains identifying information about a single integration test run. It contains a name (by default the classname#methodname() of the surrounding integration test), the date and time of the test, and the name of the user running the test. It would be easy to capture additional information.

The list of test objects gives us two big wins. First, it makes it easy to capture the state of the database if needed (e.g., after an unexpected exception). Second, cascading deletions makes it easy to delete all test objects.

@XmlRootElement
@Entity
@Table(name = "test_run")
@AttributeOverride(name = "id", column = @Column(name = "test_run_pkey"))
public class TestRun extends PersistentObject {
private static final long serialVersionUID = 1L;
private String name;
private Date testDate;
private String user;
private List<TestablePersistentObject> objects = Collections.emptyList();
@Column(length = 80, unique = false, updatable = true)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(name = "test_date", nullable = false, updatable = false)
@Temporal(TemporalType.TIMESTAMP)
public Date getTestDate() {
return testDate;
}
public void setTestDate(Date testDate) {
this.testDate = testDate;
}
@Column(length = 40, unique = false, updatable = false)
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
@OneToMany(cascade = CascadeType.ALL)
public List<TestablePersistentObject> getObjects() {
return objects;
}
public void setObjects(List<TestablePersistentObject> objects) {
this.objects = objects;
}
/**
* This is similar to standard prepersist method but we also set default
* values for everything else.
*/
@PrePersist
public void prepersist() {
if (getCreationDate() == null) {
setCreationDate(new Date());
}
if (getTestDate() == null) {
setTestDate(new Date());
}
if (getUuid() == null) {
setUuid(UUID.randomUUID().toString());
}
if (getUser() == null) {
setUser(System.getProperty("user.name"));
}
if (name == null) {
setName("test run " + getUuid());
}
}
}

@XmlRootElement
@Entity
@Table(name = "test_run")
@AttributeOverride(name = "id", column = @Column(name = "test_run_pkey"))
public class TestRun extends PersistentObject {
    private static final long serialVersionUID = 1L;

    private String name;
    private Date testDate;
    private String user;
    private List<TestablePersistentObject> objects = Collections.emptyList();

    @Column(length = 80, unique = false, updatable = true)
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Column(name = "test_date", nullable = false, updatable = false)
    @Temporal(TemporalType.TIMESTAMP)
    public Date getTestDate() {
        return testDate;
    }

    public void setTestDate(Date testDate) {
        this.testDate = testDate;
    }

    @Column(length = 40, unique = false, updatable = false)
    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    @OneToMany(cascade = CascadeType.ALL)
    public List<TestablePersistentObject> getObjects() {
        return objects;
    }

    public void setObjects(List<TestablePersistentObject> objects) {
        this.objects = objects;
    }

    /**
     * This is similar to standard prepersist method but we also set default
     * values for everything else.
     */
    @PrePersist
    public void prepersist() {
        if (getCreationDate() == null) {
            setCreationDate(new Date());
        }

        if (getTestDate() == null) {
            setTestDate(new Date());
        }

        if (getUuid() == null) {
            setUuid(UUID.randomUUID().toString());
        }

        if (getUser() == null) {
            setUser(System.getProperty("user.name"));
        }

        if (name == null) {
            setName("test run " + getUuid());
        }
    }
}

The TestRun class extends PersistentObject, not TestablePersistentObject, since our other integration tests will sufficiently exercise it.

Spring Data Repository

We must add one additional method to every Repository.

@Repository
public interface CourseRepository extends JpaRepository {
List<Course> findCoursesByTestRun(TestRun testRun);
....
}

@Repository
public interface CourseRepository extends JpaRepository {
    List<Course> findCoursesByTestRun(TestRun testRun);

    ....
}

Service Interface

Likewise we must add two additional methods to every service.

public interface CourseService {
List<Course> findAllCourses();
Course findCourseById(Integer id);
Course findCourseByUuid(String uuid);
Course createCourse(String name);
Course updateCourse(Course course, String name);
void deleteCourse(String uuid);
// new method for testing
Course createCourseForTesting(String name, TestRun testRun);
// new method for testing
List<Course> findAllCoursesForTestRun(TestRun testRun);
}

public interface CourseService {
    List<Course> findAllCourses();

    Course findCourseById(Integer id);

    Course findCourseByUuid(String uuid);

    Course createCourse(String name);

    Course updateCourse(Course course, String name);

    void deleteCourse(String uuid);

    // new method for testing
    Course createCourseForTesting(String name, TestRun testRun);

    // new method for testing
    List<Course> findAllCoursesForTestRun(TestRun testRun);
}

I won’t show the TestRunRepository, the TestRunService interface, or the TestRunService implementation since they’re identical to what I’ve described in the last few blog entries.

Service Implementation

We have to make one small change to an existing Service implementation, plus add two new methods.

@Service
public class CourseServiceImpl implements CourseService {
@Resource
private TestRunService testRunService;
/**
* @see com.invariantproperties.sandbox.student.business.CourseService#
* findAllCourses()
*/
@Transactional(readOnly = true)
@Override
public List<Course> findAllCourses() {
List<Course> courses = null;
try {
courses = courseRepository.findCoursesByTestRun(null);
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("error loading list of courses: " + e.getMessage(), e);
}
throw new PersistenceException("unable to get list of courses.", e);
}
return courses;
}
/**
* @see com.invariantproperties.sandbox.student.business.CourseService#
* findAllCoursesForTestRun(com.invariantproperties.sandbox.student.common.TestRun)
*/
@Transactional(readOnly = true)
@Override
public List<Course> findAllCoursesForTestRun(TestRun testRun) {
List<Course> courses = null;
try {
courses = courseRepository.findCoursesByTestRun(testRun);
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("error loading list of courses: " + e.getMessage(), e);
}
throw new PersistenceException("unable to get list of courses.", e);
}
return courses;
}
/**
* @see com.invariantproperties.sandbox.student.business.CourseService#
* createCourseForTesting(java.lang.String,
* com.invariantproperties.sandbox.student.common.TestRun)
*/
@Transactional
@Override
public Course createCourseForTesting(String name, TestRun testRun) {
final Course course = new Course();
course.setName(name);
course.setTestUuid(testRun.getTestUuid());
Course actual = null;
try {
actual = courseRepository.saveAndFlush(course);
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("internal error retrieving course: " + name, e);
}
throw new PersistenceException("unable to create course", e);
}
return actual;
}
}

@Service
public class CourseServiceImpl implements CourseService {
    @Resource
    private TestRunService testRunService;

    /**
     * @see com.invariantproperties.sandbox.student.business.CourseService#
     *      findAllCourses()
     */
    @Transactional(readOnly = true)
    @Override
    public List<Course> findAllCourses() {
        List<Course> courses = null;

        try {
            courses = courseRepository.findCoursesByTestRun(null);
        } catch (DataAccessException e) {
            if (!(e instanceof UnitTestException)) {
                log.info("error loading list of courses: " + e.getMessage(), e);
            }
            throw new PersistenceException("unable to get list of courses.", e);
        }

        return courses;
    }

    /**
     * @see com.invariantproperties.sandbox.student.business.CourseService#
     *      findAllCoursesForTestRun(com.invariantproperties.sandbox.student.common.TestRun)
     */
    @Transactional(readOnly = true)
    @Override
    public List<Course> findAllCoursesForTestRun(TestRun testRun) {
        List<Course> courses = null;

        try {
            courses = courseRepository.findCoursesByTestRun(testRun);
        } catch (DataAccessException e) {
            if (!(e instanceof UnitTestException)) {
                log.info("error loading list of courses: " + e.getMessage(), e);
            }
            throw new PersistenceException("unable to get list of courses.", e);
        }

        return courses;
    }

    /**
     * @see com.invariantproperties.sandbox.student.business.CourseService#
     *      createCourseForTesting(java.lang.String,
     *      com.invariantproperties.sandbox.student.common.TestRun)
     */
    @Transactional
    @Override
    public Course createCourseForTesting(String name, TestRun testRun) {
        final Course course = new Course();
        course.setName(name);
        course.setTestUuid(testRun.getTestUuid());

        Course actual = null;
        try {
            actual = courseRepository.saveAndFlush(course);
        } catch (DataAccessException e) {
            if (!(e instanceof UnitTestException)) {
                log.info("internal error retrieving course: " + name, e);
            }
            throw new PersistenceException("unable to create course", e);
        }

        return actual;
    }
}

CourseServiceIntegrationTest

We make a few changes to our integration tests. We only have to change one test method since it’s the only one that actually creates a test object. The rest of the methods are queries that don’t require test data.

Note that we change the name value to ensure it’s unique. This is a way to work around uniqueness constraints, e.g., for email addresses.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { BusinessApplicationContext.class, TestBusinessApplicationContext.class,
TestPersistenceJpaConfig.class })
@Transactional
@TransactionConfiguration(defaultRollback = true)
public class CourseServiceIntegrationTest {
@Resource
private CourseService dao;
@Resource
private TestRunService testService;
@Test
public void testCourseLifecycle() throws Exception {
final TestRun testRun = testService.createTestRun();
final String name = "Calculus 101 : " + testRun.getUuid();
final Course expected = new Course();
expected.setName(name);
assertNull(expected.getId());
// create course
Course actual = dao.createCourseForTesting(name, testRun);
expected.setId(actual.getId());
expected.setUuid(actual.getUuid());
expected.setCreationDate(actual.getCreationDate());
assertThat(expected, equalTo(actual));
assertNotNull(actual.getUuid());
assertNotNull(actual.getCreationDate());
// get course by id
actual = dao.findCourseById(expected.getId());
assertThat(expected, equalTo(actual));
// get course by uuid
actual = dao.findCourseByUuid(expected.getUuid());
assertThat(expected, equalTo(actual));
// get all courses
final List<Course> courses = dao.findCoursesByTestRun(testRun);
assertTrue(courses.contains(actual));
// update course
expected.setName("Calculus 102 : " + testRun.getUuid());
actual = dao.updateCourse(actual, expected.getName());
assertThat(expected, equalTo(actual));
// verify testRun.getObjects
final List<TestablePersistentObject> objects = testRun.getObjects();
assertTrue(objects.contains(actual));
// delete Course
dao.deleteCourse(expected.getUuid());
try {
dao.findCourseByUuid(expected.getUuid());
fail("exception expected");
} catch (ObjectNotFoundException e) {
// expected
}
testService.deleteTestRun(testRun.getUuid());
}
....
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { BusinessApplicationContext.class, TestBusinessApplicationContext.class,
        TestPersistenceJpaConfig.class })
@Transactional
@TransactionConfiguration(defaultRollback = true)
public class CourseServiceIntegrationTest {

    @Resource
    private CourseService dao;

    @Resource
    private TestRunService testService;
    
    @Test
    public void testCourseLifecycle() throws Exception {
        final TestRun testRun = testService.createTestRun();

        final String name = "Calculus 101 : " + testRun.getUuid();

        final Course expected = new Course();
        expected.setName(name);

        assertNull(expected.getId());

        // create course
        Course actual = dao.createCourseForTesting(name, testRun);
        expected.setId(actual.getId());
        expected.setUuid(actual.getUuid());
        expected.setCreationDate(actual.getCreationDate());

        assertThat(expected, equalTo(actual));
        assertNotNull(actual.getUuid());
        assertNotNull(actual.getCreationDate());

        // get course by id
        actual = dao.findCourseById(expected.getId());
        assertThat(expected, equalTo(actual));

        // get course by uuid
        actual = dao.findCourseByUuid(expected.getUuid());
        assertThat(expected, equalTo(actual));

        // get all courses
        final List<Course> courses = dao.findCoursesByTestRun(testRun);
        assertTrue(courses.contains(actual));

        // update course
        expected.setName("Calculus 102 : " + testRun.getUuid());
        actual = dao.updateCourse(actual, expected.getName());
        assertThat(expected, equalTo(actual));

        // verify testRun.getObjects
        final List<TestablePersistentObject> objects = testRun.getObjects();
        assertTrue(objects.contains(actual));

        // delete Course
        dao.deleteCourse(expected.getUuid());
        try {
            dao.findCourseByUuid(expected.getUuid());
            fail("exception expected");
        } catch (ObjectNotFoundException e) {
            // expected
        }

        testService.deleteTestRun(testRun.getUuid());
    }

    ....
}

We could use @Before and @After to transparently wrap all test methods but many tests don’t require test data and many tests that do require test data require unique test data, e.g., for email addresses. In the latter case we fold in the Test UUID as above.

REST Webservice Server

The REST webservice requires adding a test uuid to the request classes and adding a bit of logic to properly handle it when creating an object.

The REST webservice does not support getting a list of all test objects. The “correct” approach will be creating a TestRun service and providing associated objects in response to a /get/{id} query.

@XmlRootElement
public class Name {
private String name;
private String testUuid;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTestUuid() {
return testUuid;
}
public void setTestUuid(String testUuid) {
this.testUuid = testUuid;
}
}

@XmlRootElement
public class Name {
    private String name;
    private String testUuid;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getTestUuid() {
        return testUuid;
    }

    public void setTestUuid(String testUuid) {
        this.testUuid = testUuid;
    }
}

We can now check for the optional testUuid field and call the appropriate create method.

@Service
@Path("/course")
public class CourseResource extends AbstractResource {
@Resource
private CourseService service;
@Resource
private TestRunService testRunService;
/**
* Create a Course.
*
* @param req
* @return
*/
@POST
@Consumes({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
@Produces({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
public Response createCourse(Name req) {
log.debug("CourseResource: createCourse()");
final String name = req.getName();
if ((name == null) || name.isEmpty()) {
return Response.status(Status.BAD_REQUEST).entity("'name' is required'").build();
}
Response response = null;
try {
Course course = null;
if (req.getTestUuid() != null) {
TestRun testRun = testRunService.findTestRunByUuid(req.getTestUuid());
if (testRun != null) {
course = service.createCourseForTesting(name, testRun);
} else {
response = Response.status(Status.BAD_REQUEST).entity("unknown test UUID").build();
}
} else {
course = service.createCourse(name);
}
if (course == null) {
response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
} else {
response = Response.created(URI.create(course.getUuid())).entity(scrubCourse(course)).build();
}
} catch (Exception e) {
if (!(e instanceof UnitTestException)) {
log.info("unhandled exception", e);
}
response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
}
return response;
}
....
}

@Service
@Path("/course")
public class CourseResource extends AbstractResource {
    @Resource
    private CourseService service;

    @Resource
    private TestRunService testRunService;

    /**
     * Create a Course.
     * 
     * @param req
     * @return
     */
    @POST
    @Consumes({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
    @Produces({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
    public Response createCourse(Name req) {
        log.debug("CourseResource: createCourse()");

        final String name = req.getName();
        if ((name == null) || name.isEmpty()) {
            return Response.status(Status.BAD_REQUEST).entity("'name' is required'").build();
        }

        Response response = null;

        try {
            Course course = null;

            if (req.getTestUuid() != null) {
                TestRun testRun = testRunService.findTestRunByUuid(req.getTestUuid());
                if (testRun != null) {
                    course = service.createCourseForTesting(name, testRun);
                } else {
                    response = Response.status(Status.BAD_REQUEST).entity("unknown test UUID").build();
                }
            } else {
                course = service.createCourse(name);
            }
            if (course == null) {
                response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
            } else {
                response = Response.created(URI.create(course.getUuid())).entity(scrubCourse(course)).build();
            }
        } catch (Exception e) {
            if (!(e instanceof UnitTestException)) {
                log.info("unhandled exception", e);
            }
            response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
        }

        return response;
    }

    ....
}

REST Webservice Client

Finally the REST server must add one additional method. The client does not support getting a list of all test objects yet.

public interface CourseRestClient {
/**
* Create specific course for testing.
*
* @param name
* @param testRun
*/
Course createCourseForTesting(String name, TestRun testRun);
....
}

public interface CourseRestClient {

    /**
     * Create specific course for testing.
     * 
     * @param name
     * @param testRun
     */
    Course createCourseForTesting(String name, TestRun testRun);

    ....
}

and

public class CourseRestClientImpl extends AbstractRestClientImpl implements CourseRestClient {
/**
* Create JSON string.
*
* @param name
* @return
*/
String createJson(final String name, final TestRun testRun) {
return String.format("{ \"name\": \"%s\", \"testUuid\": \"%s\" }", name, testRun.getTestUuid());
}
/**
* @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#createCourse(java.lang.String)
*/
@Override
public Course createCourseForTesting(final String name, final TestRun testRun) {
if (name == null || name.isEmpty()) {
throw new IllegalArgumentException("'name' is required");
}
if (testRun == null || testRun.getTestUuid() == null || testRun.getTestUuid().isEmpty()) {
throw new IllegalArgumentException("'testRun' is required");
}
return createObject(createJson(name, testRun));
}
....
}

public class CourseRestClientImpl extends AbstractRestClientImpl implements CourseRestClient {

    /**
     * Create JSON string.
     * 
     * @param name
     * @return
     */
    String createJson(final String name, final TestRun testRun) {
        return String.format("{ \"name\": \"%s\", \"testUuid\": \"%s\" }", name, testRun.getTestUuid());
    }

    /**
     * @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#createCourse(java.lang.String)
     */
    @Override
    public Course createCourseForTesting(final String name, final TestRun testRun) {
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("'name' is required");
        }

        if (testRun == null || testRun.getTestUuid() == null || testRun.getTestUuid().isEmpty()) {
            throw new IllegalArgumentException("'testRun' is required");
        }

        return createObject(createJson(name, testRun));
    }

    ....
}

Source Code

The source code is at https://github.com/beargiles/project-student [github] and http://beargiles.github.io/project-student/ [github pages].

Clarification

I didn’t think it was possible to have a @OneToMany to TestablePersistentObject in TestRun but the integration tests using H2 succeeded. Unfortunately it’s causing problems as I bring up the fully integrated webservice with a PostgreSQL database. I’m leaving the code in place above since it’s always possible to have a list of Classrooms, a list of Courses, etc., even if we can’t have a generic collection. However the code is being removed from the version under source control.

Correction

The interface method should be findCourseByTestRun_Uuid(), not findCourseByTestRun(). Another approach is using JPA criteria queries – see Project Student: JPA Criteria Queries.

Comments: No Comments »
Categories: java
Comments rss
Trackback

Project Student: Persistence With Spring Data

Bear Giles | December 19, 2013

This is part of Project Student. Other posts are Webservice Client With Jersey, Webservice Server with Jersey and Business Layer.

The final layer of the RESTful webapp onion is the persistence layer.

There are two philosophies for persistence layers. One camp sees the database as a simple store and wants to keep this layer extremely thin. The other camp knows it’s often much faster to perform tasks in the database than to hit the database for the data, do the necessary work in java, and possibly hit the database a second time with the results. This camp often wants a fairly thick persistence layer.

The second camp also has a group of exiles that wants to use stored procedures extensively. This makes the database much more powerful but at the cost of a bit of additional complexity in the persistence layer. It has a major drawback in that stored procedures are database-specific.

A second group of exiles just uses stored procedures for security. I’ve discussed this earlier, e.g., the idea that you should call a stored procedure with username and password and get an “accept” or “deny” response instead of retrieving the hashed password and doing the comparison in the application. The first approach allows you to use the database’s GRANT and REVOKE privileges to store hashed passwords in a table that’s inaccessible even if an attacker can perform arbitrary SQL injection as the application user.

(Sidenote: you can often write your stored procedures in Java! Oracle supports it, PostgreSQL supports it (via PL/Java extension), H2 supports it (via the classpath). I don’t know if MySQL supports it. This approach has definite costs but it may be the best solution for many problems.)

Anyway this project only supports CRUD operations at the moment and they’re a classic example of using a thin persistence layer. It’s easy to add ‘thick’ methods though – simply create a CourseRepositoryImpl class with them. (This class should NOT implement the CourseRepository interface!)

Design Decisions

Spring Data – we’re using Spring Data because it autogenerates the persistence layer classes.

Limitations

Pagination – there is no attempt to support pagination. This isn’t a big issue since Spring Data already supports it – we only need to write the glue.

Configuration

The basic configuration only requires the @EnableJpaRepositories annotation.

The integration test using a pure in-memory embedded database requires a bit more work. Using the Spring embedded database directly doesn’t work even if you use the H2 url that tells it to leave the database server up. The database is properly initialized but then closed before the tests actually run. The result is failures since the database schema is missing.

It would be trivial to use an in-memory database backed by a file but that could cause problems with concurrent runs, accidently pulling in old test data, etc. The obvious solution is using a random temporary backing file but that approach introduces its own problems.

The approach below is to cache the embedded database in the configuration class and only destroy it as the app shuts down. This introduces some non-obvious behavior that forces us to explicitly create a few additional beans as well.

(IIRC if you create the embedded database in a configuration class and the transaction beans in a configuration file then spring was creating a phantom datasource in the configuration file and initialization failed. This problem went away when I started to create the transaction beans in the same place as the datasource.)

@Configuration
@EnableJpaRepositories(basePackages = { "com.invariantproperties.sandbox.student.repository" })
@EnableTransactionManagement
@PropertySource("classpath:test-application.properties")
@ImportResource("classpath:applicationContext-dao.xml")
public class TestPersistenceJpaConfig implements DisposableBean {
private static final Logger log = LoggerFactory.getLogger(TestPersistenceJpaConfig.class);
private static final String PROPERTY_NAME_HIBERNATE_DIALECT = "hibernate.dialect";
private static final String PROPERTY_NAME_HIBERNATE_FORMAT_SQL = "hibernate.format_sql";
private static final String PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY = "hibernate.ejb.naming_strategy";
private static final String PROPERTY_NAME_HIBERNATE_SHOW_SQL = "hibernate.show_sql";
private static final String PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO = "hibernate.hbm2ddl.auto";
private static final String PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN = "entitymanager.packages.to.scan";
// private static final String PROPERTY_NAME_PERSISTENCE_UNIT_NAME =
// "persistence.unit.name";
@Resource
private Environment environment;
private EmbeddedDatabase db = null;
@Bean
public DataSource dataSource() {
final EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();
db = builder.setType(EmbeddedDatabaseType.H2).build(); // .script("foo.sql")
return db;
}
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() throws ClassNotFoundException {
LocalContainerEntityManagerFactoryBean bean = new LocalContainerEntityManagerFactoryBean();
bean.setDataSource(dataSource());
bean.setPackagesToScan(environment.getRequiredProperty(PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN));
bean.setPersistenceProviderClass(HibernatePersistence.class);
// bean.setPersistenceUnitName(environment
// .getRequiredProperty(PROPERTY_NAME_PERSISTENCE_UNIT_NAME));
HibernateJpaVendorAdapter va = new HibernateJpaVendorAdapter();
bean.setJpaVendorAdapter(va);
Properties jpaProperties = new Properties();
jpaProperties.put(PROPERTY_NAME_HIBERNATE_DIALECT,
environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_DIALECT));
jpaProperties.put(PROPERTY_NAME_HIBERNATE_FORMAT_SQL,
environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_FORMAT_SQL));
jpaProperties.put(PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY,
environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY));
jpaProperties.put(PROPERTY_NAME_HIBERNATE_SHOW_SQL,
environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_SHOW_SQL));
jpaProperties.put(PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO,
environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO));
bean.setJpaProperties(jpaProperties);
return bean;
}
@Bean
public PlatformTransactionManager transactionManager() {
JpaTransactionManager tm = new JpaTransactionManager();
try {
tm.setEntityManagerFactory(this.entityManagerFactory().getObject());
} catch (ClassNotFoundException e) {
// TODO: log.
}
return tm;
}
@Bean
public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
return new PersistenceExceptionTranslationPostProcessor();
}
@Override
public void destroy() {
if (db != null) {
db.shutdown();
}
}
}

@Configuration
@EnableJpaRepositories(basePackages = { "com.invariantproperties.sandbox.student.repository" })
@EnableTransactionManagement
@PropertySource("classpath:test-application.properties")
@ImportResource("classpath:applicationContext-dao.xml")
public class TestPersistenceJpaConfig implements DisposableBean {
    private static final Logger log = LoggerFactory.getLogger(TestPersistenceJpaConfig.class);

    private static final String PROPERTY_NAME_HIBERNATE_DIALECT = "hibernate.dialect";
    private static final String PROPERTY_NAME_HIBERNATE_FORMAT_SQL = "hibernate.format_sql";
    private static final String PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY = "hibernate.ejb.naming_strategy";
    private static final String PROPERTY_NAME_HIBERNATE_SHOW_SQL = "hibernate.show_sql";
    private static final String PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO = "hibernate.hbm2ddl.auto";
    private static final String PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN = "entitymanager.packages.to.scan";
    // private static final String PROPERTY_NAME_PERSISTENCE_UNIT_NAME =
    // "persistence.unit.name";

    @Resource
    private Environment environment;

    private EmbeddedDatabase db = null;

    @Bean
    public DataSource dataSource() {
        final EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();
        db = builder.setType(EmbeddedDatabaseType.H2).build(); // .script("foo.sql")
        return db;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() throws ClassNotFoundException {
        LocalContainerEntityManagerFactoryBean bean = new LocalContainerEntityManagerFactoryBean();

        bean.setDataSource(dataSource());
        bean.setPackagesToScan(environment.getRequiredProperty(PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN));
        bean.setPersistenceProviderClass(HibernatePersistence.class);
        // bean.setPersistenceUnitName(environment
        // .getRequiredProperty(PROPERTY_NAME_PERSISTENCE_UNIT_NAME));

        HibernateJpaVendorAdapter va = new HibernateJpaVendorAdapter();
        bean.setJpaVendorAdapter(va);

        Properties jpaProperties = new Properties();
        jpaProperties.put(PROPERTY_NAME_HIBERNATE_DIALECT,
environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_DIALECT));
        jpaProperties.put(PROPERTY_NAME_HIBERNATE_FORMAT_SQL,
                environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_FORMAT_SQL));
        jpaProperties.put(PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY,
                environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY));
        jpaProperties.put(PROPERTY_NAME_HIBERNATE_SHOW_SQL,
                environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_SHOW_SQL));
        jpaProperties.put(PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO,
                environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO));

        bean.setJpaProperties(jpaProperties);

        return bean;
    }

    @Bean
    public PlatformTransactionManager transactionManager() {
        JpaTransactionManager tm = new JpaTransactionManager();

        try {
            tm.setEntityManagerFactory(this.entityManagerFactory().getObject());
        } catch (ClassNotFoundException e) {
            // TODO: log.
        }

        return tm;
    }

    @Bean
    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
        return new PersistenceExceptionTranslationPostProcessor();
    }

    @Override
    public void destroy() {
        if (db != null) {
            db.shutdown();
        }
    }
}

The applicationContext.xml file is empty. The properties file is

# hibernate configuration
hibernate.dialect=org.hibernate.dialect.H2Dialect
hibernate.ejb.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy
hibernate.show_sql=false
hibernate.format_sql=true
hibernate.hbm2ddl.auto=create
# jpa configuration
entitymanager.packages.to.scan=com.invariantproperties.sandbox.student.domain
persistence.unit.dataSource=java:comp/env/jdbc/ssDS
persistence.unit.name=ssPU

# hibernate configuration
hibernate.dialect=org.hibernate.dialect.H2Dialect
hibernate.ejb.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy
hibernate.show_sql=false
hibernate.format_sql=true
hibernate.hbm2ddl.auto=create

# jpa configuration
entitymanager.packages.to.scan=com.invariantproperties.sandbox.student.domain
persistence.unit.dataSource=java:comp/env/jdbc/ssDS
persistence.unit.name=ssPU

Unit Testing

There are no unit tests since all of the code is autogenerated. This will change as custom methods are added.

Integration Testing

We can now write the integration tests for the business layer.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { BusinessApplicationContext.class, TestBusinessApplicationContext.class,
TestPersistenceJpaConfig.class })
@Transactional
@TransactionConfiguration(defaultRollback = true)
public class CourseServiceIntegrationTest {
@Resource
private CourseService dao;
@Test
public void testCourseLifecycle() throws Exception {
final String name = "Calculus 101";
final Course expected = new Course();
expected.setName(name);
assertNull(expected.getId());
// create course
Course actual = dao.createCourse(name);
expected.setId(actual.getId());
expected.setUuid(actual.getUuid());
expected.setCreationDate(actual.getCreationDate());
assertThat(expected, equalTo(actual));
assertNotNull(actual.getUuid());
assertNotNull(actual.getCreationDate());
// get course by id
actual = dao.findCourseById(expected.getId());
assertThat(expected, equalTo(actual));
// get course by uuid
actual = dao.findCourseByUuid(expected.getUuid());
assertThat(expected, equalTo(actual));
// update course
expected.setName("Calculus 102");
actual = dao.updateCourse(actual, expected.getName());
assertThat(expected, equalTo(actual));
// delete Course
dao.deleteCourse(expected.getUuid());
try {
dao.findCourseByUuid(expected.getUuid());
fail("exception expected");
} catch (ObjectNotFoundException e) {
// expected
}
}
/**
* @test findCourseById() with unknown course.
*/
@Test(expected = ObjectNotFoundException.class)
public void testfindCourseByIdWhenCourseIsNotKnown() {
final Integer id = 1;
dao.findCourseById(id);
}
/**
* @test findCourseByUuid() with unknown Course.
*/
@Test(expected = ObjectNotFoundException.class)
public void testfindCourseByUuidWhenCourseIsNotKnown() {
final String uuid = "missing";
dao.findCourseByUuid(uuid);
}
/**
* Test updateCourse() with unknown course.
*
* @throws ObjectNotFoundException
*/
@Test(expected = ObjectNotFoundException.class)
public void testUpdateCourseWhenCourseIsNotFound() {
final Course course = new Course();
course.setUuid("missing");
dao.updateCourse(course, "Calculus 102");
}
/**
* Test deleteCourse() with unknown course.
*
* @throws ObjectNotFoundException
*/
@Test(expected = ObjectNotFoundException.class)
public void testDeleteCourseWhenCourseIsNotFound() {
dao.deleteCourse("missing");
}
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { BusinessApplicationContext.class, TestBusinessApplicationContext.class,
        TestPersistenceJpaConfig.class })
@Transactional
@TransactionConfiguration(defaultRollback = true)
public class CourseServiceIntegrationTest {

    @Resource
    private CourseService dao;

    @Test
    public void testCourseLifecycle() throws Exception {
        final String name = "Calculus 101";

        final Course expected = new Course();
        expected.setName(name);

        assertNull(expected.getId());

        // create course
        Course actual = dao.createCourse(name);
        expected.setId(actual.getId());
        expected.setUuid(actual.getUuid());
        expected.setCreationDate(actual.getCreationDate());

        assertThat(expected, equalTo(actual));
        assertNotNull(actual.getUuid());
        assertNotNull(actual.getCreationDate());

        // get course by id
        actual = dao.findCourseById(expected.getId());
        assertThat(expected, equalTo(actual));

        // get course by uuid
        actual = dao.findCourseByUuid(expected.getUuid());
        assertThat(expected, equalTo(actual));

        // update course
        expected.setName("Calculus 102");
        actual = dao.updateCourse(actual, expected.getName());
        assertThat(expected, equalTo(actual));

        // delete Course
        dao.deleteCourse(expected.getUuid());
        try {
            dao.findCourseByUuid(expected.getUuid());
            fail("exception expected");
        } catch (ObjectNotFoundException e) {
            // expected
        }
    }

    /**
     * @test findCourseById() with unknown course.
     */
    @Test(expected = ObjectNotFoundException.class)
    public void testfindCourseByIdWhenCourseIsNotKnown() {
        final Integer id = 1;
        dao.findCourseById(id);
    }

    /**
     * @test findCourseByUuid() with unknown Course.
     */
    @Test(expected = ObjectNotFoundException.class)
    public void testfindCourseByUuidWhenCourseIsNotKnown() {
        final String uuid = "missing";
        dao.findCourseByUuid(uuid);
    }

    /**
     * Test updateCourse() with unknown course.
     * 
     * @throws ObjectNotFoundException
     */
    @Test(expected = ObjectNotFoundException.class)
    public void testUpdateCourseWhenCourseIsNotFound() {
        final Course course = new Course();
        course.setUuid("missing");
        dao.updateCourse(course, "Calculus 102");
    }

    /**
     * Test deleteCourse() with unknown course.
     * 
     * @throws ObjectNotFoundException
     */
    @Test(expected = ObjectNotFoundException.class)
    public void testDeleteCourseWhenCourseIsNotFound() {
        dao.deleteCourse("missing");
    }
}

Source Code

The source code is at https://github.com/beargiles/project-student [github] and http://beargiles.github.io/project-student/ [github pages].

Comments: No Comments »
Categories: java
Comments rss
Trackback

Project Student: Business Layer

Bear Giles | December 19, 2013

This is part of Project Student. Other posts are Webservice Client With Jersey, Webservice Server with Jersey and Persistence with Spring Data.

The third layer of the RESTful webapp onion is the business layer. This is the guts of the application – well-written persistence and webservice layers are constrained but anything goes in the business layer.

We’re only implementing CRUD methods at this point so these methods are straightforward.

Design Decisions

Spring Data – we will be using Spring Data for the persistence layer so we will want to specify the persistence layer interface with that in mind. As we’ll see in the next blog this greatly simplifies our life.

Limitations

DataAccessException – no attempt is made to throw different exceptions according to the type of DataAccessException we receive. This will be important later – we should treat a constraint violation differently than a lost database connection.

Service Interface

First a reminder of the service interface we identified in the last post.

public interface CourseService {
List<Course> findAllCourses();
Course findCourseById(Integer id);
Course findCourseByUuid(String uuid);
Course createCourse(String name);
Course updateCourse(Course course, String name);
void deleteCourse(String uuid);
}

public interface CourseService {
    List<Course> findAllCourses();

    Course findCourseById(Integer id);

    Course findCourseByUuid(String uuid);

    Course createCourse(String name);

    Course updateCourse(Course course, String name);

    void deleteCourse(String uuid);
}

Service Implementation

The service implementation goes quickly since it’s basic CRUD operations. Our only concerns are if there’s a problem with the database (DataAccessException in Spring) or if an expected value can’t be found. We need to add a new exception to our API for the former, already have an exception in the API for the latter.

public class CourseServiceImpl implements CourseService {
private static final Logger log = LoggerFactory
.getLogger(CourseServiceImpl.class);
@Resource
private CourseRepository courseRepository;
/**
* Default constructor
*/
public CourseServiceImpl() {
}
/**
* Constructor used in unit tests
*/
CourseServiceImpl(CourseRepository courseRepository) {
this.courseRepository = courseRepository;
}
/**
* @see com.invariantproperties.sandbox.student.business.CourseService#
* findAllCourses()
*/
@Transactional(readOnly = true)
@Override
public List<Course> findAllCourses() {
List<Course> courses = null;
try {
courses = courseRepository.findAll();
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("error loading list of courses: " + e.getMessage(), e);
}
throw new PersistenceException("unable to get list of courses.", e);
}
return courses;
}
/**
* @see com.invariantproperties.sandbox.student.business.CourseService#
* findCourseById(java.lang.Integer)
*/
@Transactional(readOnly = true)
@Override
public Course findCourseById(Integer id) {
Course course = null;
try {
course = courseRepository.findOne(id);
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("internal error retrieving course: " + id, e);
}
throw new PersistenceException("unable to find course by id", e, id);
}
if (course == null) {
throw new ObjectNotFoundException(id);
}
return course;
}
/**
* @see com.invariantproperties.sandbox.student.business.CourseService#
* findCourseByUuid(java.lang.String)
*/
@Transactional(readOnly = true)
@Override
public Course findCourseByUuid(String uuid) {
Course course = null;
try {
course = courseRepository.findCourseByUuid(uuid);
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("internal error retrieving course: " + uuid, e);
}
throw new PersistenceException("unable to find course by uuid", e,
uuid);
}
if (course == null) {
throw new ObjectNotFoundException(uuid);
}
return course;
}
/**
* @see com.invariantproperties.sandbox.student.business.CourseService#
* createCourse(java.lang.String)
*/
@Transactional
@Override
public Course createCourse(String name) {
final Course course = new Course();
course.setName(name);
Course actual = null;
try {
actual = courseRepository.saveAndFlush(course);
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("internal error retrieving course: " + name, e);
}
throw new PersistenceException("unable to create course", e);
}
return actual;
}
/**
* @see com.invariantproperties.sandbox.course.persistence.CourseService#
* updateCourse(com.invariantproperties.sandbox.course.domain.Course,
* java.lang.String)
*/
@Transactional
@Override
public Course updateCourse(Course course, String name) {
Course updated = null;
try {
final Course actual = courseRepository.findCourseByUuid(course
.getUuid());
if (actual == null) {
log.debug("did not find course: " + course.getUuid());
throw new ObjectNotFoundException(course.getUuid());
}
actual.setName(name);
updated = courseRepository.saveAndFlush(actual);
course.setName(name);
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("internal error deleting course: " + course.getUuid(),
e);
}
throw new PersistenceException("unable to delete course", e,
course.getUuid());
}
return updated;
}
/**
* @see com.invariantproperties.sandbox.student.business.CourseService#
* deleteCourse(java.lang.String)
*/
@Transactional
@Override
public void deleteCourse(String uuid) {
Course course = null;
try {
course = courseRepository.findCourseByUuid(uuid);
if (course == null) {
log.debug("did not find course: " + uuid);
throw new ObjectNotFoundException(uuid);
}
courseRepository.delete(course);
} catch (DataAccessException e) {
if (!(e instanceof UnitTestException)) {
log.info("internal error deleting course: " + uuid, e);
}
throw new PersistenceException("unable to delete course", e, uuid);
}
}
}

public class CourseServiceImpl implements CourseService {
    private static final Logger log = LoggerFactory
            .getLogger(CourseServiceImpl.class);

    @Resource
    private CourseRepository courseRepository;

    /**
     * Default constructor
     */
    public CourseServiceImpl() {

    }

    /**
     * Constructor used in unit tests
     */
    CourseServiceImpl(CourseRepository courseRepository) {
        this.courseRepository = courseRepository;
    }

    /**
     * @see com.invariantproperties.sandbox.student.business.CourseService#
     *      findAllCourses()
     */
    @Transactional(readOnly = true)
    @Override
    public List<Course> findAllCourses() {
        List<Course> courses = null;

        try {
            courses = courseRepository.findAll();
        } catch (DataAccessException e) {
            if (!(e instanceof UnitTestException)) {
                log.info("error loading list of courses: " + e.getMessage(), e);
            }
            throw new PersistenceException("unable to get list of courses.", e);
        }

        return courses;
    }

    /**
     * @see com.invariantproperties.sandbox.student.business.CourseService#
     *      findCourseById(java.lang.Integer)
     */
    @Transactional(readOnly = true)
    @Override
    public Course findCourseById(Integer id) {
        Course course = null;
        try {
            course = courseRepository.findOne(id);
        } catch (DataAccessException e) {
            if (!(e instanceof UnitTestException)) {
                log.info("internal error retrieving course: " + id, e);
            }
            throw new PersistenceException("unable to find course by id", e, id);
        }

        if (course == null) {
            throw new ObjectNotFoundException(id);
        }

        return course;
    }

    /**
     * @see com.invariantproperties.sandbox.student.business.CourseService#
     *      findCourseByUuid(java.lang.String)
     */
    @Transactional(readOnly = true)
    @Override
    public Course findCourseByUuid(String uuid) {
        Course course = null;
        try {
            course = courseRepository.findCourseByUuid(uuid);
        } catch (DataAccessException e) {
            if (!(e instanceof UnitTestException)) {
                log.info("internal error retrieving course: " + uuid, e);
            }
            throw new PersistenceException("unable to find course by uuid", e,
                    uuid);
        }

        if (course == null) {
            throw new ObjectNotFoundException(uuid);
        }

        return course;
    }

    /**
     * @see com.invariantproperties.sandbox.student.business.CourseService#
     *      createCourse(java.lang.String)
     */
    @Transactional
    @Override
    public Course createCourse(String name) {
        final Course course = new Course();
        course.setName(name);

        Course actual = null;
        try {
            actual = courseRepository.saveAndFlush(course);
        } catch (DataAccessException e) {
            if (!(e instanceof UnitTestException)) {
                log.info("internal error retrieving course: " + name, e);
            }
            throw new PersistenceException("unable to create course", e);
        }

        return actual;
    }

    /**
     * @see com.invariantproperties.sandbox.course.persistence.CourseService#
     *      updateCourse(com.invariantproperties.sandbox.course.domain.Course,
     *      java.lang.String)
     */
    @Transactional
    @Override
    public Course updateCourse(Course course, String name) {
        Course updated = null;
        try {
            final Course actual = courseRepository.findCourseByUuid(course
                    .getUuid());

            if (actual == null) {
                log.debug("did not find course: " + course.getUuid());
                throw new ObjectNotFoundException(course.getUuid());
            }

            actual.setName(name);
            updated = courseRepository.saveAndFlush(actual);
            course.setName(name);

        } catch (DataAccessException e) {
            if (!(e instanceof UnitTestException)) {
                log.info("internal error deleting course: " + course.getUuid(),
                        e);
            }
            throw new PersistenceException("unable to delete course", e,
                    course.getUuid());
        }

        return updated;
    }

    /**
     * @see com.invariantproperties.sandbox.student.business.CourseService#
     *      deleteCourse(java.lang.String)
     */
    @Transactional
    @Override
    public void deleteCourse(String uuid) {
        Course course = null;
        try {
            course = courseRepository.findCourseByUuid(uuid);

            if (course == null) {
                log.debug("did not find course: " + uuid);
                throw new ObjectNotFoundException(uuid);
            }
            courseRepository.delete(course);

        } catch (DataAccessException e) {
            if (!(e instanceof UnitTestException)) {
                log.info("internal error deleting course: " + uuid, e);
            }
            throw new PersistenceException("unable to delete course", e, uuid);
        }
    }
}

This implementation tells us the required interface for the persistence layer.

Persistence Layer Interface

We will be using Spring Data for our persistence layer and our DAO interface is the same as a Spring Data repository. We only need one nonstandard method.

@Repository
public interface CourseRepository extends JpaRepository<Course, Integer> {
Course findCourseByUuid(String uuid);
}

@Repository
public interface CourseRepository extends JpaRepository<Course, Integer> {
    Course findCourseByUuid(String uuid);
}

Unit Testing

The unit tests also go quickly since we only need to consider three cases (at most) – the happy path, a database problem, and (sometimes) a nonexistent value.

public class CourseServiceImplTest {
@Test
public void testFindAllCourses() {
final List<Course> expected = Collections.emptyList();
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findAll()).thenReturn(expected);
final CourseService service = new CourseServiceImpl(repository);
final List<Course> actual = service.findAllCourses();
assertEquals(expected, actual);
}
@Test(expected = PersistenceException.class)
public void testFindAllCoursesError() {
final List<Course> expected = Collections.emptyList();
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findAll()).thenThrow(new UnitTestException());
final CourseService service = new CourseServiceImpl(repository);
final List<Course> actual = service.findAllCourses();
assertEquals(expected, actual);
}
@Test
public void testFindCourseById() {
final Course expected = new Course();
expected.setId(1);
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findOne(any(Integer.class))).thenReturn(expected);
final CourseService service = new CourseServiceImpl(repository);
final Course actual = service.findCourseById(expected.getId());
assertEquals(expected, actual);
}
@Test(expected = ObjectNotFoundException.class)
public void testFindCourseByIdMissing() {
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findOne(any(Integer.class))).thenReturn(null);
final CourseService service = new CourseServiceImpl(repository);
service.findCourseById(1);
}
@Test(expected = PersistenceException.class)
public void testFindCourseByIdError() {
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findOne(any(Integer.class))).thenThrow(
new UnitTestException());
final CourseService service = new CourseServiceImpl(repository);
service.findCourseById(1);
}
@Test
public void testFindCourseByUuid() {
final Course expected = new Course();
expected.setUuid("[uuid]");
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findCourseByUuid(any(String.class))).thenReturn(
expected);
final CourseService service = new CourseServiceImpl(repository);
final Course actual = service.findCourseByUuid(expected.getUuid());
assertEquals(expected, actual);
}
@Test(expected = ObjectNotFoundException.class)
public void testFindCourseByUuidMissing() {
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findCourseByUuid(any(String.class))).thenReturn(null);
final CourseService service = new CourseServiceImpl(repository);
service.findCourseByUuid("[uuid]");
}
@Test(expected = PersistenceException.class)
public void testFindCourseByUuidError() {
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findCourseByUuid(any(String.class))).thenThrow(
new UnitTestException());
final CourseService service = new CourseServiceImpl(repository);
service.findCourseByUuid("[uuid]");
}
@Test
public void testCreateCourse() {
final Course expected = new Course();
expected.setName("name");
expected.setUuid("[uuid]");
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.saveAndFlush(any(Course.class))).thenReturn(expected);
final CourseService service = new CourseServiceImpl(repository);
final Course actual = service.createCourse(expected.getName());
assertEquals(expected, actual);
}
@Test(expected = PersistenceException.class)
public void testCreateCourseError() {
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.saveAndFlush(any(Course.class))).thenThrow(
new UnitTestException());
final CourseService service = new CourseServiceImpl(repository);
service.createCourse("name");
}
@Test
public void testUpdateCourse() {
final Course expected = new Course();
expected.setName("Alice");
expected.setUuid("[uuid]");
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findCourseByUuid(any(String.class))).thenReturn(
expected);
when(repository.saveAndFlush(any(Course.class))).thenReturn(expected);
final CourseService service = new CourseServiceImpl(repository);
final Course actual = service.updateCourse(expected, "Bob");
assertEquals("Bob", actual.getName());
}
@Test(expected = ObjectNotFoundException.class)
public void testUpdateCourseMissing() {
final Course expected = new Course();
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findCourseByUuid(any(String.class))).thenReturn(null);
final CourseService service = new CourseServiceImpl(repository);
service.updateCourse(expected, "Bob");
}
@Test(expected = PersistenceException.class)
public void testUpdateCourseError() {
final Course expected = new Course();
expected.setUuid("[uuid]");
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findCourseByUuid(any(String.class))).thenReturn(
expected);
doThrow(new UnitTestException()).when(repository).saveAndFlush(
any(Course.class));
final CourseService service = new CourseServiceImpl(repository);
service.updateCourse(expected, "Bob");
}
@Test
public void testDeleteCourse() {
final Course expected = new Course();
expected.setUuid("[uuid]");
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findCourseByUuid(any(String.class))).thenReturn(
expected);
doNothing().when(repository).delete(any(Course.class));
final CourseService service = new CourseServiceImpl(repository);
service.deleteCourse(expected.getUuid());
}
@Test(expected = ObjectNotFoundException.class)
public void testDeleteCourseMissing() {
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findCourseByUuid(any(String.class))).thenReturn(null);
final CourseService service = new CourseServiceImpl(repository);
service.deleteCourse("[uuid]");
}
@Test(expected = PersistenceException.class)
public void testDeleteCourseError() {
final Course expected = new Course();
expected.setUuid("[uuid]");
final CourseRepository repository = Mockito
.mock(CourseRepository.class);
when(repository.findCourseByUuid(any(String.class))).thenReturn(
expected);
doThrow(new UnitTestException()).when(repository).delete(
any(Course.class));
final CourseService service = new CourseServiceImpl(repository);
service.deleteCourse(expected.getUuid());
}
}

public class CourseServiceImplTest {

    @Test
    public void testFindAllCourses() {
        final List<Course> expected = Collections.emptyList();

        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findAll()).thenReturn(expected);

        final CourseService service = new CourseServiceImpl(repository);
        final List<Course> actual = service.findAllCourses();

        assertEquals(expected, actual);
    }

    @Test(expected = PersistenceException.class)
    public void testFindAllCoursesError() {
        final List<Course> expected = Collections.emptyList();

        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findAll()).thenThrow(new UnitTestException());

        final CourseService service = new CourseServiceImpl(repository);
        final List<Course> actual = service.findAllCourses();

        assertEquals(expected, actual);
    }

    @Test
    public void testFindCourseById() {
        final Course expected = new Course();
        expected.setId(1);

        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findOne(any(Integer.class))).thenReturn(expected);

        final CourseService service = new CourseServiceImpl(repository);
        final Course actual = service.findCourseById(expected.getId());

        assertEquals(expected, actual);
    }

    @Test(expected = ObjectNotFoundException.class)
    public void testFindCourseByIdMissing() {
        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findOne(any(Integer.class))).thenReturn(null);

        final CourseService service = new CourseServiceImpl(repository);
        service.findCourseById(1);
    }

    @Test(expected = PersistenceException.class)
    public void testFindCourseByIdError() {
        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findOne(any(Integer.class))).thenThrow(
                new UnitTestException());

        final CourseService service = new CourseServiceImpl(repository);
        service.findCourseById(1);
    }

    @Test
    public void testFindCourseByUuid() {
        final Course expected = new Course();
        expected.setUuid("[uuid]");

        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findCourseByUuid(any(String.class))).thenReturn(
                expected);

        final CourseService service = new CourseServiceImpl(repository);
        final Course actual = service.findCourseByUuid(expected.getUuid());

        assertEquals(expected, actual);
    }

    @Test(expected = ObjectNotFoundException.class)
    public void testFindCourseByUuidMissing() {
        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findCourseByUuid(any(String.class))).thenReturn(null);

        final CourseService service = new CourseServiceImpl(repository);
        service.findCourseByUuid("[uuid]");
    }

    @Test(expected = PersistenceException.class)
    public void testFindCourseByUuidError() {
        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findCourseByUuid(any(String.class))).thenThrow(
                new UnitTestException());

        final CourseService service = new CourseServiceImpl(repository);
        service.findCourseByUuid("[uuid]");
    }

    @Test
    public void testCreateCourse() {
        final Course expected = new Course();
        expected.setName("name");
        expected.setUuid("[uuid]");

        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.saveAndFlush(any(Course.class))).thenReturn(expected);

        final CourseService service = new CourseServiceImpl(repository);
        final Course actual = service.createCourse(expected.getName());

        assertEquals(expected, actual);
    }

    @Test(expected = PersistenceException.class)
    public void testCreateCourseError() {
        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.saveAndFlush(any(Course.class))).thenThrow(
                new UnitTestException());

        final CourseService service = new CourseServiceImpl(repository);
        service.createCourse("name");
    }

    @Test
    public void testUpdateCourse() {
        final Course expected = new Course();
        expected.setName("Alice");
        expected.setUuid("[uuid]");

        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findCourseByUuid(any(String.class))).thenReturn(
                expected);
        when(repository.saveAndFlush(any(Course.class))).thenReturn(expected);

        final CourseService service = new CourseServiceImpl(repository);
        final Course actual = service.updateCourse(expected, "Bob");

        assertEquals("Bob", actual.getName());
    }

    @Test(expected = ObjectNotFoundException.class)
    public void testUpdateCourseMissing() {
        final Course expected = new Course();
        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findCourseByUuid(any(String.class))).thenReturn(null);

        final CourseService service = new CourseServiceImpl(repository);
        service.updateCourse(expected, "Bob");
    }

    @Test(expected = PersistenceException.class)
    public void testUpdateCourseError() {
        final Course expected = new Course();
        expected.setUuid("[uuid]");

        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findCourseByUuid(any(String.class))).thenReturn(
                expected);
        doThrow(new UnitTestException()).when(repository).saveAndFlush(
                any(Course.class));

        final CourseService service = new CourseServiceImpl(repository);
        service.updateCourse(expected, "Bob");
    }

    @Test
    public void testDeleteCourse() {
        final Course expected = new Course();
        expected.setUuid("[uuid]");

        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findCourseByUuid(any(String.class))).thenReturn(
                expected);
        doNothing().when(repository).delete(any(Course.class));

        final CourseService service = new CourseServiceImpl(repository);
        service.deleteCourse(expected.getUuid());
    }

    @Test(expected = ObjectNotFoundException.class)
    public void testDeleteCourseMissing() {
        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findCourseByUuid(any(String.class))).thenReturn(null);

        final CourseService service = new CourseServiceImpl(repository);
        service.deleteCourse("[uuid]");
    }

    @Test(expected = PersistenceException.class)
    public void testDeleteCourseError() {
        final Course expected = new Course();
        expected.setUuid("[uuid]");

        final CourseRepository repository = Mockito
                .mock(CourseRepository.class);
        when(repository.findCourseByUuid(any(String.class))).thenReturn(
                expected);
        doThrow(new UnitTestException()).when(repository).delete(
                any(Course.class));

        final CourseService service = new CourseServiceImpl(repository);
        service.deleteCourse(expected.getUuid());
    }
}

Integration Testing

Integration testing has been deferred until the persistence layer is implemented.

Source Code

The source code is at https://github.com/beargiles/project-student [github] and http://beargiles.github.io/project-student/ [github pages].

Comments: No Comments »
Categories: java
Comments rss
Trackback

Broken Eclipse Menubar in Ubuntu 13.10

Bear Giles | December 18, 2013

The eclipse menubar in Ubuntu 13.10 is broken. It appears but it’s inert – you can’t pull down anything.

Fortunately there’s a simple fix. We only need to create one file and then load the app via Dash. The configuration below is for Spring Tool Suite and easily modified for other versions of eclipse.

/usr/share/applications/eclipse.desktop

[Desktop Entry]
Version=3.4.0
Name=Eclipse
Comment=IDE for all seasons
Exec=env UBUNTU_MENUPROXY=0 /opt/springsource/sts-3.4.0.RELEASE/STS
Icon=/opt/springsource/sts-3.4.0.RELEASE/icon.xpm
Terminal=false
Type=Application
Categories=Utility;Application

[Desktop Entry]
Version=3.4.0
Name=Eclipse
Comment=IDE for all seasons
Exec=env UBUNTU_MENUPROXY=0 /opt/springsource/sts-3.4.0.RELEASE/STS
Icon=/opt/springsource/sts-3.4.0.RELEASE/icon.xpm
Terminal=false
Type=Application
Categories=Utility;Application

Comments: No Comments »
Categories: java, linux
Comments rss
Trackback

Project Student: Webservice Server with Jersey

Bear Giles | December 18, 2013

This is part of Project Student. Other posts are Webservice Client With Jersey, Business Layer and Persistence with Spring Data.

The second layer of the RESTful webapp onion is the webservice server. It should be a thin layer that wraps calls to the business layer but does not do significant processing of its own. This post has a lot of code but it’s mostly test classes.

Design Decisions

Jersey – I use Jersey for the REST server. I considered alternatives – Spring MVC, Netty, etc., but decided to go with Jersey for the same reason as the client. It’s lightweight and doesn’t constrain the developer.

Dependency Injection – I need dependency injection and that means I need to decide on a framework: Spring, EJB3, Guice, etc. I already know that I’ll be using Spring Data for the persistence layer so it’s a no-brainer to use the spring framework. I will still be careful to minimize any dependencies (ha!) on that framework for maximum flexibility.

Limitations

Jersey – I don’t know how well Jersey will handle high loads. This is a key reason why the REST server must be a thin wrapper around the business layer – it will be relatively painless to change libraries if it becomes necessary.

User Permissions – there is no attempt to restrict access to certain methods to specific users or hosts. This should be handled by the business layer with security exceptions translated to FORBIDDEN status codes by the REST server.

Jersey REST Server

One of our early design documents is the REST API. For the server this means that we implement the layer from the REST server down instead of from the business layer API up. In fact the REST server defines the necessary methods in the business layer API.

There is one small deviation from the standard REST CRUD API: objects are created with a POST instead of a PUT since the semantics of the latter is that the object is created exactly as provided. We can’t do that – for security reasons we never expose our internal ID and must never accept a user-defined UUID. That means we’ll violate the REST API contract so we use a POST instead.

There is also one small cheat: the CRUD contract only requires the ability to create or update objects. This means that we can figure out the required action given just the path – we don’t need to add a specific ‘action’ field. This may change as we extend the implementation to include more than just CRUD actions.

Onward to the code…

@Service
@Path("/course")
public class CourseResource extends AbstractResource {
private static final Logger log = Logger.getLogger(CourseResource.class);
private static final Course[] EMPTY_COURSE_ARRAY = new Course[0];
@Context
UriInfo uriInfo;
@Context
Request request;
@Resource
private CourseService service;
/**
* Default constructor.
*/
public CourseResource() {
}
/**
* Unit test constructor.
*
* @param service
*/
CourseResource(CourseService service) {
this.service = service;
}
/**
* Get all Courses.
*
* @return
*/
@GET
@Produces({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
public Response findAllCourses() {
log.debug("CourseResource: findAllCourses()");
Response response = null;
try {
List<Course> courses = service.findAllCourses();
List<Course> results = new ArrayList<Course>(courses.size());
for (Course course : courses) {
results.add(scrubCourse(course));
}
response = Response.ok(results.toArray(EMPTY_COURSE_ARRAY)).build();
} catch (Exception e) {
if (!(e instanceof UnitTestException)) {
log.info("unhandled exception", e);
}
response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
}
return response;
}
/**
* Create a Course.
*
* @param req
* @return
*/
@POST
@Consumes({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
@Produces({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
public Response createCourse(Name req) {
log.debug("CourseResource: createCourse()");
final String name = req.getName();
if ((name == null) || name.isEmpty()) {
return Response.status(Status.BAD_REQUEST).entity("'name' is required").build();
}
Response response = null;
try {
Course course = service.createCourse(name);
if (course == null) {
response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
} else {
response = Response.created(URI.create(course.getUuid())).entity(scrubCourse(course)).build();
}
} catch (Exception e) {
if (!(e instanceof UnitTestException)) {
log.info("unhandled exception", e);
}
response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
}
return response;
}
/**
* Get a specific Course.
*
* @param uuid
* @return
*/
@Path("/{courseId}")
@GET
@Produces({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
public Response getCourse(@PathParam("courseId") String id) {
log.debug("CourseResource: getCourse()");
Response response = null;
try {
Course course = service.findCourseByUuid(id);
response = Response.ok(scrubCourse(course)).build();
} catch (ObjectNotFoundException e) {
response = Response.status(Status.NOT_FOUND).build();
} catch (Exception e) {
if (!e instanceof UnitTestException)) {
log.info("unhandled exception", e);
}
response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
}
return response;
}
/**
* Update a Course.
*
* FIXME: what about uniqueness violations?
*
* @param id
* @param req
* @return
*/
@Path("/{courseId}")
@POST
@Consumes({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
@Produces({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
public Response updateCourse(@PathParam("courseId") String id, Name req) {
log.debug("CourseResource: updateCourse()");
final String name = req.getName();
if ((name == null) || name.isEmpty()) {
return Response.status(Status.BAD_REQUEST).entity("'name' is required").build();
}
Response response = null;
try {
final Course course = service.findCourseByUuid(id);
final Course updatedCourse = service.updateCourse(course, name);
response = Response.ok(scrubCourse(updatedCourse)).build();
} catch (ObjectNotFoundException exception) {
response = Response.status(Status.NOT_FOUND).build();
} catch (Exception e) {
if (!(e instanceof UnitTestException)) {
log.info("unhandled exception", e);
}
response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
}
return response;
}
/**
* Delete a Course.
*
* @param id
* @return
*/
@Path("/{courseId}")
@DELETE
public Response deleteCourse(@PathParam("courseId") String id) {
log.debug("CourseResource: deleteCourse()");
Response response = null;
try {
service.deleteCourse(id);
response = Response.noContent().build();
} catch (ObjectNotFoundException exception) {
response = Response.noContent().build();
} catch (Exception e) {
if (!(e instanceof UnitTestException)) {
log.info("unhandled exception", e);
}
response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
}
return response;
}
}

@Service
@Path("/course")
public class CourseResource extends AbstractResource {
    private static final Logger log = Logger.getLogger(CourseResource.class);
    private static final Course[] EMPTY_COURSE_ARRAY = new Course[0];

    @Context
    UriInfo uriInfo;

    @Context
    Request request;

    @Resource
    private CourseService service;

    /**
     * Default constructor.
     */
    public CourseResource() {

    }

    /**
     * Unit test constructor.
     * 
     * @param service
     */
    CourseResource(CourseService service) {
        this.service = service;
    }

    /**
     * Get all Courses.
     * 
     * @return
     */
    @GET
    @Produces({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
    public Response findAllCourses() {
        log.debug("CourseResource: findAllCourses()");

        Response response = null;
        try {
            List<Course> courses = service.findAllCourses();

            List<Course> results = new ArrayList<Course>(courses.size());
            for (Course course : courses) {
                results.add(scrubCourse(course));
            }

            response = Response.ok(results.toArray(EMPTY_COURSE_ARRAY)).build();
        } catch (Exception e) {
            if (!(e instanceof UnitTestException)) {
                log.info("unhandled exception", e);
            }
            response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
        }

        return response;
    }

    /**
     * Create a Course.
     * 
     * @param req
     * @return
     */
    @POST
    @Consumes({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
    @Produces({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
    public Response createCourse(Name req) {
        log.debug("CourseResource: createCourse()");

        final String name = req.getName();
        if ((name == null) || name.isEmpty()) {
            return Response.status(Status.BAD_REQUEST).entity("'name' is required").build();
        }

        Response response = null;

        try {
            Course course = service.createCourse(name);
            if (course == null) {
                response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
            } else {
                response = Response.created(URI.create(course.getUuid())).entity(scrubCourse(course)).build();
            }
        } catch (Exception e) {
            if (!(e instanceof UnitTestException)) {
                log.info("unhandled exception", e);
            }
            response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
        }

        return response;
    }

    /**
     * Get a specific Course.
     * 
     * @param uuid
     * @return
     */
    @Path("/{courseId}")
    @GET
    @Produces({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
    public Response getCourse(@PathParam("courseId") String id) {
        log.debug("CourseResource: getCourse()");

        Response response = null;
        try {
            Course course = service.findCourseByUuid(id);
            response = Response.ok(scrubCourse(course)).build();
        } catch (ObjectNotFoundException e) {
            response = Response.status(Status.NOT_FOUND).build();
        } catch (Exception e) {
            if (!e instanceof UnitTestException)) {
                log.info("unhandled exception", e);
            }
            response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
        }

        return response;
    }

    /**
     * Update a Course.
     * 
     * FIXME: what about uniqueness violations?
     * 
     * @param id
     * @param req
     * @return
     */
    @Path("/{courseId}")
    @POST
    @Consumes({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
    @Produces({ MediaType.APPLICATION_JSON, MediaType.TEXT_XML })
    public Response updateCourse(@PathParam("courseId") String id, Name req) {
        log.debug("CourseResource: updateCourse()");

        final String name = req.getName();
        if ((name == null) || name.isEmpty()) {
            return Response.status(Status.BAD_REQUEST).entity("'name' is required").build();
        }

        Response response = null;
        try {
            final Course course = service.findCourseByUuid(id);
            final Course updatedCourse = service.updateCourse(course, name);
            response = Response.ok(scrubCourse(updatedCourse)).build();
        } catch (ObjectNotFoundException exception) {
            response = Response.status(Status.NOT_FOUND).build();
        } catch (Exception e) {
            if (!(e instanceof UnitTestException)) {
                log.info("unhandled exception", e);
            }
            response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
        }

        return response;
    }

    /**
     * Delete a Course.
     * 
     * @param id
     * @return
     */
    @Path("/{courseId}")
    @DELETE
    public Response deleteCourse(@PathParam("courseId") String id) {
        log.debug("CourseResource: deleteCourse()");

        Response response = null;
        try {
            service.deleteCourse(id);
            response = Response.noContent().build();
        } catch (ObjectNotFoundException exception) {
            response = Response.noContent().build();
        } catch (Exception e) {
            if (!(e instanceof UnitTestException)) {
                log.info("unhandled exception", e);
            }
            response = Response.status(Status.INTERNAL_SERVER_ERROR).build();
        }

        return response;
    }
}

The implementation tells us that we need three things:

a service API (CourseService)
request parameter classes (Name)
a scrubber (scrubCourse)

I did not show full logging. Request parameters must be scrubbed to avoid log contamination.. As a simple example consider using a logger that writes to a SQL database for the ease of analysis. A naive implementation of this logger – one that does not use positional parameters – would permit SQL injection via carefully crafted request parameters!

OWASP ESAPI contains methods that can be used for log scrubbing. I haven’t included here since it’s a bit of a pain to set up. (It should be in the checked-in code soon.)

Why would you log to a database? One good practice is to log all unhandled exceptions that reach the server layer – you never want to rely on the user to report problems and errors written to the log files are easily overlooked. In contrast reports written to a database are easy to check with simple tools.

Advanced developers can even create new bug reports when unhandled exceptions occur. In this case it’s critical to maintain a separate exception database to avoid submitting duplicate entries and overwhelming developers. (The database can contain details for each exception but the bug reporting system should only have one bug report per exception class + stack trace.)

Service API

The service API for CRUD operations is straightforward.

public interface CourseService {
List<Course> findAllCourses();
Course findCourseById(Integer id);
Course findCourseByUuid(String uuid);
Course createCourse(String name);
Course updateCourse(Course course, String name);
void deleteCourse(String uuid);
}

public interface CourseService {
    List<Course> findAllCourses();

    Course findCourseById(Integer id);

    Course findCourseByUuid(String uuid);

    Course createCourse(String name);

    Course updateCourse(Course course, String name);

    void deleteCourse(String uuid);
}

The API also includes an ObjectNotFoundException. (This should be expanded to include the type of the object that could not be found.)

public class ObjectNotFoundException extends RuntimeException {
private static final long serialVersionUID = 1L;
private final String uuid;
public ObjectNotFoundException(String uuid) {
super("object not found: [" + uuid + "]");
this.uuid = uuid;
}
public String getUuid() {
return uuid;
}
}

public class ObjectNotFoundException extends RuntimeException {
	private static final long serialVersionUID = 1L;
	
	private final String uuid;
	
	public ObjectNotFoundException(String uuid) {
		super("object not found: [" + uuid + "]");
		this.uuid = uuid;
	}
	
	public String getUuid() {
		return uuid;
	}
}

As mentioned above we’ll also want an UnauthorizedOperationException eventually.

Request Parameters

The request parameters are simple POJOs that encapsulate POST payloads.

@XmlRootElement
public class Name {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

@XmlRootElement
public class Name {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Students and instructors also require email addresses.

@XmlRootElement
public class NameAndEmailAddress {
private String name;
private String emailAddress;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmailAddress() {
return emailAddress;
}
public void setEmailAddress(String emailAddress) {
this.emailAddress = emailAddress;
}
}

@XmlRootElement
public class NameAndEmailAddress {
    private String name;
    private String emailAddress;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmailAddress() {
        return emailAddress;
    }

    public void setEmailAddress(String emailAddress) {
        this.emailAddress = emailAddress;
    }
}

The final application will have a large number of request parameter classes.

Scrubber

A scrubber serves three purposes. First, it removes sensitive information that should not be provided to the client, e.g., internal database identifiers.

Second, it prevents an massive database dump due to pulling in collections. For instance a student should include a list of current sections, but each section has a list of enrolled students and instructors. Each of those students and instructors has his own list of current sections. Lather, rinse, repeat, and you end up dumping the entire database in response to a single query.

The solution is to only include shallow information about every object that can be independently queried. For instance a student will have a list of current sections but those sections will only contain UUID and name. A very good rule of thumb is that scrubbed collections should contain exactly the information that will be used in pulldown lists and presentation tables, nothing more. Presentation lists can include links (or AJAX actions) to pull in additional information as required.

Finally, it’s a good place to perform HTML encoding and scrubbing. The returned values should be scrubbed to prevent cross-site scripting (CSS) attacks.

public abstract class AbstractResource {
/**
* Scrub 'course' object.
*
* FIXME add HTML scrubbing and encoding for string values!
*/
public Course scrubCourse(final Course dirty) {
final Course clean = new Course();
clean.setUuid(dirty.getUuid());
clean.setName(dirty.getName());
// clean.setSelf("resource/" + dirty.getUuid());
return clean;
}
}

public abstract class AbstractResource {

    /**
     * Scrub 'course' object.
     *
     * FIXME add HTML scrubbing and encoding for string values!
     */	
    public Course scrubCourse(final Course dirty) {
        final Course clean = new Course();
        clean.setUuid(dirty.getUuid());
        clean.setName(dirty.getName());
        // clean.setSelf("resource/" + dirty.getUuid());
        return clean;
    }
}

Configuration Classes

We have two configuration classes. The first is always used by the server, the second is only used by the server during integration testing. The latter configuration (and referenced classes) are located in the integration-test source tree.

I prefer to use configuration classes (introduced in Spring 3.0) since they provide the most flexibility – e.g., I could conditionally define beans according to the user running the application or environmental variables – and allow me to still include standard configuration files.

@Configuration
@ComponentScan(basePackages = { "com.invariantproperties.sandbox.student.webservice.server.rest" })
@ImportResource({ "classpath:applicationContext-rest.xml" })
// @PropertySource("classpath:application.properties")
public class RestApplicationContext {
@Resource
private Environment environment;
}

@Configuration
@ComponentScan(basePackages = { "com.invariantproperties.sandbox.student.webservice.server.rest" })
@ImportResource({ "classpath:applicationContext-rest.xml" })
// @PropertySource("classpath:application.properties")
public class RestApplicationContext {

    @Resource
    private Environment environment;
}

Spring 3.1 introduced configuration profiles. They work – but the spring-aware jersey servlet I am using appears to be unable to properly set the active profiles.

@Configuration
//@Profile("test")
public class RestApplicationContextTest {
@Bean
StudentService studentService() {
return new DummyStudentService();
}
}

@Configuration
//@Profile("test")
public class RestApplicationContextTest {
	
    @Bean
    StudentService studentService() {
        return new DummyStudentService();
    }
}

web.xml

We now have enough to implement our web server. The servlet used is a spring-enabled
Jersey servlet that uses the configuration classes given in the contextClass parameter. (It is also possible to use configuration files, but not a combination of configuration classes and files.)

The servlet also contains a definition of spring.profiles.active. The intent is to conditionally include the definitions inside of RestApplicationContextTest via the spring 3.1 @Profile annotation but I haven’t been able to get it to work. I’ve left it in for future reference.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name>Project Student Webservice</display-name>
<context-param>
<param-name>contextClass</param-name>
<param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
</context-param>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
com.invariantproperties.sandbox.student.webservice.server.config.RestApplicationContext
com.invariantproperties.sandbox.student.webservice.server.config.RestApplicationContextTest
</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>REST dispatcher</servlet-name>
<servlet-class>com.sun.jersey.spi.spring.container.servlet.SpringServlet</servlet-class>
<init-param>
<param-name>spring.profiles.active</param-name>
<param-value>test</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>REST dispatcher</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>
</web-app>

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    <display-name>Project Student Webservice</display-name>
    
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
    </context-param>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            com.invariantproperties.sandbox.student.webservice.server.config.RestApplicationContext
            com.invariantproperties.sandbox.student.webservice.server.config.RestApplicationContextTest
        </param-value>
    </context-param>

    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>

    <servlet>
        <servlet-name>REST dispatcher</servlet-name>
        <servlet-class>com.sun.jersey.spi.spring.container.servlet.SpringServlet</servlet-class>
        <init-param>
            <param-name>spring.profiles.active</param-name>
            <param-value>test</param-value>
        </init-param>
    </servlet>

    <servlet-mapping>
        <servlet-name>REST dispatcher</servlet-name>
        <url-pattern>/rest/*</url-pattern>
    </servlet-mapping>
</web-app>

Unit Testing

The unit tests are straightforward.

public class CourseResourceTest {
private Course physics = new Course();
private Course mechanics = new Course();
@Before
public void init() {
physics.setId(1);
physics.setName("physics");
physics.setUuid(UUID.randomUUID().toString());
mechanics.setId(1);
mechanics.setName("mechanics");
mechanics.setUuid(UUID.randomUUID().toString());
}
@Test
public void testFindAllCourses() {
final List<Course> expected = Arrays.asList(physics);
final CourseService service = Mockito.mock(CourseService.class);
when(service.findAllCourses()).thenReturn(expected);
final CourseResource resource = new CourseResource(service);
final Response response = resource.findAllCourses();
assertEquals(200, response.getStatus());
final Course[] actual = (Course[]) response.getEntity();
assertEquals(expected.size(), actual.length);
assertNull(actual[0].getId());
assertEquals(expected.get(0).getName(), actual[0].getName());
assertEquals(expected.get(0).getUuid(), actual[0].getUuid());
}
@Test
public void testFindAllCoursesEmpty() {
final List<Course> expected = new ArrayList<>();
final CourseService service = Mockito.mock(CourseService.class);
when(service.findAllCourses()).thenReturn(expected);
final CourseResource resource = new CourseResource(service);
final Response response = resource.findAllCourses();
assertEquals(200, response.getStatus());
final Course[] actual = (Course[]) response.getEntity();
assertEquals(0, actual.length);
}
@Test
public void testFindAllCoursesFailure() {
final CourseService service = Mockito.mock(CourseService.class);
when(service.findAllCourses()).thenThrow(
new UnitTestException();
final CourseResource resource = new CourseResource(service);
final Response response = resource.findAllCourses();
assertEquals(500, response.getStatus());
}
@Test
public void testGetCourse() {
final Course expected = physics;
final CourseService service = Mockito.mock(CourseService.class);
when(service.findCourseByUuid(expected.getUuid())).thenReturn(expected);
final CourseResource resource = new CourseResource(service);
final Response response = resource.getCourse(expected.getUuid());
assertEquals(200, response.getStatus());
final Course actual = (Course) response.getEntity();
assertNull(actual.getId());
assertEquals(expected.getName(), actual.getName());
assertEquals(expected.getUuid(), actual.getUuid());
}
@Test
public void testGetCourseMissing() {
final CourseService service = Mockito.mock(CourseService.class);
when(service.findCourseByUuid(physics.getUuid())).thenThrow(
new ObjectNotFoundException(physics.getUuid()));
final CourseResource resource = new CourseResource(service);
final Response response = resource.getCourse(physics.getUuid());
assertEquals(404, response.getStatus());
}
@Test
public void testGetCourseFailure() {
final CourseService service = Mockito.mock(CourseService.class);
when(service.findCourseByUuid(physics.getUuid())).thenThrow(
new UnitTestException();
final CourseResource resource = new CourseResource(service);
final Response response = resource.getCourse(physics.getUuid());
assertEquals(500, response.getStatus());
}
@Test
public void testCreateCourse() {
final Course expected = physics;
final Name name = new Name();
name.setName(expected.getName());
final CourseService service = Mockito.mock(CourseService.class);
when(service.createCourse(name.getName())).thenReturn(expected);
final CourseResource resource = new CourseResource(service);
final Response response = resource.createCourse(name);
assertEquals(201, response.getStatus());
final Course actual = (Course) response.getEntity();
assertNull(actual.getId());
assertEquals(expected.getName(), actual.getName());
}
@Test
public void testCreateCourseBlankName() {
final Course expected = physics;
final Name name = new Name();
final CourseService service = Mockito.mock(CourseService.class);
final CourseResource resource = new CourseResource(service);
final Response response = resource.createCourse(name);
assertEquals(400, response.getStatus());
}
/**
* Test handling when the course can't be created for some reason. For now
* the service layer just returns a null value - it should throw an
* appropriate exception.
*/
@Test
public void testCreateCourseProblem() {
final Course expected = physics;
final Name name = new Name();
name.setName(expected.getName());
final CourseService service = Mockito.mock(CourseService.class);
when(service.createCourse(name.getName())).thenReturn(null);
final CourseResource resource = new CourseResource(service);
final Response response = resource.createCourse(name);
assertEquals(500, response.getStatus());
}
@Test
public void testCreateCourseFailure() {
final Course expected = physics;
final Name name = new Name();
name.setName(expected.getName());
final CourseService service = Mockito.mock(CourseService.class);
when(service.createCourse(name.getName())).thenThrow(
new UnitTestException();
final CourseResource resource = new CourseResource(service);
final Response response = resource.createCourse(name);
assertEquals(500, response.getStatus());
}
@Test
public void testUpdateCourse() {
final Course expected = physics;
final Name name = new Name();
name.setName(mechanics.getName());
final Course updated = new Course();
updated.setId(expected.getId());
updated.setName(mechanics.getName());
updated.setUuid(expected.getUuid());
final CourseService service = Mockito.mock(CourseService.class);
when(service.findCourseByUuid(expected.getUuid())).thenReturn(expected);
when(service.updateCourse(expected, name.getName()))
.thenReturn(updated);
final CourseResource resource = new CourseResource(service);
final Response response = resource.updateCourse(expected.getUuid(),
name);
assertEquals(200, response.getStatus());
final Course actual = (Course) response.getEntity();
assertNull(actual.getId());
assertEquals(mechanics.getName(), actual.getName());
assertEquals(expected.getUuid(), actual.getUuid());
}
/**
* Test handling when the course can't be updated for some reason. For now
* the service layer just returns a null value - it should throw an
* appropriate exception.
*/
@Test
public void testUpdateCourseProblem() {
final Course expected = physics;
final Name name = new Name();
name.setName(expected.getName());
final CourseService service = Mockito.mock(CourseService.class);
when(service.updateCourse(expected, name.getName())).thenReturn(null);
final CourseResource resource = new CourseResource(service);
final Response response = resource.createCourse(name);
assertEquals(500, response.getStatus());
}
@Test
public void testUpdateCourseFailure() {
final Course expected = physics;
final Name name = new Name();
name.setName(expected.getName());
final CourseService service = Mockito.mock(CourseService.class);
when(service.updateCourse(expected, name.getName())).thenThrow(
new UnitTestException();
final CourseResource resource = new CourseResource(service);
final Response response = resource.createCourse(name);
assertEquals(500, response.getStatus());
}
@Test
public void testDeleteCourse() {
final Course expected = physics;
final CourseService service = Mockito.mock(CourseService.class);
doNothing().when(service).deleteCourse(expected.getUuid());
final CourseResource resource = new CourseResource(service);
final Response response = resource.deleteCourse(expected.getUuid());
assertEquals(204, response.getStatus());
}
@Test
public void testDeleteCourseMissing() {
final Course expected = physics;
final Name name = new Name();
name.setName(expected.getName());
final CourseService service = Mockito.mock(CourseService.class);
doThrow(new ObjectNotFoundException(expected.getUuid())).when(service)
.deleteCourse(expected.getUuid());
final CourseResource resource = new CourseResource(service);
final Response response = resource.deleteCourse(expected.getUuid());
assertEquals(204, response.getStatus());
}
@Test
public void testDeleteCourseFailure() {
final Course expected = physics;
final CourseService service = Mockito.mock(CourseService.class);
doThrow(new UnitTestException()).when(service)
.deleteCourse(expected.getUuid());
final CourseResource resource = new CourseResource(service);
final Response response = resource.deleteCourse(expected.getUuid());
assertEquals(500, response.getStatus());
}
}

public class CourseResourceTest {
    private Course physics = new Course();
    private Course mechanics = new Course();

    @Before
    public void init() {
        physics.setId(1);
        physics.setName("physics");
        physics.setUuid(UUID.randomUUID().toString());

        mechanics.setId(1);
        mechanics.setName("mechanics");
        mechanics.setUuid(UUID.randomUUID().toString());
    }

    @Test
    public void testFindAllCourses() {
        final List<Course> expected = Arrays.asList(physics);

        final CourseService service = Mockito.mock(CourseService.class);
        when(service.findAllCourses()).thenReturn(expected);

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.findAllCourses();

        assertEquals(200, response.getStatus());
        final Course[] actual = (Course[]) response.getEntity();
        assertEquals(expected.size(), actual.length);
        assertNull(actual[0].getId());
        assertEquals(expected.get(0).getName(), actual[0].getName());
        assertEquals(expected.get(0).getUuid(), actual[0].getUuid());
    }

    @Test
    public void testFindAllCoursesEmpty() {
        final List<Course> expected = new ArrayList<>();

        final CourseService service = Mockito.mock(CourseService.class);
        when(service.findAllCourses()).thenReturn(expected);

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.findAllCourses();

        assertEquals(200, response.getStatus());
        final Course[] actual = (Course[]) response.getEntity();
        assertEquals(0, actual.length);
    }

    @Test
    public void testFindAllCoursesFailure() {
        final CourseService service = Mockito.mock(CourseService.class);
        when(service.findAllCourses()).thenThrow(
                new UnitTestException();

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.findAllCourses();

        assertEquals(500, response.getStatus());
    }

    @Test
    public void testGetCourse() {
        final Course expected = physics;

        final CourseService service = Mockito.mock(CourseService.class);
        when(service.findCourseByUuid(expected.getUuid())).thenReturn(expected);

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.getCourse(expected.getUuid());

        assertEquals(200, response.getStatus());
        final Course actual = (Course) response.getEntity();
        assertNull(actual.getId());
        assertEquals(expected.getName(), actual.getName());
        assertEquals(expected.getUuid(), actual.getUuid());
    }

    @Test
    public void testGetCourseMissing() {
        final CourseService service = Mockito.mock(CourseService.class);
        when(service.findCourseByUuid(physics.getUuid())).thenThrow(
                new ObjectNotFoundException(physics.getUuid()));

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.getCourse(physics.getUuid());

        assertEquals(404, response.getStatus());
    }

    @Test
    public void testGetCourseFailure() {
        final CourseService service = Mockito.mock(CourseService.class);
        when(service.findCourseByUuid(physics.getUuid())).thenThrow(
                new UnitTestException();

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.getCourse(physics.getUuid());

        assertEquals(500, response.getStatus());
    }

    @Test
    public void testCreateCourse() {
        final Course expected = physics;
        final Name name = new Name();
        name.setName(expected.getName());

        final CourseService service = Mockito.mock(CourseService.class);
        when(service.createCourse(name.getName())).thenReturn(expected);

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.createCourse(name);

        assertEquals(201, response.getStatus());
        final Course actual = (Course) response.getEntity();
        assertNull(actual.getId());
        assertEquals(expected.getName(), actual.getName());
    }

    @Test
    public void testCreateCourseBlankName() {
        final Course expected = physics;
        final Name name = new Name();

        final CourseService service = Mockito.mock(CourseService.class);

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.createCourse(name);

        assertEquals(400, response.getStatus());
    }

    /**
     * Test handling when the course can't be created for some reason. For now
     * the service layer just returns a null value - it should throw an
     * appropriate exception.
     */
    @Test
    public void testCreateCourseProblem() {
        final Course expected = physics;
        final Name name = new Name();
        name.setName(expected.getName());

        final CourseService service = Mockito.mock(CourseService.class);
        when(service.createCourse(name.getName())).thenReturn(null);

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.createCourse(name);

        assertEquals(500, response.getStatus());
    }

    @Test
    public void testCreateCourseFailure() {
        final Course expected = physics;
        final Name name = new Name();
        name.setName(expected.getName());

        final CourseService service = Mockito.mock(CourseService.class);
        when(service.createCourse(name.getName())).thenThrow(
                new UnitTestException();

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.createCourse(name);

        assertEquals(500, response.getStatus());
    }

    @Test
    public void testUpdateCourse() {
        final Course expected = physics;
        final Name name = new Name();
        name.setName(mechanics.getName());
        final Course updated = new Course();
        updated.setId(expected.getId());
        updated.setName(mechanics.getName());
        updated.setUuid(expected.getUuid());

        final CourseService service = Mockito.mock(CourseService.class);
        when(service.findCourseByUuid(expected.getUuid())).thenReturn(expected);
        when(service.updateCourse(expected, name.getName()))
                .thenReturn(updated);

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.updateCourse(expected.getUuid(),
                name);

        assertEquals(200, response.getStatus());
        final Course actual = (Course) response.getEntity();
        assertNull(actual.getId());
        assertEquals(mechanics.getName(), actual.getName());
        assertEquals(expected.getUuid(), actual.getUuid());
    }

    /**
     * Test handling when the course can't be updated for some reason. For now
     * the service layer just returns a null value - it should throw an
     * appropriate exception.
     */
    @Test
    public void testUpdateCourseProblem() {
        final Course expected = physics;
        final Name name = new Name();
        name.setName(expected.getName());

        final CourseService service = Mockito.mock(CourseService.class);
        when(service.updateCourse(expected, name.getName())).thenReturn(null);

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.createCourse(name);

        assertEquals(500, response.getStatus());
    }

    @Test
    public void testUpdateCourseFailure() {
        final Course expected = physics;
        final Name name = new Name();
        name.setName(expected.getName());

        final CourseService service = Mockito.mock(CourseService.class);
        when(service.updateCourse(expected, name.getName())).thenThrow(
                new UnitTestException();

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.createCourse(name);

        assertEquals(500, response.getStatus());
    }

    @Test
    public void testDeleteCourse() {
        final Course expected = physics;

        final CourseService service = Mockito.mock(CourseService.class);
        doNothing().when(service).deleteCourse(expected.getUuid());

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.deleteCourse(expected.getUuid());

        assertEquals(204, response.getStatus());
    }

    @Test
    public void testDeleteCourseMissing() {
        final Course expected = physics;
        final Name name = new Name();
        name.setName(expected.getName());

        final CourseService service = Mockito.mock(CourseService.class);
        doThrow(new ObjectNotFoundException(expected.getUuid())).when(service)
                .deleteCourse(expected.getUuid());

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.deleteCourse(expected.getUuid());

        assertEquals(204, response.getStatus());
    }

    @Test
    public void testDeleteCourseFailure() {
        final Course expected = physics;

        final CourseService service = Mockito.mock(CourseService.class);
        doThrow(new UnitTestException()).when(service)
                .deleteCourse(expected.getUuid());

        final CourseResource resource = new CourseResource(service);
        final Response response = resource.deleteCourse(expected.getUuid());

        assertEquals(500, response.getStatus());
    }
}

Integration Testing

Question: should REST server integration tests use a live database?

Answer: it’s a trick question. We need both.

The overall architecture has three maven modules. We covered student-ws-client earlier and we’re covering student-ws-server today. Each creates a .jar file. There’s a third module – student-ws-webapp – that creates the actual .war file. The integration tests for the student-ws-server module should use a dummied service layer while the integration tests for the student-ws-webapp module uses the full stack.

We start with the integration tests that mirror the unit tests in the client module.

public class CourseRestServerIntegrationTest {
CourseRestClient client = new CourseRestClientImpl(
"http://localhost:8080/rest/course/");
@Test
public void testGetAll() throws IOException {
Course[] courses = client.getAllCourses();
assertNotNull(courses);
}
@Test(expected = ObjectNotFoundException.class)
public void testUnknownCourse() throws IOException {
client.getCourse("missing");
}
@Test
public void testLifecycle() throws IOException {
final String physicsName = "Physics 201";
final Course expected = client.createCourse(physicsName);
assertEquals(physicsName, expected.getName());
final Course actual1 = client.getCourse(expected.getUuid());
assertEquals(physicsName, actual1.getName());
final Course[] courses = client.getAllCourses();
assertTrue(courses.length > 0);
final String mechanicsName = "Newtonian Mechanics 201";
final Course actual2 = client.updateCourse(actual1.getUuid(),
mechanicsName);
assertEquals(mechanicsName, actual2.getName());
client.deleteCourse(actual1.getUuid());
try {
client.getCourse(expected.getUuid());
fail("should have thrown exception");
} catch (ObjectNotFoundException e) {
// do nothing
}
}
}

public class CourseRestServerIntegrationTest {

    CourseRestClient client = new CourseRestClientImpl(
            "http://localhost:8080/rest/course/");

    @Test
    public void testGetAll() throws IOException {
        Course[] courses = client.getAllCourses();
        assertNotNull(courses);
    }

    @Test(expected = ObjectNotFoundException.class)
    public void testUnknownCourse() throws IOException {
        client.getCourse("missing");
    }

    @Test
    public void testLifecycle() throws IOException {
        final String physicsName = "Physics 201";
        final Course expected = client.createCourse(physicsName);
        assertEquals(physicsName, expected.getName());

        final Course actual1 = client.getCourse(expected.getUuid());
        assertEquals(physicsName, actual1.getName());

        final Course[] courses = client.getAllCourses();
        assertTrue(courses.length > 0);

        final String mechanicsName = "Newtonian Mechanics 201";
        final Course actual2 = client.updateCourse(actual1.getUuid(),
                mechanicsName);
        assertEquals(mechanicsName, actual2.getName());

        client.deleteCourse(actual1.getUuid());
        try {
            client.getCourse(expected.getUuid());
            fail("should have thrown exception");
        } catch (ObjectNotFoundException e) {
            // do nothing
        }
    }
}

We also need a dummy service class that implements just enough functionality to support our integration tests.

public class DummyCourseService implements CourseService {
private Map cache = Collections.synchronizedMap(new HashMap<String, Course>());
public List<Course> findAllCourses() {
return new ArrayList(cache.values());
}
public Course findCourseById(Integer id) {
throw new ObjectNotFoundException(null);
}
public Course findCourseByUuid(String uuid) {
if (!cache.containsKey(uuid)) {
throw new ObjectNotFoundException(uuid);
}
return cache.get(uuid);
}
public Course createCourse(String name) {
Course course = new Course();
course.setUuid(UUID.randomUUID().toString());
course.setName(name);
cache.put(course.getUuid(), course);
return course;
}
public Course updateCourse(Course oldCourse, String name) {
if (!cache.containsKey(oldCourse.getUuid())) {
throw new ObjectNotFoundException(oldCourse.getUuid());
}
Course course = cache.get(oldCourse.getUuid());
course.setUuid(UUID.randomUUID().toString());
course.setName(name);
return course;
}
public void deleteCourse(String uuid) {
if (cache.containsKey(uuid)) {
cache.remove(uuid);
}
}
}

public class DummyCourseService implements CourseService {
    private Map cache = Collections.synchronizedMap(new HashMap<String, Course>());

    public List<Course> findAllCourses() {
        return new ArrayList(cache.values());
    }

    public Course findCourseById(Integer id) {
        throw new ObjectNotFoundException(null);    	
    }

    public Course findCourseByUuid(String uuid) {
        if (!cache.containsKey(uuid)) {
            throw new ObjectNotFoundException(uuid);    	
        }
        return cache.get(uuid);
    }

    public Course createCourse(String name) {
        Course course = new Course();
        course.setUuid(UUID.randomUUID().toString());
        course.setName(name);
        cache.put(course.getUuid(), course);
        return course;
    }

    public Course updateCourse(Course oldCourse, String name) {
        if (!cache.containsKey(oldCourse.getUuid())) {
            throw new ObjectNotFoundException(oldCourse.getUuid());    	    		
        }
    	
        Course course = cache.get(oldCourse.getUuid());
        course.setUuid(UUID.randomUUID().toString());
        course.setName(name);
        return course;    	
    }

    public void deleteCourse(String uuid) {
        if (cache.containsKey(uuid)) {
            cache.remove(uuid);
        }
    }
}

pom.xml

The pom.xml file should include a plugin to run an embedded jetty or tomcat server. Advanced users can spin up and tear down the embedded server as part of the integration test – see the update.

<build>
<plugins>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>maven-jetty-plugin</artifactId>
<version>6.1.16</version>
<configuration>
<requestLog implementation="org.mortbay.jetty.NCSARequestLog">
<!-- This doesn't do anything for Jetty, but is a workaround for a
Maven bug that prevents the requestLog from being set. -->
<append>true</append>
</requestLog>
<webAppConfig>
<contextPath>/</contextPath>
<extraClasspath>${basedir}/target/test-classes/</extraClasspath>
</webAppConfig>
</configuration>
</plugin>
</plugins>
</build>

<build>
    <plugins>

        <!-- Run the application using "mvn jetty:run" -->
        <plugin>
            <groupId>org.mortbay.jetty</groupId>
            <artifactId>maven-jetty-plugin</artifactId>
            <version>6.1.16</version> <!-- ancient! -->
            <configuration>
                <!-- Log to the console. -->
                <requestLog implementation="org.mortbay.jetty.NCSARequestLog">
                    <!-- This doesn't do anything for Jetty, but is a workaround for a 
                        Maven bug that prevents the requestLog from being set. -->
                    <append>true</append>
                </requestLog>
                <webAppConfig>
                    <contextPath>/</contextPath>
                    <extraClasspath>${basedir}/target/test-classes/</extraClasspath>
                </webAppConfig>
            </configuration>
        </plugin>
    </plugins>
</build>

Update

After a bit more research I have the configuration to setup and teardown a jetty server during integration tests. This configuration uses non-standard ports so we can run it without having to shut down another jetty or tomcat instance running at the same time.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<build>
<plugins>
<plugin>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<version>9.1.0.v20131115</version>
<configuration>
<webApp>
<extraClasspath>${basedir}/target/test-classes/</extraClasspath>
</webApp>
<scanIntervalSeconds>10</scanIntervalSeconds>
<stopPort>18005</stopPort>
<stopKey>STOP</stopKey>
<systemProperties>
<systemProperty>
<name>jetty.port</name>
<value>18080</value>
</systemProperty>
</systemProperties>
</configuration>
<executions>
<execution>
<id>start-jetty</id>
<phase>pre-integration-test</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<scanIntervalSeconds>0</scanIntervalSeconds>
<daemon>true</daemon>
</configuration>
</execution>
<execution>
<id>stop-jetty</id>
<phase>post-integration-test</phase>
<goals>
<goal>stop</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <build>
        <plugins>

            <!-- Run the application using "mvn jetty:run" -->
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.1.0.v20131115</version>
                <configuration>
                    <webApp>
                        <extraClasspath>${basedir}/target/test-classes/</extraClasspath>
                    </webApp>
                    <scanIntervalSeconds>10</scanIntervalSeconds>
                    <stopPort>18005</stopPort>
                    <stopKey>STOP</stopKey>
                    <systemProperties>
                       <systemProperty>
                           <name>jetty.port</name>
                           <value>18080</value>
                       </systemProperty>
                    </systemProperties>
                </configuration>
                <executions>
                    <execution>
                        <id>start-jetty</id>
                        <phase>pre-integration-test</phase>
                        <goals>
                            <goal>run</goal>
                        </goals>
                        <configuration>
                            <scanIntervalSeconds>0</scanIntervalSeconds>
                            <daemon>true</daemon>
                        </configuration>
                    </execution>
                    <execution>
                        <id>stop-jetty</id>
                        <phase>post-integration-test</phase>
                        <goals>
                            <goal>stop</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Source Code

The source code is at https://github.com/beargiles/project-student [github] and http://beargiles.github.io/project-student/ [github pages].

Comments: No Comments »
Categories: java
Comments rss
Trackback

Project Student: Webservice Client with Jersey

Bear Giles | December 16, 2013

This is part of Project Student. Other posts are Webservice Client with Jersey, Business Layer and Persistence with Spring Data.

The first layer of the RESTful webapp onion is the webservice client. It can be used to mimic web pages containing AJAX content or by programmatic users of the webapp. N.B., the latter might include other webapps, e.g., if you have an internal RESTful server surrounded by a number of presentation servers that create conventional web pages.

Design Decisions

Jersey – I use the Jersey library for the REST calls. I considered several choices but decided to go with Jersey since it’s lightweight and won’t impose many restrictions on the developer. In contrast using a Spring library, for instance, could cause problems in an EJB3 environment in addition to pulling in additional libraries.

UUIDs – the database will use integer primary keys but the web service will use UUIDs to identify values. This is for security – if an attacker knows that account ID 1008 exists then it’s a fairly safe bet that account ID 1007 exists. More importantly user ID 0 probably exists and has additional privileges than the typical user.

This isn’t true with UUIDs – for the most part knowing one UUID gives no insight into other UUIDs. That’s not 100% accurate – some UUIDs are composed with IP addresses or timestamps so the universe of possible values can be dramatically reduced by a knowledgeable attacker – but a random UUID is “good enough” for now.

Limitations

I am taking a “implement the least functionality required” approach so the initial implementation has a number of limitations.

Authentication – there is no attempt made to provide authentication information.

Encryption – there is no attempt made to encrypt the webservice call.

Only CRUD methods – only basic CRUD methods are supported.

Remember – limitations are fine but they must be clearly documented. In the best of worlds they’ll be added to an agile backlog.

Client API

The client API is basic CRUD. We can add functionality later.

public interface CourseRestClient {
/**
* Get list of all courses.
*/
Course[] getAllCourses();
/**
* Get details for specific course.
* @param uuid
*/
Course getCourse(String uuid);
/**
* Create specific course.
* @param name
*/
Course createCourse(String name);
/**
* Update specific course.
* @param uuid
* @param name
*/
Course updateCourse(String uuid, String name);
/**
* Delete course.
* @param uuid
*/
void deleteCourse(String uuid);
}

public interface CourseRestClient {

    /**
     * Get list of all courses.
     */
    Course[] getAllCourses();

    /**
     * Get details for specific course.
     * @param uuid
     */
    Course getCourse(String uuid);

    /**
     * Create specific course.
     * @param name
     */
    Course createCourse(String name);

    /**
     * Update specific course.
     * @param uuid
     * @param name
     */
    Course updateCourse(String uuid, String name);

    /**
     * Delete course.
     * @param uuid
     */
    void deleteCourse(String uuid);
}

Exceptions

The API includes three runtime exceptions. The first, RestClientException, is an abstract runtime exception that is the base class for all other exceptions.

An ObjectNotFoundException is thrown when an expected value is missing. (Implementation note: this is triggered by a 404 status code.) This exception contains enough information to uniquely identify the expected object.

public class ObjectNotFoundException extends RestClientException {
private static final long serialVersionUID = 1L;
private final String resource;
private final Class<? extends PersistentObject> objectClass;
private final String uuid;
public ObjectNotFoundException(final String resource,
final Class<? extends PersistentObject> objectClass,
final String uuid) {
super("object not found: " + resource + "[" + uuid + "]");
this.resource = resource;
this.objectClass = objectClass;
this.uuid = uuid;
}
public String getResource() {
return resource;
}
public Class<? extends PersistentObject> getObjectClass() {
return objectClass;
}
public String getUuid() {
return uuid;
}
}

public class ObjectNotFoundException extends RestClientException {
    private static final long serialVersionUID = 1L;

    private final String resource;
    private final Class<? extends PersistentObject> objectClass;
    private final String uuid;

    public ObjectNotFoundException(final String resource,
            final Class<? extends PersistentObject> objectClass,
            final String uuid) {
        super("object not found: " + resource + "[" + uuid + "]");
        this.resource = resource;
        this.objectClass = objectClass;
        this.uuid = uuid;
    }

    public String getResource() {
        return resource;
    }

    public Class<? extends PersistentObject> getObjectClass() {
        return objectClass;
    }

    public String getUuid() {
        return uuid;
    }
}

A RestClientFailureException is a generic handler for unexpected or unhandled status codes.

public class RestClientFailureException extends RestClientException {
private static final long serialVersionUID = 1L;
private final String resource;
private final Class<? extends PersistentObject> objectClass;
private final String uuid;
private final int statusCode;
/**
* Constructor
*
* @param resource
* @param objectClass
* @param uuid
* @param response
*/
public RestClientFailureException(final String resource,
final Class<? extends PersistentObject> objectClass,
final String uuid, final ClientResponse response) {
super("rest client received error: " + resource + "[" + uuid + "]");
this.resource = resource;
this.objectClass = objectClass;
this.uuid = uuid;
this.statusCode = response.getStatus();
}
public String getResource() {
return resource;
}
public Class<? extends PersistentObject> getObjectClass() {
return objectClass;
}
/**
* Get UUID, "<none>" (during listAllX()) or "(name)" (during createX())
*
* @return
*/
public String getUuid() {
return uuid;
}
/**
* Get standard HTTP status code.
*
* @return
*/
public int getStatusCode() {
return statusCode;
}
}

public class RestClientFailureException extends RestClientException {
    private static final long serialVersionUID = 1L;

    private final String resource;
    private final Class<? extends PersistentObject> objectClass;
    private final String uuid;
    private final int statusCode;

    /**
     * Constructor
     * 
     * @param resource
     * @param objectClass
     * @param uuid
     * @param response
     */
    public RestClientFailureException(final String resource,
            final Class<? extends PersistentObject> objectClass,
            final String uuid, final ClientResponse response) {
        super("rest client received error: " + resource + "[" + uuid + "]");
        this.resource = resource;
        this.objectClass = objectClass;
        this.uuid = uuid;
        this.statusCode = response.getStatus();
    }

    public String getResource() {
        return resource;
    }

    public Class<? extends PersistentObject> getObjectClass() {
        return objectClass;
    }

    /**
     * Get UUID, "<none>" (during listAllX()) or "(name)" (during createX())
     * 
     * @return
     */
    public String getUuid() {
        return uuid;
    }

    /**
     * Get standard HTTP status code.
     * 
     * @return
     */
    public int getStatusCode() {
        return statusCode;
    }
}

We’ll want to add an UnauthorizedOperationException after we add client authentication.

Client Implementation

Basic CRUD implementations are typically boilerplate so we can use an abstract class to do most of the heavy lifting. More advanced functionality will probably require this class to make Jersey calls directly.

/**
* This is the Course-specific implementation.
*/
public class CourseRestClientImpl extends AbstractRestClientImpl<Course>
implements CourseRestClient {
private static final Course[] EMPTY_COURSE_ARRAY = new Course[0];
/**
* Constructor.
*
* @param courseResource
*/
public CourseRestClientImpl(final String resource) {
super(resource, Course.class, Course[].class);
}
/**
* Create JSON string.
*
* @param name
* @return
*/
String createJson(final String name) {
return String.format("{ \"name\": \"%s\" }", name);
}
/**
* @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#getAllCourses()
*/
public Course[] getAllCourses() {
return super.getAllObjects(EMPTY_COURSE_ARRAY);
}
/**
* @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#getCourse(java.lang.String)
*/
public Course getCourse(final String uuid) {
return super.getObject(uuid);
}
/**
* @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#createCourse(java.lang.String)
*/
public Course createCourse(final String name) {
if (name == null || name.isEmpty()) {
throw new IllegalArgumentException("'name' is required");
}
return createObject(createJson(name));
}
/**
* @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#updateCourse(java.lang.String,
* java.lang.String)
*/
public Course updateCourse(final String uuid, final String name) {
if (name == null || name.isEmpty()) {
throw new IllegalArgumentException("'name' is required");
}
return super.updateObject(createJson(name), uuid);
}
/**
* @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#deleteCourse(java.lang.String)
*/
public void deleteCourse(final String uuid) {
super.deleteObject(uuid);
}
}

/**
 * This is the Course-specific implementation.
 */
public class CourseRestClientImpl extends AbstractRestClientImpl<Course>
        implements CourseRestClient {
    private static final Course[] EMPTY_COURSE_ARRAY = new Course[0];

    /**
     * Constructor.
     * 
     * @param courseResource
     */
    public CourseRestClientImpl(final String resource) {
        super(resource, Course.class, Course[].class);
    }

    /**
     * Create JSON string.
     * 
     * @param name
     * @return
     */
    String createJson(final String name) {
        return String.format("{ \"name\": \"%s\" }", name);
    }

    /**
     * @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#getAllCourses()
     */
    public Course[] getAllCourses() {
        return super.getAllObjects(EMPTY_COURSE_ARRAY);
    }

    /**
     * @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#getCourse(java.lang.String)
     */
    public Course getCourse(final String uuid) {
        return super.getObject(uuid);
    }

    /**
     * @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#createCourse(java.lang.String)
     */
    public Course createCourse(final String name) {
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("'name' is required");
        }

        return createObject(createJson(name));
    }

    /**
     * @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#updateCourse(java.lang.String,
     *      java.lang.String)
     */
    public Course updateCourse(final String uuid, final String name) {
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("'name' is required");
        }

        return super.updateObject(createJson(name), uuid);
    }

    /**
     * @see com.invariantproperties.sandbox.student.webservice.client.CourseRestClient#deleteCourse(java.lang.String)
     */
    public void deleteCourse(final String uuid) {
        super.deleteObject(uuid);
    }
}

The abstract base class does the heavy lifting.

public class AbstractRestClientImpl<T extends PersistentObject> {
private final String resource;
private final Class<T> objectClass;
private final Class<T[]> objectArrayClass;
/**
* Constructor.
*
* @param resource
*/
public AbstractRestClientImpl(final String resource,
final Class<T> objectClass, final Class<T[]> objectArrayClass) {
this.resource = resource;
this.objectClass = objectClass;
this.objectArrayClass = objectArrayClass;
}
/**
* Helper method for testing.
*
* @return
*/
Client createClient() {
return Client.create();
}
/**
* List all objects. This is a risky method since there's no attempt at
* pagination.
*/
public T[] getAllObjects(final T[] emptyListClass) {
final Client client = createClient();
try {
final WebResource webResource = client.resource(resource);
final ClientResponse response = webResource.accept(
MediaType.APPLICATION_JSON).get(ClientResponse.class);
if (response.getStatus() == Response.Status.OK.getStatusCode()) {
T[] entities = response.getEntity(objectArrayClass);
return entities;
} else {
throw new RestClientFailureException(resource, objectClass,
"<none>", response);
}
} finally {
client.destroy();
}
}
/**
* Get a specific object.
*/
public T getObject(String uuid) {
final Client client = createClient();
try {
final WebResource webResource = client.resource(resource + uuid);
final ClientResponse response = webResource.accept(
MediaType.APPLICATION_JSON).get(ClientResponse.class);
if (response.getStatus() == Response.Status.OK.getStatusCode()) {
final T entity = response.getEntity(objectClass);
return entity;
} else if (response.getStatus() == Response.Status.NOT_FOUND
.getStatusCode()) {
throw new ObjectNotFoundException(resource, objectClass, uuid);
} else {
throw new RestClientFailureException(resource, objectClass,
uuid, response);
}
} finally {
client.destroy();
}
}
/**
* Create an object with the specified values.
*/
public T createObject(final String json) {
final Client client = createClient();
try {
final WebResource webResource = client.resource(resource);
final ClientResponse response = webResource
.type(MediaType.APPLICATION_JSON)
.accept(MediaType.APPLICATION_JSON)
.post(ClientResponse.class, json);
if (response.getStatus() == Response.Status.CREATED.getStatusCode()) {
final T entity = response.getEntity(objectClass);
return entity;
} else {
throw new RestClientFailureException(resource, objectClass, "("
+ json + ")", response);
}
} finally {
client.destroy();
}
}
/**
* Update an object with the specified json.
*/
public T updateObject(final String json, final String uuid) {
final Client client = createClient();
try {
final WebResource webResource = client.resource(resource + uuid);
final ClientResponse response = webResource
.type(MediaType.APPLICATION_JSON)
.accept(MediaType.APPLICATION_JSON)
.post(ClientResponse.class, json);
if (response.getStatus() == Response.Status.OK.getStatusCode()) {
final T entity = response.getEntity(objectClass);
return entity;
} else if (response.getStatus() == Response.Status.NOT_FOUND
.getStatusCode()) {
throw new ObjectNotFoundException(resource, objectClass, uuid);
} else {
throw new RestClientFailureException(resource, objectClass,
uuid, response);
}
} finally {
client.destroy();
}
}
/**
* Delete specified object.
*/
public void deleteObject(String uuid) {
final Client client = createClient();
try {
final WebResource webResource = client.resource(resource + uuid);
final ClientResponse response = webResource.accept(
MediaType.APPLICATION_JSON).delete(ClientResponse.class);
if (response.getStatus() == Response.Status.GONE.getStatusCode()) {
// do nothing
} else if (response.getStatus() == Response.Status.NOT_FOUND
.getStatusCode()) {
// do nothing - delete is idempotent
} else {
throw new RestClientFailureException(resource, objectClass,
uuid, response);
}
} finally {
client.destroy();
}
}
}

public class AbstractRestClientImpl<T extends PersistentObject> {
    private final String resource;
    private final Class<T> objectClass;
    private final Class<T[]> objectArrayClass;

    /**
     * Constructor.
     * 
     * @param resource
     */
    public AbstractRestClientImpl(final String resource,
            final Class<T> objectClass, final Class<T[]> objectArrayClass) {
        this.resource = resource;
        this.objectClass = objectClass;
        this.objectArrayClass = objectArrayClass;
    }

    /**
     * Helper method for testing.
     * 
     * @return
     */
    Client createClient() {
        return Client.create();
    }

    /**
     * List all objects. This is a risky method since there's no attempt at
     * pagination.
     */
    public T[] getAllObjects(final T[] emptyListClass) {
        final Client client = createClient();

        try {
            final WebResource webResource = client.resource(resource);
            final ClientResponse response = webResource.accept(
                    MediaType.APPLICATION_JSON).get(ClientResponse.class);

            if (response.getStatus() == Response.Status.OK.getStatusCode()) {
                T[] entities = response.getEntity(objectArrayClass);
                return entities;
            } else {
                throw new RestClientFailureException(resource, objectClass,
                        "<none>", response);
            }
        } finally {
            client.destroy();
        }
    }

    /**
     * Get a specific object.
     */
    public T getObject(String uuid) {
        final Client client = createClient();

        try {
            final WebResource webResource = client.resource(resource + uuid);
            final ClientResponse response = webResource.accept(
                    MediaType.APPLICATION_JSON).get(ClientResponse.class);

            if (response.getStatus() == Response.Status.OK.getStatusCode()) {
                final T entity = response.getEntity(objectClass);
                return entity;
            } else if (response.getStatus() == Response.Status.NOT_FOUND
                    .getStatusCode()) {
                throw new ObjectNotFoundException(resource, objectClass, uuid);
            } else {
                throw new RestClientFailureException(resource, objectClass,
                        uuid, response);
            }
        } finally {
            client.destroy();
        }
    }

    /**
     * Create an object with the specified values.
     */
    public T createObject(final String json) {
        final Client client = createClient();

        try {
            final WebResource webResource = client.resource(resource);
            final ClientResponse response = webResource
                    .type(MediaType.APPLICATION_JSON)
                    .accept(MediaType.APPLICATION_JSON)
                    .post(ClientResponse.class, json);

            if (response.getStatus() == Response.Status.CREATED.getStatusCode()) {
                final T entity = response.getEntity(objectClass);
                return entity;
            } else {
                throw new RestClientFailureException(resource, objectClass, "("
                        + json + ")", response);
            }
        } finally {
            client.destroy();
        }
    }

    /**
     * Update an object with the specified json.
     */
    public T updateObject(final String json, final String uuid) {
        final Client client = createClient();

        try {
            final WebResource webResource = client.resource(resource + uuid);
            final ClientResponse response = webResource
                    .type(MediaType.APPLICATION_JSON)
                    .accept(MediaType.APPLICATION_JSON)
                    .post(ClientResponse.class, json);

            if (response.getStatus() == Response.Status.OK.getStatusCode()) {
                final T entity = response.getEntity(objectClass);
                return entity;
            } else if (response.getStatus() == Response.Status.NOT_FOUND
                    .getStatusCode()) {
                throw new ObjectNotFoundException(resource, objectClass, uuid);
            } else {
                throw new RestClientFailureException(resource, objectClass,
                        uuid, response);
            }
        } finally {
            client.destroy();
        }
    }

    /**
     * Delete specified object.
     */
    public void deleteObject(String uuid) {
        final Client client = createClient();

        try {
            final WebResource webResource = client.resource(resource + uuid);
            final ClientResponse response = webResource.accept(
                    MediaType.APPLICATION_JSON).delete(ClientResponse.class);

            if (response.getStatus() == Response.Status.GONE.getStatusCode()) {
                // do nothing
            } else if (response.getStatus() == Response.Status.NOT_FOUND
                    .getStatusCode()) {
                // do nothing - delete is idempotent
            } else {
                throw new RestClientFailureException(resource, objectClass,
                        uuid, response);
            }
        } finally {
            client.destroy();
        }
    }
}

Unit Testing

We now come to our test code. Important: we want to test our code’s behavior and not its implementation.

public class CourseRestClientImplTest {
private static final String UUID = "uuid";
private static final String NAME = "name";
@Test
public void testGetAllCoursesEmpty() {
CourseRestClient client = new CourseRestClientMock(200, new Course[0]);
Course[] results = client.getAllCourses();
assertEquals(0, results.length);
}
@Test
public void testGetAllCoursesNonEmpty() {
Course course = new Course();
course.setUuid(UUID);
CourseRestClient client = new CourseRestClientMock(200,
new Course[] { course });
Course[] results = client.getAllCourses();
assertEquals(1, results.length);
}
@Test(expected = RestClientFailureException.class)
public void testGetAllCoursesError() {
CourseRestClient client = new CourseRestClientMock(500, null);
client.getAllCourses();
}
@Test
public void testGetCourse() {
Course course = new Course();
course.setUuid(UUID);
CourseRestClient client = new CourseRestClientMock(200, course);
Course results = client.getCourse(course.getUuid());
assertEquals(course.getUuid(), results.getUuid());
}
@Test(expected = ObjectNotFoundException.class)
public void testGetCourseMissing() {
CourseRestClient client = new CourseRestClientMock(404, null);
client.getCourse(UUID);
}
@Test(expected = RestClientFailureException.class)
public void testGetCourseError() {
CourseRestClient client = new CourseRestClientMock(500, null);
client.getCourse(UUID);
}
@Test
public void testCreateCourse() {
Course course = new Course();
course.setName(NAME);
CourseRestClient client = new CourseRestClientMock(
Response.Status.CREATED.getStatusCode(), course);
Course results = client.createCourse(course.getName());
assertEquals(course.getName(), results.getName());
}
@Test(expected = RestClientFailureException.class)
public void testCreateCourseError() {
CourseRestClient client = new CourseRestClientMock(500, null);
client.createCourse(UUID);
}
@Test
public void testUpdateCourse() {
Course course = new Course();
course.setUuid(UUID);
course.setName(NAME);
CourseRestClient client = new CourseRestClientMock(200, course);
Course results = client
.updateCourse(course.getUuid(), course.getName());
assertEquals(course.getUuid(), results.getUuid());
assertEquals(course.getName(), results.getName());
}
@Test(expected = ObjectNotFoundException.class)
public void testUpdateCourseMissing() {
CourseRestClient client = new CourseRestClientMock(404, null);
client.updateCourse(UUID, NAME);
}
@Test(expected = RestClientFailureException.class)
public void testUpdateCourseError() {
CourseRestClient client = new CourseRestClientMock(500, null);
client.updateCourse(UUID, NAME);
}
@Test
public void testDeleteCourse() {
Course course = new Course();
course.setUuid(UUID);
CourseRestClient client = new CourseRestClientMock(
Response.Status.GONE.getStatusCode(), null);
client.deleteCourse(course.getUuid());
}
@Test
public void testDeleteCourseMissing() {
CourseRestClient client = new CourseRestClientMock(404, null);
client.deleteCourse(UUID);
}
@Test(expected = RestClientFailureException.class)
public void testDeleteCourseError() {
CourseRestClient client = new CourseRestClientMock(500, null);
client.deleteCourse(UUID);
}
}

public class CourseRestClientImplTest {
    private static final String UUID = "uuid";
    private static final String NAME = "name";

    @Test
    public void testGetAllCoursesEmpty() {
        CourseRestClient client = new CourseRestClientMock(200, new Course[0]);
        Course[] results = client.getAllCourses();
        assertEquals(0, results.length);
    }

    @Test
    public void testGetAllCoursesNonEmpty() {
        Course course = new Course();
        course.setUuid(UUID);
        CourseRestClient client = new CourseRestClientMock(200,
                new Course[] { course });
        Course[] results = client.getAllCourses();
        assertEquals(1, results.length);
    }

    @Test(expected = RestClientFailureException.class)
    public void testGetAllCoursesError() {
        CourseRestClient client = new CourseRestClientMock(500, null);
        client.getAllCourses();
    }

    @Test
    public void testGetCourse() {
        Course course = new Course();
        course.setUuid(UUID);
        CourseRestClient client = new CourseRestClientMock(200, course);
        Course results = client.getCourse(course.getUuid());
        assertEquals(course.getUuid(), results.getUuid());
    }

    @Test(expected = ObjectNotFoundException.class)
    public void testGetCourseMissing() {
        CourseRestClient client = new CourseRestClientMock(404, null);
        client.getCourse(UUID);
    }

    @Test(expected = RestClientFailureException.class)
    public void testGetCourseError() {
        CourseRestClient client = new CourseRestClientMock(500, null);
        client.getCourse(UUID);
    }

    @Test
    public void testCreateCourse() {
        Course course = new Course();
        course.setName(NAME);
        CourseRestClient client = new CourseRestClientMock(
                Response.Status.CREATED.getStatusCode(), course);
        Course results = client.createCourse(course.getName());
        assertEquals(course.getName(), results.getName());
    }

    @Test(expected = RestClientFailureException.class)
    public void testCreateCourseError() {
        CourseRestClient client = new CourseRestClientMock(500, null);
        client.createCourse(UUID);
    }

    @Test
    public void testUpdateCourse() {
        Course course = new Course();
        course.setUuid(UUID);
        course.setName(NAME);
        CourseRestClient client = new CourseRestClientMock(200, course);
        Course results = client
                .updateCourse(course.getUuid(), course.getName());
        assertEquals(course.getUuid(), results.getUuid());
        assertEquals(course.getName(), results.getName());
    }

    @Test(expected = ObjectNotFoundException.class)
    public void testUpdateCourseMissing() {
        CourseRestClient client = new CourseRestClientMock(404, null);
        client.updateCourse(UUID, NAME);
    }

    @Test(expected = RestClientFailureException.class)
    public void testUpdateCourseError() {
        CourseRestClient client = new CourseRestClientMock(500, null);
        client.updateCourse(UUID, NAME);
    }

    @Test
    public void testDeleteCourse() {
        Course course = new Course();
        course.setUuid(UUID);
        CourseRestClient client = new CourseRestClientMock(
                Response.Status.GONE.getStatusCode(), null);
        client.deleteCourse(course.getUuid());
    }

    @Test
    public void testDeleteCourseMissing() {
        CourseRestClient client = new CourseRestClientMock(404, null);
        client.deleteCourse(UUID);
    }

    @Test(expected = RestClientFailureException.class)
    public void testDeleteCourseError() {
        CourseRestClient client = new CourseRestClientMock(500, null);
        client.deleteCourse(UUID);
    }
}

Finally we need to create a to-be-tested object with a mocked REST client. We can’t use dependency injection since Client.createClient is a static method but we’ve wrapped that call in a package-private method that we can override. That method creates a mocked Client that provides the rest of the values required from Jersey library.

class CourseRestClientMock extends CourseRestClientImpl {
static final String RESOURCE = "test://rest/course/";
private Client client;
private WebResource webResource;
private WebResource.Builder webResourceBuilder;
private ClientResponse response;
private final int status;
private final Object results;
CourseRestClientMock(int status, Object results) {
super(RESOURCE);
this.status = status;
this.results = results;
}
/**
* Override createClient() so it returns mocked object. These expectations
* will handle basic CRUD operations, more advanced functionality will
* require inspecting JSON payload of POST call.
*/
Client createClient() {
client = Mockito.mock(Client.class);
webResource = Mockito.mock(WebResource.class);
webResourceBuilder = Mockito.mock(WebResource.Builder.class);
response = Mockito.mock(ClientResponse.class);
when(client.resource(any(String.class))).thenReturn(webResource);
when(webResource.accept(any(String.class))).thenReturn(
webResourceBuilder);
when(webResource.type(any(String.class)))
.thenReturn(webResourceBuilder);
when(webResourceBuilder.accept(any(String.class))).thenReturn(
webResourceBuilder);
when(webResourceBuilder.type(any(String.class))).thenReturn(
webResourceBuilder);
when(webResourceBuilder.get(eq(ClientResponse.class))).thenReturn(
response);
when(
webResourceBuilder.post(eq(ClientResponse.class),
any(String.class))).thenReturn(response);
when(
webResourceBuilder.put(eq(ClientResponse.class),
any(String.class))).thenReturn(response);
when(webResourceBuilder.delete(eq(ClientResponse.class))).thenReturn(
response);
when(response.getStatus()).thenReturn(status);
when(response.getEntity(any(Class.class))).thenReturn(results);
return client;
}
}

class CourseRestClientMock extends CourseRestClientImpl {
    static final String RESOURCE = "test://rest/course/";
    private Client client;
    private WebResource webResource;
    private WebResource.Builder webResourceBuilder;
    private ClientResponse response;
    private final int status;
    private final Object results;

    CourseRestClientMock(int status, Object results) {
        super(RESOURCE);
        this.status = status;
        this.results = results;
    }

    /**
     * Override createClient() so it returns mocked object. These expectations
     * will handle basic CRUD operations, more advanced functionality will
     * require inspecting JSON payload of POST call.
     */
    Client createClient() {
        client = Mockito.mock(Client.class);
        webResource = Mockito.mock(WebResource.class);
        webResourceBuilder = Mockito.mock(WebResource.Builder.class);
        response = Mockito.mock(ClientResponse.class);
        when(client.resource(any(String.class))).thenReturn(webResource);
        when(webResource.accept(any(String.class))).thenReturn(
                webResourceBuilder);
        when(webResource.type(any(String.class)))
                .thenReturn(webResourceBuilder);
        when(webResourceBuilder.accept(any(String.class))).thenReturn(
                webResourceBuilder);
        when(webResourceBuilder.type(any(String.class))).thenReturn(
                webResourceBuilder);
        when(webResourceBuilder.get(eq(ClientResponse.class))).thenReturn(
                response);
        when(
                webResourceBuilder.post(eq(ClientResponse.class),
                        any(String.class))).thenReturn(response);
        when(
                webResourceBuilder.put(eq(ClientResponse.class),
                        any(String.class))).thenReturn(response);
        when(webResourceBuilder.delete(eq(ClientResponse.class))).thenReturn(
                response);
        when(response.getStatus()).thenReturn(status);
        when(response.getEntity(any(Class.class))).thenReturn(results);
        return client;
    }
}

Integration Testing

This is the outermost layer of the onion so there’s no meaningful integration tests.

Source Code

The source code is at https://github.com/beargiles/project-student [github] and http://beargiles.github.io/project-student/ [github pages].

Comments: No Comments »
Categories: java
Comments rss
Trackback

Maintenance Webapp

Limitations

Goal

Course template

GridDataSources

AppModule

CourseFinderServiceTapestryImpl

Wrapping up

Source Code

Design Decisions

Limitations

Refactoring Prior Work

Metadata

Specifications

Spring Data Repository

FinderService Implementation

Unit Testing

Integration Testing

Source Code

Limitations

Container-Managed Datasource and JNDI

JPA Configuration

Web Configuration

Spring Configuration

Database Schema and Security

Integration Testing

Source Code

Correction

TestablePersistentObject abstract base class

TestRun class

Spring Data Repository

Service Interface

Service Implementation

CourseServiceIntegrationTest

REST Webservice Server

REST Webservice Client

Source Code

Clarification

Correction

Design Decisions

Limitations

Configuration

Unit Testing

Integration Testing

Source Code

Design Decisions

Limitations

Service Interface

Service Implementation

Persistence Layer Interface

Unit Testing

Integration Testing

Source Code

Design Decisions

Limitations

Jersey REST Server

Service API

Request Parameters

Scrubber

Configuration Classes

web.xml

Unit Testing

Integration Testing

pom.xml

Update

Source Code

Design Decisions

Limitations

Client API

Exceptions

Client Implementation

Unit Testing

Integration Testing

Source Code

Archives

Recent Posts

Meta

Pages

Syndication

Know Your Rights