usergrid-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From g...@apache.org
Subject [02/15] usergrid git commit: Initial commit for new JavaSDK.
Date Thu, 19 May 2016 17:17:16 GMT
http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/main/java/org/apache/usergrid/java/client/response/UsergridResponseError.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/main/java/org/apache/usergrid/java/client/response/UsergridResponseError.java b/sdks/java/src/main/java/org/apache/usergrid/java/client/response/UsergridResponseError.java
new file mode 100644
index 0000000..387ae56
--- /dev/null
+++ b/sdks/java/src/main/java/org/apache/usergrid/java/client/response/UsergridResponseError.java
@@ -0,0 +1,98 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.usergrid.java.client.response;
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.JsonNode;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@SuppressWarnings("unused")
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class UsergridResponseError {
+
+    @Nullable private String errorName;
+    @Nullable private String errorDescription;
+    @Nullable private String errorException;
+
+    @NotNull private final Map<String, JsonNode> properties = new HashMap<>();
+
+    public UsergridResponseError() {
+        this(null,null,null);
+    }
+    public UsergridResponseError(@Nullable final String errorName) {
+        this(errorName, null, null);
+    }
+    public UsergridResponseError(@Nullable final String errorName, @Nullable final String errorDescription) {
+        this(errorName,errorDescription,null);
+    }
+    public UsergridResponseError(@Nullable final String errorName, @Nullable final String errorDescription, @Nullable final String errorException) {
+        this.errorName = errorName;
+        this.errorDescription = errorDescription;
+        this.errorException = errorException;
+    }
+
+    @NotNull
+    @JsonAnyGetter
+    public Map<String, JsonNode> getProperties() {
+        return properties;
+    }
+
+    @JsonAnySetter
+    public void setProperty(@NotNull final String key, @NotNull final JsonNode value) {
+        properties.put(key, value);
+    }
+
+    @Nullable
+    @JsonProperty("error")
+    public String getErrorName() {
+        return errorName;
+    }
+
+    @JsonProperty("error")
+    public void setErrorName(@NotNull final String errorName) {
+        this.errorName = errorName;
+    }
+
+    @Nullable
+    @JsonProperty("exception")
+    public String getErrorException() {
+        return errorException;
+    }
+
+    @JsonProperty("exception")
+    public void setErrorException(@NotNull final String errorException) {
+        this.errorException = errorException;
+    }
+
+    @Nullable
+    @JsonProperty("error_description")
+    public String getErrorDescription() {
+        return errorDescription;
+    }
+
+    @JsonProperty("error_description")
+    public void setErrorDescription(@NotNull final String errorDescription) {
+        this.errorDescription = errorDescription;
+    }
+}

http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/JsonUtils.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/JsonUtils.java b/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/JsonUtils.java
index a465199..d2f43fb 100644
--- a/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/JsonUtils.java
+++ b/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/JsonUtils.java
@@ -16,167 +16,119 @@
  */
 package org.apache.usergrid.java.client.utils;
 
-import java.io.IOException;
-import java.util.Map;
-import java.util.UUID;
-
 import com.fasterxml.jackson.core.JsonGenerationException;
 import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.JsonNodeFactory;
-import org.apache.usergrid.java.client.exception.ClientException;
-
-public class JsonUtils {
-
-
-	static ObjectMapper mapper = new ObjectMapper();
-
-	public static String getStringProperty(Map<String, JsonNode> properties,
-			String name) {
-		JsonNode value = properties.get(name);
-		if (value != null) {
-			return value.asText();
-		}
-		return null;
-	}
-
-	public static void setStringProperty(Map<String, JsonNode> properties,
-			String name, String value) {
-		if (value == null) {
-			properties.remove(name);
-		} else {
-			properties.put(name, JsonNodeFactory.instance.textNode(value));
-		}
-	}
-
-	public static Long getLongProperty(Map<String, JsonNode> properties,
-			String name) {
-		JsonNode value = properties.get(name);
-		if (value != null) {
-			return value.asLong(0);
-		}
-		return null;
-	}
-
-	public static void setLongProperty(Map<String, JsonNode> properties,
-			String name, Long value) {
-		if (value == null) {
-			properties.remove(name);
-		} else {
-			properties.put(name, JsonNodeFactory.instance.numberNode(value));
-		}
-	}
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.databind.node.*;
+import org.apache.usergrid.java.client.exception.UsergridException;
+import org.apache.usergrid.java.client.model.UsergridEntity;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
-	public static void setFloatProperty(Map<String, JsonNode> properties, String name, Float value){
-	    if(value == null){
-	        properties.remove(name);
-	    }else{
-	        properties.put(name, JsonNodeFactory.instance.numberNode(value));
-	    }
-	}
-
-	public static Boolean getBooleanProperty(Map<String, JsonNode> properties,
-			String name) {
-		JsonNode value = properties.get(name);
-		if (value != null) {
-			return value.asBoolean();
-		}
-		return false;
-	}
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Map;
 
-	public static void setBooleanProperty(Map<String, JsonNode> properties,
-			String name, Boolean value) {
-		if (value == null) {
-			properties.remove(name);
-		} else {
-			properties.put(name, JsonNodeFactory.instance.booleanNode(value));
-		}
-	}
+@SuppressWarnings("unused")
+public final class JsonUtils {
 
-	public static UUID getUUIDProperty(Map<String, JsonNode> properties,
-			String name) {
-		JsonNode value = properties.get(name);
-		if (value != null) {
-			UUID uuid = null;
-			try {
-				uuid = UUID.fromString(value.asText());
-			} catch (Exception e) {
-			}
-			return uuid;
-		}
-		return null;
-	}
+    @NotNull public static final ObjectMapper mapper = new ObjectMapper();
 
-	public static void setUUIDProperty(Map<String, JsonNode> properties,
-			String name, UUID value) {
-		if (value == null) {
-			properties.remove(name);
-		} else {
-			properties.put(name,
-					JsonNodeFactory.instance.textNode(value.toString()));
-		}
-	}
+    static {
+        SimpleModule module = new SimpleModule();
+        module.addDeserializer(UsergridEntity.class, new UsergridEntityDeserializer());
+        mapper.registerModule(module);
+    }
 
-	public static String toJsonString(Object obj) {
-		try {
-			return mapper.writeValueAsString(obj);
-		} catch (JsonGenerationException e) {
-			throw new ClientException("Unable to generate json", e);
-		} catch (JsonMappingException e) {
-		    throw new ClientException("Unable to map json", e);
-		} catch (IOException e) {
-		    throw new ClientException("IO error", e);
-		}
-	}
+    @NotNull
+    public static ObjectNode createObjectNode() {
+        return mapper.createObjectNode();
+    }
 
-	public static <T> T parse(String json, Class<T> c) {
-		try {
-			return mapper.readValue(json, c);
-		} catch (JsonGenerationException e) {
-            throw new ClientException("Unable to generate json", e);
+    @Nullable
+    public static String getStringProperty(@NotNull final Map<String, JsonNode> properties, @NotNull final String name) {
+        JsonNode value = properties.get(name);
+        if (value != null) {
+            return value.asText();
+        }
+        return null;
+    }
+
+    @NotNull
+    public static ArrayList<Object> convertToArrayList(@NotNull final ArrayNode arrayNode) {
+        ArrayList<Object> arrayList = new ArrayList<>();
+        Iterator<JsonNode> iterator = arrayNode.elements();
+        while( iterator.hasNext() ) {
+            arrayList.add(iterator.next());
+        }
+        return arrayList;
+    }
+
+    @NotNull
+    public static String toJsonString(@NotNull final Object obj) {
+        try {
+            return mapper.writeValueAsString(obj);
+        } catch (JsonGenerationException e) {
+            throw new UsergridException("Unable to generate json", e);
         } catch (JsonMappingException e) {
-            throw new ClientException("Unable to map json", e);
+            throw new UsergridException("Unable to map json", e);
         } catch (IOException e) {
-            throw new ClientException("IO error", e);
+            throw new UsergridException("IO error", e);
         }
-	}
-
-	public static JsonNode toJsonNode(Object obj) {
-		return mapper.convertValue(obj, JsonNode.class);
-	}
-
-	public static <T> T fromJsonNode(JsonNode json, Class<T> c) {
-		try {
-			JsonParser jp = json.traverse();
-			return mapper.readValue(jp, c);
-		} catch (JsonGenerationException e) {
-            throw new ClientException("Unable to generate json", e);
+    }
+
+    @NotNull
+    public static JsonNode toJsonNode(@NotNull final Object obj) {
+        return mapper.convertValue(obj, JsonNode.class);
+    }
+
+    @NotNull
+    public static <T> T fromJsonNode(@NotNull final JsonNode json, @NotNull final Class<T> c) {
+        try {
+            JsonParser jp = json.traverse();
+            return mapper.readValue(jp, c);
+        } catch (JsonGenerationException e) {
+            throw new UsergridException("Unable to generate json", e);
         } catch (JsonMappingException e) {
-            throw new ClientException("Unable to map json", e);
+            throw new UsergridException("Unable to map json", e);
         } catch (IOException e) {
-            throw new ClientException("IO error", e);
+            throw new UsergridException("IO error", e);
         }
-	}
-
-	public static <T> T getObjectProperty(Map<String, JsonNode> properties,
-			String name, Class<T> c) {
-		JsonNode value = properties.get(name);
-		if (value != null) {
-			return fromJsonNode(value, c);
-		}
-		return null;
-	}
-
-	public static void setObjectProperty(Map<String, JsonNode> properties,
-			String name, Object value) {
-		if (value == null) {
-			properties.remove(name);
-		} else {
-			properties.put(name,
-					JsonNodeFactory.instance.textNode(value.toString()));
-		}
-	}
+    }
 
+    public static void setObjectProperty(@NotNull final Map<String, JsonNode> properties, @NotNull final String name, @Nullable final ObjectNode value) {
+        if (value == null) {
+            properties.remove(name);
+        } else {
+            properties.put(name, value);
+        }
+    }
+
+    @Nullable
+    @SuppressWarnings("unchecked")
+    public static <T> T getProperty(@NotNull final Map<String, JsonNode> properties, @NotNull final String name) {
+        JsonNode value = properties.get(name);
+        if( value == null ) {
+            return null;
+        } else if (value instanceof TextNode) {
+            return (T) value.asText();
+        } else if (value instanceof LongNode) {
+            Long valueLong = value.asLong();
+            return (T) valueLong;
+        } else if (value instanceof BooleanNode) {
+            Boolean valueBoolean = value.asBoolean();
+            return (T) valueBoolean;
+        } else if (value instanceof IntNode) {
+            Integer valueInteger = value.asInt();
+            return (T) valueInteger;
+        } else if (value instanceof FloatNode) {
+            return (T) Float.valueOf(value.toString());
+        } else {
+            return (T) value;
+        }
+    }
 }

http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/MapUtils.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/MapUtils.java b/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/MapUtils.java
index dd128eb..cbf6d51 100644
--- a/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/MapUtils.java
+++ b/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/MapUtils.java
@@ -16,24 +16,21 @@
  */
 package org.apache.usergrid.java.client.utils;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-public class MapUtils {
-
-	public static <T> Map<String, T> newMapWithoutKeys(Map<String, T> map,
-			List<String> keys) {
-		Map<String, T> newMap = null;
-		if (map != null) {
-			newMap = new HashMap<String, T>(map);
-		} else {
-			newMap = new HashMap<String, T>();
-		}
-		for (String key : keys) {
-			newMap.remove(key);
-		}
-		return newMap;
-	}
+@SuppressWarnings("unused")
+public final class MapUtils {
 
+    @NotNull
+    public static <T> Map<String, T> newMapWithoutKeys(@NotNull  final Map<String, T> map, @NotNull final List<String> keys) {
+        Map<String, T> newMap = new HashMap<>();
+        for (String key : keys) {
+            newMap.remove(key);
+        }
+        return newMap;
+    }
 }

http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/ObjectUtils.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/ObjectUtils.java b/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/ObjectUtils.java
index 465845a..1d05405 100644
--- a/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/ObjectUtils.java
+++ b/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/ObjectUtils.java
@@ -16,21 +16,23 @@
  */
 package org.apache.usergrid.java.client.utils;
 
+import org.jetbrains.annotations.Nullable;
+
 import java.util.Map;
 
-public class ObjectUtils {
+public final class ObjectUtils {
 
-	public static boolean isEmpty(Object s) {
-		if (s == null) {
-			return true;
-		}
-		if ((s instanceof String) && (((String) s).trim().length() == 0)) {
-			return true;
-		}
-		if (s instanceof Map) {
-			return ((Map<?, ?>) s).isEmpty();
-		}
-		return false;
-	}
+    public static boolean isEmpty(@Nullable final Object s) {
+        if (s == null) {
+            return true;
+        }
+        if ((s instanceof String) && (((String) s).trim().length() == 0)) {
+            return true;
+        }
+        if (s instanceof Map) {
+            return ((Map<?, ?>) s).isEmpty();
+        }
+        return false;
+    }
 
 }

http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/UrlUtils.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/UrlUtils.java b/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/UrlUtils.java
deleted file mode 100644
index bf2a2b3..0000000
--- a/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/UrlUtils.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.usergrid.java.client.utils;
-
-import static java.net.URLEncoder.encode;
-import static org.apache.usergrid.java.client.utils.ObjectUtils.isEmpty;
-
-import java.io.UnsupportedEncodingException;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import org.apache.usergrid.java.client.exception.ClientException;
-
-public class UrlUtils {
-
-
-    public static URL url(String s) {
-        try {
-            return new URL(s);
-        } catch (MalformedURLException e) {
-            throw new ClientException("Incorrect URL format", e);
-        }
-    }
-
-    public static URL url(URL u, String s) {
-        try {
-            return new URL(u, s);
-        } catch (MalformedURLException e) {
-            throw new ClientException("Incorrect URL format", e);
-        }
-    }
-
-    public static String path(Object... segments) {
-        String path = "";
-        boolean first = true;
-        for (Object segment : segments) {
-            if (segment instanceof Object[]) {
-                segment = path((Object[]) segment);
-            }
-            if (!isEmpty(segment)) {
-                if (first) {
-                    path = segment.toString();
-                    first = false;
-                } else {
-                    if (!path.endsWith("/")) {
-                        path += "/";
-                    }
-                    path += segment.toString();
-                }
-            }
-        }
-        return path;
-    }
-
-    @SuppressWarnings("rawtypes")
-    public static String encodeParams(Map<String, Object> params) {
-        if (params == null) {
-            return "";
-        }
-        boolean first = true;
-        StringBuilder results = new StringBuilder();
-        for (Entry<String, Object> entry : params.entrySet()) {
-            if (entry.getValue() instanceof List) {
-                for (Object o : (List) entry.getValue()) {
-                    if (!isEmpty(o)) {
-                        if (!first) {
-                            results.append('&');
-                        }
-                        first = false;
-                        results.append(entry.getKey());
-                        results.append("=");
-                        try {
-                            results.append(encode(o.toString(), "UTF-8"));
-                        } catch (UnsupportedEncodingException e) {
-                            throw new ClientException("Unknown encoding", e);
-                        }
-                    }
-                }
-            } else if (!isEmpty(entry.getValue())) {
-                if (!first) {
-                    results.append('&');
-                }
-                first = false;
-                results.append(entry.getKey());
-                results.append("=");
-                try {
-                    results.append(encode(entry.getValue().toString(), "UTF-8"));
-                } catch (UnsupportedEncodingException e) {
-                    throw new ClientException("Unsupported string encoding", e);
-                }
-            }
-        }
-        return results.toString();
-    }
-
-    public static String addQueryParams(String url, Map<String, Object> params) {
-        if (params == null) {
-            return url;
-        }
-        if (!url.contains("?")) {
-            url += "?";
-        }
-        url += encodeParams(params);
-        return url;
-    }
-
-}

http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/UsergridEntityDeserializer.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/UsergridEntityDeserializer.java b/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/UsergridEntityDeserializer.java
new file mode 100644
index 0000000..5daeace
--- /dev/null
+++ b/sdks/java/src/main/java/org/apache/usergrid/java/client/utils/UsergridEntityDeserializer.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.usergrid.java.client.utils;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.usergrid.java.client.model.UsergridEntity;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+
+public final class UsergridEntityDeserializer extends JsonDeserializer<UsergridEntity> {
+
+    @NotNull private static final ObjectMapper objectMapper = new ObjectMapper();
+
+    @NotNull
+    public UsergridEntity deserialize(JsonParser jsonParser, DeserializationContext context) throws IOException {
+        UsergridEntity entity = UsergridEntityDeserializer.objectMapper.readValue(jsonParser,UsergridEntity.class);
+        Class<? extends UsergridEntity> entitySubClass = UsergridEntity.customSubclassForType(entity.getType());
+        if( entitySubClass != null ) {
+            entity = JsonUtils.mapper.convertValue(entity,entitySubClass);
+        }
+        return entity;
+    }
+}

http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/test/java/org/apache/usergrid/client/ClientAuthFallBackTestCase.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/test/java/org/apache/usergrid/client/ClientAuthFallBackTestCase.java b/sdks/java/src/test/java/org/apache/usergrid/client/ClientAuthFallBackTestCase.java
new file mode 100644
index 0000000..944aaef
--- /dev/null
+++ b/sdks/java/src/test/java/org/apache/usergrid/client/ClientAuthFallBackTestCase.java
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.usergrid.client;
+
+import org.apache.usergrid.java.client.*;
+import org.apache.usergrid.java.client.auth.UsergridAppAuth;
+import org.apache.usergrid.java.client.query.UsergridQuery;
+import org.apache.usergrid.java.client.response.UsergridResponse;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertTrue;
+
+public class ClientAuthFallBackTestCase {
+
+    private static UsergridQuery usersQuery = new UsergridQuery("users").desc("created");
+
+    @Before
+    public void before() {
+        Usergrid.initSharedInstance(SDKTestConfiguration.ORG_NAME, SDKTestConfiguration.APP_NAME, SDKTestConfiguration.USERGRID_URL, SDKTestConfiguration.authFallBack);
+        Usergrid.authenticateApp(new UsergridAppAuth(SDKTestConfiguration.APP_CLIENT_ID, SDKTestConfiguration.APP_CLIENT_SECRET));
+
+        String[] segments = {"roles","guest","permissions"};
+        Map<String, Object> params = new HashMap<>();
+        params.put("permission","get,post,put,delete:/**");
+        UsergridRequest request = new UsergridRequest(UsergridEnums.UsergridHttpMethod.DELETE, UsergridRequest.APPLICATION_JSON_MEDIA_TYPE, Usergrid.clientAppUrl(), params, null, Usergrid.authForRequests(), segments);
+        Usergrid.sendRequest(request);
+    }
+
+    @After
+    public void after() {
+        Usergrid.setAuthMode(UsergridEnums.UsergridAuthMode.APP);
+        String[] segments = {"roles","guest","permissions"};
+        Map<String, Object> params = new HashMap<>();
+        params.put("permission","get,post,put,delete:/**");
+        UsergridRequest request = new UsergridRequest(UsergridEnums.UsergridHttpMethod.POST, UsergridRequest.APPLICATION_JSON_MEDIA_TYPE, Usergrid.clientAppUrl(), params, null, Usergrid.authForRequests(), segments);
+        Usergrid.sendRequest(request);
+        Usergrid.reset();
+    }
+
+    @Test
+    public void authFallBackNONETest() {
+        Usergrid.setAuthMode(UsergridEnums.UsergridAuthMode.NONE);
+        UsergridResponse resp = Usergrid.GET(usersQuery);
+        assertTrue("The returned response should have error", resp.getResponseError() != null);
+    }
+
+    @Test
+    public void authFallBackAPPTest() {
+        Usergrid.setAuthMode(UsergridEnums.UsergridAuthMode.APP);
+        UsergridResponse resp = Usergrid.GET(usersQuery);
+        assertTrue("The returned response should not have error", resp.getResponseError() == null);
+    }
+}

http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/test/java/org/apache/usergrid/client/ClientAuthTestCase.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/test/java/org/apache/usergrid/client/ClientAuthTestCase.java b/sdks/java/src/test/java/org/apache/usergrid/client/ClientAuthTestCase.java
new file mode 100644
index 0000000..79e1bbc
--- /dev/null
+++ b/sdks/java/src/test/java/org/apache/usergrid/client/ClientAuthTestCase.java
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.usergrid.client;
+
+import org.apache.usergrid.java.client.Usergrid;
+import org.apache.usergrid.java.client.UsergridEnums.*;
+import org.apache.usergrid.java.client.auth.UsergridAppAuth;
+import org.apache.usergrid.java.client.auth.UsergridUserAuth;
+import org.apache.usergrid.java.client.model.UsergridUser;
+import org.apache.usergrid.java.client.response.UsergridResponse;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ClientAuthTestCase {
+
+    @Before
+    public void before() {
+        Usergrid.initSharedInstance(SDKTestConfiguration.ORG_NAME, SDKTestConfiguration.APP_NAME, SDKTestConfiguration.USERGRID_URL);
+    }
+
+    @After
+    public void after() {
+        Usergrid.reset();
+    }
+
+    @Test
+    public void clientAuth_APP() {
+        Usergrid.setAuthMode(UsergridAuthMode.APP);
+        UsergridAppAuth appAuth = new UsergridAppAuth(SDKTestConfiguration.APP_CLIENT_ID, SDKTestConfiguration.APP_CLIENT_SECRET);
+        UsergridResponse response = Usergrid.authenticateApp(appAuth);
+        assertTrue("response status is OK", response.ok());
+        assertNull("no error thrown", response.getResponseError());
+        assertTrue("appAuth.isValidToken should be true", appAuth.isValidToken());
+        assertNotNull("should have a valid token", appAuth.getAccessToken());
+        assertNotNull("should have an expiry", appAuth.getExpiry());
+        assertEquals("client.appAuth.token should be set to the token returned from Usergrid", Usergrid.getAppAuth(), appAuth);
+        assertTrue("should have a token that is not empty", appAuth.getAccessToken().length() > 0);
+        assertTrue("client.appAuth.expiry should be set to a future date", appAuth.getExpiry() > System.currentTimeMillis());
+    }
+
+    @Test
+    public void clientAuth_USER() {
+        Usergrid.setAuthMode(UsergridAuthMode.USER);
+        UsergridUserAuth userAuth = new UsergridUserAuth(SDKTestConfiguration.APP_UserName, SDKTestConfiguration.APP_Password);
+        UsergridResponse response = Usergrid.authenticateUser(userAuth);
+        assertTrue("response status is OK", response.ok());
+        assertNull("no error thrown", response.getResponseError());
+        assertTrue("appAuth.isValidToken should be true", userAuth.isValidToken());
+        assertNotNull("should have a token", userAuth.getAccessToken());
+        assertNotNull("should have an expiry", userAuth.getExpiry());
+
+        UsergridUser currentUser = Usergrid.getCurrentUser();
+        assertNotNull("client.currentUser should not be null", currentUser);
+        assertNotNull("client.currentUser().getUserAuth() should not be null", currentUser.getUserAuth());
+        assertEquals("client.currentUser().userAuth should be the same as userAuth", currentUser.getUserAuth(), userAuth);
+        assertTrue("should have a token that is not empty", userAuth.getAccessToken().length() > 0);
+        assertTrue("client.currentUser().userAuth.getExpiry() should be set to a future date", userAuth.getExpiry() > System.currentTimeMillis());
+        assertEquals("client.authForRequests() should be the same as userAuth", Usergrid.authForRequests(), userAuth);
+    }
+
+    @Test
+    public void clientAuth_NONE() {
+        Usergrid.setAuthMode(UsergridAuthMode.NONE);
+        UsergridUserAuth userAuth = new UsergridUserAuth(SDKTestConfiguration.APP_UserName, SDKTestConfiguration.APP_Password);
+        Usergrid.authenticateUser(userAuth);
+        assertNull("no auth should be returned from client.authForRequests", Usergrid.authForRequests());
+    }
+}

http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/test/java/org/apache/usergrid/client/ClientConnectionsTestCase.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/test/java/org/apache/usergrid/client/ClientConnectionsTestCase.java b/sdks/java/src/test/java/org/apache/usergrid/client/ClientConnectionsTestCase.java
new file mode 100644
index 0000000..72b88dd
--- /dev/null
+++ b/sdks/java/src/test/java/org/apache/usergrid/client/ClientConnectionsTestCase.java
@@ -0,0 +1,171 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.usergrid.client;
+
+import org.apache.usergrid.java.client.UsergridEnums.UsergridDirection;
+import org.apache.usergrid.java.client.Usergrid;
+import org.apache.usergrid.java.client.auth.UsergridAppAuth;
+import org.apache.usergrid.java.client.model.UsergridEntity;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ClientConnectionsTestCase {
+
+    @Before
+    public void before() {
+        Usergrid.initSharedInstance(SDKTestConfiguration.ORG_NAME, SDKTestConfiguration.APP_NAME, SDKTestConfiguration.USERGRID_URL, SDKTestConfiguration.authFallBack);
+        UsergridAppAuth appAuth = new UsergridAppAuth(SDKTestConfiguration.APP_CLIENT_ID, SDKTestConfiguration.APP_CLIENT_SECRET);
+        Usergrid.authenticateApp(appAuth);
+    }
+
+    @After
+    public void after() {
+        Usergrid.reset();
+    }
+
+    @Test
+    public void clientConnect() {
+        String collectionName = "testClientConnection" + System.currentTimeMillis();
+
+        UsergridEntity entityOne = new UsergridEntity(collectionName,"john");
+        entityOne.putProperty("place","San Jose");
+        entityOne.save();
+        assertNotNull(entityOne.getUuid());
+
+        UsergridEntity entityTwo = new UsergridEntity(collectionName,"amici");
+        entityOne.putProperty("place","San Jose");
+        entityTwo.save();
+        assertNotNull(entityTwo.getUuid());
+
+        //should connect entities by passing UsergridEntity objects as parameters
+        Usergrid.connect(entityOne, "likes", entityTwo);
+
+        UsergridEntity responseEntity = Usergrid.getConnections(UsergridDirection.OUT, entityOne, "likes").first();
+        assertNotNull(responseEntity);
+        assertEquals("both entities name should be same", entityTwo.getName(),responseEntity.getName());
+        assertEquals("both entities uuid should be same", entityTwo.getUuid(),responseEntity.getUuid());
+
+        //should connect entities by passing a source UsergridEntity object and a target uuid.
+        Usergrid.connect(entityOne.getType(), entityOne.getUuid(), "visited", entityTwo.getUuid());
+
+        responseEntity = Usergrid.getConnections(UsergridDirection.OUT, entityOne, "visited").first();
+        assertNotNull(responseEntity);
+        assertEquals("both entities name should be same", entityTwo.getName(),responseEntity.getName());
+        assertEquals("both entities uuid should be same", entityTwo.getUuid(),responseEntity.getUuid());
+
+        //should connect entities by passing source type, source uuid, and target uuid as parameters
+        Usergrid.connect(entityTwo.getType(), entityTwo.getUuid(), "visitor", entityOne.getUuid());
+
+        responseEntity = Usergrid.getConnections(UsergridDirection.OUT, entityTwo, "visitor").first();
+        assertNotNull(responseEntity);
+        assertEquals("both entities name should be same", entityOne.getName(),responseEntity.getName());
+        assertEquals("both entities uuid should be same", entityOne.getUuid(),responseEntity.getUuid());
+
+        //should connect entities by passing source type, source name, target type, and target name as parameters
+        assertNotNull(entityOne.getName());
+        assertNotNull(entityTwo.getName());
+        Usergrid.connect(entityTwo.getType(), entityTwo.getName(), "welcomed", entityOne.getType(), entityOne.getName());
+
+        responseEntity = Usergrid.getConnections(UsergridDirection.OUT, entityTwo, "welcomed").first();
+        assertNotNull(responseEntity);
+        assertEquals("both entities name should be same", entityOne.getName(),responseEntity.getName());
+        assertEquals("both entities uuid should be same", entityOne.getUuid(),responseEntity.getUuid());
+
+        //should connect entities by passing source type, source name, target type, and target name as parameters
+        Usergrid.connect(entityTwo.getType(), entityTwo.getName(), "invalidLink", "invalidName");
+        responseEntity = Usergrid.getConnections(UsergridDirection.OUT, entityTwo, "invalidLink").first();
+        assertNull("response entity should be null.", responseEntity);
+    }
+
+    @Test
+    public void clientGetConnect() {
+        String collectionName = "testClientGetConnection" + System.currentTimeMillis();
+
+        //should set properties for a given object, overwriting properties that exist and creating those that don\'t
+        UsergridEntity entityOne = new UsergridEntity(collectionName, "john");
+        entityOne.putProperty("place","San Jose");
+        entityOne.save();
+
+        //should set properties for a given object, overwriting properties that exist and creating those that don\'t
+        UsergridEntity entityTwo = new UsergridEntity(collectionName, "amici");
+        entityTwo.putProperty("place","San Jose");
+        entityTwo.save();
+
+        //should connect entities by passing UsergridEntity objects as parameters
+        Usergrid.connect(entityOne, "likes", entityTwo);
+        Usergrid.connect(entityOne, "visited", entityTwo);
+
+        UsergridEntity responseEntity = Usergrid.getConnections(UsergridDirection.OUT, entityOne, "likes").first();
+        assertNotNull(responseEntity);
+        assertEquals("both entities name should be same", entityTwo.getName(),responseEntity.getName());
+        assertEquals("both entities uuid should be same", entityTwo.getUuid(),responseEntity.getUuid());
+
+        responseEntity = Usergrid.getConnections(UsergridDirection.IN, entityTwo, "visited").first();
+        assertNotNull(responseEntity);
+        assertEquals("both entities name should be same", entityOne.getName(),responseEntity.getName());
+        assertEquals("both entities uuid should be same", entityOne.getUuid(),responseEntity.getUuid());
+
+    }
+
+    @Test
+    public void clientDisConnect() {
+        String collectionName = "testClientGetConnection" + System.currentTimeMillis();
+
+        //should set properties for a given object, overwriting properties that exist and creating those that don\'t
+        UsergridEntity entityOne = new UsergridEntity(collectionName,"john");
+        entityOne.putProperty("place","San Jose");
+        entityOne.save();
+        assertNotNull(entityOne.getName());
+        assertNotNull(entityOne.getUuid());
+
+        //should set properties for a given object, overwriting properties that exist and creating those that don\'t
+        UsergridEntity entityTwo = new UsergridEntity(collectionName, "amici");
+        entityTwo.putProperty("place","San Jose");
+        entityTwo.save();
+        assertNotNull(entityTwo.getName());
+        assertNotNull(entityTwo.getUuid());
+
+        //should connect entities by passing UsergridEntity objects as parameters
+        Usergrid.connect(entityOne, "likes", entityTwo);
+        Usergrid.connect(entityOne, "visited", entityTwo);
+        Usergrid.connect(entityOne, "twice", entityTwo);
+        Usergrid.connect(entityOne, "thrice", entityTwo);
+
+        //should disConnect entities by passing UsergridEntity objects as parameters
+        Usergrid.disconnect(entityOne, "likes", entityTwo);
+        UsergridEntity responseEntity = Usergrid.getConnections(UsergridDirection.IN, entityTwo, "likes").first();
+        assertNull("responseEntity should be null", responseEntity);
+
+        //should disConnect entities by passing source type, source uuid, and target uuid as parameters
+        Usergrid.disconnect(entityOne.getType(), entityOne.getUuid(), "visited", entityTwo.getUuid());
+        responseEntity = Usergrid.getConnections(UsergridDirection.OUT, entityOne, "visited").first();
+        assertNull("responseEntity should be null", responseEntity);
+
+        //should disConnect entities by passing source type, source name, target type, and target name as parameters
+        Usergrid.disconnect(entityOne.getType(), entityOne.getName(), "twice", entityTwo.getType(), entityTwo.getName());
+        responseEntity = Usergrid.getConnections(UsergridDirection.OUT, entityOne, "twice").first();
+        assertNull("responseEntity should be null", responseEntity);
+
+        //should fail to disConnect entities when specifying target name without type
+        Usergrid.disconnect(entityTwo.getType(), entityTwo.getName(), "thrice", entityOne.getName());
+        responseEntity = Usergrid.getConnections(UsergridDirection.OUT, entityTwo, "thrice").first();
+        assertNull("both entities name should be same",responseEntity);
+    }
+}

http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/test/java/org/apache/usergrid/client/ClientRestTestCase.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/test/java/org/apache/usergrid/client/ClientRestTestCase.java b/sdks/java/src/test/java/org/apache/usergrid/client/ClientRestTestCase.java
new file mode 100644
index 0000000..b01a167
--- /dev/null
+++ b/sdks/java/src/test/java/org/apache/usergrid/client/ClientRestTestCase.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.usergrid.client;
+
+import org.apache.usergrid.java.client.Usergrid;
+import org.apache.usergrid.java.client.auth.UsergridAppAuth;
+import org.apache.usergrid.java.client.model.UsergridEntity;
+import org.apache.usergrid.java.client.response.UsergridResponse;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+import static org.junit.Assert.*;
+
+public class ClientRestTestCase {
+
+    final String collectionName = "testClientConnection" + System.currentTimeMillis();
+
+    @Before
+    public void before()  {
+        Usergrid.initSharedInstance(SDKTestConfiguration.ORG_NAME, SDKTestConfiguration.APP_NAME, SDKTestConfiguration.USERGRID_URL, SDKTestConfiguration.authFallBack);
+        UsergridAppAuth appAuth = new UsergridAppAuth(SDKTestConfiguration.APP_CLIENT_ID, SDKTestConfiguration.APP_CLIENT_SECRET);
+        Usergrid.authenticateApp(appAuth);
+        createCollectionAndEntity();
+    }
+
+    @After
+    public void after() {
+        Usergrid.reset();
+    }
+
+    public void createCollectionAndEntity()  {
+        UsergridEntity entityOne = new UsergridEntity(collectionName,"john");
+        entityOne.putProperty("place", "San Jose");
+        entityOne.save();
+
+        UsergridEntity entityTwo = new UsergridEntity(collectionName,"amici");
+        entityTwo.putProperty("place", "San Jose");
+        entityTwo.save();
+
+        assertNotNull(entityOne.getUuid());
+        assertNotNull(entityTwo.getUuid());
+
+        Usergrid.connect(entityOne, "likes", entityTwo);
+        Usergrid.connect(entityOne.getType(), entityOne.getUuid(), "visited", entityTwo.getUuid());
+    }
+
+    @Test
+    public void clientGET() {
+        // Retrieve the response.
+        UsergridResponse response = Usergrid.GET(collectionName, "john");
+        assertTrue("response should be ok", response.ok());
+        assertNull("no error thrown", response.getResponseError());
+
+        assertNotNull(response.getEntities());
+        assertTrue("response entities is an Array", response.getEntities().getClass() == ArrayList.class);
+
+        // response.first should exist and have a valid uuid
+        UsergridEntity firstEntity = response.first();
+        assertNotNull(firstEntity);
+        assertNotNull("first entity is not null and has uuid", firstEntity.getUuid());
+
+        // response.entity should exist, equals the first entity, and have a valid uuid
+        UsergridEntity responseEntity = response.entity();
+        assertNotNull(responseEntity);
+        assertEquals(firstEntity, responseEntity);
+        assertNotNull("entity is not null and has uuid", responseEntity.getUuid());
+
+        // response.last should exist and have a valid uuid
+        UsergridEntity lastEntity = response.last();
+        assertNotNull(lastEntity);
+        assertNotNull("last entity is not null and has uuid", lastEntity.getUuid());
+    }
+}

http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/test/java/org/apache/usergrid/client/EntityTestCase.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/test/java/org/apache/usergrid/client/EntityTestCase.java b/sdks/java/src/test/java/org/apache/usergrid/client/EntityTestCase.java
new file mode 100644
index 0000000..42c3054
--- /dev/null
+++ b/sdks/java/src/test/java/org/apache/usergrid/client/EntityTestCase.java
@@ -0,0 +1,676 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.usergrid.client;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.TextNode;
+import org.apache.usergrid.java.client.UsergridEnums.UsergridDirection;
+import org.apache.usergrid.java.client.Usergrid;
+import org.apache.usergrid.java.client.auth.UsergridAppAuth;
+import org.apache.usergrid.java.client.model.UsergridEntity;
+import org.apache.usergrid.java.client.query.UsergridQuery;
+import org.apache.usergrid.java.client.response.UsergridResponse;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+public class EntityTestCase {
+
+    @Before
+    public void before() {
+        Usergrid.initSharedInstance(SDKTestConfiguration.ORG_NAME, SDKTestConfiguration.APP_NAME, SDKTestConfiguration.USERGRID_URL, SDKTestConfiguration.authFallBack);
+        Usergrid.authenticateApp(new UsergridAppAuth(SDKTestConfiguration.APP_CLIENT_ID, SDKTestConfiguration.APP_CLIENT_SECRET));
+    }
+
+    @After
+    public void after() {
+        Usergrid.reset();
+    }
+
+    @Test
+    public void testEntityCreationSuccess() {
+        String collectionName = "ect" + System.currentTimeMillis();
+        String entityName = "testEntity1";
+
+        HashMap<String,JsonNode> map = new HashMap<>();
+        map.put("name",new TextNode(entityName));
+        map.put("color",new TextNode("red"));
+        map.put("shape",new TextNode("square"));
+
+        UsergridEntity entity = new UsergridEntity(collectionName,null,map);
+        UsergridResponse response = entity.save();
+        assertNull(response.getResponseError());
+
+        UsergridEntity eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The returned entity is null!", eLookUp);
+        assertEquals("entities has the correct type", eLookUp.getType(),collectionName);
+        assertEquals("entities has the correct name", eLookUp.getName(),entityName);
+        assertEquals("entities has the correct color", eLookUp.getStringProperty("color"),"red");
+        assertEquals("entities has the correct shape", eLookUp.getStringProperty("shape"),"square");
+    }
+
+    @Test
+    public void testDuplicateEntityNameFailure() {
+        String collectionName = "testDuplicateEntityNameFailure" + System.currentTimeMillis();
+
+        UsergridEntity entity = new UsergridEntity(collectionName,"test3");
+        UsergridResponse response = Usergrid.POST(entity);
+        assertNull("First entity create should have succeeded.", response.getResponseError());
+
+        response = Usergrid.POST(entity);
+        assertNotNull("Second entity create should not succeed!", response.getResponseError());
+    }
+
+    @Test
+    public void testEntityLookupByName() {
+        String collectionName = "testEntityLookupByName" + System.currentTimeMillis();
+        String entityName = "testEntity4";
+
+        UsergridEntity entity = new UsergridEntity(collectionName,entityName);
+        entity.save();
+
+        UsergridEntity eLookup = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The returned entity is null!", eLookup);
+        assertEquals("The returned entity does not have the same UUID", entity.getUuid(),eLookup.getUuid());
+    }
+
+    @Test
+    public void testEntityLookupByUUID() {
+        String collectionName = "testEntityLookupByUUID" + System.currentTimeMillis();
+        String entityName = "testEntity5";
+
+        UsergridEntity entity = new UsergridEntity(collectionName,entityName);
+        entity.save();
+        assertNotNull(entity.getUuid());
+
+        UsergridEntity eLookup = Usergrid.GET(collectionName, entity.getUuid()).first();
+        assertNotNull("The returned entity is null!", eLookup);
+        assertEquals("The returned entity does not have the same UUID", entity.getUuid(),eLookup.getUuid());
+    }
+
+    @Test
+    public void testEntityLookupByQuery() {
+        String collectionName = "testEntityLookupByQuery" + System.currentTimeMillis();
+        String entityName = "testEntity6";
+
+        UsergridEntity entity = new UsergridEntity(collectionName,entityName);
+        entity.putProperty("color","red");
+        entity.putProperty("shape","square");
+        entity.save();
+
+        SDKTestUtils.indexSleep();
+
+        UsergridQuery query = new UsergridQuery(collectionName).eq("color", "red");
+        UsergridEntity eLookup = Usergrid.GET(query).first();
+
+        assertNotNull("The entity was not returned on lookup", eLookup);
+        assertEquals("The returned entity does not have the same UUID", entity.getUuid(),eLookup.getUuid());
+
+        query = new UsergridQuery(collectionName).eq("name", entityName);
+        eLookup = Usergrid.GET(query).first();
+
+        assertNotNull("The entity was not returned on lookup", eLookup);
+        assertEquals("The returned entity does not have the same UUID", entity.getUuid(),eLookup.getUuid());
+
+        query = new UsergridQuery(collectionName).eq("shape", "square");
+        eLookup = Usergrid.GET(query).first();
+
+        assertNotNull("The entity was not returned on lookup", eLookup);
+        assertEquals("The returned entity does not have the same UUID", entity.getUuid(),eLookup.getUuid());
+
+        query = new UsergridQuery(collectionName).eq("shape", "circle");
+        eLookup = Usergrid.GET(query).first();
+
+        assertNull("The entity was not expected to be returned on lookup", eLookup);
+    }
+
+    @Test
+    public void testEntityUpdate() {
+        String collectionName = "testEntityLookupByUUID" + System.currentTimeMillis();
+        String entityName = "testEntity7";
+
+        UsergridEntity entity = new UsergridEntity(collectionName,entityName);
+        entity.putProperty("color","red");
+        entity.putProperty("shape","square");
+        entity.putProperty("orientation","up");
+        entity.save();
+
+        SDKTestUtils.sleep(1000);
+
+        UsergridQuery query = new UsergridQuery(collectionName).eq("orientation", "up");
+        UsergridEntity eLookup = Usergrid.GET(query).first();
+        assertNotNull(eLookup);
+
+        assertEquals("The returned entity does not have the same UUID when querying by field", entity.getUuid(),eLookup.getUuid());
+
+        entity.putProperty("orientation", "down");
+        entity.save();
+        assertNotNull(entity.getUuid());
+
+        eLookup = Usergrid.GET(collectionName, entity.getUuid()).first();
+        assertNotNull(eLookup);
+
+        assertEquals("The returned entity does not have the same UUID", entity.getUuid(),eLookup.getUuid());
+        assertEquals("The field was not updated!", eLookup.getStringProperty("orientation"),"down");
+
+        SDKTestUtils.sleep(1000);
+
+        query = new UsergridQuery(collectionName).eq("orientation", "up");
+        eLookup = Usergrid.GET(query).first();
+
+        assertNull("The entity was returned for old value!", eLookup);
+    }
+
+    @Test
+    public void testEntityDelete() {
+        String collectionName = "testEntityDelete" + System.currentTimeMillis();
+        String entityName = "testEntity8";
+
+        UsergridEntity entity = new UsergridEntity(collectionName,entityName);
+        entity.putProperty("color","red");
+        entity.putProperty("shape","square");
+        entity.putProperty("orientation","up");
+        entity.save();
+
+        SDKTestUtils.indexSleep();
+
+        assertNotNull(entity.getUuid());
+        assertNotNull(entity.getName());
+
+        UsergridQuery query = new UsergridQuery(collectionName).eq("orientation", "up");
+        UsergridEntity eLookup = Usergrid.GET(query).first();
+
+        assertNotNull("The returned entity was null!", eLookup);
+        assertEquals("The returned entity does not have the same UUID when querying by field", entity.getUuid(),eLookup.getUuid());
+
+        Usergrid.DELETE(entity);
+
+        eLookup = Usergrid.GET(collectionName, entity.getUuid()).first();
+        assertNull("The entity was not expected to be returned by UUID", eLookup);
+
+        eLookup = Usergrid.GET(collectionName, entity.getName()).first();
+        assertNull("The entity was not expected to be returned by getName", eLookup);
+
+        query = new UsergridQuery(collectionName).eq("color", "red");
+        eLookup = Usergrid.GET(query).first();
+        assertNull("The entity was not expected to be returned", eLookup);
+
+        query = new UsergridQuery(collectionName).eq("shape", "square");
+        eLookup = Usergrid.GET(query).first();
+        assertNull("The entity was not expected to be returned", eLookup);
+
+        query = new UsergridQuery(collectionName).eq("orientation", "up");
+        eLookup = Usergrid.GET(query).first();
+        assertNull("The entity was not expected to be returned", eLookup);
+    }
+
+    @Test
+    public void testEntityPutPropertyAndSave() {
+        String collectionName = "testEntityPutProperty" + System.currentTimeMillis();
+        String entityName = "testEntity9";
+
+        UsergridEntity entity = new UsergridEntity(collectionName,entityName);
+        entity.putProperty("color","red");
+        entity.putProperty("shape","square");
+        entity.putProperty("orientation","up");
+        entity.putProperty("sides", 4);
+        entity.save();
+
+        UsergridEntity eLookUp = Usergrid.GET(collectionName, entityName).first();
+
+        //Check if the property was added correctly
+        assertNotNull("The entity returned is not null.", eLookUp);
+        assertEquals("The entity putProperty() was successful ", eLookUp.getStringProperty("orientation"),"up");
+        assertEquals("The entity putProperty() was successful ", eLookUp.getIntegerProperty("sides"), new Integer(4));
+
+        //Overwrite the property if it exists.
+        entity.putProperty("orientation", "horizontal");
+        entity.save();
+
+        eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The returned entity was null!", eLookUp);
+        assertEquals("The entity putProperty() was successful ", eLookUp.getStringProperty("orientation"),"horizontal");
+
+        //should not be able to set the name key (name is immutable)
+        entity.putProperty("name","entityNew");
+        entity.save();
+
+        eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The returned entity was null!", eLookUp);
+        assertEquals("The entity putProperty() was successful ", eLookUp.getName(),"testEntity9");
+    }
+
+    @Test
+    public void testEntityPutProperties() {
+        String collectionName = "testEntityProperties" + System.currentTimeMillis();
+        String entityName = "testEntity9";
+
+        UsergridEntity entity = new UsergridEntity(collectionName,entityName);
+        entity.putProperty("color","black");
+        entity.putProperty("orientation","up");
+        entity.save();
+
+        UsergridEntity eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+        assertEquals("The entity putProperty() was successful ", eLookUp.getStringProperty("orientation"),"up");
+        assertEquals("overwrite existing property", eLookUp.getStringProperty("color"),"black");
+    }
+
+    @Test
+    public void testEntityRemovePropertiesAndSave() {
+        String collectionName = "testEntityProperties" + System.currentTimeMillis();
+
+        Map<String, String> fields = new HashMap<>(3);
+        fields.put("color", "red");
+
+        String entityName = "testEntity9";
+
+        //should set properties for a given object, overwriting properties that exist and creating those that don\'t
+        UsergridEntity entity = SDKTestUtils.createEntity(collectionName, entityName, fields);
+        Map<String, Object> properties = new HashMap<>();
+        properties.put("shape", "square");
+        properties.put("orientation", "up");
+        properties.put("color", "black");
+        entity.putProperties(properties);
+        entity.save();
+
+        UsergridEntity eLookUp = Usergrid.GET(collectionName, "testEntity9").first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        String[] removeProperties = {"shape", "color"};
+        entity.removeProperties(Arrays.asList(removeProperties));
+        entity.save();
+
+        eLookUp = Usergrid.GET(collectionName, "testEntity9").first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+        assertTrue("overwrite existing property", eLookUp.getStringProperty("color") == null);
+        assertTrue("overwrite existing property", eLookUp.getStringProperty("shape") == null);
+
+    }
+
+    @Test
+    public void testEntityRemoveProperty() {
+        String collectionName = "testEntityProperties" + System.currentTimeMillis();
+
+        Map<String, String> fields = new HashMap<>(3);
+        fields.put("color", "red");
+
+        String entityName = "testEntity11";
+
+        //should set properties for a given object, overwriting properties that exist and creating those that don\'t
+        UsergridEntity entity = SDKTestUtils.createEntity(collectionName, entityName, fields);
+        Map<String, Object> properties = new HashMap<>();
+        properties.put("shape", "square");
+        properties.put("orientation", "up");
+        properties.put("color", "black");
+        entity.putProperties(properties);
+        entity.save();
+
+        UsergridEntity eLookUp = Usergrid.GET(collectionName, "testEntity11").first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        entity.removeProperty("color");
+        entity.removeProperty("shape");
+        entity.save();
+
+        eLookUp = Usergrid.GET(collectionName, "testEntity11").first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+        assertTrue("overwrite existing property", eLookUp.getStringProperty("color") == null);
+        assertTrue("overwrite existing property", eLookUp.getStringProperty("shape") == null);
+
+    }
+
+    @Test
+    public void testEntityAppendInArray() {
+        String collectionName = "testEntityProperties" + System.currentTimeMillis();
+        String entityName = "testEntity1";
+
+        UsergridEntity entity = new UsergridEntity(collectionName,entityName);
+        entity.save();
+
+        ArrayList<Object> lenArr = new ArrayList<>();
+        lenArr.add(1);
+        lenArr.add(2);
+        lenArr.add(3);
+        lenArr.add(4);
+        entity.insert("lenArray", lenArr);
+        entity.save();
+
+        lenArr = new ArrayList<>();
+        lenArr.add(6);
+        lenArr.add(7);
+        entity.append("lenArray", lenArr);
+        entity.save();
+
+        UsergridEntity eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        ArrayNode toCompare = new ArrayNode(JsonNodeFactory.instance);
+        toCompare.add(1).add(2).add(3).add(4).add(6).add(7);
+        assertEquals("The two arrays should be equal.", eLookUp.getJsonNodeProperty("lenArray"),toCompare);
+    }
+
+    @Test
+    public void testEntityPrependInArray() {
+        String collectionName = "testEntityProperties" + System.currentTimeMillis();
+        String entityName = "testEntity1";
+
+        UsergridEntity entity = new UsergridEntity(collectionName,entityName);
+        entity.save();
+
+        ArrayList<Object> lenArr = new ArrayList<>();
+        lenArr.add(1);
+        lenArr.add(2);
+        lenArr.add(3);
+        lenArr.add(4);
+        entity.putProperty("lenArray", lenArr);
+        entity.save();
+
+        lenArr = new ArrayList<>();
+        lenArr.add(6);
+        lenArr.add(7);
+
+        entity.insert("lenArray", lenArr, 0);
+        entity.save();
+        UsergridEntity eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        ArrayNode toCompare = new ArrayNode(JsonNodeFactory.instance);
+        toCompare.add(6).add(7).add(1).add(2).add(3).add(4);
+        assertEquals("The two arrays should be equal.", eLookUp.getJsonNodeProperty("lenArray"),toCompare);
+    }
+
+    @Test
+    public void testEntityPopInArray() {
+        String collectionName = "testEntityProperties" + System.currentTimeMillis();
+        String entityName = "testEntity1";
+
+        UsergridEntity entity = new UsergridEntity(collectionName,entityName);
+        entity.save();
+
+        ArrayList<Object> lenArr = new ArrayList<>();
+        lenArr.add(1);
+        lenArr.add(2);
+        lenArr.add(3);
+        entity.putProperty("lenArray", lenArr);
+        entity.save();
+
+        // should remove the last value of an existing array
+        entity.pop("lenArray");
+        entity.save();
+
+        UsergridEntity eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        ArrayNode toCompare = new ArrayNode(JsonNodeFactory.instance);
+        toCompare.add(1).add(2);
+        assertEquals("The two arrays should be equal.", eLookUp.getJsonNodeProperty("lenArray"),toCompare);
+
+        // value should remain unchanged if it is not an array
+        entity.putProperty("foo", "test1");
+        entity.save();
+
+        entity.pop("foo");
+        entity.save();
+
+        eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+        assertEquals("foo should equal test1.", eLookUp.getStringProperty("foo"), "test1");
+
+        //should gracefully handle empty arrays
+        ArrayList<Object> lenArr2 = new ArrayList<>();
+        entity.putProperty("foo", lenArr2);
+        entity.save();
+        entity.pop("foo");
+
+        eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        toCompare = new ArrayNode(JsonNodeFactory.instance);
+        assertEquals("The two arrays should be equal.", eLookUp.getJsonNodeProperty("foo"),toCompare);
+    }
+
+    @Test
+    public void testEntityShiftInArray() {
+        String collectionName = "testEntityProperties" + System.currentTimeMillis();
+        String entityName = "testEntity1";
+
+        //should remove the last value of an existing array
+        UsergridEntity entity = new UsergridEntity(collectionName,entityName);
+        entity.save();
+
+        ArrayList<Object> lenArr = new ArrayList<>();
+        lenArr.add(1);
+        lenArr.add(2);
+        lenArr.add(3);
+        entity.putProperty("lenArray", lenArr);
+        entity.save();
+
+        entity.shift("lenArray");
+        entity.save();
+
+        UsergridEntity eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        ArrayNode toCompare = new ArrayNode(JsonNodeFactory.instance);
+        toCompare.add(2).add(3);
+        assertEquals("The two arrays should be equal.", eLookUp.getJsonNodeProperty("lenArray"),toCompare);
+
+        //value should remain unchanged if it is not an array
+        entity.putProperty("foo", "test1");
+        entity.shift("foo");
+        entity.save();
+
+        eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+        assertEquals("The entity returned is not null.", eLookUp.getStringProperty("foo"), "test1");
+
+        //should gracefully handle empty arrays
+        ArrayList<Object> lenArr2 = new ArrayList<>();
+        entity.putProperty("foo", lenArr2);
+        entity.shift("foo");
+        entity.save();
+
+        eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+        assertEquals("The two arrays should be equal.", eLookUp.getJsonNodeProperty("foo"), new ArrayNode(JsonNodeFactory.instance));
+    }
+
+    @Test
+    public void testEntityInsertInArray() {
+        String collectionName = "testEntityProperties" + System.currentTimeMillis();
+        String entityName = "testEntity1";
+
+        //should set properties for a given object, overwriting properties that exist and creating those that don\'t
+        UsergridEntity entity = new UsergridEntity(collectionName,entityName);
+        entity.save();
+
+        ArrayList<Object> lenArr = new ArrayList<>();
+        lenArr.add(1);
+        lenArr.add(2);
+        lenArr.add(3);
+        lenArr.add(4);
+        entity.putProperty("lenArray", lenArr);
+        entity.save();
+
+        ArrayList<Object> lenArr2 = new ArrayList<>();
+        lenArr2.add(6);
+        lenArr2.add(7);
+
+        entity.insert("lenArray", lenArr2, 6);
+        entity.save();
+
+        UsergridEntity eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        ArrayNode toCompare = new ArrayNode(JsonNodeFactory.instance);
+        toCompare.add(1).add(2).add(3).add(4).add(6).add(7);
+        assertEquals("The two arrays should be equal.", eLookUp.getJsonNodeProperty("lenArray"),toCompare);
+
+        //should merge an array of values into an existing array at the specified index
+        lenArr = new ArrayList<>();
+        lenArr.add(1);
+        lenArr.add(2);
+        lenArr.add(3);
+        lenArr.add(4);
+
+        entity.putProperty("lenArray", lenArr);
+        entity.save();
+
+        lenArr2 = new ArrayList<>();
+        lenArr2.add(5);
+        lenArr2.add(6);
+        lenArr2.add(7);
+        lenArr2.add(8);
+
+        entity.insert("lenArray", lenArr2, 2);
+        entity.save();
+
+        eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        toCompare = new ArrayNode(JsonNodeFactory.instance);
+        toCompare.add(1).add(2).add(5).add(6).add(7).add(8).add(3).add(4);
+        assertEquals("The two arrays should be equal.", eLookUp.getJsonNodeProperty("lenArray"),toCompare);
+
+        //should convert an existing value into an array when inserting a second value
+        entity.putProperty("foo", "test");
+        entity.insert("foo", "test1", 1);
+        entity.save();
+
+        eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        toCompare = new ArrayNode(JsonNodeFactory.instance);
+        toCompare.add("test").add("test1");
+        assertEquals("The two arrays should be equal.", eLookUp.getJsonNodeProperty("foo"),toCompare);
+
+        //should create a new array when a property does not exist
+        entity.insert("foo1", "test2", 1);
+        entity.save();
+
+        eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        toCompare = new ArrayNode(JsonNodeFactory.instance);
+        toCompare.add("test2");
+        assertEquals("The two arrays should be equal.", eLookUp.getJsonNodeProperty("foo1"),toCompare);
+
+        //should gracefully handle index out of positive range
+        entity.putProperty("ArrayIndex", "test1");
+        entity.insert("ArrayIndex", "test2", 1000);
+        entity.save();
+
+        eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        toCompare = new ArrayNode(JsonNodeFactory.instance);
+        toCompare.add("test1").add("test2");
+        assertEquals("The two arrays should be equal.", eLookUp.getJsonNodeProperty("ArrayIndex"),toCompare);
+
+        //should gracefully handle index out of negative range
+        entity.insert("ArrayIndex", "test3", -1000);
+        entity.save();
+
+        eLookUp = Usergrid.GET(collectionName, entityName).first();
+        assertNotNull("The entity returned is not null.", eLookUp);
+
+        toCompare = new ArrayNode(JsonNodeFactory.instance);
+        toCompare.add("test3").add("test1").add("test2");
+        assertEquals("The two arrays should be equal.", eLookUp.getJsonNodeProperty("ArrayIndex"),toCompare);
+    }
+
+    @Test
+    public void testEntityConnectDisconnectGetConnections() {
+        String collectionName = "testEntityProperties" + System.currentTimeMillis();
+        String entityOneName = "testEntity1";
+        String entityTwoName = "testEntity2";
+
+        UsergridEntity entityOne = new UsergridEntity(collectionName,entityOneName);
+        entityOne.putProperty("color","red");
+        entityOne.putProperty("shape","square");
+        entityOne.save();
+
+        UsergridEntity entityTwo = new UsergridEntity(collectionName,entityTwoName);
+        entityTwo.putProperty("color","green");
+        entityTwo.putProperty("shape","circle");
+        entityTwo.save();
+
+        assertNotNull(entityOne.getUuid());
+        assertNotNull(entityTwo.getUuid());
+        assertNotNull(entityOne.getName());
+        assertNotNull(entityTwo.getName());
+        assertNotNull(entityOne.uuidOrName());
+        assertNotNull(entityTwo.uuidOrName());
+
+        //should connect entities by passing a target UsergridEntity object as a parameter
+        entityOne.connect("likes", entityTwo);
+        entityOne.save();
+
+        UsergridEntity eLookUpConnectedEntity = entityOne.getConnections(UsergridDirection.OUT, "likes").first();
+        assertNotNull("The connected entity returned is not null.", eLookUpConnectedEntity);
+
+        assertEquals("The entity name should be equals.", eLookUpConnectedEntity.getName(),entityTwoName);
+
+        eLookUpConnectedEntity = entityTwo.getConnections(UsergridDirection.IN, "likes").first();
+        assertNotNull("The connected entity returned is not null.", eLookUpConnectedEntity);
+        assertEquals("The entity name should be equals.", eLookUpConnectedEntity.getName(),entityOneName);
+
+        entityOne.disconnect("likes", entityTwo);
+        entityOne.save();
+
+        eLookUpConnectedEntity = entityTwo.getConnections(UsergridDirection.IN, "likes").first();
+        assertNull("The entity returned is not null.", eLookUpConnectedEntity);
+
+        //should connect entities by passing target uuid as a parameter
+        Usergrid.connect(entityOne.getType(),entityOne.getUuid(),"visited",entityTwo.getUuid());
+        entityOne.save();
+
+        eLookUpConnectedEntity = entityOne.getConnections(UsergridDirection.OUT, "visited").first();
+        assertNotNull("The connected entity returned is not null.", eLookUpConnectedEntity);
+        assertEquals("The entity name should be equals.", eLookUpConnectedEntity.getName(),entityTwoName);
+
+        Usergrid.disconnect(entityOne.getType(),entityOne.getUuid(),"visited",entityTwo.getUuid());
+        entityOne.save();
+
+        eLookUpConnectedEntity = entityOne.getConnections(UsergridDirection.OUT, "visited").first();
+        assertNull("The entity returned is not null.", eLookUpConnectedEntity);
+
+        //should connect entities by passing target type and name as parameters
+        Usergrid.connect(entityOne.getType(),entityOne.getUuid(),"revisit",entityTwo.getType(),entityTwo.getName());
+        entityOne.save();
+
+        eLookUpConnectedEntity = entityOne.getConnections(UsergridDirection.OUT, "revisit").first();
+        assertNotNull("The connected entity returned is not null.", eLookUpConnectedEntity);
+        assertEquals("The entity name should be equals.", eLookUpConnectedEntity.getName(),entityTwoName);
+
+        Usergrid.disconnect(entityOne.getType(),entityOne.getUuid(),"revisit",entityTwo.getType(),entityTwo.getName());
+        entityOne.save();
+
+        eLookUpConnectedEntity = entityOne.getConnections(UsergridDirection.OUT, "revisit").first();
+        assertNull("The entity returned is not null.", eLookUpConnectedEntity);
+    }
+}

http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/test/java/org/apache/usergrid/client/QueryTestCase.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/test/java/org/apache/usergrid/client/QueryTestCase.java b/sdks/java/src/test/java/org/apache/usergrid/client/QueryTestCase.java
new file mode 100644
index 0000000..f013134
--- /dev/null
+++ b/sdks/java/src/test/java/org/apache/usergrid/client/QueryTestCase.java
@@ -0,0 +1,194 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.usergrid.client;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.DoubleNode;
+import org.apache.usergrid.java.client.Usergrid;
+import org.apache.usergrid.java.client.auth.UsergridAppAuth;
+import org.apache.usergrid.java.client.model.UsergridEntity;
+import org.apache.usergrid.java.client.query.UsergridQuery;
+import org.apache.usergrid.java.client.response.UsergridResponse;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+public class QueryTestCase {
+
+    public static final String COLLECTION = "shapes";
+
+    public static float distFrom(float lat1, float lng1, float lat2, float lng2) {
+        double earthRadius = 6371000; //meters
+        double dLat = Math.toRadians(lat2 - lat1);
+        double dLng = Math.toRadians(lng2 - lng1);
+        double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
+        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+        return (float) (earthRadius * c);
+    }
+
+    @Before
+    public void before() {
+        Usergrid.initSharedInstance(SDKTestConfiguration.ORG_NAME, SDKTestConfiguration.APP_NAME, SDKTestConfiguration.USERGRID_URL, SDKTestConfiguration.authFallBack);
+        Usergrid.authenticateApp(new UsergridAppAuth(SDKTestConfiguration.APP_CLIENT_ID, SDKTestConfiguration.APP_CLIENT_SECRET));
+    }
+
+    @After
+    public void after() {
+        Usergrid.reset();
+    }
+
+    /**
+     * Test a basic set of queries where there is inclusion and exclusion based on
+     * two fields
+     */
+    @Test
+    public void testBasicQuery() {
+
+        UsergridQuery qDelete = new UsergridQuery(COLLECTION);
+        Usergrid.DELETE(qDelete);
+
+        Map<String, UsergridEntity> entityMapByUUID = SDKTestUtils.createColorShapes(COLLECTION);
+        Map<String, UsergridEntity> entityMapByName = new HashMap<>(entityMapByUUID.size());
+
+        for (Map.Entry<String, UsergridEntity> uuidEntity : entityMapByUUID.entrySet()) {
+            entityMapByName.put(uuidEntity.getValue().getName(), uuidEntity.getValue());
+        }
+
+        SDKTestUtils.indexSleep();
+
+        Map<String, String> fields = new HashMap<>(7);
+        fields.put("red", "square");
+        fields.put("blue", "circle");
+        fields.put("yellow", "triangle");
+
+        for (Map.Entry<String, String> entry : fields.entrySet()) {
+            UsergridEntity targetEntity = entityMapByName.get(entry.getKey() + entry.getValue());
+
+            UsergridResponse response = Usergrid.GET(new UsergridQuery(COLLECTION).eq("color", entry.getKey()));
+            assertNotNull("entities returned should not be null.", response.getEntities());
+            assertTrue("query for " + entry.getKey() + " shape should return 1, not: " + response.getEntities().size(), response.getEntities().size() == 1);
+
+            UsergridEntity responseEntity = response.first();
+            assertNotNull("first entity should not be null.", responseEntity);
+            assertEquals("query for " + entry.getKey() + " shape should the right UUID", responseEntity.getUuid(),targetEntity.getUuid());
+        }
+        Usergrid.DELETE(qDelete);
+    }
+
+    /**
+     * Test that geolocation is working as expected with different ranges and radius
+     * also test that results are sorted ascending by distance from the specified point
+     */
+    @Test
+    public void testGeoQuery() {
+
+        String collectionName = "sdkTestLocation";
+
+        UsergridQuery deleteQuery = new UsergridQuery(collectionName);
+        Usergrid.DELETE(deleteQuery);
+
+        ArrayList<UsergridEntity> entities = new ArrayList<>();
+        UsergridEntity apigeeOffice = new UsergridEntity(collectionName,"Apigee Office");
+        apigeeOffice.setLocation(37.334115, -121.894340);
+        entities.add(apigeeOffice);
+
+        UsergridEntity amicis = new UsergridEntity(collectionName,"Amicis");
+        amicis.setLocation(37.335616, -121.894168);
+        entities.add(amicis);
+
+        UsergridEntity sanPedroMarket = new UsergridEntity(collectionName,"SanPedroMarket");
+        sanPedroMarket.setLocation(37.336499, -121.894356);
+        entities.add(sanPedroMarket);
+
+        UsergridEntity saintJamesPark = new UsergridEntity(collectionName,"saintJamesPark");
+        saintJamesPark.setLocation(37.339079, -121.891422);
+        entities.add(saintJamesPark);
+
+        UsergridEntity sanJoseNews = new UsergridEntity(collectionName,"sanJoseNews");
+        sanJoseNews.setLocation(37.337812, -121.890784);
+        entities.add(sanJoseNews);
+
+        UsergridEntity deAnza = new UsergridEntity(collectionName,"deAnza");
+        deAnza.setLocation(37.334370, -121.895081);
+        entities.add(deAnza);
+
+        Usergrid.POST(entities);
+
+        SDKTestUtils.indexSleep();
+
+        float centerLat = 37.334110f;
+        float centerLon = -121.894340f;
+
+        // Test a large distance
+        UsergridResponse queryResponse = Usergrid.GET(new UsergridQuery(collectionName).locationWithin(611.00000, centerLat, centerLon));
+        assertNotNull(queryResponse.getEntities());
+
+        float lastDistanceFrom = 0;
+        for (UsergridEntity entity : queryResponse.getEntities()) {
+
+            JsonNode locationNode = entity.getEntityProperty("location");
+            assertNotNull("location node should not be null", locationNode);
+
+            DoubleNode lat = (DoubleNode) locationNode.get("latitude");
+            DoubleNode lon = (DoubleNode) locationNode.get("longitude");
+
+            float distanceFrom = distFrom(centerLat, centerLon, lat.floatValue(), lon.floatValue());
+            System.out.println("Entity " + entity.getName() + " is " + distanceFrom + " away");
+
+            assertTrue("Entity " + entity.getName() + " was included but is not within specified distance (" + distanceFrom + ")", distanceFrom <= 611.0);
+
+            if (lastDistanceFrom != 0) {
+                assertTrue("GEO results are not sorted by distance ascending: expected " + lastDistanceFrom + " <= " + distanceFrom, lastDistanceFrom <= distanceFrom);
+            }
+
+            lastDistanceFrom = distanceFrom;
+        }
+
+        // Test a small distance
+        queryResponse = Usergrid.GET(new UsergridQuery(collectionName).locationWithin(150, centerLat, centerLon));
+        assertNotNull(queryResponse.getEntities());
+
+        lastDistanceFrom = 0;
+        for (UsergridEntity entity : queryResponse.getEntities()) {
+
+            JsonNode locationNode = entity.getEntityProperty("location");
+            assertNotNull("location node should not be null", locationNode);
+
+            DoubleNode lat = (DoubleNode) locationNode.get("latitude");
+            DoubleNode lon = (DoubleNode) locationNode.get("longitude");
+
+            float distanceFrom = distFrom(centerLat, centerLon, lat.floatValue(), lon.floatValue());
+            System.out.println("Entity " + entity.getName() + " is " + distanceFrom + " away");
+
+            assertTrue("Entity " + entity.getName() + " was included but is not within specified distance (" + distanceFrom + ")", distanceFrom <= 150);
+
+            if (lastDistanceFrom != 0) {
+                assertTrue("GEO results are not sorted by distance ascending: expected " + lastDistanceFrom + " <= " + distanceFrom, lastDistanceFrom <= distanceFrom);
+            }
+
+            lastDistanceFrom = distanceFrom;
+        }
+
+        Usergrid.DELETE(deleteQuery);
+    }
+}

http://git-wip-us.apache.org/repos/asf/usergrid/blob/2e127e62/sdks/java/src/test/java/org/apache/usergrid/client/SDKTestConfiguration.java
----------------------------------------------------------------------
diff --git a/sdks/java/src/test/java/org/apache/usergrid/client/SDKTestConfiguration.java b/sdks/java/src/test/java/org/apache/usergrid/client/SDKTestConfiguration.java
new file mode 100644
index 0000000..8663326
--- /dev/null
+++ b/sdks/java/src/test/java/org/apache/usergrid/client/SDKTestConfiguration.java
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.usergrid.client;
+
+import org.apache.usergrid.java.client.UsergridEnums.UsergridAuthMode;
+
+public class SDKTestConfiguration {
+    public static final String APP_CLIENT_ID = "b3U6THNcevskEeOQZLcUROUUVA"; //"YXA6_j0WsfFCEeWKoy6txsCOfA" ;
+    public static final String APP_CLIENT_SECRET = "b3U6RZHYznP28xieBzQPackFPmmnevU"; //"YXA6jg8x4wjq1AAyQBKtn4bRd1l0gJ8"; //
+
+    public static final String APP_UserName = "rwalsh"; //"test";// //"b3U66ne33W4OEeWXmAIj6QFb-Q";
+    public static final String APP_Password = "Apigee123"; //"test";//"b3U6PxbpQiTrXKCWu0n1CjK1uTZXuG4";
+    public static final String USERGRID_URL = "https://api.usergrid.com/";
+    public static final String ORG_NAME = "rwalsh";
+    public static final String APP_NAME = "sandbox";
+
+    public static UsergridAuthMode authFallBack = UsergridAuthMode.APP;
+
+//  public static final String APP_CLIENT_ID = "YXA61n2kpFffEeWs9QLknKqhHw";
+//  public static final String APP_CLIENT_SECRET = "YXA69_aRW1IHLgMTUUYSitsGwOLY8uQ";
+//  public static final String USERGRID_URL = "https://fhirsandbox-prod.apigee.net/appservices";
+//  public static final String ORG_NAME = "usergrid";
+//  public static final String APP_NAME = "sandbox";
+}


Mime
View raw message