@Override
public MutateWherePath useKeysValues(String... keys) {
if (keys.length == 1) {
return useKeys(s(keys[0]));
}
return useKeys(JsonArray.from((Object[]) keys));
}
@Test
public void testConstructorWithEmptyCollectionOverwrites() {
JsonArrayDocument preExisting = JsonArrayDocument.create(uuid, JsonArray.from("test", "test2"));
bucket.upsert(preExisting);
Map<String, Object> map =
new CouchbaseMap<Object>(uuid, bucket, Collections.<String, Object>emptyMap());
assertEquals(0, map.size());
}
@Test
public void testConstructorWithCollectionDataOverwrites() {
JsonArrayDocument preExisting = JsonArrayDocument.create(uuid, JsonArray.from("test", "test2"));
bucket.upsert(preExisting);
Map<String, Object> map =
new CouchbaseMap<Object>(uuid, bucket, Collections.singletonMap("foo", "bar"));
assertEquals(1, map.size());
assertTrue(map.containsKey("foo"));
assertEquals("bar", map.get("foo"));
}
private void key(Iterator<Object> iterator) {
if (!iterator.hasNext() && treeCount > 1) {
throw new IllegalArgumentException("Not enough parameters for key");
} else if (!iterator.hasNext()) {
// probably pattern like findAllByUsername(), just apply query without parameters
return;
}
Object next = iterator.next();
if (next instanceof String) {
query.key((String) next);
} else if (next instanceof Boolean) {
query.key((Boolean) next);
} else if (next instanceof Double) {
query.key((Double) next);
} else if (next instanceof Integer) {
query.key((Integer) next);
} else if (next instanceof Long) {
query.key((Long) next);
} else if (next instanceof Collection) {
// when creating a JsonArray, the from(List) method is preferred because it will convert
// internal
// Lists and Maps to JsonObject and JsonArray respectively
List<Object> arrayContent = new ArrayList<Object>((Collection) next);
query.key(JsonArray.from(arrayContent));
} else if (next.getClass().isArray()) {
List<Object> arrayContent = Arrays.asList((Object[]) next);
query.key(JsonArray.from(arrayContent));
} else if (next
instanceof
JsonArray) { // discouraged, since it's leaking store-specifics in the method signature
query.key((JsonArray) next);
} else if (next
instanceof
JsonObject) { // discouraged, since it's leaking store-specifics in the method signature
query.key((JsonObject) next);
} else {
throw new IllegalArgumentException("Unsupported parameter type for key: " + next.getClass());
}
}
@Test
public void testConstructorWithPreExistingDocumentOfWrongTypeFails() {
JsonArrayDocument preExisting = JsonArrayDocument.create(uuid, JsonArray.from("test"));
bucket.upsert(preExisting);
Map<String, Object> map = new CouchbaseMap<Object>(uuid, bucket);
try {
map.size();
fail("Expected TranscodingException");
} catch (TranscodingException e) {
// expected
}
}
@Test
public void shouldConcatMoreParams() {
ViewQuery query =
ViewQuery.from("design", "view")
.descending()
.debug()
.development()
.group()
.reduce(false)
.startKey(JsonArray.from("foo", true));
assertEquals(
"reduce=false&group=true&debug=true&descending=true&startkey=%5B%22foo%22%2Ctrue%5D",
query.toString());
}
private JsonArray in(Iterator<Object> iterator) {
if (!iterator.hasNext()) {
throw new IllegalArgumentException("Not enough parameters for in");
}
Object next = iterator.next();
List<Object> values;
if (next instanceof Collection) {
values = new ArrayList<Object>((Collection<?>) next);
} else if (next.getClass().isArray()) {
values = Arrays.asList((Object[]) next);
} else {
values = Collections.singletonList(next);
}
// using the from(List) method ensure that contained Lists and Maps will be converted to
// JsonArrays and JsonObjects
return JsonArray.from(values);
}
@Test
public void shouldHandleEndKey() {
ViewQuery query = ViewQuery.from("design", "view").endKey("key");
assertEquals("endkey=%22key%22", query.toString());
query = ViewQuery.from("design", "view").endKey(1);
assertEquals("endkey=1", query.toString());
query = ViewQuery.from("design", "view").endKey(true);
assertEquals("endkey=true", query.toString());
query = ViewQuery.from("design", "view").endKey(3.55);
assertEquals("endkey=3.55", query.toString());
query = ViewQuery.from("design", "view").endKey(JsonArray.from("foo", 3));
assertEquals("endkey=%5B%22foo%22%2C3%5D", query.toString());
query = ViewQuery.from("design", "view").endKey(JsonObject.empty().put("foo", true));
assertEquals("endkey=%7B%22foo%22%3Atrue%7D", query.toString());
}
@Test
public void shouldHandleKeys() {
ViewQuery query = ViewQuery.from("design", "view").keys(JsonArray.from("foo", 3, true));
assertEquals("keys=%5B%22foo%22%2C3%2Ctrue%5D", query.toString());
}