Merge remote-tracking branch 'upstream/master'

libraries-5/pom.xml

@@ -52,6 +52,32 @@
     </dependencyManagement>
 
     <dependencies>
+        <dependency>
+            <groupId>io.activej</groupId>
+            <artifactId>activej-http</artifactId>
+            <version>${activej.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>${jackson-databind.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.activej</groupId>
+            <artifactId>activej-inject</artifactId>
+            <version>${activej.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.activej</groupId>
+            <artifactId>activej-promise</artifactId>
+            <version>${activej.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.activej</groupId>
+            <artifactId>activej-test</artifactId>
+            <version>${activej.version}</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>com.alicp.jetcache</groupId>
             <artifactId>jetcache-core</artifactId>
@@ -189,6 +215,8 @@
         <armeria.version>1.29.2</armeria.version>
         <yauaa.version>7.28.1</yauaa.version>
         <yavi.version>0.14.1</yavi.version>
+        <activej.version>6.0-rc2</activej.version>
+        <jackson-databind.version>2.17.0</jackson-databind.version>
         <sootup.version>1.3.0</sootup.version>
         <resilience4j.version>2.1.0</resilience4j.version>
         <jline.version>3.28.0</jline.version>

libraries-5/src/main/java/com/baeldung/activej/config/PersonModule.java

@@ -0,0 +1,82 @@
+package com.baeldung.activej.config;
+
+import com.baeldung.activej.controller.PersonController;
+import com.baeldung.activej.repository.PersonRepository;
+import com.baeldung.activej.service.PersonService;
+import io.activej.inject.annotation.Provides;
+import io.activej.inject.module.AbstractModule;
+
+import javax.sql.DataSource;
+import java.io.PrintWriter;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
+import java.util.logging.Logger;
+
+public class PersonModule extends AbstractModule {
+
+    @Provides
+    PersonController personController(PersonService personService) {
+        return new PersonController(personService);
+    }
+
+    @Provides
+    PersonService personService(PersonRepository personRepository) {
+        return new PersonService(personRepository);
+    }
+
+    @Provides
+    PersonRepository personRepository(DataSource dataSource) {
+        return new PersonRepository(dataSource);
+    }
+
+    @Provides
+    DataSource dataSource() {
+        return new DataSource() {
+            @Override
+            public Connection getConnection() throws SQLException {
+                return null;
+            }
+
+            @Override
+            public Connection getConnection(String username, String password) throws SQLException {
+                return null;
+            }
+
+            @Override
+            public PrintWriter getLogWriter() throws SQLException {
+                return null;
+            }
+
+            @Override
+            public void setLogWriter(PrintWriter out) throws SQLException {
+
+            }
+
+            @Override
+            public void setLoginTimeout(int seconds) throws SQLException {
+
+            }
+
+            @Override
+            public int getLoginTimeout() throws SQLException {
+                return 0;
+            }
+
+            @Override
+            public <T> T unwrap(Class<T> iface) throws SQLException {
+                return null;
+            }
+
+            @Override
+            public boolean isWrapperFor(Class<?> iface) throws SQLException {
+                return false;
+            }
+
+            @Override
+            public Logger getParentLogger() throws SQLFeatureNotSupportedException {
+                return null;
+            }
+        };
+    }
+}

libraries-5/src/main/java/com/baeldung/activej/controller/PersonController.java

@@ -0,0 +1,25 @@
+package com.baeldung.activej.controller;
+
+import com.baeldung.activej.service.PersonService;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.activej.http.AsyncServlet;
+import io.activej.http.HttpRequest;
+import io.activej.http.HttpResponse;
+import io.activej.promise.Promise;
+
+public class PersonController implements AsyncServlet {
+    private final PersonService personService;
+    private final ObjectMapper objectMapper;
+
+    public PersonController(PersonService personService) {
+        this.personService = personService;
+        this.objectMapper = new ObjectMapper();
+    }
+
+    @Override
+    public Promise<HttpResponse> serve(HttpRequest httpRequest) {
+        return personService.findAndVerifyPerson(httpRequest.getQueryParameter("name"))
+          .map((p) -> HttpResponse.ok200().withJson(objectMapper.writeValueAsString(p)).build())
+          .mapException(e -> e);
+    }
+}

libraries-5/src/main/java/com/baeldung/activej/model/Person.java

@@ -0,0 +1,4 @@
+package com.baeldung.activej.model;
+
+public record Person(String name, String description) {
+}

libraries-5/src/main/java/com/baeldung/activej/model/VerifiedPerson.java

@@ -0,0 +1,5 @@
+package com.baeldung.activej.model;
+
+public record VerifiedPerson(String name, String description,
+                             String notes, String result) {
+}

libraries-5/src/main/java/com/baeldung/activej/repository/PersonRepository.java

@@ -0,0 +1,25 @@
+package com.baeldung.activej.repository;
+
+import com.baeldung.activej.model.Person;
+import io.activej.promise.Promise;
+import io.activej.promise.Promises;
+
+import javax.sql.DataSource;
+import java.time.Duration;
+
+public class PersonRepository {
+    private final DataSource dataSource;
+
+    public PersonRepository(DataSource dataSource) {
+        this.dataSource = dataSource;
+    }
+
+    public DataSource getDataSource() {
+        return dataSource;
+    }
+
+    public Promise<Person> findPerson(String name) {
+        return Promises
+          .delay(Duration.ofMillis(100), new Person(name, name + " description"));
+    }
+}

libraries-5/src/main/java/com/baeldung/activej/service/PersonService.java

@@ -0,0 +1,38 @@
+package com.baeldung.activej.service;
+
+import com.baeldung.activej.model.VerifiedPerson;
+import com.baeldung.activej.repository.PersonRepository;
+import io.activej.promise.Promise;
+
+public class PersonService {
+    private final PersonRepository personRepository;
+
+    public PersonService(PersonRepository personRepository) {
+        this.personRepository = personRepository;
+    }
+
+    public PersonRepository getPersonRepository() {
+        return personRepository;
+    }
+
+    public Promise<VerifiedPerson> findAndVerifyPerson(String name) {
+        return personRepository.findPerson(name)
+          .combine(findPersonNotes(name),
+            (person, notes) -> new VerifiedPerson(person.name(), person.description(), notes, null))
+          .map(person -> verify(person));
+    }
+
+    private VerifiedPerson verify(VerifiedPerson person) {
+        if(person.description().startsWith("Good")) {
+            return new VerifiedPerson(person.name(), person.description(),
+                    person.notes(), "SUCCESS");
+        }
+
+        return new VerifiedPerson(person.name(), person.description(),
+                person.notes(), "FAIL");
+    }
+
+    private Promise<String> findPersonNotes(String name) {
+        return Promise.of(name + " notes");
+    }
+}

libraries-5/src/test/java/com/baeldung/activej/ActiveJIntegrationTest.java

@@ -0,0 +1,81 @@
+package com.baeldung.activej;
+
+import com.baeldung.activej.config.PersonModule;
+import com.baeldung.activej.controller.PersonController;
+import com.baeldung.activej.model.VerifiedPerson;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.activej.dns.DnsClient;
+import io.activej.eventloop.Eventloop;
+import io.activej.http.*;
+import io.activej.inject.Injector;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.net.InetAddress;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ActiveJIntegrationTest {
+
+    private static final ObjectMapper objectMapper = new ObjectMapper();
+    private static HttpServer server;
+    private static HttpClient client;
+    private static int port;
+    private static Eventloop eventloop;
+
+    @BeforeAll
+    static void setUp() throws Exception {
+        eventloop = Eventloop.create();
+
+        PersonModule personModule = new PersonModule();
+        PersonController personController = Injector.of(personModule).getInstance(PersonController.class);
+
+        RoutingServlet servlet = RoutingServlet.builder(eventloop)
+          .with(HttpMethod.GET,"/person", personController)
+          .build();
+
+        server = HttpServer.builder(eventloop, servlet)
+          .withListenPort(8080)
+          .build();
+
+        server.listen();
+
+        port = server.getListenAddresses().get(0).getPort();
+
+        InetAddress dnsServerAddress = InetAddress.getByName("8.8.8.8");
+        DnsClient dnsClient = DnsClient.builder(eventloop, dnsServerAddress).build();
+        client = HttpClient.builder(eventloop, dnsClient).build();
+    }
+
+    @AfterAll
+    static void tearDown() {
+        if (server != null) {
+            server.close();
+        }
+    }
+
+    @Test
+    void givenHttpServer_whenCallPersonEndpoint_thenExpectedVerificationResultShouldPresentInResponse() {
+        HttpRequest request = HttpRequest.get("http://localhost:" + port + "/person?name=my-name").build();
+
+        client.request(request)
+          .whenResult(response -> {
+              assertEquals(response.getCode(), 200);
+
+              response.loadBody()
+                .whenResult(body -> {
+                    try {
+                        VerifiedPerson responseData = objectMapper.readValue(body.getArray(),
+                          VerifiedPerson.class);
+                        assertEquals(responseData.result(), "FAIL");
+                        eventloop.breakEventloop();
+                    } catch (Exception e) {
+                        throw new RuntimeException(e);
+                    }
+                });
+          });
+
+        eventloop.run();
+    }
+}

libraries-5/src/test/java/com/baeldung/activej/ActiveJTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.activej;
+
+import com.baeldung.activej.config.PersonModule;
+import com.baeldung.activej.repository.PersonRepository;
+import com.baeldung.activej.service.PersonService;
+import io.activej.eventloop.Eventloop;
+import io.activej.inject.Injector;
+import org.junit.jupiter.api.Test;
+
+import javax.sql.DataSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class ActiveJTest {
+
+    @Test
+    void givenPersonModule_whenGetTheServiceBean_thenAllTheDependenciesShouldBePresent() {
+        PersonModule personModule = new PersonModule();
+
+        PersonService personService = Injector.of(personModule).getInstance(PersonService.class);
+        assertNotNull(personService);
+        PersonRepository personRepository = personService.getPersonRepository();
+        assertNotNull(personRepository);
+        DataSource dataSource = personRepository.getDataSource();
+        assertNotNull(dataSource);
+    }
+
+    @Test
+    void givenEventloop_whenCallFindAndVerifyPerson_thenExpectedVerificationResultShouldBePresent() {
+        PersonModule personModule = new PersonModule();
+
+        PersonService personService = Injector.of(personModule).getInstance(PersonService.class);
+
+        Eventloop eventloop = Eventloop.create();
+        eventloop.run();
+        personService.findAndVerifyPerson("Good person")
+          .whenResult(verifiedPerson -> assertEquals("SUCCESS", verifiedPerson.result()));
+    }
+}