package examples;

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Future;
import io.vertx.core.Handler;
import io.vertx.core.Promise;
import io.vertx.core.Vertx;
import io.vertx.core.eventbus.EventBus;
import io.vertx.core.http.HttpClient;
import io.vertx.core.http.HttpClientRequest;
import io.vertx.core.http.HttpMethod;
import io.vertx.core.http.HttpServer;
import io.vertx.core.http.HttpServerRequest;
import io.vertx.docgen.Source;
import io.vertx.ext.unit.*;
import io.vertx.ext.unit.collect.EventBusCollector;
import io.vertx.ext.unit.report.ReportOptions;
import io.vertx.ext.unit.report.ReportingOptions;
import org.junit.Assert;

import java.util.concurrent.atomic.AtomicBoolean;

Author:Julien Viet
/** * @author <a href="mailto:julien@julienviet.com">Julien Viet</a> */
public class Examples { public static void test_01() { TestSuite suite = TestSuite.create("the_test_suite"); suite.test("my_test_case", context -> { String s = "value"; context.assertEquals("value", s); }); suite.run(); } public static void test_02() { TestSuite suite = TestSuite.create("the_test_suite"); suite.test("my_test_case", context -> { String s = "value"; context.assertEquals("value", s); }); suite.run(new TestOptions().addReporter(new ReportOptions().setTo("console"))); } public static void writing_test_suite_01() { TestSuite suite = TestSuite.create("the_test_suite"); suite.test("my_test_case_1", context -> { // Test 1 }); suite.test("my_test_case_2", context -> { // Test 2 }); suite.test("my_test_case_3", context -> { // Test 3 }); } public static void writing_test_suite_02() { TestSuite suite = TestSuite.create("the_test_suite"); suite.test("my_test_case_1", context -> { // Test 1 }).test("my_test_case_2", context -> { // Test 2 }).test("my_test_case_3", context -> { // Test 3 }); } public static void writing_test_suite_03() { TestSuite suite = TestSuite.create("the_test_suite"); suite.before(context -> { // Test suite setup }).test("my_test_case_1", context -> { // Test 1 }).test("my_test_case_2", context -> { // Test 2 }).test("my_test_case_3", context -> { // Test 3 }).after(context -> { // Test suite cleanup }); } public static void writing_test_suite_04() { TestSuite suite = TestSuite.create("the_test_suite"); suite.beforeEach(context -> { // Test case setup }).test("my_test_case_1", context -> { // Test 1 }).test("my_test_case_2", context -> { // Test 2 }).test("my_test_case_3", context -> { // Test 3 }).afterEach(context -> { // Test case cleanup }); } public static void asserting_01(io.vertx.ext.unit.TestSuite suite, int callbackCount) { suite.test("my_test_case", context -> { context.assertEquals(10, callbackCount); }); } public static void asserting_02(io.vertx.ext.unit.TestSuite suite, int callbackCount) { suite.test("my_test_case", context -> { context.assertEquals(10, callbackCount, "Should have been 10 instead of " + callbackCount); }); } public static void asserting_03(io.vertx.ext.unit.TestSuite suite, int callbackCount) { suite.test("my_test_case", context -> { context.assertNotEquals(10, callbackCount); }); } public static void asserting_04(io.vertx.ext.unit.TestSuite suite, int callbackCount) { suite.test("my_test_case", context -> { context.assertNull(null); }); } public static void asserting_05(io.vertx.ext.unit.TestSuite suite, int callbackCount) { suite.test("my_test_case", context -> { context.assertNotNull("not null!"); }); } public static void asserting_06(io.vertx.ext.unit.TestSuite suite, int callbackCount) { suite.test("my_test_case", context -> { // Assert that 0.1 is equals to 0.2 +/- 0.5 context.assertInRange(0.1, 0.2, 0.5); }); } public static void asserting_07(io.vertx.ext.unit.TestSuite suite, boolean var, int value) { suite.test("my_test_case", context -> { context.assertTrue(var); context.assertFalse(value > 10); }); } public static void asserting_08(io.vertx.ext.unit.TestSuite suite) { suite.test("my_test_case", context -> { context.fail("That should never happen"); // Following statements won't be executed }); } public static void asserting_09(io.vertx.ext.unit.TestSuite suite, int callbackCount) { suite.test("my_test_case", context -> context.verify(v -> { // Using here Assert from junit, could be assertj, hamcrest or any other // Even manually throwing an AssertionError. Assert.assertNotNull("not null!"); Assert.assertEquals(10, callbackCount); })); } public static void async_01(io.vertx.ext.unit.TestSuite suite, EventBus eventBus) { suite.test("my_test_case", context -> { Async async = context.async(); eventBus.consumer("the-address", msg -> { // <2> async.complete(); }); // <1> }); } public static void async_02(io.vertx.ext.unit.TestSuite suite, Vertx vertx) { suite.test("my_test_case", context -> { HttpClient client = vertx.createHttpClient(); client.request(HttpMethod.GET, 8080, "localhost", "/", context.asyncAssertSuccess(req -> { req.send(context.asyncAssertSuccess(resp -> { context.assertEquals(200, resp.statusCode()); })); })); Async async = context.async(); vertx.eventBus().consumer("the-address", msg -> { async.complete(); }); }); } public static void async_03(io.vertx.ext.unit.TestSuite suite, Vertx vertx, Handler<HttpServerRequest> requestHandler) { suite.before(context -> { Async async = context.async(); HttpServer server = vertx.createHttpServer(); server.requestHandler(requestHandler); server.listen(8080, ar -> { context.assertTrue(ar.succeeded()); async.complete(); }); }); } public static void async_04(TestContext context, Vertx vertx, Handler<HttpServerRequest> requestHandler) { Async async = context.async(); HttpServer server = vertx.createHttpServer(); server.requestHandler(requestHandler); server.listen(8080, ar -> { context.assertTrue(ar.succeeded()); async.complete(); }); // Wait until completion async.awaitSuccess(); // Do something else } public static void async_05(TestContext context, Vertx vertx, Handler<HttpServerRequest> requestHandler) { Async async = context.async(2); HttpServer server = vertx.createHttpServer(); server.requestHandler(requestHandler); server.listen(8080, ar -> { context.assertTrue(ar.succeeded()); async.countDown(); }); vertx.setTimer(1000, id -> { async.complete(); }); // Wait until completion of the timer and the http request async.awaitSuccess(); // Do something else } @Source(translate = false) public static void asyncAssertSuccess_01(Vertx vertx, TestContext context) { Async async = context.async(); vertx.deployVerticle("my.verticle", ar -> { if (ar.succeeded()) { async.complete(); } else { context.fail(ar.cause()); } }); // Can be replaced by vertx.deployVerticle("my.verticle", context.asyncAssertSuccess()); } @Source(translate = false) public static void asyncAssertSuccess_02(Vertx vertx, TestContext context) { AtomicBoolean started = new AtomicBoolean(); Async async = context.async(); vertx.deployVerticle(new AbstractVerticle() { public void start() throws Exception { started.set(true); } }, ar -> { if (ar.succeeded()) { context.assertTrue(started.get()); async.complete(); } else { context.fail(ar.cause()); } }); // Can be replaced by vertx.deployVerticle("my.verticle", context.asyncAssertSuccess(id -> { context.assertTrue(started.get()); })); } @Source(translate = false) public static void asyncAssertSuccess_03(Vertx vertx, TestContext context) { Async async = context.async(); vertx.deployVerticle("my.verticle", ar1 -> { if (ar1.succeeded()) { vertx.deployVerticle("my.otherverticle", ar2 -> { if (ar2.succeeded()) { async.complete(); } else { context.fail(ar2.cause()); } }); } else { context.fail(ar1.cause()); } }); // Can be replaced by vertx.deployVerticle("my.verticle", context.asyncAssertSuccess(id -> vertx.deployVerticle("my_otherverticle", context.asyncAssertSuccess()) )); } @Source(translate = false) public static void asyncAssertFailure_01(Vertx vertx, TestContext context) { Async async = context.async(); vertx.deployVerticle("my.verticle", ar -> { if (ar.succeeded()) { context.fail(); } else { async.complete(); } }); // Can be replaced by vertx.deployVerticle("my.verticle", context.asyncAssertFailure()); } @Source(translate = false) public static void asyncAssertFailure_02(Vertx vertx, TestContext context) { Async async = context.async(); vertx.deployVerticle("my.verticle", ar -> { if (ar.succeeded()) { context.fail(); } else { context.assertTrue(ar.cause() instanceof IllegalArgumentException); async.complete(); } }); // Can be replaced by vertx.deployVerticle("my.verticle", context.asyncAssertFailure(cause -> { context.assertTrue(cause instanceof IllegalArgumentException); })); } public static void repeating(Vertx vertx) { TestSuite.create("my_suite").test("my_test", 1000, context -> { // This will be executed 1000 times }); } public static void sharing_01(Vertx vertx, Helper helper) { TestSuite.create("my_suite").before(context -> { // host is available for all test cases context.put("host", "localhost"); }).beforeEach(context -> { // Generate a random port for each test int port = helper.randomPort(); // Get host String host = context.get("host"); // Setup server Async async = context.async(); HttpServer server = vertx.createHttpServer(); server.requestHandler(req -> { req.response().setStatusCode(200).end(); }); server.listen(port, host, ar -> { context.assertTrue(ar.succeeded()); context.put("port", port); async.complete(); }); }).test("my_test", context -> { // Get the shared state int port = context.get("port"); String host = context.get("host"); // Do request HttpClient client = vertx.createHttpClient(); client.request(HttpMethod.GET, port, host, "/resource", context.asyncAssertSuccess(req -> { req.send(context.asyncAssertSuccess(resp -> { context.assertEquals(200, resp.statusCode()); })); })); }); } public static void running_01(TestSuite suite) { suite.run(); } public static void running_02(TestSuite suite, Vertx vertx) { suite.run(vertx); } public static void completion_01(TestSuite suite, Vertx vertx) { TestCompletion completion = suite.run(vertx); // Simple completion callback completion.handler(ar -> { if (ar.succeeded()) { System.out.println("Test suite passed!"); } else { System.out.println("Test suite failed:"); ar.cause().printStackTrace(); } }); } public static void completion_02(TestSuite suite, Promise<Void> startPromise) { TestCompletion completion = suite.run(); // When the suite completes, the promise is resolved completion.resolve(startPromise); } public static void completion_03(TestSuite suite) { Completion completion = suite.run(); // Wait until the test suite completes completion.await(); } public static void completion_04(TestSuite suite) { Completion completion = suite.run(); // Wait until the test suite succeeds otherwise throw an exception completion.awaitSuccess(); } public static void running_05(TestSuite suite) { TestOptions options = new TestOptions().setTimeout(10000); // Run with a 10 seconds time out suite.run(options); } public static void reporter_01(TestSuite suite) { // Report to console ReportOptions consoleReport = new ReportOptions(). setTo("console"); // Report junit files to the current directory ReportOptions junitReport = new ReportOptions(). setTo("file:."). setFormat("junit"); suite.run(new TestOptions(). addReporter(consoleReport). addReporter(junitReport) ); } public static void reporter_02(Vertx vertx) { EventBusCollector collector = EventBusCollector.create( vertx, new ReportingOptions().addReporter( new ReportOptions().setTo("file:report.xml").setFormat("junit"))); collector.register("the-address"); } public static void vertxInteg1(Vertx vertx, TestSuite suite) throws Exception { suite.test("my_test_case", ctx -> { // The failure will be reported by Vert.x Unit throw new RuntimeException("it failed!"); }); } public static void vertxInteg2(Vertx vertx, TestSuite suite) throws Exception { suite.test("test-server", testContext -> { HttpServer server = vertx.createHttpServer().requestHandler(req -> { if (req.path().equals("/somepath")) { throw new AssertionError("Wrong path!"); } req.response().end(); }); }); } public static void vertxInteg3(Vertx vertx, TestSuite suite) throws Exception { suite.before(testContext -> { // Report uncaught exceptions as Vert.x Unit failures vertx.exceptionHandler(testContext.exceptionHandler()); }); suite.test("test-server", testContext -> { HttpServer server = vertx.createHttpServer().requestHandler(req -> { if (req.path().equals("/somepath")) { throw new AssertionError("Wrong path!"); } req.response().end(); }); }); } }