Testing#

jimble has no test-only module and no test annotations. You write tests with JUnit 5 and java.net.http.HttpClient, and nothing else.

That is the whole toolbox.

Start it, hit it#

This is the basic shape. Helidon really starts, so you check routing, filters, error handling and Content-Type end to end.

@BeforeAll
static void startServer () {

	server = JimbleServer.start(new SampleApp(), 0);
	client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(5)).build();

}

@AfterAll
static void stopServer () {

	if (server != null) {
		server.stop();
	}

}

/**
 * リクエストを送る
 */
private static HttpResponse<String> request (String method, String path) throws Exception {

	HttpRequest request = HttpRequest.newBuilder()
		.uri(URI.create("http://127.0.0.1:" + server.port() + path))
		.method(method, HttpRequest.BodyPublishers.noBody())
		.timeout(Duration.ofSeconds(10))
		.build();

	return client.send(request, HttpResponse.BodyHandlers.ofString());

}

Passing 0 for the port is the point. Fix the port and it fails only when another test happens to run at the same time.

@Test
void hello () throws Exception {
	assertEquals("hello", request("GET", "/hello").body());
}

Hitting the router without HTTP#

You can call Dispatcher directly, without starting a server. It is faster, and in exchange you check nothing on the Helidon side (streamed sends, compression).

private Fakes.FakeResponseSink dispatch (JimbleApp app, String method, String rawPath) {

	Dispatcher dispatcher = new Dispatcher(app);
	Fakes.FakeRequestSource source = new Fakes.FakeRequestSource(method, rawPath);
	Fakes.FakeResponseSink sink = new Fakes.FakeResponseSink();

	try (WebContext context = new WebContext(source, sink)) {
		dispatcher.dispatch(context);
		return sink;
	}

Tests that use the DB#

Keep them separate#

Tag the tests that need a DB and leave them out of the everyday build. That keeps the build from going red where there is nothing to connect to — CI, or a fresh clone.

@Tag("db")
class PostIntegrationTest { ... }

Add this to your application's build.gradle.kts.

tasks.withType<Test>().configureEach {
	useJUnitPlatform { excludeTags("db") }
}

tasks.register<Test>("dbTest") {
	group = "verification"
	testClassesDirs = sourceSets.test.get().output.classesDirs
	classpath = sourceSets.test.get().runtimeClasspath
	useJUnitPlatform { includeTags("db") }

	// switch the configuration over to dbtest
	systemProperty("jimble.env", "dbtest")

	// run every time, so it never sees what an earlier test TRUNCATEd
	outputs.upToDateWhen { false }
}

Put conf/application.dbtest.conf in place and write the connection there. The include on the first line is what reads the shared configuration (Configuration).

include "application.conf"

db {
	main {
		url      = "jdbc:mariadb://127.0.0.1:3306/app_test"
		url      = ${?TEST_DB_URL}
	}
}

Bringing it up#

@BeforeAll
static void startServer () {

	Conf.reload();

	/*
	 * <b>本番の入口と同じものを呼ぶ。</b>
	 * ここでテストだけの用意を書くと、入口が変わったときに<b>テストだけ通る</b>。
	 */
	Bootstrap.load();

	// ポート 0 で空いているところを使う。他のテストと衝突しない
	server = JimbleServer.start(new BlogApp(), 0);

	client = HttpClient.newBuilder()
		.connectTimeout(Duration.ofSeconds(5))
		.cookieHandler(new CookieManager())
		.followRedirects(HttpClient.Redirect.NEVER)
		.build();

}

The order is fixed.

1. Conf.reload() — the environment (jimble.env) is settled the first time the configuration is read, so read it again
2. Migration.install() — create the tables
3. DBUtil.load(...) — connect
4. JimbleServer.start(app, 0)

Cleanup is DBUtil.stop() in @AfterAll, and TRUNCATE TABLE ... before each test.

Do not run them in parallel#

Swapping in configuration#

// layer over the existing configuration (this is the usual one)
Conf.replace(ConfigFactory
	.parseString("upload.max_file_size = 10")
	.withFallback(Conf.conf().config()));

Running jimble's own tests#

./gradlew build                 # the ones that need no DB
./gradlew :jimble-db:dbTest     # the ones that use a real MySQL / MariaDB
./gradlew :jimble-db:pgTest     # the same tests against a real PostgreSQL

dbTest and pgTest run exactly the same tests. The only difference is which configuration file they read (application.dbtest.conf / application.pgtest.conf), and the latter carries product = "postgresql". Not one line of the test code changes.

You can point them somewhere else with environment variables.

JIMBLE_TEST_DB_URL="jdbc:mariadb://127.0.0.1:3306/jimble_test" \
JIMBLE_TEST_DB_USER=jimble \
JIMBLE_TEST_DB_PASSWORD=jimble \
  ./gradlew :jimble-db:dbTest

JIMBLE_TEST_PG_URL="jdbc:postgresql://127.0.0.1:5432/jimble_test" \
JIMBLE_TEST_PG_USER=jimble \
JIMBLE_TEST_PG_PASSWORD=jimble \
  ./gradlew :jimble-db:pgTest

These are for jimble's own tests. The samples under examples/ read different names: JIMBLE_SAMPLE_DB_* / JIMBLE_SAMPLE_PG_*.