fix: fix CI to run tests of EtcdStorageITCase (#380)

 * Fix some EtcdStorage methods to pass failed tests
 *  Introduce EtcdMeta, metadata class for EtcdStorage
 *  Enable EtcdStorageITCase and pull automatically Etcd docker image before all tests

Close: #309

Author: baudoliver7

pom.xml

@@ -240,20 +240,12 @@ SOFTWARE.
     <plugins>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-surefire-plugin</artifactId>
-        <version>2.22.2</version>
-        <dependencies>
-          <dependency>
-            <groupId>org.apache.maven.surefire</groupId>
-            <artifactId>surefire-junit-platform</artifactId>
-            <version>2.22.2</version>
-          </dependency>
-        </dependencies>
-      </plugin>
-      <plugin>
         <artifactId>maven-failsafe-plugin</artifactId>
+        <version>3.0.0-M5</version>
         <configuration>
-          <parallel>none</parallel>
+          <forkCount>1</forkCount>
+          <reuseForks>true</reuseForks>
+          <useSystemClassLoader>true</useSystemClassLoader>
         </configuration>
         <executions>
           <execution>

src/main/java/com/artipie/asto/etcd/EtcdMeta.java

@@ -0,0 +1,40 @@
+/*
+ * The MIT License (MIT) Copyright (c) 2020-2021 artipie.com
+ * https://github.com/artipie/asto/LICENSE.txt
+ */
+package com.artipie.asto.etcd;
+
+import com.artipie.asto.Meta;
+import io.etcd.jetcd.KeyValue;
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Metadata from Etcd key value.
+ * @since 1.9
+ */
+final class EtcdMeta implements Meta {
+
+    /**
+     * Key value.
+     */
+    private final KeyValue kvs;
+
+    /**
+     * New metadata.
+     * @param kvs Key value
+     */
+    EtcdMeta(final KeyValue kvs) {
+        this.kvs = kvs;
+    }
+
+    @Override
+    public <T> T read(final ReadOperator<T> opr) {
+        final Map<String, String> raw = new HashMap<>();
+        Meta.OP_SIZE.put(raw, Long.valueOf(this.kvs.getValue().size()));
+        Meta.OP_CREATED_AT.put(raw, Instant.ofEpochMilli(this.kvs.getCreateRevision()));
+        Meta.OP_UPDATED_AT.put(raw, Instant.ofEpochMilli(this.kvs.getModRevision()));
+        return opr.take(raw);
+    }
+}

src/main/java/com/artipie/asto/etcd/EtcdStorage.java

@@ -15,11 +15,14 @@
 import com.artipie.asto.ext.PublisherAs;
 import io.etcd.jetcd.ByteSequence;
 import io.etcd.jetcd.Client;
+import io.etcd.jetcd.KeyValue;
+import io.etcd.jetcd.kv.GetResponse;
 import io.etcd.jetcd.options.GetOption;
 import io.etcd.jetcd.options.GetOption.SortOrder;
 import io.vavr.NotImplementedError;
 import java.nio.charset.StandardCharsets;
 import java.util.Collection;
+import java.util.Comparator;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.function.Function;
@@ -36,6 +39,7 @@
  * </p>
  * @since 1.0
  * @checkstyle ReturnCountCheck (200 lines)
+ * @checkstyle ClassDataAbstractionCouplingCheck (500 lines)
  */
 public final class EtcdStorage implements Storage {
 
@@ -44,6 +48,12 @@ public final class EtcdStorage implements Storage {
      */
     private static final long MAX_SIZE = 1024 * 1024 * 10;
 
+    /**
+     * Etcd root key.
+     */
+    private static final ByteSequence ETCD_ROOT_KEY =
+        ByteSequence.from("\0", StandardCharsets.UTF_8);
+
     /**
      * Etcd client.
      */
@@ -67,13 +77,27 @@ public CompletableFuture<Boolean> exists(final Key key) {
 
     @Override
     public CompletableFuture<Collection<Key>> list(final Key prefix) {
-        return this.client.getKVClient().get(
-            keyToSeq(prefix),
-            GetOption.newBuilder()
-                .withKeysOnly(true)
-                .withSortOrder(SortOrder.ASCEND)
-                .build()
-        ).thenApply(
+        final CompletableFuture<GetResponse> future;
+        if (prefix == Key.ROOT) {
+            future = this.client.getKVClient().get(
+                EtcdStorage.ETCD_ROOT_KEY,
+                GetOption.newBuilder()
+                    .withKeysOnly(true)
+                    .withSortOrder(SortOrder.ASCEND)
+                    .withRange(EtcdStorage.ETCD_ROOT_KEY)
+                    .build()
+            );
+        } else {
+            future = this.client.getKVClient().get(
+                keyToSeq(prefix),
+                GetOption.newBuilder()
+                    .withKeysOnly(true)
+                    .withSortOrder(SortOrder.ASCEND)
+                    .isPrefix(true)
+                    .build()
+            );
+        }
+        return future.thenApply(
             rsp -> rsp.getKvs().stream()
                 .map(kv -> new String(kv.getKey().getBytes(), StandardCharsets.UTF_8))
                 .map(str -> new Key.From(str))
@@ -108,14 +132,22 @@ public CompletableFuture<Void> move(final Key source, final Key destination) {
 
     @Override
     public CompletableFuture<? extends Meta> metadata(final Key key) {
-        return CompletableFuture.completedFuture(Meta.EMPTY);
+        return this.client.getKVClient().get(keyToSeq(key)).thenApply(
+            rsp -> rsp.getKvs().stream().max(
+                Comparator.comparingLong(KeyValue::getVersion)
+            )
+        ).thenApply(
+            kv -> kv.orElseThrow(
+                () -> new ValueNotFoundException(key)
+            )
+        ).thenApply(kv -> new EtcdMeta(kv));
     }
 
     @Override
     public CompletableFuture<Content> value(final Key key) {
         return this.client.getKVClient().get(keyToSeq(key)).thenApply(
             rsp -> rsp.getKvs().stream().max(
-                (left, right) -> Long.compare(left.getVersion(), right.getVersion())
+                Comparator.comparingLong(KeyValue::getVersion)
             )
         ).thenApply(
             kv -> kv.orElseThrow(

src/test/java/com/artipie/asto/etcd/EtcdStorageITCase.java

@@ -5,54 +5,114 @@
 
 package com.artipie.asto.etcd;
 
+import com.artipie.asto.Content;
 import com.artipie.asto.Key;
 import com.artipie.asto.Storage;
 import com.artipie.asto.blocking.BlockingStorage;
+import com.github.dockerjava.api.DockerClient;
 import io.etcd.jetcd.Client;
-import io.etcd.jetcd.launcher.EtcdCluster;
+import io.etcd.jetcd.launcher.EtcdContainer;
 import io.etcd.jetcd.test.EtcdClusterExtension;
+import java.nio.charset.StandardCharsets;
 import java.util.concurrent.CompletionException;
 import org.hamcrest.MatcherAssert;
 import org.hamcrest.Matchers;
 import org.hamcrest.core.IsEqual;
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.api.condition.DisabledOnOs;
+import org.junit.jupiter.api.condition.OS;
+import org.testcontainers.DockerClientFactory;
 
 /**
  * Test case for etcd-storage.
  * @since 1.0
- * @todo #306:90min The test is disabled,
- *  the CI can't start ETCD extension which depends on testcontainer with
- *  etcd Docker image. Let's fix this issue on CI and enable the test.
  * @todo #306:90min Add etcd storage to StorageExtension to run all common
  *  tests on EtcdStorage too. It could be not an easy task, since etcd
  *  test depends on etcd clust with at least one node. For this test
  *  it starts using testcontainers and `EtcdCluster` junit extension.
+ * @todo #309:30min Run Etcd in windows containers while testing on windows.
+ *  Currently, when we try to run integration tests based on testcontainers within a platform
+ *  windows, we notice that Etcd container (presently based on Linux) doesn't work. We have to build
+ *  and publish an Etcd docker image based on windows to avoid this issue.
+ *  Please, build an Etcd image for windows (version 3.5.1) and write tests so as to detect before
+ *  running integration tests, the type of platform (linux or windows) in order to pull the right
+ *  docker image. After that, enable the test below for windows by removing
+ *  {@code @DisabledOnOs(OS.WINDOWS)}.
  */
-@Disabled
-public final class EtcdStorageITCase {
+@SuppressWarnings("PMD.AvoidDuplicateLiterals")
+@DisabledOnOs(OS.WINDOWS)
+final class EtcdStorageITCase {
 
     /**
      * Test cluster.
      */
-    @RegisterExtension
-    static final EtcdCluster ETCD = new EtcdClusterExtension("test-etcd", 1);
+    static final EtcdClusterExtension ETCD = new EtcdClusterExtension(
+        "test-etcd",
+        1,
+        false,
+        "--data-dir",
+        "/data.etcd0"
+    );
 
     /**
      * Storage.
      */
     private Storage storage;
 
+    @BeforeAll
+    static void beforeAll() throws InterruptedException {
+        final DockerClient client = DockerClientFactory.instance().client();
+        client.pullImageCmd(EtcdContainer.ETCD_DOCKER_IMAGE_NAME)
+            .start()
+            .awaitCompletion();
+        ETCD.start();
+    }
+
     @BeforeEach
     void setUp() {
         this.storage = new EtcdStorage(
             Client.builder().endpoints(ETCD.getClientEndpoints()).build()
         );
     }
 
+    @AfterAll
+    static void afterAll() {
+        ETCD.close();
+    }
+
+    @Test
+    void listsItems() {
+        final Key one = new Key.From("one");
+        final Key two = new Key.From("a/two");
+        final Key three = new Key.From("a/three");
+        this.storage.save(
+            one,
+            new Content.From("data 1".getBytes(StandardCharsets.UTF_8))
+        ).join();
+        this.storage.save(
+            two,
+            new Content.From("data 2".getBytes(StandardCharsets.UTF_8))
+        ).join();
+        this.storage.save(
+            three,
+            new Content.From("data 3".getBytes(StandardCharsets.UTF_8))
+        ).join();
+        MatcherAssert.assertThat(
+            "Should list all items",
+            new BlockingStorage(this.storage).list(Key.ROOT),
+            Matchers.hasItems(one, two, three)
+        );
+        MatcherAssert.assertThat(
+            "Should list prefixed items",
+            new BlockingStorage(this.storage).list(new Key.From("a")),
+            Matchers.hasItems(two, three)
+        );
+    }
+
     @Test
     void readAndWrite() {
         final Key key = new Key.From("one", "two", "three");
@@ -114,8 +174,8 @@ void failsIfNothingToDelete() {
             () -> bsto.delete(key)
         );
         MatcherAssert.assertThat(
-            cex.getCause().getMessage(),
-            Matchers.stringContainsInOrder("Key", key.toString(), "was not found")
+            cex.getCause().getCause().getMessage(),
+            new IsEqual<>(String.format("No value for key: %s", key))
         );
     }
 }