Example of testing a RPC call using GWT-TestCase with GAE

Question

How is that for a lot of acronyms!

I am having trouble testing GWT's RPC mechanism using GWT's GWTTestCase. I created a class for testing using the junitCreator tool included with GWT. I am attempting to test using the built in Google App Engine using the created "hosted mode" testing profile created by junitCreator. When I run the test, I keep getting errors saying things like

Starting HTTP on port 0
   HTTP listening on port 49569
The development shell servlet received a request for 'greet' in module 'com.google.gwt.sample.stockwatcher.StockWatcher.JUnit.gwt.xml' 
   [WARN] Resource not found: greet; (could a file be missing from the public path or a <servlet> tag misconfigured in module com.google.gwt.sample.stockwatcher.StockWatcher.JUnit.gwt.xml ?)
com.google.gwt.user.client.rpc.StatusCodeException: Cannot find resource 'greet' in the public path of module 'com.google.gwt.sample.stockwatcher.StockWatcher.JUnit'

I hope that someone somewhere has successfully run junit test (using GWTTestCase or just plain TestCase) that will allow for the testing of gwt RPC. If this is the case, could you please mention the steps you took, or better yet, just post code that works. Thanks.

Answer 1

SyncProxy allows you to make GWT RPC call from Java. So you can test your GWT RPC with regular Testcase (and faster than GwtTestcase)

See
http://www.gdevelop.com/w/blog/2010/01/10/testing-gwt-rpc-services/
http://www.gdevelop.com/w/blog/2010/03/13/invoke-gwt-rpc-services-deployed-on-google-app-engine/

Answer 2

I got this working. This answer assume's you're using Gradle, but this could easily be adopted to run from ant. First, you'll have to make sure that you separate your GWT tests from your regular JUnit tests. I created 'tests/standalone' for the regular tests, and 'tests/gwt' for my GWT tests. I still get 1 single HTML report in the end that has all of the info.

Next, you need to make sure JUnit is part of your ant classpath, as described here:

http://gradle.1045684.n5.nabble.com/Calling-ant-test-target-fails-with-junit-classpath-issue-newbie-td4385167.html

Then, use something similar to this to compile your GWT tests and run them:

    task gwtTestCompile(dependsOn: [compileJava]) << {
    ant.echo("Copy the test sources in so they're part of the source...");
    copy {
        from "tests/gwt"
        into "$buildDir/src"
    }
    gwtTestBuildDir = "$buildDir/classes/test-gwt";
    (new File(gwtTestBuildDir)).mkdirs()
    (new File("$buildDir/test-results")).mkdirs()

    ant.echo("Compile the tests...");
    ant.javac(srcdir: "tests/gwt", destdir: gwtTestBuildDir) {
        classpath {
            pathElement(location: "$buildDir/src")
            pathElement(location: "$buildDir/classes/main")
            pathElement(path: configurations.runtime.asPath)
            pathElement(path: configurations.testCompile.asPath)
            pathElement(path: configurations.gwt.asPath)
            pathElement(path: configurations.gwtSources.asPath)
        }
    }

    ant.echo("Run the tests...");
    ant.junit(haltonfailure: "true", fork: "true") {
        classpath {
            pathElement(location: "$buildDir/src")
            pathElement(location: "$buildDir/classes/main")
            pathElement(location: gwtTestBuildDir)
            pathElement(path: configurations.runtime.asPath)
            pathElement(path: configurations.testCompile.asPath)
            pathElement(path: configurations.gwt.asPath)
            pathElement(path: configurations.gwtSources.asPath)
        }
        jvmarg(value: "-Xmx512m")
        jvmarg(line: "-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005")
        test(name: "com.onlyinsight.client.LoginTest", todir: "$buildDir/test-results")
        formatter(type: "xml")
    }
}

test.dependsOn(gwtTestCompile);

Finally, here's a simple GWT test:

public class LoginTest extends GWTTestCase  
{
    public String getModuleName()
    {
        return "com.onlyinsight.ConfModule";
    }

    public void testRealUserLogin()
    {
        UserServiceAsync userService = UserService.App.getInstance();

        userService.login("a", "a", new AsyncCallback<User>()
        {
            public void onFailure(Throwable caught)
            {
                throw new RuntimeException("Unexpected Exception occurred.", caught);
            }

            public void onSuccess(User user)
            {
                assertEquals("a", user.getUserName());
                assertEquals("a", user.getPassword());
                assertEquals(UserRole.Administrator, user.getRole());
                assertEquals("Test", user.getFirstName());
                assertEquals("User", user.getLastName());
                assertEquals("[email protected]", user.getEmail());

                // Okay, now this test case can finish.
                finishTest();
            }
        });

        // Tell JUnit not to quit the test, so it allows the asynchronous method above to run.
        delayTestFinish(10 * 1000);
    }
}

If your RPC instance doesn't have a handy getInstance() method, then add one:

public interface UserService extends RemoteService {

    public User login(String username, String password) throws NotLoggedInException;

    public String getLoginURL(OAuthProviderEnum provider) throws NotLoggedInException;

    public User loginWithOAuth(OAuthProviderEnum provider, String email, String authToken) throws NotLoggedInException;

    /**
     * Utility/Convenience class.
     * Use UserService.App.getInstance() to access static instance of UserServiceAsync
     */
    public static class App {
        private static final UserServiceAsync ourInstance = (UserServiceAsync) GWT.create(UserService.class);

        public static UserServiceAsync getInstance()
        {
            return ourInstance;
        }
    }
}

I hope that helps.