@Test public void testConvertFindResponse() throws Exception { // Make mock response JSONObject mockResponse = generateBasicMockResponse(); // Make mock state ParseQuery.State mockState = mock(ParseQuery.State.class); when(mockState.className()).thenReturn("Test"); when(mockState.selectedKeys()).thenReturn(null); when(mockState.constraints()).thenReturn(new ParseQuery.QueryConstraints()); NetworkQueryController controller = new NetworkQueryController(mock(ParseHttpClient.class)); List<ParseObject> objects = controller.convertFindResponse(mockState, mockResponse); verifyBasicParseObjects(mockResponse, objects, "Test"); }
private static void verifyCondition( ParseQuery query, String key, String conditionKey, Map values) { // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); ParseQuery.QueryConstraints queryConstraints = state.constraints(); ParseQuery.KeyConstraints keyConstraints = (ParseQuery.KeyConstraints) queryConstraints.get(key); Map map = (Map) keyConstraints.get(conditionKey); assertEquals(values.size(), map.size()); for (Object constraintKey : map.keySet()) { assertTrue(values.containsKey(constraintKey)); assertEquals(map.get(constraintKey), values.get(constraintKey)); } }
@Test public void testCountAsyncWithSessionToken() throws Exception { // Make mock response and client JSONObject mockResponse = new JSONObject(); mockResponse.put("count", 2); ParseHttpClient restClient = ParseTestUtils.mockParseHttpClientWithResponse(mockResponse, 200, "OK"); // Make mock state ParseQuery.State mockState = mock(ParseQuery.State.class); when(mockState.className()).thenReturn("Test"); when(mockState.selectedKeys()).thenReturn(null); when(mockState.constraints()).thenReturn(new ParseQuery.QueryConstraints()); NetworkQueryController controller = new NetworkQueryController(restClient); Task<Integer> countTask = controller.countAsync(mockState, "sessionToken", null); ParseTaskUtils.wait(countTask); int count = countTask.getResult(); assertEquals(2, count); }
@Test public void testFindAsyncWithSessionToken() throws Exception { // Make mock response JSONObject mockResponse = generateBasicMockResponse(); mockResponse.put("trace", "serverTrace"); ParseHttpClient restClient = ParseTestUtils.mockParseHttpClientWithResponse(mockResponse, 200, "OK"); // Make mock state ParseQuery.State mockState = mock(ParseQuery.State.class); when(mockState.className()).thenReturn("Test"); when(mockState.selectedKeys()).thenReturn(null); when(mockState.constraints()).thenReturn(new ParseQuery.QueryConstraints()); NetworkQueryController controller = new NetworkQueryController(restClient); Task<List<ParseObject>> findTask = controller.findAsync(mockState, "sessionToken", null); ParseTaskUtils.wait(findTask); List<ParseObject> objects = findTask.getResult(); verifyBasicParseObjects(mockResponse, objects, "Test"); // TODO(mengyan): Verify PLog is called }
@Test public void testWhereWithinPolygon() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); ParseGeoPoint point1 = new ParseGeoPoint(10, 10); ParseGeoPoint point2 = new ParseGeoPoint(20, 20); ParseGeoPoint point3 = new ParseGeoPoint(30, 30); List<ParseGeoPoint> points = Arrays.asList(point1, point2, point3); query.whereWithinPolygon("key", points); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); ParseQuery.QueryConstraints queryConstraints = state.constraints(); ParseQuery.KeyConstraints keyConstraints = (ParseQuery.KeyConstraints) queryConstraints.get("key"); Map map = (Map) keyConstraints.get("$geoWithin"); List<Object> list = (List<Object>) map.get("$polygon"); assertEquals(3, list.size()); assertTrue(list.contains(point1)); assertTrue(list.contains(point2)); assertTrue(list.contains(point3)); }
@Test public void testDefaults() { ParseQuery.State.Builder<ParseObject> builder = new ParseQuery.State.Builder<>("TestObject"); ParseQuery.State<ParseObject> state = builder.build(); assertEquals("TestObject", state.className()); assertTrue(state.constraints().isEmpty()); assertTrue(state.includes().isEmpty()); assertNull(state.selectedKeys()); assertEquals(-1, state.limit()); assertEquals(0, state.skip()); assertTrue(state.order().isEmpty()); assertTrue(state.extraOptions().isEmpty()); assertFalse(state.isTracingEnabled()); assertEquals(ParseQuery.CachePolicy.IGNORE_CACHE, state.cachePolicy()); assertEquals(Long.MAX_VALUE, state.maxCacheAge()); assertFalse(state.isFromLocalDatastore()); assertNull(state.pinName()); assertFalse(state.ignoreACLs()); }
@Test public void testWhereWithinPolygonWithPolygon() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); ParseGeoPoint point1 = new ParseGeoPoint(10, 10); ParseGeoPoint point2 = new ParseGeoPoint(20, 20); ParseGeoPoint point3 = new ParseGeoPoint(30, 30); List<ParseGeoPoint> points = Arrays.asList(point1, point2, point3); query.whereWithinPolygon("key", new ParsePolygon(points)); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); ParseQuery.QueryConstraints queryConstraints = state.constraints(); ParseQuery.KeyConstraints keyConstraints = (ParseQuery.KeyConstraints) queryConstraints.get("key"); Map map = (Map) keyConstraints.get("$geoWithin"); List<Object> list = (List<Object>) map.get("$polygon"); assertEquals(3, list.size()); assertTrue(list.contains(point1)); assertTrue(list.contains(point2)); assertTrue(list.contains(point3)); }
@Test public void testConstraints() { ParseQuery.QueryConstraints constraints; ParseQuery.State.Builder<ParseObject> builder = new ParseQuery.State.Builder<>("TestObject"); constraints = builder .whereEqualTo("foo", "bar") .whereEqualTo("foo", "baz") // Should overwrite since same key .addCondition("people", "$in", Collections.singletonList("stanley")) // Collection .addCondition("people", "$in", Collections.singletonList("grantland")) // Collection (overwrite) .addCondition("something", "$exists", false) // Object .build() .constraints(); assertEquals(3, constraints.size()); assertEquals("baz", constraints.get("foo")); Collection<?> in = ((Collection<?>) ((ParseQuery.KeyConstraints) constraints.get("people")).get("$in")); assertEquals(1, in.size()); assertEquals("grantland", new ArrayList<>(in).get(0)); assertEquals(false, ((ParseQuery.KeyConstraints) constraints.get("something")).get("$exists")); }
@Test public void testOrIsMutable() { List<ParseQuery.State.Builder<ParseObject>> subqueries = new ArrayList<>(); ParseQuery.State.Builder<ParseObject> builderA = new ParseQuery.State.Builder<>("TestObject"); subqueries.add(builderA); ParseQuery.State.Builder<ParseObject> builderB = new ParseQuery.State.Builder<>("TestObject"); subqueries.add(builderB); ParseQuery.State.Builder<ParseObject> builder = ParseQuery.State.Builder.or(subqueries); // Mutate subquery after `or` builderA.whereEqualTo("name", "grantland"); ParseQuery.State<ParseObject> state = builder.build(); ParseQuery.QueryConstraints constraints = state.constraints(); @SuppressWarnings("unchecked") List<ParseQuery.QueryConstraints> or = (List<ParseQuery.QueryConstraints>) constraints.get("$or"); assertEquals("grantland", or.get(0).get("name")); }
@Test public void testWhereWithinGeoBox() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); ParseGeoPoint point = new ParseGeoPoint(10, 10); ParseGeoPoint pointAgain = new ParseGeoPoint(20, 20); query.whereWithinGeoBox("key", point, pointAgain); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); ParseQuery.QueryConstraints queryConstraints = state.constraints(); ParseQuery.KeyConstraints keyConstraints = (ParseQuery.KeyConstraints) queryConstraints.get("key"); Map map = (Map) keyConstraints.get("$within"); List<Object> list = (List<Object>) map.get("$box"); assertEquals(2, list.size()); assertTrue(list.contains(point)); assertTrue(list.contains(pointAgain)); }
@Test public void testGetQueryWithNoTargetClass() { ParseObject parent = new ParseObject("Parent"); ParseRelation relation = new ParseRelation(parent, "key"); ParseQuery query = relation.getQuery(); // Make sure className is correct assertEquals("Parent", query.getClassName()); ParseQuery.State state = query.getBuilder().build(); // Make sure redirectClassNameForKey is set assertEquals("key", state.extraOptions().get("redirectClassNameForKey")); // Make sure where condition is set ParseQuery.RelationConstraint relationConstraint = (ParseQuery.RelationConstraint) state.constraints().get("$relatedTo"); assertEquals("key", relationConstraint.getKey()); assertSame(parent, relationConstraint.getObject()); }
@Test public void testOr() { List<ParseQuery.State.Builder<ParseObject>> subqueries = new ArrayList<>(); subqueries.add(new ParseQuery.State.Builder<>("TestObject").whereEqualTo("name", "grantland")); subqueries.add(new ParseQuery.State.Builder<>("TestObject").whereEqualTo("name", "stanley")); ParseQuery.State<ParseObject> state = ParseQuery.State.Builder.or(subqueries).build(); assertEquals("TestObject", state.className()); ParseQuery.QueryConstraints constraints = state.constraints(); assertEquals(1, constraints.size()); @SuppressWarnings("unchecked") List<ParseQuery.QueryConstraints> or = (List<ParseQuery.QueryConstraints>) constraints.get("$or"); assertEquals(2, or.size()); assertEquals("grantland", or.get(0).get("name")); assertEquals("stanley", or.get(1).get("name")); }
public Builder(State state) { className = state.className(); where.putAll(state.constraints()); includes.addAll(state.includes()); selectedKeys = state.selectedKeys() != null ? new HashSet(state.selectedKeys()) : null; limit = state.limit(); skip = state.skip(); order.addAll(state.order()); extraOptions.putAll(state.extraOptions()); trace = state.isTracingEnabled(); cachePolicy = state.cachePolicy(); maxCacheAge = state.maxCacheAge(); isFromLocalDatastore = state.isFromLocalDatastore(); pinName = state.pinName(); ignoreACLs = state.ignoreACLs(); }
@Test public void testWhereFullText() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); String text = "TestString"; query.whereFullText("key", text); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); ParseQuery.QueryConstraints queryConstraints = state.constraints(); ParseQuery.KeyConstraints keyConstraints = (ParseQuery.KeyConstraints) queryConstraints.get("key"); Map searchDictionary = (Map) keyConstraints.get("$text"); Map termDictionary = (Map) searchDictionary.get("$search"); String value = (String) termDictionary.get("$term"); assertEquals(value, text); }
@Test public void testWherePolygonContains() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); ParseGeoPoint point = new ParseGeoPoint(10, 10); query.wherePolygonContains("key", point); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); ParseQuery.QueryConstraints queryConstraints = state.constraints(); ParseQuery.KeyConstraints keyConstraints = (ParseQuery.KeyConstraints) queryConstraints.get("key"); Map map = (Map) keyConstraints.get("$geoIntersects"); ParseGeoPoint geoPoint = (ParseGeoPoint) map.get("$point"); assertEquals(geoPoint, point); }
@Test public void testGetQueryWithTargetClass() { ParseObject parent = new ParseObject("Parent"); ParseRelation relation = new ParseRelation(parent, "key"); relation.setTargetClass("targetClass"); ParseQuery query = relation.getQuery(); // Make sure className is correct assertEquals("targetClass", query.getClassName()); ParseQuery.State state = query.getBuilder().build(); // Make sure where condition is set ParseQuery.RelationConstraint relationConstraint = (ParseQuery.RelationConstraint) state.constraints().get("$relatedTo"); assertEquals("key", relationConstraint.getKey()); assertSame(parent, relationConstraint.getObject()); }
@Test public void testCopy() { ParseQuery<ParseObject> query = new ParseQuery<>("TestObject"); query.setUser(new ParseUser()); query.whereEqualTo("foo", "bar"); ParseQuery.State.Builder<ParseObject> builder = query.getBuilder(); ParseQuery.State<ParseObject> state = query.getBuilder().build(); ParseQuery<ParseObject> queryCopy = new ParseQuery<>(query); ParseQuery.State.Builder<ParseObject> builderCopy = queryCopy.getBuilder(); ParseQuery.State<ParseObject> stateCopy = queryCopy.getBuilder().build(); assertNotSame(query, queryCopy); assertSame(query.getUserAsync(state).getResult(), queryCopy.getUserAsync(stateCopy).getResult()); assertNotSame(builder, builderCopy); assertSame(state.constraints().get("foo"), stateCopy.constraints().get("foo")); }
private static void verifyCondition( ParseQuery query, String key, String conditionKey, List values) { // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); ParseQuery.QueryConstraints queryConstraints = state.constraints(); ParseQuery.KeyConstraints keyConstraints = (ParseQuery.KeyConstraints) queryConstraints.get(key); Collection<String> list = (Collection<String>) keyConstraints.get(conditionKey); assertEquals(values.size(), list.size()); for (Object value : values) { assertTrue(list.contains(value)); } }
private static void verifyCondition( ParseQuery query, String key, String conditionKey, Object value) { // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); ParseQuery.QueryConstraints queryConstraints = state.constraints(); ParseQuery.KeyConstraints keyConstraints = (ParseQuery.KeyConstraints) queryConstraints.get(key); assertEquals(value, keyConstraints.get(conditionKey)); }
private static void verifyCondition(ParseQuery query, String key, Object value) { // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); ParseQuery.QueryConstraints queryConstraints = state.constraints(); assertEquals(value, queryConstraints.get(key)); }