Merge pull request #109 from gcurtis/connection-restore

gcurtis · gcurtis · commit 76606b59f696 · 2015-04-10T15:54:06.000-07:00
Improve saving and restoring BoxAPIConnections
diff --git a/src/main/java/com/box/sdk/BoxAPIConnection.java b/src/main/java/com/box/sdk/BoxAPIConnection.java
@@ -102,6 +102,42 @@ public BoxAPIConnection(String clientID, String clientSecret) {
         this(clientID, clientSecret, null, null);
     }
 
+    /**
+     * Restores a BoxAPIConnection from a saved state.
+     *
+     * @see    #save
+     * @param  state the saved state that was created with {@link #save}.
+     * @return       a restored API connection.
+     */
+    public static BoxAPIConnection restore(String state) {
+        JsonObject json = JsonObject.readFrom(state);
+        String clientID = json.get("clientID").asString();
+        String clientSecret = json.get("clientSecret").asString();
+        String accessToken = json.get("accessToken").asString();
+        String refreshToken = json.get("refreshToken").asString();
+        long lastRefresh = json.get("lastRefresh").asLong();
+        long expires = json.get("expires").asLong();
+        String userAgent = json.get("userAgent").asString();
+        String tokenURL = json.get("tokenURL").asString();
+        String baseURL = json.get("baseURL").asString();
+        String baseUploadURL = json.get("baseUploadURL").asString();
+        boolean autoRefresh = json.get("autoRefresh").asBoolean();
+        int maxRequestAttempts = json.get("maxRequestAttempts").asInt();
+
+        BoxAPIConnection api = new BoxAPIConnection(clientID, clientSecret, accessToken, refreshToken);
+        api.accessToken = accessToken;
+        api.refreshToken = refreshToken;
+        api.lastRefresh = lastRefresh;
+        api.expires = expires;
+        api.userAgent = userAgent;
+        api.tokenURL = tokenURL;
+        api.baseURL = baseURL;
+        api.baseUploadURL = baseUploadURL;
+        api.autoRefresh = autoRefresh;
+        api.maxRequestAttempts = maxRequestAttempts;
+        return api;
+    }
+
     /**
      * Authenticates the API connection by obtaining access and refresh tokens using the auth code that was obtained
      * from the first half of OAuth.
@@ -262,6 +298,27 @@ public void setRefreshToken(String refreshToken) {
         this.refreshToken = refreshToken;
     }
 
+    /**
+     * Gets the last time that the access token was refreshed.
+     *
+     * @return the last refresh time in milliseconds.
+     */
+    public long getLastRefresh() {
+        return this.lastRefresh;
+    }
+
+    /**
+     * Sets the last time that the access token was refreshed.
+     *
+     * <p>This value is used when determining if an access token needs to be auto-refreshed. If the amount of time since
+     * the last refresh exceeds the access token's expiration time, then the access token will be refreshed.</p>
+     *
+     * @param lastRefresh the new last refresh time in milliseconds.
+     */
+    public void setLastRefresh(long lastRefresh) {
+        this.lastRefresh = lastRefresh;
+    }
+
     /**
      * Enables or disables automatic refreshing of this connection's access token. Defaults to true.
      * @param autoRefresh true to enable auto token refresh; otherwise false.
@@ -354,6 +411,7 @@ public void refresh() {
             BoxJSONResponse response = (BoxJSONResponse) request.send();
             json = response.getJSON();
         } catch (BoxAPIException e) {
+            this.notifyError(e);
             this.refreshLock.writeLock().unlock();
             throw e;
         }
@@ -370,11 +428,20 @@ public void refresh() {
     }
 
     /**
-     * Notifies refresh event to all the listeners.
+     * Notifies a refresh event to all the listeners.
      */
     private void notifyRefresh() {
         for (BoxAPIConnectionListener listener : this.listeners) {
-            listener.onRefresh();
+            listener.onRefresh(this);
+        }
+    }
+
+    /**
+     * Notifies an error event to all the listeners.
+     */
+    private void notifyError(BoxAPIException error) {
+        for (BoxAPIConnectionListener listener : this.listeners) {
+            listener.onError(this, error);
         }
     }
 
@@ -409,4 +476,27 @@ public RequestInterceptor getRequestInterceptor() {
     public void setRequestInterceptor(RequestInterceptor interceptor) {
         this.interceptor = interceptor;
     }
+
+    /**
+     * Saves the state of this connection to a string so that it can be persisted and restored at a later time.
+     *
+     * @see    #restore
+     * @return the state of this connection.
+     */
+    public String save() {
+        JsonObject state = new JsonObject()
+            .add("clientID", this.clientID)
+            .add("clientSecret", this.clientSecret)
+            .add("accessToken", this.accessToken)
+            .add("refreshToken", this.refreshToken)
+            .add("lastRefresh", this.lastRefresh)
+            .add("expires", this.expires)
+            .add("userAgent", this.userAgent)
+            .add("tokenURL", this.tokenURL)
+            .add("baseURL", this.baseURL)
+            .add("baseUploadURL", this.baseUploadURL)
+            .add("autoRefresh", this.autoRefresh)
+            .add("maxRequestAttempts", this.maxRequestAttempts);
+        return state.toString();
+    }
 }
diff --git a/src/main/java/com/box/sdk/BoxAPIConnectionListener.java b/src/main/java/com/box/sdk/BoxAPIConnectionListener.java
@@ -7,6 +7,22 @@ public interface BoxAPIConnectionListener {
 
     /**
      * Called when the Box API connection refreshes its tokens.
+     *
+     * <p>The provided connection is guaranteed to not be auto-refreshed or modified by another listener until this
+     * method returns.</p>
+     *
+     * @param api the API connection that was refreshed.
      */
-    void onRefresh();
+    void onRefresh(BoxAPIConnection api);
+
+    /**
+     * Called when an error occurs while attempting to refresh the Box API connection's tokens.
+     *
+     * <p>The provided connection is guaranteed to not be auto-refreshed or modified by another listener until this
+     * method returns.</p>
+     *
+     * @param api   the API connection that encountered an error.
+     * @param error the error that occurred.
+     */
+    void onError(BoxAPIConnection api, BoxAPIException error);
 }
diff --git a/src/test/java/com/box/sdk/BoxAPIConnectionTest.java b/src/test/java/com/box/sdk/BoxAPIConnectionTest.java
@@ -6,14 +6,18 @@
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.not;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
+import com.eclipsesource.json.JsonObject;
+
 public class BoxAPIConnectionTest {
     @Test
     @Category(UnitTest.class)
@@ -78,6 +82,45 @@ public void interceptorReceivesSentRequest() throws MalformedURLException {
         assertThat(response, is(equalTo(fakeResponse)));
     }
 
+    @Test
+    @Category(UnitTest.class)
+    public void restoreConnectionThatDoesNotNeedRefresh() {
+        BoxAPIConnection api = new BoxAPIConnection("fake client ID", "fake client secret", "fake access token",
+            "fake refresh token");
+        api.setExpires(3600000L);
+        api.setLastRefresh(System.currentTimeMillis());
+        String state = api.save();
+
+        final BoxAPIConnection restoredAPI = BoxAPIConnection.restore(state);
+        restoredAPI.setRequestInterceptor(new RequestInterceptor() {
+            @Override
+            public BoxAPIResponse onRequest(BoxAPIRequest request) {
+                String tokenURLString = restoredAPI.getTokenURL().toString();
+                String requestURLString = request.getUrl().toString();
+                if (requestURLString.contains(tokenURLString)) {
+                    fail("The connection was refreshed.");
+                }
+
+                if (requestURLString.contains("folders")) {
+                    return new BoxJSONResponse() {
+                        @Override
+                        public String getJSON() {
+                            JsonObject responseJSON = new JsonObject()
+                                .add("id", "fake ID")
+                                .add("type", "folder");
+                            return responseJSON.toString();
+                        }
+                    };
+                }
+
+                fail("Unexpected request.");
+                return null;
+            }
+        });
+
+        assertFalse(restoredAPI.needsRefresh());
+    }
+
     @Test
     @Category(IntegrationTest.class)
     public void requestIsSentNormallyWhenInterceptorReturnsNullResponse() throws MalformedURLException {
@@ -150,4 +193,20 @@ public void doesNotRefreshWhenGetAccessTokenIsCalledAndTokenHasNotExpired() {
         TestConfig.setAccessToken(actualAccessToken);
         TestConfig.setRefreshToken(actualRefreshToken);
     }
+
+    @Test
+    @Category(IntegrationTest.class)
+    public void successfullySavesAndRestoresConnection() {
+        final String originalAccessToken = TestConfig.getAccessToken();
+        final String originalRefreshToken = TestConfig.getRefreshToken();
+        BoxAPIConnection api = new BoxAPIConnection(TestConfig.getClientID(), TestConfig.getClientSecret(),
+            originalAccessToken, originalRefreshToken);
+        String state = api.save();
+
+        BoxAPIConnection restoredAPI = BoxAPIConnection.restore(state);
+        BoxFolder.Info rootFolderInfo = BoxFolder.getRootFolder(restoredAPI).getInfo();
+
+        TestConfig.setAccessToken(restoredAPI.getAccessToken());
+        TestConfig.setRefreshToken(restoredAPI.getRefreshToken());
+    }
 }
