[Android][Signin] Test ConfirmSyncDataStateMachine

This CL added tests to the class ConfirmSyncDataStateMachine and
refactored its ctor.

Bug: 1028583
Change-Id: I143a5d05181f063bec89f5fb4835b8d296bcc9a9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1982539
Commit-Queue: Alice Wang <aliceywang@chromium.org>
Reviewed-by: Boris Sazonov <bsazonov@chromium.org>
Cr-Commit-Position: refs/heads/master@{#727966}

chrome/android/chrome_junit_test_java_sources.gni

@@ -192,6 +192,7 @@ chrome_junit_test_java_sources = [
   "junit/src/org/chromium/chrome/browser/signin/ConfirmImportSyncDataDialogTest.java",
   "junit/src/org/chromium/chrome/browser/signin/ConfirmManagedSyncDataDialogTest.java",
   "junit/src/org/chromium/chrome/browser/signin/ConfirmSyncDataStateMachineDelegateTest.java",
+  "junit/src/org/chromium/chrome/browser/signin/ConfirmSyncDataStateMachineTest.java",
   "junit/src/org/chromium/chrome/browser/signin/SigninManagerTest.java",
   "junit/src/org/chromium/chrome/browser/signin/SigninPromoUtilTest.java",
   "junit/src/org/chromium/chrome/browser/signin/SigninUtilsStartActivityTest.java",

chrome/android/java/src/org/chromium/chrome/browser/signin/ConfirmSyncDataStateMachine.java

@@ -4,9 +4,7 @@
 
 package org.chromium.chrome.browser.signin;
 
-import android.content.Context;
 import android.os.Handler;
-import android.support.v4.app.FragmentManager;
 import android.text.TextUtils;
 
 import androidx.annotation.IntDef;
@@ -66,8 +64,6 @@ public class ConfirmSyncDataStateMachine
     private final ConfirmImportSyncDataDialog.Listener mCallback;
     private final @Nullable String mOldAccountName;
     private final String mNewAccountName;
-    private final FragmentManager mFragmentManager;
-    private final Context mContext;
     private final ConfirmSyncDataStateMachineDelegate mDelegate;
     private final Handler mHandler = new Handler();
 
@@ -80,22 +76,21 @@ public class ConfirmSyncDataStateMachine
      * @param oldAccountName the name of the last signed in account or null
      * @param newAccountName the name of the account user is signing in with
      * @param callback the listener to receive the result of this state machine
+     * @param delegate the delegate responsible of showing dialogs
+     * TODO(https://crbug.com/1038502):
+     * Use a separate interface for the callback to avoid confusion.
      */
-    public ConfirmSyncDataStateMachine(Context context, FragmentManager fragmentManager,
+    public ConfirmSyncDataStateMachine(ConfirmSyncDataStateMachineDelegate delegate,
             @Nullable String oldAccountName, String newAccountName,
             ConfirmImportSyncDataDialog.Listener callback) {
         ThreadUtils.assertOnUiThread();
-        // Includes implicit not-null assertion.
-        assert !newAccountName.equals("") : "New account name must be provided.";
+        assert !TextUtils.isEmpty(newAccountName) : "New account name must be provided.";
 
+        mDelegate = delegate;
         mOldAccountName = oldAccountName;
         mNewAccountName = newAccountName;
-        mFragmentManager = fragmentManager;
-        mContext = context;
         mCallback = callback;
 
-        mDelegate = new ConfirmSyncDataStateMachineDelegate(mFragmentManager);
-
         // New account management status isn't needed right now, but fetching it
         // can take a few seconds, so we kick it off early.
         requestNewAccountManagementStatus();

chrome/android/java/src/org/chromium/chrome/browser/signin/SigninFragmentBase.java

@@ -436,8 +436,8 @@ public abstract class SigninFragmentBase
     }
 
     private void runStateMachineAndSignin(boolean settingsClicked) {
-        mConfirmSyncDataStateMachine = new ConfirmSyncDataStateMachine(getContext(),
-                getChildFragmentManager(),
+        mConfirmSyncDataStateMachine = new ConfirmSyncDataStateMachine(
+                new ConfirmSyncDataStateMachineDelegate(getChildFragmentManager()),
                 PrefServiceBridge.getInstance().getString(Pref.SYNC_LAST_ACCOUNT_NAME),
                 mSelectedAccountName, new ConfirmImportSyncDataDialog.Listener() {
                     @Override

chrome/android/junit/src/org/chromium/chrome/browser/signin/ConfirmSyncDataStateMachineTest.java

+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.chrome.browser.signin;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Matchers;
+import org.mockito.Mock;
+
+import org.chromium.base.Callback;
+import org.chromium.base.test.BaseRobolectricTestRunner;
+import org.chromium.base.test.util.JniMocker;
+
+/** Tests for {@link ConfirmSyncDataStateMachine}. */
+@RunWith(BaseRobolectricTestRunner.class)
+public class ConfirmSyncDataStateMachineTest {
+    @Rule
+    public final JniMocker mocker = new JniMocker();
+
+    @Mock
+    private SigninManager.Natives mSigninManagerNativeMock;
+
+    @Mock
+    private ConfirmSyncDataStateMachineDelegate mDelegateMock;
+
+    @Mock
+    private ConfirmImportSyncDataDialog.Listener mImportSyncDataListenerMock;
+
+    @Mock
+    private SigninManager mSigninManagerMock;
+
+    @Captor
+    private ArgumentCaptor<Callback<Boolean>> mCallbackArgument;
+
+    private final String mOldAccountName = "old.account.test@testdomain.com";
+
+    private final String mNewAccountName = "new.account.test@testdomain.com";
+
+    @Before
+    public void setUp() {
+        initMocks(this);
+        mocker.mock(SigninManagerJni.TEST_HOOKS, mSigninManagerNativeMock);
+        IdentityServicesProvider.setInstanceForTests(mock(IdentityServicesProvider.class));
+        when(IdentityServicesProvider.get().getSigninManager()).thenReturn(mSigninManagerMock);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void testNewAccountNameCannotBeEmpty() {
+        ConfirmSyncDataStateMachine stateMachine = new ConfirmSyncDataStateMachine(
+                mDelegateMock, mOldAccountName, null, mImportSyncDataListenerMock);
+    }
+
+    @Test
+    public void testImportSyncDataDialogShownWhenOldAndNewAccountNamesAreDifferent() {
+        ConfirmSyncDataStateMachine stateMachine = new ConfirmSyncDataStateMachine(
+                mDelegateMock, mOldAccountName, mNewAccountName, mImportSyncDataListenerMock);
+        verify(mDelegateMock)
+                .showConfirmImportSyncDataDialog(any(ConfirmImportSyncDataDialog.Listener.class),
+                        eq(mOldAccountName), eq(mNewAccountName));
+    }
+
+    @Test
+    public void testProgressDialogShownWhenOldAndNewAccountNamesAreEqual() {
+        String oldAndNewAccountName = "test.old.new@testdomain.com";
+        ConfirmSyncDataStateMachine stateMachine = new ConfirmSyncDataStateMachine(mDelegateMock,
+                oldAndNewAccountName, oldAndNewAccountName, mImportSyncDataListenerMock);
+        verify(mDelegateMock, never())
+                .showConfirmImportSyncDataDialog(
+                        any(ConfirmImportSyncDataDialog.Listener.class), anyString(), anyString());
+        verify(mDelegateMock)
+                .showFetchManagementPolicyProgressDialog(
+                        any(ConfirmSyncDataStateMachineDelegate.ProgressDialogListener.class));
+    }
+
+    @Test
+    public void testProgressDialogShownWhenOldAccountNameIsEmpty() {
+        ConfirmSyncDataStateMachine stateMachine = new ConfirmSyncDataStateMachine(
+                mDelegateMock, null, mNewAccountName, mImportSyncDataListenerMock);
+        verify(mDelegateMock, never())
+                .showConfirmImportSyncDataDialog(
+                        any(ConfirmImportSyncDataDialog.Listener.class), anyString(), anyString());
+        verify(mDelegateMock)
+                .showFetchManagementPolicyProgressDialog(
+                        any(ConfirmSyncDataStateMachineDelegate.ProgressDialogListener.class));
+    }
+
+    @Test
+    public void testListenerConfirmedWhenNewAccountIsNotManaged() {
+        mockSigninManagerIsAccountManaged(false);
+        ConfirmSyncDataStateMachine stateMachine = new ConfirmSyncDataStateMachine(
+                mDelegateMock, null, mNewAccountName, mImportSyncDataListenerMock);
+        verify(mDelegateMock).dismissAllDialogs();
+        verify(mImportSyncDataListenerMock).onConfirm(false);
+    }
+
+    @Test
+    public void testManagedAccountDialogShownWhenNewAccountIsManaged() {
+        mockSigninManagerIsAccountManaged(true);
+        when(mSigninManagerNativeMock.extractDomainName(anyString())).thenReturn(mNewAccountName);
+        ConfirmSyncDataStateMachine stateMachine = new ConfirmSyncDataStateMachine(
+                mDelegateMock, null, mNewAccountName, mImportSyncDataListenerMock);
+        verify(mDelegateMock)
+                .showSignInToManagedAccountDialog(
+                        any(ConfirmManagedSyncDataDialog.Listener.class), eq(mNewAccountName));
+    }
+
+    @Test
+    public void testWhenManagedAccountStatusIsFetchedAfterNewAccountDialog() {
+        String newAccountName = "test.account@manageddomain.com";
+        String domain = "manageddomain.com";
+        when(mSigninManagerNativeMock.extractDomainName(newAccountName)).thenReturn(domain);
+        ConfirmSyncDataStateMachine stateMachine = new ConfirmSyncDataStateMachine(
+                mDelegateMock, null, newAccountName, mImportSyncDataListenerMock);
+        verify(mDelegateMock, never())
+                .showSignInToManagedAccountDialog(
+                        any(ConfirmManagedSyncDataDialog.Listener.class), anyString());
+        verify(mSigninManagerMock)
+                .isAccountManaged(eq(newAccountName), mCallbackArgument.capture());
+        Callback<Boolean> callback = mCallbackArgument.getValue();
+        callback.onResult(true);
+        verify(mDelegateMock)
+                .showSignInToManagedAccountDialog(
+                        any(ConfirmManagedSyncDataDialog.Listener.class), eq(domain));
+    }
+
+    @Test
+    public void testCancelWhenIsNotBeingDestroyed() {
+        ConfirmSyncDataStateMachine stateMachine = new ConfirmSyncDataStateMachine(
+                mDelegateMock, mOldAccountName, mNewAccountName, mImportSyncDataListenerMock);
+        stateMachine.onCancel();
+        verify(mImportSyncDataListenerMock).onCancel();
+        verify(mDelegateMock).dismissAllDialogs();
+    }
+
+    @Test
+    public void testCancelWhenIsBeingDestroyed() {
+        ConfirmSyncDataStateMachine stateMachine = new ConfirmSyncDataStateMachine(
+                mDelegateMock, mOldAccountName, mNewAccountName, mImportSyncDataListenerMock);
+        stateMachine.cancel(true);
+        verify(mImportSyncDataListenerMock, never()).onCancel();
+        verify(mDelegateMock, never()).dismissAllDialogs();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testStateCannotChangeOnceDone() {
+        ConfirmSyncDataStateMachine stateMachine = new ConfirmSyncDataStateMachine(
+                mDelegateMock, mOldAccountName, mNewAccountName, mImportSyncDataListenerMock);
+        stateMachine.cancel(true);
+        stateMachine.onConfirm();
+    }
+
+    private void mockSigninManagerIsAccountManaged(boolean isAccountManaged) {
+        doAnswer(invocation -> {
+            Callback<Boolean> callback = invocation.getArgument(1);
+            callback.onResult(isAccountManaged);
+            return null;
+        })
+                .when(mSigninManagerMock)
+                .isAccountManaged(anyString(), Matchers.<Callback<Boolean>>any());
+    }
+}