com.couchbase.client.java.AsyncBucket Java Examples

@Override
public List<T> readBulk(Iterable<String> ids) {
    final AsyncBucket asyncBucket = bucket.async();
    Observable<JsonDocument> asyncOperation = Observable.from(ids).flatMap(new Func1<String, Observable<JsonDocument>>() {
        public Observable<JsonDocument> call(String key) {
            return asyncBucket.get(key);
        }
    });

    final List<T> items = new ArrayList<T>();
    try {
        asyncOperation.toBlocking().forEach(new Action1<JsonDocument>() {
            public void call(JsonDocument doc) {
                T item = converter.fromDocument(doc);
                items.add(item);
            }
        });
    } catch (Exception e) {
        logger.error("Error during bulk get", e);
    }

    return items;
}
 

@Override
public List<JsonDocument> getDocumentsAsync(final AsyncBucket asyncBucket, Iterable<String> keys) {
    Observable<JsonDocument> asyncBulkGet = Observable.from(keys).flatMap(new Func1<String, Observable<JsonDocument>>() {
        public Observable<JsonDocument> call(String key) {
            return asyncBucket.get(key);
        }
    });

    final List<JsonDocument> docs = new ArrayList<>();
    try {
        asyncBulkGet.toBlocking().forEach(new Action1<JsonDocument>() {
            public void call(JsonDocument doc) {
                docs.add(doc);
            }
        });
    } catch (Exception e) {
        logger.error("Error during bulk get", e);
    }

    return docs;
}
 

@Test
public void testGetAsyncNonExistingKey() throws Exception {
  String key = "NonExistingKey";
  Bucket bucket = mock(Bucket.class);
  AsyncBucket asyncBucket = mock(AsyncBucket.class);
  CouchbaseTableReadFunction readFunction = createAndInit(String.class, new StringSerde(), bucket, asyncBucket);
  when(asyncBucket.get(eq(key), anyObject(), anyLong(), any(TimeUnit.class))).thenReturn(Observable.empty());
  assertNull(readFunction.getAsync(key).get());
}
 

@Override
public void deleteBulk(Iterable<String> ids) {
    final AsyncBucket asyncBucket = bucket.async();
    Observable.from(ids).flatMap(new Func1<String, Observable<JsonDocument>>() {
        @SuppressWarnings("unchecked")
        @Override
        public Observable<JsonDocument> call(String key) {
            return asyncBucket.remove(key).retryWhen(RetryBuilder.anyOf(BackpressureException.class).delay(Delay.exponential(TimeUnit.MILLISECONDS, 100)).max(10).build());
        }
    }).last().toBlocking().single();
}
 

@Override
public void updateBulk(Iterable<T> items) {
    final AsyncBucket asyncBucket = bucket.async();
    Observable.from(items).flatMap(new Func1<T, Observable<JsonDocument>>() {
        @SuppressWarnings("unchecked")
        @Override
        public Observable<JsonDocument> call(final T t) {
            JsonDocument doc = converter.toDocument(t);
            return asyncBucket.upsert(doc).retryWhen(RetryBuilder.anyOf(BackpressureException.class).delay(Delay.exponential(TimeUnit.MILLISECONDS, 100)).max(10).build());
        }
    }).last().toBlocking().single();
}
 

@Override
public void createBulk(Iterable<T> items) {
    final AsyncBucket asyncBucket = bucket.async();
    Observable.from(items).flatMap(new Func1<T, Observable<JsonDocument>>() {
        @SuppressWarnings("unchecked")
        @Override
        public Observable<JsonDocument> call(final T t) {
            if (t.getId() == null) {
                t.setId(UUID.randomUUID().toString());
            }
            JsonDocument doc = converter.toDocument(t);
            return asyncBucket.insert(doc).retryWhen(RetryBuilder.anyOf(BackpressureException.class).delay(Delay.exponential(TimeUnit.MILLISECONDS, 100)).max(10).build());
        }
    }).last().toBlocking().single();
}
 

private <V> CouchbaseTableReadFunction<V> createAndInit(Class<V> valueClass, Serde<V> serde, Bucket bucket,
    AsyncBucket asyncBucket) {
  when(bucket.async()).thenReturn(asyncBucket);
  PowerMockito.stub(PowerMockito.method(CouchbaseBucketRegistry.class, "getBucket", String.class, List.class,
      CouchbaseEnvironmentConfigs.class)).toReturn(bucket);
  CouchbaseTableReadFunction<V> readFunction =
      new CouchbaseTableReadFunction<>(DEFAULT_BUCKET_NAME, valueClass, DEFAULT_CLUSTER_NODE).withSerde(serde);
  readFunction.init(mock(Context.class), mock(AsyncReadWriteTable.class));
  return readFunction;
}
 

@Test
public void testGetAsyncJsonObjectValue() throws Exception {
  String key = "key";
  JsonObject value = JsonObject.fromJson("{\"id\": 1}");
  Bucket bucket = mock(Bucket.class);
  AsyncBucket asyncBucket = mock(AsyncBucket.class);
  CouchbaseTableReadFunction readFunction = createAndInit(bucket, asyncBucket);
  when(asyncBucket.get(eq(key), anyObject(), anyLong(), any(TimeUnit.class))).thenReturn(
      Observable.just(JsonDocument.create(key, value)));
  assertEquals(value, readFunction.getAsync(key).get());
}
 

@Test
public void testGetAsyncStringValue() throws Exception {
  String key = "key";
  String value = "value";
  StringSerde stringSerde = new StringSerde();
  Bucket bucket = mock(Bucket.class);
  AsyncBucket asyncBucket = mock(AsyncBucket.class);
  CouchbaseTableReadFunction readFunction = createAndInit(String.class, stringSerde, bucket, asyncBucket);
  when(asyncBucket.get(eq(key), anyObject(), anyLong(), any(TimeUnit.class))).thenReturn(
      Observable.just(BinaryDocument.create(key, Unpooled.wrappedBuffer(stringSerde.toBytes(value)))));
  assertEquals(value, readFunction.getAsync(key).get());
}
 

@Test
public void testPutAsyncException() {
  String key = "throwExceptionKey";
  JsonObject value = JsonObject.create();
  Bucket bucket = mock(Bucket.class);
  AsyncBucket asyncBucket = mock(AsyncBucket.class);
  CouchbaseTableWriteFunction<JsonObject> writeFunction = createAndInit(bucket, asyncBucket);
  when(asyncBucket.upsert(any(Document.class), anyLong(), any(TimeUnit.class))).thenReturn(
      Observable.error(new CouchbaseException()));
  assertTrue(writeFunction.putAsync(key, value).isCompletedExceptionally());
}
 

@Test
public void testGetAsyncNullValue() throws Exception {
  String key = "NonExistingKey";
  Bucket bucket = mock(Bucket.class);
  AsyncBucket asyncBucket = mock(AsyncBucket.class);
  CouchbaseTableReadFunction readFunction = createAndInit(String.class, new StringSerde(), bucket, asyncBucket);
  when(asyncBucket.get(eq(key), anyObject(), anyLong(), any(TimeUnit.class))).thenReturn(Observable.empty());
  assertNull(readFunction.getAsync(key).get());
}
 

@Test
public void testGetAsyncFailedToDeserialize() {
  String key = "key";
  Bucket bucket = mock(Bucket.class);
  AsyncBucket asyncBucket = mock(AsyncBucket.class);
  CouchbaseTableReadFunction readFunction = createAndInit(String.class, new StringSerde(), bucket, asyncBucket);
  when(asyncBucket.get(eq(key), anyObject(), anyLong(), any(TimeUnit.class))).thenReturn(
      Observable.just(BinaryDocument.create(key, null)));
  assertTrue(readFunction.getAsync(key).isCompletedExceptionally());
}
 

@Test
public void testGetAsyncException() {
  String key = "throwExceptionKey";
  Bucket bucket = mock(Bucket.class);
  AsyncBucket asyncBucket = mock(AsyncBucket.class);
  CouchbaseTableReadFunction readFunction = createAndInit(bucket, asyncBucket);
  when(asyncBucket.get(eq(key), anyObject(), anyLong(), any(TimeUnit.class))).thenReturn(
      Observable.error(new CouchbaseException()));
  assertTrue(readFunction.getAsync(key).isCompletedExceptionally());
}
 

private <V> CouchbaseTableWriteFunction<V> createAndInit(Class<V> valueClass, Serde<V> serde, Bucket bucket,
    AsyncBucket asyncBucket) {
  when(bucket.async()).thenReturn(asyncBucket);
  PowerMockito.stub(PowerMockito.method(CouchbaseBucketRegistry.class, "getBucket", String.class, List.class,
      CouchbaseEnvironmentConfigs.class)).toReturn(bucket);
  CouchbaseTableWriteFunction<V> writeFunction =
      new CouchbaseTableWriteFunction<>(DEFAULT_BUCKET_NAME, valueClass, DEFAULT_CLUSTER_NODE).withSerde(serde);
  writeFunction.init(mock(Context.class), mock(AsyncReadWriteTable.class));
  return writeFunction;
}
 

@Test
public void testDeleteAsyncStringValue() throws Exception {
  String key = "key";
  Bucket bucket = mock(Bucket.class);
  AsyncBucket asyncBucket = mock(AsyncBucket.class);
  CouchbaseTableWriteFunction<String> writeFunction =
      createAndInit(String.class, new StringSerde(), bucket, asyncBucket);
  when(asyncBucket.remove(eq(key), anyLong(), any(TimeUnit.class))).thenReturn(Observable.just(null));
  assertNull(writeFunction.deleteAsync(key).get());
}
 

@Test
public void testDeleteAsyncJsonObjectValue() throws Exception {
  String key = "key";
  Bucket bucket = mock(Bucket.class);
  AsyncBucket asyncBucket = mock(AsyncBucket.class);
  CouchbaseTableWriteFunction<JsonObject> writeFunction = createAndInit(bucket, asyncBucket);
  when(asyncBucket.remove(eq(key), anyLong(), any(TimeUnit.class))).thenReturn(Observable.just(null));
  assertNull(writeFunction.deleteAsync(key).get());
}
 

@Test
public void testDeleteAsyncException() {
  String key = "throwExceptionKey";
  Bucket bucket = mock(Bucket.class);
  AsyncBucket asyncBucket = mock(AsyncBucket.class);
  CouchbaseTableWriteFunction<JsonObject> writeFunction = createAndInit(bucket, asyncBucket);
  when(asyncBucket.remove(eq(key), anyLong(), any(TimeUnit.class))).thenReturn(
      Observable.error(new CouchbaseException()));
  assertTrue(writeFunction.deleteAsync(key).isCompletedExceptionally());
}
 

@Test
public void testPutAsyncStringValue() throws Exception {
  String key = "key";
  String value = "value";
  Bucket bucket = mock(Bucket.class);
  AsyncBucket asyncBucket = mock(AsyncBucket.class);
  CouchbaseTableWriteFunction<String> writeFunction =
      createAndInit(String.class, new StringSerde(), bucket, asyncBucket);
  when(asyncBucket.upsert(any(Document.class), anyLong(), any(TimeUnit.class))).thenReturn(Observable.just(null));
  assertNull(writeFunction.putAsync(key, value).get());
}
 

@Test
public void testPutAsyncJsonObjectValue() throws Exception {
  String key = "key";
  JsonObject value = JsonObject.fromJson("{\"id\": 1}");
  Bucket bucket = mock(Bucket.class);
  AsyncBucket asyncBucket = mock(AsyncBucket.class);
  CouchbaseTableWriteFunction<JsonObject> writeFunction = createAndInit(bucket, asyncBucket);
  when(asyncBucket.upsert(any(Document.class), anyLong(), any(TimeUnit.class))).thenReturn(Observable.just(null));
  assertNull(writeFunction.putAsync(key, value).get());
}
 

private CouchbaseTableWriteFunction<JsonObject> createAndInit(Bucket bucket, AsyncBucket asyncBucket) {
  return createAndInit(JsonObject.class, null, bucket, asyncBucket);
}
 

private CouchbaseTableReadFunction<JsonObject> createAndInit() {
  return createAndInit(mock(Bucket.class), mock(AsyncBucket.class));
}
 

private CouchbaseTableReadFunction<JsonObject> createAndInit(Bucket bucket, AsyncBucket asyncBucket) {
  return createAndInit(JsonObject.class, null, bucket, asyncBucket);
}
 

private CouchbaseTableWriteFunction<JsonObject> createAndInit() {
  return createAndInit(mock(Bucket.class), mock(AsyncBucket.class));
}
 

/**
 * Returns a reference to the Couchbase bucket
 * @return the instantiated bucket
 */
public AsyncBucket bucket() {
  return this.bucket;
}
 

List<JsonDocument> getDocumentsAsync(AsyncBucket bucket, Iterable<String> keys);