Permission API's (#4558)

Add PermissionManager as a convenience API on top of the __permission and __management realms.

This PR adds support for
- Listing permissions
- Changing permissions
- Creating offers
- Accepting offers
- Revoking offers

Author: cmelchior

CHANGELOG.md

@@ -1,5 +1,17 @@
 ## 3.7.0 (YYYY-MM-DD)
 
+### Deprecated
+
+* [ObjectServer] `SyncUser.getManagementRealm()`. Use `SyncUser.getPermissionManager()` instead.
+
+### Enhancements
+
+* [ObjectServer] `SyncUser.getPermissionManager` added as a helper API for working with permissions and permission offers.
+
+### Internal
+
+* [ObjectServer] Upgraded OkHttp to 3.7.0.
+
 
 ## 3.6.0 (2017-09-01)
 
@@ -27,6 +39,28 @@ and `SyncUser#retrieveInfoForUserAsync` which returns a `SyncUserInfo` with mode
 
 ### Bug Fixes
 
+### Internal
+
+* [ObjectServer] removed `ObjectServerUser` and its inner classes, in a step to reduce `SyncUser` complexity (#3741).
+* [ObjectServer] changed the `SyncSessionStopPolicy` to `AfterChangesUploaded` to align with other binding and to prevent use cases where the Realm might be deleted before the last changes get synchronized (#5028).
+* Upgraded Realm Sync to 1.10.8
+* Let Object Store handle migration.
+
+## 3.5.1 (YYYY-MM-DD)
+
+### Bug Fixes
+
+### Internal
+
+* [ObjectServer] removed `ObjectServerUser` and its inner classes, in a step to reduce `SyncUser` complexity (#3741).
+* [ObjectServer] changed the `SyncSessionStopPolicy` to `AfterChangesUploaded` to align with other binding and to prevent use cases where the Realm might be deleted before the last changes get synchronized (#5028).
+* [ObjectServer] Upgraded Realm Sync to 1.10.8.
+* Let Object Store handle migrations and schema validation.
+
+## 3.5.1 (YYYY-MM-DD)
+
+### Bug Fixes
+
 * Potential crash after using `Realm.getSchema()` to change the schema of a typed Realm. `Realm.getSchema()` now returns an immutable `RealmSchema` instance.
 * `Realm.copyToRealmOrUpdate()` might cause a `RealmList` field to contain duplicated elements (#4957).
 * `RealmSchema.create(String)` and `RealmObjectSchema.setClassName(String)` did not accept class name whose length was 51 to 57.
@@ -157,6 +191,7 @@ and `SyncUser#retrieveInfoForUserAsync` which returns a `SyncUserInfo` with mode
 ### Enhancements
 
 * [ObjectServer] Added support for `SyncUser.isAdmin()` (#4353).
+* [ObjectServer] New set of Permission API's have been added to `SyncUser` through `SyncUser.getPermissionManager()` (#4296).
 * [ObjectServer] Added support for changing passwords through `SyncUser.changePassword()` (#4423).
 * [ObjectServer] Added support for `SyncConfiguration.Builder.waitForInitialRemoteData()` (#4270).
 * Transient fields are now allowed in model classes, but are implicitly treated as having the `@Ignore` annotation (#4279).

realm/config/findbugs/findbugs-filter.xml

@@ -21,5 +21,8 @@
     <Match>
         <Class name="io.realm.PermissionOfferResponseRealmProxy"/>
     </Match>
+    <Match>
+        <Class name="io.realm.PermissionRealmProxy"/>
+    </Match>
 
 </FindBugsFilter>

realm/realm-library/build.gradle

@@ -180,7 +180,7 @@ dependencies {
     implementation 'com.getkeepsafe.relinker:relinker:1.2.2'
 
     kaptObjectServer project(':realm-annotations-processor')
-    objectServerImplementation 'com.squareup.okhttp3:okhttp:3.4.1'
+    objectServerImplementation 'com.squareup.okhttp3:okhttp:3.7.0'
 
     kaptAndroidTest project(':realm-annotations-processor')
     androidTestImplementation fileTree(dir: 'testLibs', include: ['*.jar'])

realm/realm-library/src/androidTest/java/io/realm/TestHelper.java

@@ -39,6 +39,7 @@
 import java.util.Date;
 import java.util.Locale;
 import java.util.Random;
+import java.util.UUID;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.TimeUnit;
@@ -319,6 +320,13 @@ public static byte[] getRandomKey() {
         return key;
     }
 
+    public static String getRandomEmail() {
+        StringBuilder sb = new StringBuilder(UUID.randomUUID().toString().toLowerCase());
+        sb.append('@');
+        sb.append("androidtest.realm.io");
+        return sb.toString();
+    }
+
     // Returns a random key from the given seed. Used by encrypted Realms.
     public static byte[] getRandomKey(long seed) {
         byte[] key = new byte[64];
@@ -1134,7 +1142,7 @@ public static void waitRealmThreadExecutorFinish() {
             }
             counter--;
         }
-        fail("'BaseRealm.asyncTaskExecutor' is not finished in " + counter/10 + " seconds");
+        fail("'BaseRealm.asyncTaskExecutor' is not finished in " + counter/10.0D + " seconds");
     }
 
     /**

realm/realm-library/src/androidTest/java/io/realm/rule/RunInLooperThread.java

@@ -62,6 +62,9 @@ public class RunInLooperThread extends TestRealmConfigurationFactory {
     // Thread safe
     private final CountDownLatch signalTestCompleted = new CountDownLatch(1);
 
+    // Thread safe
+    private boolean ruleBeingUsed = false;
+
     // Access guarded by 'lock'
     private RealmConfiguration realmConfiguration;
 
@@ -298,6 +301,9 @@ public Statement apply(Statement base, Description description) {
         if (annotation == null) {
             return base;
         }
+        synchronized (lock) {
+            ruleBeingUsed = true;
+        }
         return new RunInLooperThreadStatement(annotation, base);
     }
 
@@ -348,6 +354,13 @@ public boolean isTestComplete() {
         }
     }
 
+    /**
+     * Returns true if the current test being run is using this rule.
+     */
+    public boolean isRuleUsed() {
+        return ruleBeingUsed;
+    }
+
     /**
      * If an implementation of this is supplied with the annotation, the {@link RunnableBefore#run(RealmConfiguration)}
      * will be executed before the looper thread starts. It is normally for populating the Realm before the test.

realm/realm-library/src/androidTestObjectServer/java/io/realm/PermissionRequestTests.java

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2017 Realm Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.realm;
+
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import io.realm.permissions.AccessLevel;
+import io.realm.permissions.PermissionRequest;
+import io.realm.permissions.UserCondition;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+
+@RunWith(AndroidJUnit4.class)
+public class PermissionRequestTests {
+
+    @Test
+    public void nullArgumentsThrows() {
+        try {
+            new PermissionRequest(null, "*", AccessLevel.ADMIN);
+            fail();
+        } catch (IllegalArgumentException e) {
+            assertTrue(e.getMessage().contains("Non-null 'condition' required."));
+        }
+
+        try {
+            new PermissionRequest(UserCondition.userId("id"), null, AccessLevel.ADMIN);
+            fail();
+        } catch (IllegalArgumentException e) {
+            assertTrue(e.getMessage().contains("Non-empty 'realmUrl' required."));
+        }
+
+        try {
+            new PermissionRequest(UserCondition.userId("id"), "*", null);
+            fail();
+        } catch (IllegalArgumentException e) {
+            assertTrue(e.getMessage().contains("Non-null 'accessLevel' required."));
+        }
+    }
+
+    @Test
+    public void url_throwsOnInvalidURIs() {
+        String[] invalidUrls = { "", "\\", "<foo>" };
+        for (String url : invalidUrls) {
+            try {
+                new PermissionRequest(UserCondition.userId("id"), url, AccessLevel.ADMIN);
+                fail(url + " should have thrown");
+            } catch (IllegalArgumentException ignore) {
+            }
+        }
+    }
+
+    @Test
+    public void url_validURIs() {
+        // We support "*" and valid URI's
+        // We don't attempt to do more validation than that and leaves that up to ROS
+        String[] validUrls = {
+                "*",
+                "http://foo/bar/baz",
+                "https://foo/bar/baz",
+                "realm://foo.bar/~/default",
+                "realms://foo.bar/~/default"
+        };
+        for (String url : validUrls) {
+            PermissionRequest request = new PermissionRequest(UserCondition.userId("id"), url, AccessLevel.ADMIN);
+            assertEquals(url, request.getUrl());
+        }
+    }
+
+    @Test
+    public void getters() {
+        UserCondition condition = UserCondition.userId("id");
+        String url = "*";
+        AccessLevel accessLevel = AccessLevel.ADMIN;
+
+        PermissionRequest request = new PermissionRequest(condition, url, accessLevel);
+
+        assertEquals(condition, request.getCondition());
+        assertEquals(url, request.getUrl());
+        assertEquals(accessLevel, request.getAccessLevel());
+    }
+
+    @Test
+    public void equals() {
+        PermissionRequest r1 = new PermissionRequest(UserCondition.userId("id"), "*", AccessLevel.ADMIN);
+        PermissionRequest r2 = new PermissionRequest(UserCondition.userId("id"), "*", AccessLevel.ADMIN);
+
+        assertTrue(r1.equals(r2));
+        assertTrue(r2.equals(r1));
+        assertEquals(r1.hashCode(), r2.hashCode());
+    }
+
+}

realm/realm-library/src/androidTestObjectServer/java/io/realm/SessionTests.java

@@ -21,10 +21,13 @@
 import android.support.test.runner.AndroidJUnit4;
 
 import org.junit.Before;
+import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
+import java.util.concurrent.atomic.AtomicReference;
+
 import io.realm.rule.RunInLooperThread;
 import io.realm.rule.RunTestInLooperThread;
 import io.realm.rule.TestSyncConfigurationFactory;
@@ -188,6 +191,56 @@ public void onError(SyncSession session, ObjectServerError error) {
         SyncManager.simulateClientReset(SyncManager.getSession(config));
     }
 
+    // Check that if we manually trigger a Client Reset, then it should be possible to start
+    // downloading the Realm immediately after.
+    @Test
+    @RunTestInLooperThread
+    @Ignore("https://github.com/realm/realm-java/issues/5143")
+    public void clientReset_manualTriggerAllowSessionToRestart() {
+        SyncUser user = createTestUser();
+        String url = "realm://objectserver.realm.io/~/myrealm";
+        final AtomicReference<SyncConfiguration> configRef = new AtomicReference<>(null);
+        final SyncConfiguration config = configFactory.createSyncConfigurationBuilder(user , url)
+                .errorHandler(new SyncSession.ErrorHandler() {
+                    @Override
+                    public void onError(SyncSession session, ObjectServerError error) {
+                        final ClientResetRequiredError handler = (ClientResetRequiredError) error;
+
+                        // Execute Client Reset
+                        looperThread.closeTestRealms();
+                        handler.executeClientReset();
+
+                        // Try to re-open Realm and download it again
+                        looperThread.postRunnable(new Runnable() {
+                            @Override
+                            public void run() {
+                                // Validate that files have been moved
+                                assertFalse(handler.getOriginalFile().exists());
+                                assertTrue(handler.getBackupFile().exists());
+
+                                SyncConfiguration config = configRef.get();
+                                Realm instance = Realm.getInstance(config);
+                                looperThread.addTestRealm(instance);
+                                try {
+                                    SyncManager.getSession(config).downloadAllServerChanges();
+                                    looperThread.testComplete();
+                                } catch (InterruptedException e) {
+                                    fail(e.toString());
+                                }
+                            }
+                        });
+                    }
+                })
+                .build();
+        configRef.set(config);
+
+        Realm realm = Realm.getInstance(config);
+        looperThread.addTestRealm(realm);
+
+        // Trigger error
+        SyncManager.simulateClientReset(SyncManager.getSession(config));
+    }
+
     @Test
     @UiThreadTest
     public void uploadAllLocalChanges_throwsOnUiThread() throws InterruptedException {

realm/realm-library/src/androidTestObjectServer/java/io/realm/SyncManagerTests.java

@@ -18,6 +18,7 @@
 
 import android.support.test.runner.AndroidJUnit4;
 
+import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -26,7 +27,9 @@
 
 import java.io.IOException;
 import java.util.Collection;
+import java.util.Collections;
 
+import io.realm.objectserver.utils.UserFactory;
 import io.realm.rule.TestRealmConfigurationFactory;
 
 import static io.realm.util.SyncTestUtils.createTestUser;
@@ -66,7 +69,7 @@ public void remove(String identity, String authenticationUrl) {
 
             @Override
             public Collection<SyncUser> allUsers() {
-                return null;
+                return Collections.emptySet();
             }
 
             @Override
@@ -76,6 +79,12 @@ public boolean isActive(String identity, String authenticationUrl) {
         };
     }
 
+    @After
+    public void tearDown() {
+        UserFactory.logoutAllUsers();
+        SyncManager.reset();
+    }
+
     @Test
     public void set_userStore() {
         SyncManager.setUserStore(userStore);