/** * Constructs a copy of {@code query}; * * @param query The query to copy. */ public ParseQuery(ParseQuery<T> query) { this(new State.Builder<>(query.getBuilder())); user = query.user; }
/** * Add a constraint to the query that requires a particular key's value matches a value for a key * in the results of another {@code ParseQuery}. * * @param key The key whose value is being checked * @param keyInQuery The key in the objects from the sub query to look in * @param query The sub query to run * @return this, so you can chain this call. */ public ParseQuery<T> whereMatchesKeyInQuery(String key, String keyInQuery, ParseQuery<?> query) { builder.whereMatchesKeyInQuery(key, keyInQuery, query.getBuilder()); return this; }
/** * Add a constraint to the query that requires a particular key's value does not match another * {@code ParseQuery}. * <p/> * This only works on keys whose values are {@link ParseObject}s or lists of {@link ParseObject}s. * * @param key The key to check. * @param query The query that the value should not match * @return this, so you can chain this call. */ public ParseQuery<T> whereDoesNotMatchQuery(String key, ParseQuery<?> query) { builder.whereDoesNotMatchQuery(key, query.getBuilder()); return this; }
@Test public void testWhereMatchesKeyInQuery() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); ParseQuery<ParseObject> conditionQuery = new ParseQuery<>("Test"); conditionQuery.whereExists("keyAgain"); query.whereMatchesKeyInQuery("key", "keyAgain", conditionQuery); Map<String, Object> conditions = new HashMap<>(); conditions.put("key", "keyAgain"); conditions.put("query", conditionQuery.getBuilder()); verifyCondition(query, "key", "$select", conditions); }
@Test public void testWhereDoesNotMatchKeyInQuery() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); ParseQuery<ParseObject> conditionQuery = new ParseQuery<>("Test"); conditionQuery.whereExists("keyAgain"); query.whereDoesNotMatchKeyInQuery("key", "keyAgain", conditionQuery); Map<String, Object> conditions = new HashMap<>(); conditions.put("key", "keyAgain"); conditions.put("query", conditionQuery.getBuilder()); verifyCondition(query, "key", "$dontSelect", conditions); }
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)); } }
@Test public void testAddDescendingOrder() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); query.addDescendingOrder("key"); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); assertEquals(1, state.order().size()); assertTrue(state.order().contains(String.format("-%s", "key"))); }
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)); }
@Test public void testSelectKeys() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); query.selectKeys(Arrays.asList("key", "keyAgain")); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); assertEquals(2, state.selectedKeys().size()); assertTrue(state.selectedKeys().contains("key")); assertTrue(state.selectedKeys().contains("keyAgain")); }
@Test public void testOrderByDescending() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); query.orderByDescending("key"); query.orderByDescending("keyAgain"); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); assertEquals(1, state.order().size()); assertTrue(state.order().contains(String.format("-%s", "keyAgain"))); }
@Test public void testInclude() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); query.include("key"); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); assertEquals(1, state.includes().size()); assertTrue(state.includes().contains("key")); }
@Test public void testAddAscendingOrder() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); query.addAscendingOrder("key"); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); assertEquals(1, state.order().size()); assertTrue(state.order().contains("key")); }
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)); }
@Test public void testOrderByAscending() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); query.orderByAscending("key"); query.orderByAscending("keyAgain"); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); assertEquals(1, state.order().size()); assertTrue(state.order().contains("keyAgain")); }
@Test public void testWhereMatchesQuery() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); ParseQuery<ParseObject> conditionQuery = new ParseQuery<>("Test"); conditionQuery.whereExists("keyAgain"); query.whereMatchesQuery("key", conditionQuery); verifyCondition(query, "key", "$inQuery", conditionQuery.getBuilder()); }
@Test public void testWhereDoesNotMatchQuery() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); ParseQuery<ParseObject> conditionQuery = new ParseQuery<>("Test"); conditionQuery.whereExists("keyAgain"); query.whereDoesNotMatchQuery("key", conditionQuery); verifyCondition(query, "key", "$notInQuery", conditionQuery.getBuilder()); }
@Test public void testGetQuery() { ParseQuery<?> query = ParseRole.getQuery(); assertEquals(ParseCorePlugins.getInstance().getSubclassingController().getClassName(ParseRole.class), query.getBuilder().getClassName()); }
@Test public void testSetUser() throws ParseException { ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); ParseUser user = new ParseUser(); query.setUser(user); assertSame(user, ParseTaskUtils.wait(query.getUserAsync(query.getBuilder().build()))); // TODO(grantland): Test that it gets the current user Parse.enableLocalDatastore(null); query.fromLocalDatastore() .ignoreACLs(); assertNull(ParseTaskUtils.wait(query.getUserAsync(query.getBuilder().build()))); }
@Test public void testFromPin() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); Parse.enableLocalDatastore(null); query.fromPin(); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); assertTrue(state.isFromLocalDatastore()); assertEquals(ParseObject.DEFAULT_PIN, state.pinName()); }
@Test public void testConstructors() { assertEquals("_User", ParseQuery.getQuery(ParseUser.class).getClassName()); assertEquals("TestObject", ParseQuery.getQuery("TestObject").getClassName()); assertEquals("_User", new ParseQuery<>(ParseUser.class).getClassName()); assertEquals("TestObject", new ParseQuery<>("TestObject").getClassName()); ParseQuery.State.Builder<ParseObject> builder = new ParseQuery.State.Builder<>("TestObject"); ParseQuery<ParseObject> query = new ParseQuery<>(builder); assertEquals("TestObject", query.getClassName()); assertSame(builder, query.getBuilder()); }