50 Adding integration tests

.github/workflows/release.yml

@@ -26,7 +26,7 @@ jobs:
           cache: maven
 
       - name: Compile and test with Maven
-        run: mvn -B test --file pom.xml
+        run: mvn -B verify --file pom.xml
 
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v2

Dockerfile

@@ -1,6 +1,16 @@
 FROM eclipse-temurin:19-jre-jammy
-COPY target/dependency /lib
-COPY target/classes /app
+#COPY target/dependency /lib
 WORKDIR /app
+ARG USERNAME=hazeuser
+ARG USER_UID=1000
+ARG USER_GID=$USER_UID
+RUN groupadd --gid $USER_GID $USERNAME && \
+    useradd --uid $USER_UID --gid $USER_GID -m $USERNAME
+ADD https://repo1.maven.org/maven2/org/apache/logging/log4j/log4j-core/2.20.0/log4j-core-2.20.0.jar ./lib/
+ADD https://repo1.maven.org/maven2/org/apache/logging/log4j/log4j-api/2.20.0/log4j-api-2.20.0.jar ./lib/
+#RUN chmod --recursive 440 ./lib/
+COPY target/classes .
+RUN chown --recursive $USERNAME:$USERNAME .
+USER $USERNAME
 EXPOSE 6379
-ENTRYPOINT ["java","-cp" , "/app:/lib/*", "--enable-preview", "org.fungover.haze.Main"]
+ENTRYPOINT ["java","-cp","/app:/app/lib/*","--enable-preview","org.fungover.haze.Main"]

pom.xml

@@ -48,6 +48,30 @@
       <artifactId>log4j-core</artifactId>
       <version>2.20.0</version>
     </dependency>
+    <dependency>
+      <groupId>redis.clients</groupId>
+      <artifactId>jedis</artifactId>
+      <version>4.3.1</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.testcontainers</groupId>
+      <artifactId>testcontainers</artifactId>
+      <version>1.17.6</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.testcontainers</groupId>
+      <artifactId>junit-jupiter</artifactId>
+      <version>1.17.6</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-nop</artifactId>
+      <version>1.7.36</version>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
   <build>
     <plugins>
@@ -95,6 +119,16 @@
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-jar-plugin</artifactId>
         <version>3.3.0</version>
+        <executions>
+          <execution>
+            <id>default-jar</id>
+            <phase>none</phase>
+            <configuration>
+              <finalName>unwanted</finalName>
+              <classifier>unwanted</classifier>
+            </configuration>
+          </execution>
+        </executions>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
@@ -163,23 +197,6 @@
           <argLine>@{argLine} --enable-preview</argLine>
         </configuration>
       </plugin>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-dependency-plugin</artifactId>
-        <version>3.5.0</version>
-        <executions>
-          <execution>
-            <id>copy-dependencies</id>
-            <phase>test</phase>
-            <goals>
-              <goal>copy-dependencies</goal>
-            </goals>
-            <configuration>
-              <includeScope>runtime</includeScope>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
     </plugins>
   </build>
 </project>

src/main/java/org/fungover/haze/Main.java

@@ -9,6 +9,7 @@
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 import java.net.Socket;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -35,7 +36,6 @@ public static void main(String[] args) {
             serverSocket.bind(new InetSocketAddress(initialize.getPort()));
             while (serverOpen) {
                 var client = serverSocket.accept();
-                logger.info("Application started: serverSocket.accept()");
 
                 Runnable newThread = () -> {
                     try {
@@ -45,19 +45,16 @@ public static void main(String[] args) {
                             List<String> inputList = new ArrayList<>();
 
                             String firstReading = input.readLine();
+                            logger.debug(firstReading);
                             readInputStream(input, inputList, firstReading);
 
                             clientAuthenticated = authenticateClient(auth, isPasswordSet, client, inputList, clientAuthenticated);
 
-                            client.getOutputStream().write(executeCommand(hazeDatabase, inputList, hazeList).getBytes());
-
-                            inputList.forEach(System.out::println); // For checking incoming message
-
-                            printThreadDebug();
+                            client.getOutputStream().write(executeCommand(hazeDatabase, inputList, hazeList).getBytes(StandardCharsets.UTF_8));
+                            client.getOutputStream().flush();
 
                             inputList.clear();
                         }
-
                     } catch (IOException e) {
                         logger.error(e);
                     }
@@ -75,14 +72,9 @@ private static void shutdown(HazeDatabase hazeDatabase) {
         logger.info("Shutting down....");
     }
 
-    private static void printThreadDebug() {
-        logger.debug("ThreadID {}", () -> Thread.currentThread().threadId());  // Only for Debug
-        logger.debug("Is virtual Thread {}", () -> Thread.currentThread().isVirtual()); // Only for Debug
-    }
-
     public static String executeCommand(HazeDatabase hazeDatabase, List<String> inputList, HazeList hazeList) {
         if (inputList.isEmpty() || inputList.get(0).isEmpty()) {
-            return "-ERR no command provided\r\n";
+            return "-ERR unknown command\r\n";
         }
 
         logger.debug("executeCommand: {} {} ", () -> hazeDatabase, () -> inputList);
@@ -118,7 +110,7 @@ public static String executeCommand(HazeDatabase hazeDatabase, List<String> inpu
 
     private static void readInputStream(BufferedReader input, List<String> inputList, String firstReading) throws
             IOException {
-        logger.debug("readInputStream: {} {} {}", () -> input, () -> inputList, () -> firstReading);
+        logger.debug("readInputStream: {} {}", () -> inputList, () -> firstReading);
         int size;
         if (firstReading.startsWith("*")) {
             size = Integer.parseInt(firstReading.substring(1)) * 2;

src/test/java/org/fungover/haze/MainTest.java

@@ -21,7 +21,7 @@ void callingExecuteCommandWithValidNonExistingInputReturnsColonOne() {
 
     @Test
     void callingExecuteCommandWithInvalidInputStringReturnsErrorMessage() {
-        assertThat(Main.executeCommand(database, List.of(""), hazeList)).isEqualTo("-ERR no command provided\r\n");
+        assertThat(Main.executeCommand(database, List.of(""), hazeList)).isEqualTo("-ERR unknown command\r\n");
 
     }
 

src/test/java/org/fungover/haze/integration/HazeExtension.java

@@ -0,0 +1,55 @@
+package org.fungover.haze.integration;
+
+import org.junit.jupiter.api.extension.AfterAllCallback;
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+import redis.clients.jedis.JedisPooled;
+
+import java.lang.reflect.Field;
+import java.nio.file.Path;
+import java.util.List;
+
+public class HazeExtension implements BeforeAllCallback, AfterAllCallback, BeforeEachCallback {
+
+    private GenericContainer<?> haze;
+    private JedisPooled pool;
+
+    @Override
+    public void beforeAll(ExtensionContext extensionContext) throws Exception {
+        haze = new GenericContainer<>(new ImageFromDockerfile()
+                .withDockerfile(Path.of("./Dockerfile")))
+                .withExposedPorts(6379);
+        haze.start();
+        pool = new JedisPooled(haze.getHost(), haze.getFirstMappedPort());
+    }
+
+    @Override
+    public void afterAll(ExtensionContext context) {
+        // do nothing, Testcontainers handles container shutdown
+        if (pool != null)
+            pool.close();
+    }
+
+    @Override
+    public void beforeEach(ExtensionContext extensionContext) throws Exception {
+
+        // Get the list of test instances (instances of test classes)
+        final List<Object> testInstances =
+                extensionContext.getRequiredTestInstances().getAllInstances();
+
+        testInstances.forEach((ti) -> {
+            for (Field field : ti.getClass().getDeclaredFields()) {
+                if (field.isAnnotationPresent(Pool.class)) {
+                    try {
+                        field.set(ti, pool);
+                    } catch (IllegalAccessException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            }
+        });
+    }
+}

src/test/java/org/fungover/haze/integration/HazeIT.java

@@ -0,0 +1,90 @@
+package org.fungover.haze.integration;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import redis.clients.jedis.JedisPooled;
+import redis.clients.jedis.Protocol;
+import redis.clients.jedis.util.SafeEncoder;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@ExtendWith(HazeExtension.class)
+class HazeIT {
+
+    @Pool
+    JedisPooled pool;
+
+    @Test
+    void pingPong() {
+        //Simple PING command with no message should return PONG as simple string
+        var result = pool.sendCommand(Protocol.Command.PING);
+        assertThat(SafeEncoder.encode((byte[]) result)).isEqualTo("PONG");
+        //PING with message argument should return bulk string with the argument
+        result = pool.sendCommand(Protocol.Command.PING, "HELLO");
+        assertThat(SafeEncoder.encode((byte[]) result)).isEqualTo("HELLO");
+        //PING with message argument containing space should return bulk string with the argument
+        //    result = pool.sendCommand(Protocol.Command.PING, "HELLO\r\n There");
+        //    assertThat(SafeEncoder.encode((byte[]) result)).isEqualTo("HELLO\r\n There");
+    }
+
+    @Test
+    void setNx() {
+        pool.del("test");
+        pool.del("test1");
+        assertThat(pool.setnx("test", "test")).isEqualTo(1);
+        assertThat(pool.setnx("test1", "test")).isEqualTo(1);
+        //Key test already exists so should not be set
+        assertThat(pool.setnx("test", "test1")).isZero();
+        pool.del("test");
+        pool.del("test1");
+    }
+
+    @Test
+    void setGet() {
+        assertThat(pool.set("test", "test")).isEqualTo("OK");
+        assertThat(pool.get("test")).isEqualTo("test");
+        pool.del("test");
+    }
+
+    @Test
+    void exists() {
+        assertThat(pool.set("test", "test")).isEqualTo("OK");
+        assertThat(pool.exists("test")).isTrue();
+        pool.del("notused");
+        assertThat(pool.exists("notused")).isFalse();
+    }
+
+    @Test
+    void listLPushLPop() {
+        assertThat(pool.lpush("left", "first")).isEqualTo(1);
+        assertThat(pool.llen("left")).isEqualTo(1);
+        assertThat(pool.lpop("left")).isEqualTo("first");
+        assertThat(pool.llen("left")).isZero();
+        pool.del("left");
+        assertThat(pool.exists("left")).isFalse();
+    }
+
+    @Test
+    void listRPushRPop() {
+        assertThat(pool.rpush("right", "first")).isEqualTo(1);
+        assertThat(pool.llen("right")).isEqualTo(1);
+        assertThat(pool.rpop("right")).isEqualTo("first");
+        assertThat(pool.llen("right")).isZero();
+        pool.del("right");
+        assertThat(pool.exists("right")).isFalse();
+    }
+
+    @Test
+    void listKeyWithMultipleValues() {
+        assertThat(pool.lpush("test", "first")).isEqualTo(1);
+        assertThat(pool.lpush("test", "second")).isEqualTo(2);
+        assertThat(pool.llen("test")).isEqualTo(2);
+        assertThat(pool.lpush("test", "third", "fourth")).isEqualTo(4);
+        assertThat(pool.llen("test")).isEqualTo(4);
+        assertThat(pool.rpush("test", "fifth", "sixth")).isEqualTo(6);
+        assertThat(pool.llen("test")).isEqualTo(6);
+
+        pool.del("test");
+        assertThat(pool.exists("right")).isFalse();
+    }
+}

src/test/java/org/fungover/haze/integration/Pool.java

@@ -0,0 +1,9 @@
+package org.fungover.haze.integration;
+
+import java.lang.annotation.*;
+
+@Documented
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Pool {
+}