Merge pull request #78 from eclipse/fix_couchbase_fiel

Fix couchbase field

Author: otaviojava

couchbase-driver/src/main/java/org/jnosql/diana/couchbase/key/CouchbaseBucketManager.java

@@ -29,6 +29,7 @@
 import java.util.Objects;
 import java.util.Optional;
 
+import static java.util.Objects.requireNonNull;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.stream.Collectors.toList;
 import static java.util.stream.StreamSupport.stream;
@@ -39,8 +40,6 @@
  */
 public class CouchbaseBucketManager implements BucketManager {
 
-    private static final String VALUE_FIELD = "value";
-
     private static final Jsonb JSONB = JsonbBuilder.create();
 
     private final Bucket bucket;
@@ -54,57 +53,56 @@ public class CouchbaseBucketManager implements BucketManager {
 
     @Override
     public <K, V> void put(K key, V value) throws NullPointerException {
-        Objects.requireNonNull(key, "key is required");
-        Objects.requireNonNull(value, "value is required");
-        JsonObject jsonObject = JsonObject.create()
-                .put("value", JSONB.toJson(value));
-
-        bucket.upsert(JsonDocument.create(key.toString(), jsonObject));
+        requireNonNull(key, "key is required");
+        requireNonNull(value, "value is required");
+        bucket.upsert(JsonDocument.create(key.toString(), JsonObjectCouchbaseUtil.toJson(JSONB, value)));
     }
 
     @Override
     public <K> void put(KeyValueEntity<K> entity) throws NullPointerException {
-        Objects.requireNonNull(entity, "entity is required");
+        requireNonNull(entity, "entity is required");
         put(entity.getKey(), convert(entity.getValue()));
     }
 
     @Override
     public <K> void put(KeyValueEntity<K> entity, Duration ttl) throws NullPointerException, UnsupportedOperationException {
-        Objects.requireNonNull(entity, "entity is required");
-        Objects.requireNonNull(ttl, "ttl is required");
-        JsonObject jsonObject = JsonObject.create()
-                .put(VALUE_FIELD, entity.getValue().get());
+        requireNonNull(entity, "entity is required");
+        requireNonNull(ttl, "ttl is required");
+
+
+        JsonObject jsonObject = JsonObjectCouchbaseUtil.toJson(JSONB, entity.get());
 
-        bucket.upsert(JsonDocument.create(entity.getKey().toString(), jsonObject), ttl.toMillis(), MILLISECONDS);
+        JsonDocument jsonDocument = JsonDocument.create(entity.getKey().toString(), (int) ttl.getSeconds(), jsonObject);
+        bucket.upsert(jsonDocument, ttl.toMillis(), MILLISECONDS);
     }
 
     @Override
     public <K> void put(Iterable<KeyValueEntity<K>> keyValueEntities) throws NullPointerException {
-        Objects.requireNonNull(keyValueEntities, "keyValueEntities is required");
+        requireNonNull(keyValueEntities, "keyValueEntities is required");
         keyValueEntities.forEach(this::put);
     }
 
     @Override
     public <K> void put(Iterable<KeyValueEntity<K>> keyValueEntities, Duration ttl) throws NullPointerException, UnsupportedOperationException {
-        Objects.requireNonNull(keyValueEntities, "keyValueEntities is required");
-        Objects.requireNonNull(ttl, "ttl is required");
+        requireNonNull(keyValueEntities, "keyValueEntities is required");
+        requireNonNull(ttl, "ttl is required");
         keyValueEntities.forEach(k -> this.put(k, ttl));
     }
 
     @Override
     public <K> Optional<Value> get(K key) throws NullPointerException {
-        Objects.requireNonNull(key, "key is required");
+        requireNonNull(key, "key is required");
         JsonDocument jsonDocument = bucket.get(key.toString());
         if (Objects.isNull(jsonDocument)) {
             return Optional.empty();
         }
-        Object value = jsonDocument.content().get(VALUE_FIELD);
+        Object value = jsonDocument.content();
         return Optional.of(ValueJSON.of(value.toString()));
     }
 
     @Override
     public <K> Iterable<Value> get(Iterable<K> keys) throws NullPointerException {
-        Objects.requireNonNull(keys, "keys is required");
+        requireNonNull(keys, "keys is required");
         return stream(keys.spliterator(), false)
                 .map(this::get)
                 .filter(Optional::isPresent)
@@ -114,13 +112,13 @@ public <K> Iterable<Value> get(Iterable<K> keys) throws NullPointerException {
 
     @Override
     public <K> void remove(K key) throws NullPointerException {
-        Objects.requireNonNull(key, "key is required");
+        requireNonNull(key, "key is required");
         bucket.remove(key.toString());
     }
 
     @Override
     public <K> void remove(Iterable<K> keys) throws NullPointerException {
-        Objects.requireNonNull(keys, "keys is required");
+        requireNonNull(keys, "keys is required");
         keys.forEach(this::remove);
     }
 

couchbase-driver/src/main/java/org/jnosql/diana/couchbase/key/JsonObjectCouchbaseUtil.java

@@ -0,0 +1,45 @@
+/*
+ *  Copyright (c) 2017 Otávio Santana and others
+ *   All rights reserved. This program and the accompanying materials
+ *   are made available under the terms of the Eclipse Public License v1.0
+ *   and Apache License v2.0 which accompanies this distribution.
+ *   The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ *   and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php.
+ *
+ *   You may elect to redistribute this code under either of these licenses.
+ *
+ *   Contributors:
+ *
+ *   Otavio Santana
+ */
+package org.jnosql.diana.couchbase.key;
+
+import com.couchbase.client.java.document.json.JsonObject;
+
+import javax.json.bind.Jsonb;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+
+final class JsonObjectCouchbaseUtil {
+
+    private static final Type TYPE = new HashMap<String, Object>() {
+    }.getClass().getGenericSuperclass();
+
+    private JsonObjectCouchbaseUtil() {
+    }
+
+    static JsonObject toJson(Jsonb jsonb, Object value) {
+
+        ByteArrayOutputStream stream = new ByteArrayOutputStream();
+        jsonb.toJson(value, stream);
+        InputStream inputStream = new ByteArrayInputStream(stream.toByteArray());
+        Map<String, ?> map = jsonb.fromJson(inputStream, TYPE);
+
+        return JsonObject.from(map);
+
+    }
+}

couchbase-driver/src/test/java/org/jnosql/diana/couchbase/key/CouchbaseBucketManagerTest.java

@@ -21,17 +21,23 @@
 import org.jnosql.diana.couchbase.CouchbaseUtil;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
+import java.time.Duration;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
 
 import static java.util.Arrays.asList;
+import static java.util.Collections.singleton;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class CouchbaseBucketManagerTest {
 
@@ -73,6 +79,49 @@ public void shouldPutValue() {
         assertEquals(userOtavio, otavio.get().get(User.class));
     }
 
+    @Test
+    public void shouldPutValues() {
+
+        List<KeyValueEntity<String>> entities = asList(KeyValueEntity.of(KEY_OTAVIO, userOtavio),
+                KeyValueEntity.of(KEY_SORO, userSoro));
+
+        keyValueEntityManager.put(entities);
+        Optional<Value> otavio = keyValueEntityManager.get(KEY_OTAVIO);
+        assertTrue(otavio.isPresent());
+        assertEquals(userOtavio, otavio.get().get(User.class));
+
+        Optional<Value> soro = keyValueEntityManager.get(KEY_SORO);
+        assertTrue(soro.isPresent());
+        assertEquals(userSoro, soro.get().get(User.class));
+    }
+
+    @Test
+    @Disabled
+    public void shouldPutValueTtl() throws InterruptedException {
+
+        keyValueEntityManager.put(KeyValueEntity.of(KEY_OTAVIO, userOtavio), Duration.ofSeconds(1L));
+
+        Optional<Value> otavio = keyValueEntityManager.get(KEY_OTAVIO);
+        assertTrue(otavio.isPresent());
+        Thread.sleep(5_000);
+        otavio = keyValueEntityManager.get(KEY_OTAVIO);
+        assertFalse(otavio.isPresent());
+    }
+
+    @Test
+    @Disabled
+    public void shouldPutValuesTtl() throws InterruptedException {
+
+        keyValueEntityManager.put(singleton(KeyValueEntity.of(KEY_OTAVIO, userOtavio)), Duration.ofSeconds(1L));
+        Optional<Value> otavio = keyValueEntityManager.get(KEY_OTAVIO);
+        assertTrue(otavio.isPresent());
+        Thread.sleep(5_000);
+        otavio = keyValueEntityManager.get(KEY_OTAVIO);
+        assertFalse(otavio.isPresent());
+    }
+
+
+
     @Test
     public void shouldPutKeyValue() {
         keyValueEntityManager.put(entityOtavio);