Oktober, 2009

Ein weiterer Blogpost aus dem Firmenblog, wieder in Englisch.

GarageTest

This test case demonstrate the use of JMockIt and it’s Expectations to resolve dependencies in unit tests. Expectations are a way to easily mock the behavior of an object in unit tests, without creating interfaces, classes and other overhead. Take a look at the full unit test first, and I’ll explain what’s done there later. You can find the interface Garage and the classes CheapGarage and EngineFactory at the end of this blogpost.

package de.kopis.example;

import static org.junit.Assert.*;

import mockit.Mocked;
import mockit.Mockit;
import mockit.Expectations;
import mockit.integration.junit4.JMockit;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

public class GarageTest {
  @Test
  public void testRepair() {
    Garage g = new CheapGarage();
    Engine expectedEngine = new GasolineEngine();
    Car expectedCar = new Car(expectedEngine);
    Car actualCar = g.repairEngine(expectedCar);
    assertSame(expectedCar, actualCar);
    assertNotSame(expectedCar.engine, expectedEngine);
  }

  @Test
  public void testRepairWithExpectationEngineFactory() throws InstantiationException, IllegalAccessException {
    final Engine expectedEngine = new DieselEngine();
    final Car expectedCar = new Car(expectedEngine);
    final Garage g = new CheapGarage();
    new Expectations() {
      EngineFactory mock;
      {
        mock.instantiate(expectedEngine); returns(new DieselEngine());
      }
    };

    Car actualCar = g.repairEngine(expectedCar);
    assertSame(expectedCar, actualCar);
    assertTrue(expectedCar.engine instanceof DieselEngine);
    assertNotSame(expectedCar.engine, expectedEngine);
  }
}

Now, back to the method testRepairWithExpectationEngineFactory(). The EngineFactory is a dependency buried down in the CheapGarage class that is responsible for replacing the Engine in a Car. There is a mocked instance of EngineFactory in this unit test that will return a new DieselEngine every time the method instantiate() is called with any kind of argument. This way I can control exactly how the hidden call to a factory behaves.

JMockIt has a bunch of other useful features and I recommend it for all unit tests. If you care about your tests and try to avoid testing dependencies instead of your logic, then you should start using JMockIt today.

Garage & GarageTest

package de.kopis.example;

public interface Garage {
  public Car repairEngine(Car car);
}

abstract class AbstractGarage implements Garage {
  public abstract Car repairEngine(Car car);
}

class CheapGarage extends AbstractGarage {
  public Car repairEngine(Car car) {
    replaceEngineWithNewInstance(car);
    return car;
  }

  private void replaceEngineWithNewInstance(Car car) {
    try {
      Engine newEngine = EngineFactory.instantiate(car.engine);
      car.replaceEngine(newEngine);
    } catch ( InstantiationException e ) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch ( IllegalAccessException e ) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
}

class EngineFactory {
  public EngineFactory() {}

  public static Engine instantiate(Engine engine) throws InstantiationException, IllegalAccessException {
    Class<? extends Engine> engineClass = engine.getClass();
    Engine newEngine = engineClass.newInstance();
    return newEngine;
  }
}

Ich habe diesen Blogeintrag in einem Firmenblog veröffentlicht, daher ist er in Englisch. Und bitte:

Today I created a simple unit test that runs Mortbays Jetty as an embedded servlet container for a unit test with JUnit 4. It’s quite simple to run the ServletTester and add Servlets to it, so you can create HTTP requests and assert against the responses.

To run Jetty you need the following JAR files in your classpath:

• jetty-6.X.Y.jar
• jetty-servlet-tester-6.X.Y.jar
• jetty-util-6.X.Y.jar
• servlet-api-2.5-*.jar

HelloServletTest

The HelloServletTest simple setups Jetty to initialize a servlet, runs one test and stops Jetty after it.

import static org.junit.Assert.*;

import java.util.Properties;import java.util.Vector;

import org.junit.After;import org.junit.Before;import org.junit.Test;import org.mortbay.jetty.testing.HttpTester;import org.mortbay.jetty.testing.ServletTester;

public class HelloServletTest {

  private ServletTester tester;

  @Before  public void setUp() throws Exception {      tester = new ServletTester();      tester.setContextPath("/context");      tester.addServlet(HelloServlet.class, "/hello/*");      tester.start();  }

  @After  public void tearDown() throws Exception {      tester.stop();  }

  @Test  public void testDefaultServlet() throws Exception {      HttpTester request = withRequest("/context/hello/info", null);

      HttpTester response = new HttpTester();      response.parse(tester.getResponses(request.generate()));

      assertNull(response.getMethod());      assertEquals(200, response.getStatus());      assertEquals("<h1>Hello, World!</h1>", response.getContent().trim());  }

  private HttpTester withRequest(String path, Vector<String[]> parameters) {      String requestParameters = "";      for ( String[] params : parameters ) {          requestParameters += ("".equals(requestParameters) ? "?" : "&");          requestParameters += params[0] + "=" + params[1];      }      String uri = path;      if(requestParameters != "") uri += requestParameters;      HttpTester request = new HttpTester();      request.setMethod("GET");      request.setHeader("Host", "127.0.0.1");      request.setURI(uri);      request.setVersion("HTTP/1.0");      return request;  }

}

HelloServlet

This is the servlet I used for the first test. It’s the obvious Hello World example.

import java.io.IOException;import java.io.PrintWriter;

import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;

public class HelloServlet extends HttpServlet {

  @Override  public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException,                  IOException {      PrintWriter out = resp.getWriter();      out.println("<h1>Hello, World!</h1>");      out.flush();  }

}

Now you can remove HelloServlet, add your own servlet classes and go unit test them.