FIS getAuthToken implementation.

firebase-installations-interop/src/main/java/com/google/firebase/installations/FirebaseInstallationsApi.java

@@ -14,7 +14,11 @@
 
 package com.google.firebase.installations;
 
+import static java.lang.annotation.RetentionPolicy.SOURCE;
+
+import androidx.annotation.IntDef;
 import com.google.android.gms.tasks.Task;
+import java.lang.annotation.Retention;
 
 /**
  * This is an interface of {@code FirebaseInstallations} that is only exposed to 2p via component
@@ -24,14 +28,29 @@
  */
 public interface FirebaseInstallationsApi {
 
+  /** Specifies the options to get a FIS AuthToken. */
+  @IntDef({DO_NOT_FORCE_REFRESH, FORCE_REFRESH})
+  @Retention(SOURCE)
+  @interface AuthTokenOption {}
+  /**
+   * AuthToken is not refreshed until requested by the developer or if one doesn't exist, is expired
+   * or about to expire.
+   */
+  int DO_NOT_FORCE_REFRESH = 0;
+  /**
+   * AuthToken is forcefully refreshed on calling the {@link
+   * FirebaseInstallationsApi#getAuthToken(int)}.
+   */
+  int FORCE_REFRESH = 1;
+
   /**
    * Async function that returns a globally unique identifier of this Firebase app installation.
    * This is a url-safe base64 string of a 128-bit integer.
    */
   Task<String> getId();
 
   /** Async function that returns a auth token(public key) of this Firebase app installation. */
-  Task<InstallationTokenResult> getAuthToken(boolean forceRefresh);
+  Task<InstallationTokenResult> getAuthToken(@AuthTokenOption int authTokenOption);
 
   /**
    * Async function that deletes this Firebase app installation from Firebase backend. This call

firebase-installations-interop/src/main/java/com/google/firebase/installations/InstallationTokenResult.java

@@ -25,11 +25,10 @@ public abstract class InstallationTokenResult {
   @NonNull
   public abstract String getToken();
   /**
-   * The amount of time, in milliseconds, before the auth-token expires for this Firebase
-   * Installation.
+   * The amount of time, in seconds, before the auth-token expires for this Firebase Installation.
    */
   @NonNull
-  public abstract long getTokenExpirationTimestampMillis();
+  public abstract long getTokenExpirationInSecs();
 
   @NonNull
   public abstract Builder toBuilder();
@@ -46,7 +45,7 @@ public abstract static class Builder {
     public abstract Builder setToken(@NonNull String value);
 
     @NonNull
-    public abstract Builder setTokenExpirationTimestampMillis(@NonNull long value);
+    public abstract Builder setTokenExpirationInSecs(@NonNull long value);
 
     @NonNull
     public abstract InstallationTokenResult build();

firebase-installations/src/androidTest/java/com/google/firebase/installations/FirebaseInstallationsInstrumentedTest.java

@@ -17,19 +17,29 @@
 import static com.google.common.truth.Truth.assertWithMessage;
 import static com.google.firebase.installations.FisAndroidTestConstants.TEST_APP_ID_1;
 import static com.google.firebase.installations.FisAndroidTestConstants.TEST_AUTH_TOKEN;
+import static com.google.firebase.installations.FisAndroidTestConstants.TEST_AUTH_TOKEN_2;
+import static com.google.firebase.installations.FisAndroidTestConstants.TEST_AUTH_TOKEN_3;
+import static com.google.firebase.installations.FisAndroidTestConstants.TEST_AUTH_TOKEN_4;
 import static com.google.firebase.installations.FisAndroidTestConstants.TEST_CREATION_TIMESTAMP_1;
+import static com.google.firebase.installations.FisAndroidTestConstants.TEST_CREATION_TIMESTAMP_2;
 import static com.google.firebase.installations.FisAndroidTestConstants.TEST_FID_1;
 import static com.google.firebase.installations.FisAndroidTestConstants.TEST_PROJECT_ID;
 import static com.google.firebase.installations.FisAndroidTestConstants.TEST_REFRESH_TOKEN;
 import static com.google.firebase.installations.FisAndroidTestConstants.TEST_TOKEN_EXPIRATION_TIMESTAMP;
+import static com.google.firebase.installations.FisAndroidTestConstants.TEST_TOKEN_EXPIRATION_TIMESTAMP_2;
 import static org.junit.Assert.fail;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import android.util.Log;
+import androidx.annotation.NonNull;
 import androidx.test.core.app.ApplicationProvider;
 import androidx.test.runner.AndroidJUnit4;
 import com.google.android.gms.common.util.Clock;
+import com.google.android.gms.tasks.Task;
 import com.google.android.gms.tasks.Tasks;
 import com.google.firebase.FirebaseApp;
 import com.google.firebase.FirebaseOptions;
@@ -68,12 +78,53 @@ public class FirebaseInstallationsInstrumentedTest {
   @Mock private PersistedFid persistedFidReturnsError;
   @Mock private Utils mockUtils;
   @Mock private Clock mockClock;
+  @Mock private PersistedFid mockPersistedFid;
+
+  private static final PersistedFidEntry REGISTERED_FID_ENTRY =
+      PersistedFidEntry.builder()
+          .setFirebaseInstallationId(TEST_FID_1)
+          .setAuthToken(TEST_AUTH_TOKEN)
+          .setRefreshToken(TEST_REFRESH_TOKEN)
+          .setTokenCreationEpochInSecs(TEST_CREATION_TIMESTAMP_2)
+          .setExpiresInSecs(TEST_TOKEN_EXPIRATION_TIMESTAMP)
+          .setRegistrationStatus(PersistedFid.RegistrationStatus.REGISTERED)
+          .build();
+
+  private static final PersistedFidEntry EXPIRED_AUTH_TOKEN_ENTRY =
+      PersistedFidEntry.builder()
+          .setFirebaseInstallationId(TEST_FID_1)
+          .setAuthToken(TEST_AUTH_TOKEN)
+          .setRefreshToken(TEST_REFRESH_TOKEN)
+          .setTokenCreationEpochInSecs(TEST_CREATION_TIMESTAMP_2)
+          .setExpiresInSecs(TEST_TOKEN_EXPIRATION_TIMESTAMP_2)
+          .setRegistrationStatus(PersistedFid.RegistrationStatus.REGISTERED)
+          .build();
+
+  private static final PersistedFidEntry UNREGISTERED_FID_ENTRY =
+      PersistedFidEntry.builder()
+          .setFirebaseInstallationId(TEST_FID_1)
+          .setAuthToken("")
+          .setRefreshToken("")
+          .setTokenCreationEpochInSecs(TEST_CREATION_TIMESTAMP_2)
+          .setExpiresInSecs(0)
+          .setRegistrationStatus(PersistedFid.RegistrationStatus.UNREGISTERED)
+          .build();
+
+  private static final PersistedFidEntry UPDATED_AUTH_TOKEN_FID_ENTRY =
+      PersistedFidEntry.builder()
+          .setFirebaseInstallationId(TEST_FID_1)
+          .setAuthToken(TEST_AUTH_TOKEN_2)
+          .setRefreshToken(TEST_REFRESH_TOKEN)
+          .setTokenCreationEpochInSecs(TEST_CREATION_TIMESTAMP_2)
+          .setExpiresInSecs(TEST_TOKEN_EXPIRATION_TIMESTAMP)
+          .setRegistrationStatus(PersistedFid.RegistrationStatus.REGISTERED)
+          .build();
 
   @Before
   public void setUp() throws FirebaseInstallationServiceException {
     MockitoAnnotations.initMocks(this);
     FirebaseApp.clearInstancesForTest();
-    executor = new ThreadPoolExecutor(0, 2, 10L, TimeUnit.SECONDS, new SynchronousQueue<>());
+    executor = new ThreadPoolExecutor(0, 4, 10L, TimeUnit.SECONDS, new SynchronousQueue<>());
     firebaseApp =
         FirebaseApp.initializeApp(
             ApplicationProvider.getApplicationContext(),
@@ -92,9 +143,16 @@ public void setUp() throws FirebaseInstallationServiceException {
                 .setAuthToken(
                     InstallationTokenResult.builder()
                         .setToken(TEST_AUTH_TOKEN)
-                        .setTokenExpirationTimestampMillis(TEST_TOKEN_EXPIRATION_TIMESTAMP)
+                        .setTokenExpirationInSecs(TEST_TOKEN_EXPIRATION_TIMESTAMP)
                         .build())
                 .build());
+    when(backendClientReturnsOk.generateAuthToken(
+            anyString(), anyString(), anyString(), anyString()))
+        .thenReturn(
+            InstallationTokenResult.builder()
+                .setToken(TEST_AUTH_TOKEN_2)
+                .setTokenExpirationInSecs(TEST_TOKEN_EXPIRATION_TIMESTAMP)
+                .build());
     when(backendClientReturnsError.createFirebaseInstallation(
             anyString(), anyString(), anyString(), anyString()))
         .thenThrow(
@@ -217,4 +275,217 @@ public void testGetId_PersistedFidError_BackendOk() throws InterruptedException
           .isEqualTo(FirebaseInstallationsException.Status.CLIENT_ERROR);
     }
   }
+
+  @Test
+  public void testGetAuthToken_fidDoesNotExist_successful() throws Exception {
+    FirebaseInstallations firebaseInstallations =
+        new FirebaseInstallations(
+            mockClock, executor, firebaseApp, backendClientReturnsOk, persistedFid, mockUtils);
+
+    Tasks.await(firebaseInstallations.getAuthToken(FirebaseInstallationsApi.DO_NOT_FORCE_REFRESH));
+
+    PersistedFidEntry entryValue = persistedFid.readPersistedFidEntryValue();
+    assertWithMessage("Persisted Auth Token doesn't match")
+        .that(entryValue.getAuthToken())
+        .isEqualTo(TEST_AUTH_TOKEN);
+  }
+
+  @Test
+  public void testGetAuthToken_PersistedFidError_failure() throws Exception {
+    FirebaseInstallations firebaseInstallations =
+        new FirebaseInstallations(
+            mockClock,
+            executor,
+            firebaseApp,
+            backendClientReturnsOk,
+            persistedFidReturnsError,
+            mockUtils);
+
+    // Expect exception
+    try {
+      Tasks.await(
+          firebaseInstallations.getAuthToken(FirebaseInstallationsApi.DO_NOT_FORCE_REFRESH));
+      fail();
+    } catch (ExecutionException expected) {
+      Throwable cause = expected.getCause();
+      assertWithMessage("Exception class doesn't match")
+          .that(cause)
+          .isInstanceOf(FirebaseInstallationsException.class);
+      assertWithMessage("Exception status doesn't match")
+          .that(((FirebaseInstallationsException) cause).getStatus())
+          .isEqualTo(FirebaseInstallationsException.Status.SDK_INTERNAL_ERROR);
+    }
+  }
+
+  @Test
+  public void testGetAuthToken_fidExists_successful() throws Exception {
+    when(mockPersistedFid.readPersistedFidEntryValue()).thenReturn(REGISTERED_FID_ENTRY);
+    FirebaseInstallations firebaseInstallations =
+        new FirebaseInstallations(
+            mockClock, executor, firebaseApp, backendClientReturnsOk, mockPersistedFid, mockUtils);
+
+    InstallationTokenResult installationTokenResult =
+        Tasks.await(
+            firebaseInstallations.getAuthToken(FirebaseInstallationsApi.DO_NOT_FORCE_REFRESH));
+
+    assertWithMessage("Persisted Auth Token doesn't match")
+        .that(installationTokenResult.getToken())
+        .isEqualTo(TEST_AUTH_TOKEN);
+  }
+
+  @Test
+  public void testGetAuthToken_expiredAuthToken_fetchedNewTokenFromFIS() throws Exception {
+    when(mockPersistedFid.readPersistedFidEntryValue()).thenReturn(EXPIRED_AUTH_TOKEN_ENTRY);
+    FirebaseInstallations firebaseInstallations =
+        new FirebaseInstallations(
+            mockClock, executor, firebaseApp, backendClientReturnsOk, mockPersistedFid, mockUtils);
+
+    InstallationTokenResult installationTokenResult =
+        Tasks.await(
+            firebaseInstallations.getAuthToken(FirebaseInstallationsApi.DO_NOT_FORCE_REFRESH));
+
+    assertWithMessage("Persisted Auth Token doesn't match")
+        .that(installationTokenResult.getToken())
+        .isEqualTo(TEST_AUTH_TOKEN_2);
+  }
+
+  @Test
+  public void testGetAuthToken_unregisteredFid_fetchedNewTokenFromFIS() throws Exception {
+    when(mockPersistedFid.readPersistedFidEntryValue())
+        .thenReturn(UNREGISTERED_FID_ENTRY, REGISTERED_FID_ENTRY);
+    FirebaseInstallations firebaseInstallations =
+        new FirebaseInstallations(
+            mockClock, executor, firebaseApp, backendClientReturnsOk, mockPersistedFid, mockUtils);
+
+    InstallationTokenResult installationTokenResult =
+        Tasks.await(
+            firebaseInstallations.getAuthToken(FirebaseInstallationsApi.DO_NOT_FORCE_REFRESH));
+
+    assertWithMessage("Persisted Auth Token doesn't match")
+        .that(installationTokenResult.getToken())
+        .isEqualTo(TEST_AUTH_TOKEN);
+  }
+
+  @Test
+  public void testGetAuthToken_serverError_failure() throws Exception {
+    when(mockPersistedFid.readPersistedFidEntryValue()).thenReturn(REGISTERED_FID_ENTRY);
+    when(backendClientReturnsError.generateAuthToken(
+            anyString(), anyString(), anyString(), anyString()))
+        .thenThrow(
+            new FirebaseInstallationServiceException(
+                "Server Error", FirebaseInstallationServiceException.Status.SERVER_ERROR));
+    FirebaseInstallations firebaseInstallations =
+        new FirebaseInstallations(
+            mockClock,
+            executor,
+            firebaseApp,
+            backendClientReturnsError,
+            mockPersistedFid,
+            mockUtils);
+
+    // Expect exception
+    try {
+      Tasks.await(firebaseInstallations.getAuthToken(FirebaseInstallationsApi.FORCE_REFRESH));
+      fail();
+    } catch (ExecutionException expected) {
+      Throwable cause = expected.getCause();
+      assertWithMessage("Exception class doesn't match")
+          .that(cause)
+          .isInstanceOf(FirebaseInstallationsException.class);
+      assertWithMessage("Exception status doesn't match")
+          .that(((FirebaseInstallationsException) cause).getStatus())
+          .isEqualTo(FirebaseInstallationsException.Status.SDK_INTERNAL_ERROR);
+    }
+  }
+
+  @Test
+  public void testGetAuthToken_multipleCalls_fetchedNewTokenOnce() throws Exception {
+    when(mockPersistedFid.readPersistedFidEntryValue())
+        .thenReturn(
+            EXPIRED_AUTH_TOKEN_ENTRY,
+            EXPIRED_AUTH_TOKEN_ENTRY,
+            EXPIRED_AUTH_TOKEN_ENTRY,
+            UPDATED_AUTH_TOKEN_FID_ENTRY);
+    FirebaseInstallations firebaseInstallations =
+        new FirebaseInstallations(
+            mockClock, executor, firebaseApp, backendClientReturnsOk, mockPersistedFid, mockUtils);
+
+    // Call getAuthToken multiple times with DO_NOT_FORCE_REFRESH option
+    Task<InstallationTokenResult> task1 =
+        firebaseInstallations.getAuthToken(FirebaseInstallationsApi.DO_NOT_FORCE_REFRESH);
+    Task<InstallationTokenResult> task2 =
+        firebaseInstallations.getAuthToken(FirebaseInstallationsApi.DO_NOT_FORCE_REFRESH);
+
+    Tasks.await(Tasks.whenAllComplete(task1, task2));
+
+    assertWithMessage("Persisted Auth Token doesn't match")
+        .that(task1.getResult().getToken())
+        .isEqualTo(TEST_AUTH_TOKEN_2);
+    assertWithMessage("Persisted Auth Token doesn't match")
+        .that(task2.getResult().getToken())
+        .isEqualTo(TEST_AUTH_TOKEN_2);
+    verify(backendClientReturnsOk, times(1))
+        .generateAuthToken(anyString(), anyString(), anyString(), anyString());
+  }
+
+  @Test
+  public void testGetAuthToken_multipleCallsForceRefresh_fetchedNewTokenTwice() throws Exception {
+    when(mockPersistedFid.readPersistedFidEntryValue()).thenReturn(REGISTERED_FID_ENTRY);
+    // Use a custom ServiceClient to mock the network calls ensuring task1 is not completed
+    // before task2. Hence, we can test multiple calls to getAUthToken() and verify task2 waits for
+    // task1 to complete.
+    ServiceClient serviceClient = new ServiceClient();
+    FirebaseInstallations firebaseInstallations =
+        new FirebaseInstallations(
+            mockClock, executor, firebaseApp, serviceClient, mockPersistedFid, mockUtils);
+
+    // Call getAuthToken multiple times with FORCE_REFRESH option. Also, sleep for 500ms in between
+    // the calls to ensure tasks are called in order.
+    Task<InstallationTokenResult> task1 =
+        firebaseInstallations.getAuthToken(FirebaseInstallationsApi.FORCE_REFRESH);
+    Thread.sleep(500);
+    Task<InstallationTokenResult> task2 =
+        firebaseInstallations.getAuthToken(FirebaseInstallationsApi.FORCE_REFRESH);
+    Tasks.await(Tasks.whenAllComplete(task1, task2));
+
+    assertWithMessage("Persisted Auth Token doesn't match")
+        .that(task1.getResult().getToken())
+        .isEqualTo(TEST_AUTH_TOKEN_3);
+    assertWithMessage("Persisted Auth Token doesn't match")
+        .that(task2.getResult().getToken())
+        .isEqualTo(TEST_AUTH_TOKEN_4);
+  }
+
+  class ServiceClient extends FirebaseInstallationServiceClient {
+
+    private boolean secondCall;
+
+    @Override
+    @NonNull
+    public InstallationTokenResult generateAuthToken(
+        @NonNull String apiKey,
+        @NonNull String fid,
+        @NonNull String projectID,
+        @NonNull String refreshToken)
+        throws FirebaseInstallationServiceException {
+      try {
+        Thread.sleep(2000);
+      } catch (InterruptedException e) {
+        Log.e("InterruptedException", e.getMessage());
+      }
+
+      if (!secondCall) {
+        secondCall = true;
+        return InstallationTokenResult.builder()
+            .setToken(TEST_AUTH_TOKEN_3)
+            .setTokenExpirationInSecs(TEST_TOKEN_EXPIRATION_TIMESTAMP)
+            .build();
+      }
+
+      return InstallationTokenResult.builder()
+          .setToken(TEST_AUTH_TOKEN_4)
+          .setTokenExpirationInSecs(TEST_TOKEN_EXPIRATION_TIMESTAMP)
+          .build();
+    }
+  }
 }