6.1 Running the Embedded Server

To run the server, create an Application class with a static void main method, for example:

  1. import io.micronaut.runtime.Micronaut;
  2. public class Application {
  3. public static void main(String[] args) {
  4. Micronaut.run(Application.class);
  5. }
  6. }
  1. import io.micronaut.runtime.Micronaut
  2. class Application {
  3. static void main(String... args) {
  4. Micronaut.run Application
  5. }
  6. }
  1. import io.micronaut.runtime.Micronaut
  2. object Application {
  3. @JvmStatic
  4. fun main(args: Array<String>) {
  5. Micronaut.run(Application.javaClass)
  6. }
  7. }

To run the application from a unit test, use the EmbeddedServer interface:

  1. import io.micronaut.http.HttpRequest;
  2. import io.micronaut.http.client.HttpClient;
  3. import io.micronaut.http.client.annotation.Client;
  4. import io.micronaut.runtime.server.EmbeddedServer;
  5. import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
  6. import org.junit.jupiter.api.Test;
  7. import jakarta.inject.Inject;
  8. import static org.junit.jupiter.api.Assertions.assertEquals;
  9. @MicronautTest
  10. public class HelloControllerSpec {
  11. @Inject
  12. EmbeddedServer server; (1)
  13. @Inject
  14. @Client("/")
  15. HttpClient client; (2)
  16. @Test
  17. void testHelloWorldResponse() {
  18. String response = client.toBlocking() (3)
  19. .retrieve(HttpRequest.GET("/hello"));
  20. assertEquals("Hello World", response); (4)
  21. }
  22. }
  1. import io.micronaut.http.HttpRequest
  2. import io.micronaut.http.client.HttpClient
  3. import io.micronaut.http.client.annotation.Client
  4. import io.micronaut.runtime.server.EmbeddedServer
  5. import io.micronaut.test.extensions.spock.annotation.MicronautTest
  6. import spock.lang.Specification
  7. import jakarta.inject.Inject
  8. @MicronautTest
  9. class HelloControllerSpec extends Specification {
  10. @Inject
  11. EmbeddedServer embeddedServer (1)
  12. @Inject
  13. @Client("/")
  14. HttpClient client (2)
  15. void "test hello world response"() {
  16. expect:
  17. client.toBlocking() (3)
  18. .retrieve(HttpRequest.GET('/hello')) == "Hello World" (4)
  19. }
  20. }
  1. import io.micronaut.http.client.HttpClient
  2. import io.micronaut.http.client.annotation.Client
  3. import io.micronaut.runtime.server.EmbeddedServer
  4. import io.micronaut.test.extensions.junit5.annotation.MicronautTest
  5. import org.junit.jupiter.api.Assertions.assertEquals
  6. import org.junit.jupiter.api.Test
  7. import jakarta.inject.Inject
  8. @MicronautTest
  9. class HelloControllerSpec {
  10. @Inject
  11. lateinit var server: EmbeddedServer (1)
  12. @Inject
  13. @field:Client("/")
  14. lateinit var client: HttpClient (2)
  15. @Test
  16. fun testHelloWorldResponse() {
  17. val rsp: String = client.toBlocking() (3)
  18. .retrieve("/hello")
  19. assertEquals("Hello World", rsp) (4)
  20. }
  21. }
1The EmbeddedServer is run and the Spock @AutoCleanup annotation ensures the server is stopped after the specification completes.
2The EmbeddedServer interface provides the URL of the server under test which runs on a random port.
3The test uses the Micronaut HTTP client to make the call
4The retrieve method returns the response of the controller as a String
Without explicit port configuration, the port will be 8080, unless the application is run under the test environment where the port is random. When the application context starts from the context of a test class, the test environment is added automatically.