Test parcel while saving, tests for ParseRelation

Author: natario1

Parse/src/main/java/com/parse/ParseObjectParcelDecoder.java

@@ -12,8 +12,7 @@
  * {@code ParseObject}s have been decoded. When a pointer is found and we have already decoded
  * an instance for the same object id, we use the decoded instance.
  *
- * This is very similar to what {@link KnownParseObjectDecoder} does for JSON, and is meant to be
- * used with {@link ParseObjectParcelEncoder}.
+ * This is very similar to what {@link KnownParseObjectDecoder} does for JSON.
  */
 /* package */ class ParseObjectParcelDecoder extends ParseParcelDecoder {
 
@@ -32,11 +31,13 @@ protected ParseObject decodePointer(Parcel source) {
     if (objects.containsKey(objectId)) {
       return objects.get(objectId);
     }
-    // Should not happen if using in conjunction with ParseObjectParcelEncoder .
-    return ParseObject.createWithoutData(className, objectId);
+    // Should not happen if encoding was done through ParseObjectParcelEncoder.
+    ParseObject object = ParseObject.createWithoutData(className, objectId);
+    objects.put(objectId, object);
+    return object;
   }
 
-  /* package for tests */ String getObjectOrLocalId(ParseObject object) {
+  private String getObjectOrLocalId(ParseObject object) {
     return object.getObjectId() != null ? object.getObjectId() : object.getOrCreateLocalId();
   }
 }

Parse/src/main/java/com/parse/ParseParcelEncoder.java

@@ -133,7 +133,7 @@ public void encode(Object object, Parcel dest) {
             + object.getClass().toString());
       }
 
-    } catch (Exception e) {
+    } catch (IllegalArgumentException e) {
       throw new IllegalArgumentException("Could not encode this object into Parcel. "
             + object.getClass().toString());
     }

Parse/src/test/java/com/parse/ParseObjectTest.java

@@ -41,6 +41,7 @@
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyString;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 @RunWith(RobolectricTestRunner.class)
@@ -582,6 +583,61 @@ public void testRecursiveParcel() throws Exception {
     assertEquals(newObject.getParseObject("self").getParseObject("self").getObjectId(), "id");
   }
 
+  @Test
+  public void testParcelWhileSaving() throws Exception {
+    ParseFieldOperations.registerDefaultDecoders();
+    ParseObject object, other;
+    List<Task<Void>> tasks = new ArrayList<>();
+
+    // Mocked to let save work
+    ParseCurrentUserController userController = mock(ParseCurrentUserController.class);
+    when(userController.getAsync()).thenReturn(Task.<ParseUser>forResult(null));
+    ParseCorePlugins.getInstance().registerCurrentUserController(userController);
+
+    // Mocked to simulate in-flight save
+    TaskCompletionSource<ParseObject.State> tcs = new TaskCompletionSource<>();
+    ParseObjectController objectController = mock(ParseObjectController.class);
+    when(objectController.saveAsync(
+        any(ParseObject.State.class),
+        any(ParseOperationSet.class),
+        anyString(),
+        any(ParseDecoder.class)))
+        .thenReturn(tcs.getTask());
+    ParseCorePlugins.getInstance().registerObjectController(objectController);
+
+    // Create multiple ParseOperationSets
+    object = new ParseObject("TestObject");
+    object.setObjectId("id");
+    object.put("key", "value");
+    object.put("number", 5);
+    tasks.add(object.saveInBackground());
+
+    object.put("key", "newValue");
+    object.increment("number", 6);
+    tasks.add(object.saveInBackground());
+
+    object.increment("number", -1);
+    tasks.add(object.saveInBackground());
+
+    // Ensure Log.w is called...
+    assertTrue(object.hasOutstandingOperations());
+    Parcel parcel = Parcel.obtain();
+    object.writeToParcel(parcel, 0);
+    parcel.setDataPosition(0);
+    other = ParseObject.CREATOR.createFromParcel(parcel);
+    assertTrue(other.isDirty("key"));
+    assertTrue(other.isDirty("number"));
+    assertEquals(other.getString("key"), "newValue");
+    assertEquals(other.getNumber("number"), 10);
+    // By design, we assume that old operations failed even if
+    // they are still running on the old instance.
+    assertFalse(other.hasOutstandingOperations());
+
+    // Force finish save operations on the old instance.
+    tcs.setResult(null);
+    ParseTaskUtils.wait(Task.whenAll(tasks));
+  }
+
   // TODO test ParseGeoPoint and ParseFile after merge
 
   //endregion

Parse/src/test/java/com/parse/ParseRelationTest.java

@@ -8,11 +8,16 @@
  */
 package com.parse;
 
+import android.os.Parcel;
+
 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
 import org.skyscreamer.jsonassert.JSONCompareMode;
 
 import static org.junit.Assert.assertEquals;
@@ -24,6 +29,8 @@
 import static org.mockito.Mockito.when;
 import static org.skyscreamer.jsonassert.JSONAssert.assertEquals;
 
+@RunWith(RobolectricTestRunner.class)
+@Config(constants = BuildConfig.class, sdk = 23)
 public class ParseRelationTest {
 
   @Rule
@@ -77,6 +84,36 @@ public void testConstructorWithJSONAndDecoder() throws Exception {
 
   //endregion
 
+  //region testParcelable
+
+  @Test
+  public void testParcelable() throws Exception {
+    ParseFieldOperations.registerDefaultDecoders();
+    ParseRelation<ParseObject> relation = new ParseRelation<>("Test");
+    ParseObject parent = new ParseObject("Parent");
+    parent.setObjectId("parentId");
+    relation.ensureParentAndKey(parent, "key");
+    ParseObject inner = new ParseObject("Test");
+    inner.setObjectId("innerId");
+    relation.add(inner);
+
+    Parcel parcel = Parcel.obtain();
+    relation.writeToParcel(parcel, 0);
+    parcel.setDataPosition(0);
+    //noinspection unchecked
+    ParseRelation<ParseObject> newRelation = ParseRelation.CREATOR.createFromParcel(parcel);
+    assertEquals(newRelation.getTargetClass(), "Test");
+    assertEquals(newRelation.getKey(), "key");
+    assertEquals(newRelation.getParent().getClassName(), "Parent");
+    assertEquals(newRelation.getParent().getObjectId(), "parentId");
+    assertEquals(newRelation.getKnownObjects().size(), 1);
+
+    // This would fail assertTrue(newRelation.hasKnownObject(inner)).
+    // That is because ParseRelation uses == to check for known objects.
+  }
+
+  //endregion
+
   //region testEnsureParentAndKey
 
   @Test