To provide a framework that we can perform client side testing with all standard expresso services such as logging, database connection management, and many others we provide the following class: com.jcorporate.expresso.services.test.ExpressoTestCase . To create your own test case use the following sample as a model:

import junit.framework.*;
import junit.extensions.*;
import com.jcorporate.expresso.services.test.*;


public class SampleTestSuite extends ExpressoTestCase {
	public SampleTestSuite(String name) throws Exception {
	  super(name);
	}


	public static void main(String[] args) throws java.lang.Exception {
	  //Set the system properties we need
	  junit.textui.TestRunner.run (suite());
	}


	public static junit.framework.Test suite() {
		return new TestSuite(SampleTestSuite.class);
	}

	public void test1() {
		//Do your testing code here
	}

	public void test2() {
		//Do more testing here
	}

	public void test3() {
		//You can do more testing here
	}
		/*....Do as many test cases as you want, all with the public void signature */
}

To run the test case, you need to set the following Java Virtual Machine parameters to:

junit.argv.configDir= junit.argv.webAppDir=

Usually in the command line you'll do this by having the command line:

-Djunit.argv.configDir= -Djunit.argv.webAppDir= -Djunit.argv.logDir=

The JUnit framework will automatically use Java Introspection to run all the public(void) test cases. See the JUnit documentation on how to use the framework to signal if a test passed or failed. Also, see the class: com.jcorporate.expresso.core.misc.CookieTests to see a fully functional sample of integration with JUnit Framework.

All expresso test case classes will play well with the JUnit test runners. So if you wish to run a text-based only test case, you can run junit.textui.TextRunner. If you wish to run within a nice graphical environment, you can run your test suite with:

To run all test cases within a graphical environment, run the class:

junit.swingui.TestRunner use the UI to pick the class you wish to test and let her run.

The -c will determine which test suite to run. You can use your own test cases, or use the class sample above to run all Expresso test cases at once.

There are a couple of necessary guidelines to follow when writing your own test cases:

When we're first creating our application, we want to make sure it runs correctly, right? But as we're developing our schema, and creating out databases, we have to each time go through the monotonous task of dropping a database, recreating it, starting up Expresso, running DBCreate, etc. This quickly becomes quite a chore. So we've created a special test case for testing Schema Creation. Here's all the code you need. The following example is borrowed directly from eForum and is complete:

import junit.framework.*;
Import com.jcorporate.expresso.services.test.*;
Import com.jcorporate.expresso.core.utility.DBToolTests;

public class SchemaTests extends DBToolTests {
 public SchemaTests(String testName) throws Exception {
	   super(testName);
   }

 public static void main(String[] args) throws Exception {
	   //Set the system properties we need
	   junit.textui.TestRunner.run (suite());
   }

   public static junit.framework.Test suite() throws Exception {
   		return DBToolTests.suite();
   }

   protected void setUp() throws Exception {
	   //System must be initialized prior to instanatiating the schema instance
	   TestSystemInitializer.setUp();
	   Class c = Class.forName("com.jcorporate.eforum.ForumSchema");
	   schemaList.add(c.newInstance());
	   super.setUp();
   }
}

That's it! To make this code work for your schema all you do is change the ONE line in setup() that loads ForumSchema to use your own schema class. When this class is run, it will make sure that all tables are removed from the Test database, and then attempt to create all schemas (Including Expresso's) in the test database. It will also run separately populateDefaultValues() and setupDefaultSecurity() so you can make sure that everything is cooprating.

This kind of testing is an extremely helpful and powerful tool for testing your schemas as you're building them.

The bulk of your web application is going to be logic within an Expresso Controller object, or possibly a standard Servlet. Unfortunately, standard JUnit client-side testing procedures definitely fall flat in being able to cope in this area. Enter Apache's Cactus project.

Cactus was designed to provide the unification of JUnit's client side testing API and in-container server-side testing. What it does is initiate a test case on the client side so you can stuff all the HTTP request parameters with everything you need such as state to request, login cookies, etc. The test case then serializes itself to the server, where a specially designed servlet loads your test class and executes the code on the server side. The result is then sent back to the client side so you can examine cookies sent back to client or other results.

Here is an animation created by the Apache Cactus documentation project that highlights what was said above.

If you are writing a servlet, the Cactus documentation will be sufficient to get you started on a servlet. Even if you're writing a controller test case, it is strongly recommended that you browse through the Cactus website to get an idea of how a Cactus test case is written since the controller test cases are extensions to a standard Cactus test.

If you are writing a controller test harness, there are quite a few things to consider such as having a running underlying database, negotiating security, and parsing the controller response. To assist in this, we've provided the classes: com.jcorporporate.expresso.services.test.ControllerTestCase and com.jcorporate.expresso.services.test.ControllerTestSuite

Below is a sample showing a simple usage of a controller test case (suite). All comments with a number are footnoted/explained in the area below the code sample.

import com.jcorporate.expresso.services.test.*;
import com.jcorporate.expresso.core.controller.*;
import org.apache.commons.cactus.*;
import org.apache.commons.cactus.util.*;
import junit.framework.*;
import org.w3c.dom.*;

import java.net.HttpURLConnection;
import java.io.IOException;
import javax.servlet.*;
import java.util.*;
 

public class SampleControllerTest extends ControllerTestCase {
	public SampleControllerTest(String name) {
	  super(name, "com.jcorporate.expresso.services.DBSecurityMatrix"); //1
	}


	public static void main(String[] args) throws Exception {
	   junit.textui.TestRunner.run(suite());  //2
   	}

 	public static TestSuite suite() throws Exception {
	   ControllerTestSuite cts = new ControllerTestSuite();  //3
	   cts.addReadOnlySchemaDependency("com.jcorporate.expresso.core.ExpressoSchema"); //4
	   cts.addTestSuite(SampleControllerTest.class);
	   return CTS;
   }
 

  /* Executed on the client side of the web request */ 
  public void beginPromptState(WebRequest theRequest) throws Exception
    {
        super.logIn(theRequest);  //5
        super.setupParameters("prompt",theRequest);  //6
    }

  /* Executed on the server side of the web request */ 
   public void testPromptState() throws Exception {
	   ControllerResponse response = super.controllerProcess();  //7
	   assertTrue("Got a null response", response != null);


		assertTrue("Title returned from the controller state.",
				response.getTitle().length() > 0);             //8
    }


	/*....Do as many test cases as you want, all with the public void signature */
}

To run the Cactus tests you need the following software pieces.

The following persons have contributed their time to this chapter:

Copyright © 2001-2004 Jcorporate Ltd. All rights reserved.