/** * Constructs a query for {@code ParseUser}. * * @see com.parse.ParseQuery#getQuery(Class) */ public static ParseQuery<ParseUser> getQuery() { return ParseQuery.getQuery(ParseUser.class); }
/** * Constructs a query for {@code ParseSession}. * * @see com.parse.ParseQuery#getQuery(Class) */ public static ParseQuery<ParseSession> getQuery() { return ParseQuery.getQuery(ParseSession.class); }
/** * Gets a {@link ParseQuery} over the Role collection. * * @return A new query over the Role collection. */ public static ParseQuery<ParseRole> getQuery() { return ParseQuery.getQuery(ParseRole.class); }
/** * Constructs a query for {@code ParseInstallation}. * <p/> * <strong>Note:</strong> We only allow the following types of queries for installations: * <pre> * query.get(objectId) * query.whereEqualTo("installationId", value) * query.whereMatchesKeyInQuery("installationId", keyInQuery, query) * </pre> * <p/> * You can add additional query clauses, but one of the above must appear as a top-level * {@code AND} clause in the query. * * @see com.parse.ParseQuery#getQuery(Class) */ public static ParseQuery<ParseInstallation> getQuery() { return ParseQuery.getQuery(ParseInstallation.class); }
public static ParseQuery<Person> getQuery() { return ParseQuery.getQuery(Person.class); }
@Override public Task<Boolean> existsAsync() { // We need to set `ignoreACLs` since we can't use ACLs without the current user. ParseQuery<T> query = ParseQuery.<T>getQuery(className) .fromPin(pinName) .ignoreACLs(); return query.countInBackground().onSuccessTask(new Continuation<Integer, Task<Boolean>>() { @Override public Task<Boolean> then(Task<Integer> task) { boolean exists = task.getResult() == 1; if (exists) { return Task.forResult(true); } return legacy.existsAsync(); } }); }
@Test public void testCountLimit() { CacheQueryController controller = mock(CacheQueryController.class); ParseCorePlugins.getInstance().registerQueryController(controller); when(controller.countAsync( any(ParseQuery.State.class), any(ParseUser.class), any(Task.class))).thenReturn(Task.forResult(0)); ArgumentCaptor<ParseQuery.State> state = ArgumentCaptor.forClass(ParseQuery.State.class); final ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); query.countInBackground(); verify(controller, times(1)).countAsync(state.capture(), any(ParseUser.class), any(Task.class)); assertEquals(0, state.getValue().limit()); }
@Test public void testCountWithCallbackLimit() { CacheQueryController controller = mock(CacheQueryController.class); ParseCorePlugins.getInstance().registerQueryController(controller); when(controller.countAsync( any(ParseQuery.State.class), any(ParseUser.class), any(Task.class))).thenReturn(Task.forResult(0)); ArgumentCaptor<ParseQuery.State> state = ArgumentCaptor.forClass(ParseQuery.State.class); final ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); query.countInBackground(null); verify(controller, times(1)).countAsync(state.capture(), any(ParseUser.class), any(Task.class)); assertEquals(0, state.getValue().limit()); }
final ParseQuery<T> query = ParseQuery.<T>getQuery(className) .whereContainedIn(KEY_OBJECT_ID, objectIds); return toAwait.continueWithTask(new Continuation<Void, Task<List<T>>>() {
@Test public void testCountLimitReset() { // Mock CacheQueryController ParseQueryController controller = mock(CacheQueryController.class); ParseCorePlugins.getInstance().registerQueryController(controller); when(controller.countAsync( any(ParseQuery.State.class), any(ParseUser.class), any(Task.class))).thenReturn(Task.forResult(0)); final ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); query.countInBackground(); assertEquals(-1, query.getLimit()); }
@Test public void testCountWithCallbackLimitReset() { // Mock CacheQueryController CacheQueryController controller = mock(CacheQueryController.class); ParseCorePlugins.getInstance().registerQueryController(controller); when(controller.countAsync( any(ParseQuery.State.class), any(ParseUser.class), any(Task.class))).thenReturn(Task.forResult(0)); final ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); query.countInBackground(null); assertEquals(-1, query.getLimit()); }
@Override public Task<T> getAsync() { // We need to set `ignoreACLs` since we can't use ACLs without the current user. ParseQuery<T> query = ParseQuery.<T>getQuery(className) .fromPin(pinName) .ignoreACLs(); return query.findInBackground().onSuccessTask(new Continuation<List<T>, Task<T>>() { @Override public Task<T> then(Task<List<T>> task) { List<T> results = task.getResult(); if (results != null) { if (results.size() == 1) { return Task.forResult(results.get(0)); } else { return ParseObject.unpinAllInBackground(pinName).cast(); } } return Task.forResult(null); } }).onSuccessTask(new Continuation<T, Task<T>>() { @Override public Task<T> then(Task<T> task) { T ldsObject = task.getResult(); if (ldsObject != null) { return task; } return migrate(legacy, OfflineObjectStore.this).cast(); } }); }
@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()); }
@Override public ParseQuery<T> create() { ParseQuery<T> query = ParseQuery.getQuery(className); query.orderByDescending("createdAt"); return query; } });
@Test public void testQueryCancellation() throws ParseException { TestQueryController controller = new TestQueryController(); ParseCorePlugins.getInstance().registerQueryController(controller); TaskCompletionSource<Void> tcs = new TaskCompletionSource(); controller.await(tcs.getTask()); ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); query.setUser(new ParseUser()); Task<Void> task = query.findInBackground().makeVoid(); query.cancel(); tcs.setResult(null); try { ParseTaskUtils.wait(task); } catch (RuntimeException e) { assertThat(e.getCause(), instanceOf(CancellationException.class)); } // Should succeed task = query.findInBackground().makeVoid(); ParseTaskUtils.wait(task); }
@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 testMultipleQueriesWithInflightChanges() throws ParseException { Parse.enableLocalDatastore(null); TestQueryController controller = new TestQueryController(); TaskCompletionSource<Void> tcs = new TaskCompletionSource<>(); controller.await(tcs.getTask()); ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); query.setUser(new ParseUser()); ParseCorePlugins.getInstance().registerQueryController(controller); List<Task<Void>> tasks = Arrays.asList( query.fromNetwork().findInBackground().makeVoid(), query.fromLocalDatastore().findInBackground().makeVoid(), query.setLimit(10).findInBackground().makeVoid(), query.whereEqualTo("key", "value").countInBackground().makeVoid()); assertTrue(query.isRunning()); tcs.trySetResult(null); ParseTaskUtils.wait(Task.whenAll(tasks)); assertFalse(query.isRunning()); }
@NonNull @CheckReturnValue public static <R extends ParseObject> Single<R> get(@NonNull final Class<R> clazz, @NonNull final String objectId) { return get(ParseQuery.getQuery(clazz), objectId); }
@Test public void testIsRunning() { TestQueryController controller = new TestQueryController(); ParseCorePlugins.getInstance().registerQueryController(controller); TaskCompletionSource<Void> tcs = new TaskCompletionSource<>(); controller.await(tcs.getTask()); ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); query.setUser(new ParseUser()); assertFalse(query.isRunning()); query.findInBackground(); assertTrue(query.isRunning()); tcs.setResult(null); assertFalse(query.isRunning()); // Run another tcs = new TaskCompletionSource<>(); controller.await(tcs.getTask()); query.findInBackground(); assertTrue(query.isRunning()); query.cancel(); assertFalse(query.isRunning()); }
@Test public void testMultipleQueries() { TestQueryController controller1 = new TestQueryController(); TestQueryController controller2 = new TestQueryController(); TaskCompletionSource<Void> tcs1 = new TaskCompletionSource<>(); TaskCompletionSource<Void> tcs2 = new TaskCompletionSource<>(); controller1.await(tcs1.getTask()); controller2.await(tcs2.getTask()); ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); query.setUser(new ParseUser()); ParseCorePlugins.getInstance().registerQueryController(controller1); query.findInBackground(); assertTrue(query.isRunning()); ParseCorePlugins.getInstance().reset(); ParseCorePlugins.getInstance().registerQueryController(controller2); query.countInBackground(); assertTrue(query.isRunning()); // Stop the first operation. tcs1.setResult(null); assertTrue(query.isRunning()); // Stop the second. tcs2.setResult(null); assertFalse(query.isRunning()); }