/** * Counts the number of objects that match this query. This does not use caching. * * @throws ParseException Throws an exception when the network connection fails or when the query is invalid. */ public int count() throws ParseException { return ParseTaskUtils.wait(countInBackground()); }
@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 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()); }
@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 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()); }
@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<Integer> count(@NonNull final ParseQuery<R> query) { return RxTask.single(() -> query.countInBackground()); }
@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()); }
@Test public void testParseObservableAllNextAfterCompleted() { List<ParseUser> users = mocker(ParseUser.class).when(user -> user.getObjectId()).thenReturn(user -> String.valueOf(user.hashCode())).asList(3); rx.parse2.ParseObservable.all(mocker(ParseQuery.class) .when(query -> query.countInBackground()).thenReturn(query -> Task.forResult(users.size())) .when(query -> query.findInBackground()).thenReturn(query -> Task.forResult(users)) .when(query -> query.setSkip(any(int.class))).thenReturn(query -> null) .when(query -> query.setLimit(any(int.class))).thenReturn(query -> null).mock()) //.doOnNext(user -> System.out.println("" + ((ParseUser) user).getObjectId()))) .test() .assertNoErrors() //.assertValue(check(l -> assertThat(l).isEqualTo(users))) .assertComplete(); }
@Test public void testParseObservableAllForMass() { // FIXME: how mockito to make mass mocks? List<ParseUser> users = Observable.range(1, 1001) .map(i -> mocker(ParseUser.class).when(user -> user.getObjectId()).thenReturn(user -> "" + i + user.hashCode()).mock()) .toList() .blockingGet(); rx.parse2.ParseObservable.all(mocker(ParseQuery.class) .when(query -> query.countInBackground()).thenReturn(query -> Task.forResult(users.size())) .when(query -> query.findInBackground()).thenReturn(query -> Task.forResult(users)) .when(query -> query.setSkip(any(int.class))).thenReturn(query -> null) .when(query -> query.setLimit(any(int.class))).thenReturn(query -> null).mock()) .test() .assertNoErrors() //.assertValue(check(l -> assertThat(l).isEqualTo(users))) .assertComplete(); }