String resultClassName = response.optString("className", null); if (resultClassName == null) { resultClassName = state.className();
public static <T extends ParseObject> ParseRESTQueryCommand countCommand( ParseQuery.State<T> state, String sessionToken) { String httpPath = String.format("classes/%s", state.className()); Map<String, String> parameters = encode(state, true); return new ParseRESTQueryCommand( httpPath, ParseHttpRequest.Method.GET, parameters, sessionToken); }
public static <T extends ParseObject> ParseRESTQueryCommand findCommand( ParseQuery.State<T> state, String sessionToken) { String httpPath = String.format("classes/%s", state.className()); Map<String, String> parameters = encode(state, false); return new ParseRESTQueryCommand( httpPath, ParseHttpRequest.Method.GET, parameters, sessionToken); }
where += " AND " + OfflineSQLiteOpenHelper.KEY_IS_DELETING_EVENTUALLY + "=0"; String[] args = {query.className()};
@Test public void testCopy() throws JSONException { ParsePush.State state = mock(ParsePush.State.class); when(state.expirationTime()).thenReturn(1L); when(state.expirationTimeInterval()).thenReturn(2L); when(state.pushTime()).thenReturn(3L); Set channelSet = Sets.newSet("one", "two"); when(state.channelSet()).thenReturn(channelSet); JSONObject data = new JSONObject(); data.put("foo", "bar"); when(state.data()).thenReturn(data); ParseQuery.State<ParseInstallation> queryState = new ParseQuery.State.Builder<>(ParseInstallation.class).build(); when(state.queryState()).thenReturn(queryState); ParsePush.State copy = new ParsePush.State.Builder(state).build(); assertSame(1L, copy.expirationTime()); assertSame(2L, copy.expirationTimeInterval()); assertSame(3L, copy.pushTime()); Set channelSetCopy = copy.channelSet(); assertNotSame(channelSet, channelSetCopy); assertTrue(channelSetCopy.size() == 2 && channelSetCopy.contains("one")); JSONObject dataCopy = copy.data(); assertNotSame(data, dataCopy); assertEquals("bar", dataCopy.get("foo")); ParseQuery.State<ParseInstallation> queryStateCopy = copy.queryState(); assertNotSame(queryState, queryStateCopy); assertEquals("_Installation", queryStateCopy.className()); }
@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 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 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()); }
@Override public Task<Cursor> then(Task<String> task) { String uuid = task.getResult(); String table = OfflineSQLiteOpenHelper.TABLE_OBJECTS + " A " + " INNER JOIN " + OfflineSQLiteOpenHelper.TABLE_DEPENDENCIES + " B " + " ON A." + OfflineSQLiteOpenHelper.KEY_UUID + "=B." + OfflineSQLiteOpenHelper.KEY_UUID; String[] select = {"A." + OfflineSQLiteOpenHelper.KEY_UUID}; String where = OfflineSQLiteOpenHelper.KEY_CLASS_NAME + "=?" + " AND " + OfflineSQLiteOpenHelper.KEY_KEY + "=?"; if (!includeIsDeletingEventually) { where += " AND " + OfflineSQLiteOpenHelper.KEY_IS_DELETING_EVENTUALLY + "=0"; } String[] args = {query.className(), uuid}; return db.queryAsync(table, select, where, args); } });
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 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")); }
@Test public void testClassName() { ParseQuery.State<ParseObject> stateA = new ParseQuery.State.Builder<>("TestObject") .build(); assertEquals("TestObject", stateA.className()); ParseQuery.State<ParseUser> stateB = new ParseQuery.State.Builder<>(ParseUser.class) .build(); assertEquals("_User", stateB.className()); }
@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"); }