The way it stands now after my last several posts on unit testing is that each test method in a JUnit TestCase runs its own context, including its own PersistenceManager injected with Guice. Because I’m initializing the AppEngine test environment with LocalDatastoreService.NO_STORAGE_PROPERTY = TRUE, any test data I create in one test is not available to the next test method, even in the same TestCase class. This is typical behavior for JUnit test cases, and generally a good thing as each test should be independent, but it does mean we need a convenient way to create test data. My current strategy is twofold:
- Create test data used by all tests in the TestCase setUp() method that runs before each test
- Create common test data (used by multiple TestCases) in test data generator services
The first problem to solve is how to get access to a dispatch service and PersistenceManager inside the test data generators. Both are now being injected by Guice as covered in previous posts, so I’ve written a BaseTestDataService that does the Guice magic:
package com.roa.test.service;
import net.customware.gwt.dispatch.client.standard.StandardDispatchService;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.roa.server.guice.ServerModule;
import com.turbomanage.gwt.server.PMF;
import com.turbomanage.gwt.server.guice.DispatchTestModule;
public class BaseTestDataService
{
protected static Injector inj = Guice.createInjector(new ServerModule(),
new DispatchTestModule());;
protected static StandardDispatchService getService()
{
return inj.getInstance(StandardDispatchService.class);
}
protected static PMF getPMF()
{
return inj.getInstance(PMF.class);
}
}
I’m intentionally using a static getPMF() method to make it as simple as possible to use the test data services in a unit test via static methods. Alternatively, I could have used instance methods and constructor injection, but then you’d have to create a new instance of a test data service in each test, which is just that much more code to write… Also, constructor injection is not possible in this case because the TestCases themselves are not instantiated by Guice, so instantiating a new test data service from a test case would not involve Guice, either.
It does not matter that the BaseTestDataService and BaseTest (below) are both calling Guice.createInjector() and thereby creating multiple Guice contexts, each having its own PMF instance. The important thing for these database tests is that they’re all going against one Datastore, not one PersistenceManager.
Here’s a simple test data generator that extends BaseTestDataService and provides a method to add a test user:
package com.roa.test.service;
import com.roa.client.domain.User;
import com.roa.shared.rpc.AddUserAction;
import com.roa.shared.rpc.AddUserResult;
public class UserTestDataService extends BaseTestDataService
{
public static User addTestUser() throws Exception
{
// Create new user
User u = new User();
u.setEmailAddress("test@example.com");
u.setFirstName("Test");
u.setLastName("User");
u.setGoogleAccountId("testAccountId");
AddUserResult userResult = (AddUserResult) getService().execute(
new AddUserAction(u));
u = userResult.getUser();
return u;
}
}
Note the call to getService() on line 17. Thanks to Guice, test data generator services can invoke gwt-dispatch ActionHandlers the same way as the tests themselves.
Finally, here’s a test case that calls the above service to create a test user in the Datastore:
package com.roa.test;
import java.util.List;
import javax.jdo.Query;
import com.appenginefan.toolkit.unittests.BaseTest;
import com.roa.client.domain.User;
import com.roa.test.service.UserTestDataService;
public class UserTestCase extends BaseTest
{
@Override
protected void setUp() throws Exception
{
super.setUp();
UserTestDataService.addTestUser();
}
public void testUserAdded() throws Exception
{
// Run tests here
Query q = pm.newQuery(User.class, "emailAddress == e");
q.declareParameters("java.lang.String e");
List<User> users = (List<com.roa.client.domain.User>) q.execute("test@example.com");
assertEquals(1, users.size());
User user = users.get(0);
assertNotNull(user.getId());
}
}
I should probably show my BaseTest method, too. I’m using AppEngineFan’s BaseTest as discussed in previous posts and modified the setUp() method for Guice injection as follows:
/**
* Sets up the App Engine environment.
*/
@Override
protected void setUp() throws Exception
{
if (initializer != null)
{
throw new UnsupportedOperationException(
"setup may only be called once!");
}
super.setUp();
initializer = new TestInitializer(getEnvironmentOrNull());
initializer.setUp();
Injector inj = Guice.createInjector(new ServerModule(),
new DispatchTestModule());
this.testSvc = inj.getInstance(StandardDispatchService.class);
this.pm = inj.getInstance(PMF.class).getPersistenceManager();
}
Thanks to Guice, we can now get access to the PersistenceManager and call ActionHandlers via a dispatch test service even from static methods in test data generators. This greatly streamlines unit testing.
TurboManage (RSS)