Merge "Fix search index for a financed device" into sc-dev

res/xml/security_dashboard_settings.xml

@@ -111,6 +111,12 @@
             android:summary="@string/summary_placeholder"
             android:fragment="com.android.settings.enterprise.EnterprisePrivacySettings" />
 
+        <Preference
+            android:key="financed_privacy"
+            android:title="@string/financed_privacy_settings"
+            android:summary="@string/summary_placeholder"
+            android:fragment="com.android.settings.enterprise.EnterprisePrivacySettings" />
+
     </PreferenceCategory>
 
     <Preference

src/com/android/settings/enterprise/EnterprisePrivacyPreferenceController.java

@@ -13,61 +13,47 @@
  */
 package com.android.settings.enterprise;
 
-import static android.app.admin.DevicePolicyManager.DEVICE_OWNER_TYPE_FINANCED;
-
-import android.app.admin.DevicePolicyManager;
 import android.content.Context;
 
 import androidx.preference.Preference;
 
-import com.android.settings.R;
+import com.android.internal.annotations.VisibleForTesting;
 import com.android.settings.core.PreferenceControllerMixin;
-import com.android.settings.overlay.FeatureFactory;
 import com.android.settingslib.core.AbstractPreferenceController;
 
+import java.util.Objects;
+
 public class EnterprisePrivacyPreferenceController extends AbstractPreferenceController implements
         PreferenceControllerMixin {
 
     private static final String KEY_ENTERPRISE_PRIVACY = "enterprise_privacy";
-    private final EnterprisePrivacyFeatureProvider mFeatureProvider;
+    private final PrivacyPreferenceControllerHelper mPrivacyPreferenceControllerHelper;
 
     public EnterprisePrivacyPreferenceController(Context context) {
-        super(context);
+        this(Objects.requireNonNull(context), new PrivacyPreferenceControllerHelper(context));
-        mFeatureProvider = FeatureFactory.getFactory(context)
+    }
-                .getEnterprisePrivacyFeatureProvider(context);
+
+    @VisibleForTesting
+    EnterprisePrivacyPreferenceController(
+            Context context, PrivacyPreferenceControllerHelper privacyPreferenceControllerHelper) {
+        super(Objects.requireNonNull(context));
+        mPrivacyPreferenceControllerHelper = Objects.requireNonNull(
+                privacyPreferenceControllerHelper);
     }
 
     @Override
     public void updateState(Preference preference) {
-        if (preference == null) {
+        mPrivacyPreferenceControllerHelper.updateState(preference);
-            return;
-        }
-        if (isFinancedDevice()) {
-            preference.setTitle(R.string.financed_privacy_settings);
-        }
-
-        final String organizationName = mFeatureProvider.getDeviceOwnerOrganizationName();
-        if (organizationName == null) {
-            preference.setSummary(R.string.enterprise_privacy_settings_summary_generic);
-        } else {
-            preference.setSummary(mContext.getResources().getString(
-                    R.string.enterprise_privacy_settings_summary_with_name, organizationName));
-        }
     }
 
     @Override
     public boolean isAvailable() {
-        return mFeatureProvider.hasDeviceOwner();
+        return mPrivacyPreferenceControllerHelper.hasDeviceOwner()
+                && !mPrivacyPreferenceControllerHelper.isFinancedDevice();
     }
 
     @Override
     public String getPreferenceKey() {
         return KEY_ENTERPRISE_PRIVACY;
     }
-
-    private boolean isFinancedDevice() {
-        final DevicePolicyManager dpm = mContext.getSystemService(DevicePolicyManager.class);
-        return dpm.isDeviceManaged() && dpm.getDeviceOwnerType(
-                dpm.getDeviceOwnerComponentOnAnyUser()) == DEVICE_OWNER_TYPE_FINANCED;
-    }
 }

src/com/android/settings/enterprise/FinancedPrivacyPreferenceController.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * 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 com.android.settings.enterprise;
+
+import android.content.Context;
+
+import androidx.preference.Preference;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settingslib.core.AbstractPreferenceController;
+
+import java.util.Objects;
+
+/** Preference controller which displays a financed preference for financed devices. */
+public class FinancedPrivacyPreferenceController extends AbstractPreferenceController implements
+        PreferenceControllerMixin {
+
+    private static final String PREF_KEY_FINANCED_PRIVACY = "financed_privacy";
+    private final PrivacyPreferenceControllerHelper mPrivacyPreferenceControllerHelper;
+
+    public FinancedPrivacyPreferenceController(Context context) {
+        this(Objects.requireNonNull(context), new PrivacyPreferenceControllerHelper(context));
+    }
+
+    @VisibleForTesting
+    FinancedPrivacyPreferenceController(
+            Context context, PrivacyPreferenceControllerHelper privacyPreferenceControllerHelper) {
+        super(Objects.requireNonNull(context));
+        mPrivacyPreferenceControllerHelper = Objects.requireNonNull(
+                privacyPreferenceControllerHelper);
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        mPrivacyPreferenceControllerHelper.updateState(preference);
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return mPrivacyPreferenceControllerHelper.isFinancedDevice();
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return PREF_KEY_FINANCED_PRIVACY;
+    }
+}

src/com/android/settings/enterprise/PrivacyPreferenceControllerHelper.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * 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 com.android.settings.enterprise;
+
+import static android.app.admin.DevicePolicyManager.DEVICE_OWNER_TYPE_FINANCED;
+
+import android.app.admin.DevicePolicyManager;
+import android.content.Context;
+
+import androidx.preference.Preference;
+
+import com.android.settings.R;
+import com.android.settings.overlay.FeatureFactory;
+
+import java.util.Objects;
+
+/** Helper class for the privacy preference in Settings for a managed device. */
+class PrivacyPreferenceControllerHelper {
+
+    private final Context mContext;
+    private final EnterprisePrivacyFeatureProvider mFeatureProvider;
+    private final DevicePolicyManager mDevicePolicyManager;
+
+    PrivacyPreferenceControllerHelper(Context context) {
+        mContext = Objects.requireNonNull(context);
+        mFeatureProvider = FeatureFactory.getFactory(context)
+                .getEnterprisePrivacyFeatureProvider(context);
+        mDevicePolicyManager = context.getSystemService(DevicePolicyManager.class);
+    }
+
+    /** Updates the privacy preference summary. */
+    void updateState(Preference preference) {
+        if (preference == null) {
+            return;
+        }
+
+        final String organizationName = mFeatureProvider.getDeviceOwnerOrganizationName();
+        if (organizationName == null) {
+            preference.setSummary(R.string.enterprise_privacy_settings_summary_generic);
+        } else {
+            preference.setSummary(mContext.getResources().getString(
+                    R.string.enterprise_privacy_settings_summary_with_name, organizationName));
+        }
+    }
+
+    /** Returns {@code true} if the device has a device owner. */
+    boolean hasDeviceOwner() {
+        return mFeatureProvider.hasDeviceOwner();
+    }
+
+    boolean isFinancedDevice() {
+        return mDevicePolicyManager.isDeviceManaged() && mDevicePolicyManager.getDeviceOwnerType(
+                mDevicePolicyManager.getDeviceOwnerComponentOnAnyUser())
+                == DEVICE_OWNER_TYPE_FINANCED;
+    }
+}

src/com/android/settings/security/SecuritySettings.java

@@ -28,6 +28,7 @@ import com.android.settings.biometrics.fingerprint.FingerprintProfileStatusPrefe
 import com.android.settings.biometrics.fingerprint.FingerprintStatusPreferenceController;
 import com.android.settings.dashboard.DashboardFragment;
 import com.android.settings.enterprise.EnterprisePrivacyPreferenceController;
+import com.android.settings.enterprise.FinancedPrivacyPreferenceController;
 import com.android.settings.search.BaseSearchIndexProvider;
 import com.android.settings.security.trustagent.ManageTrustAgentsPreferenceController;
 import com.android.settings.security.trustagent.TrustAgentListPreferenceController;
@@ -103,6 +104,7 @@ public class SecuritySettings extends DashboardFragment {
             Lifecycle lifecycle, SecuritySettings host) {
         final List<AbstractPreferenceController> controllers = new ArrayList<>();
         controllers.add(new EnterprisePrivacyPreferenceController(context));
+        controllers.add(new FinancedPrivacyPreferenceController(context));
         controllers.add(new ManageTrustAgentsPreferenceController(context));
         controllers.add(new ScreenPinningPreferenceController(context));
         controllers.add(new SimLockPreferenceController(context));

tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java

@@ -16,22 +16,15 @@
 
 package com.android.settings.enterprise;
 
-import static android.app.admin.DevicePolicyManager.DEVICE_OWNER_TYPE_DEFAULT;
-import static android.app.admin.DevicePolicyManager.DEVICE_OWNER_TYPE_FINANCED;
-
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-import android.app.admin.DevicePolicyManager;
-import android.content.ComponentName;
 import android.content.Context;
 
 import androidx.preference.Preference;
 
-import com.android.settings.R;
-import com.android.settings.testutils.FakeFeatureFactory;
-
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -43,82 +36,50 @@ import org.robolectric.RobolectricTestRunner;
 @RunWith(RobolectricTestRunner.class)
 public class EnterprisePrivacyPreferenceControllerTest {
 
-    private static final String MANAGED_GENERIC = "managed by organization";
-    private static final String MANAGED_WITH_NAME = "managed by Foo, Inc.";
-    private static final String MANAGING_ORGANIZATION = "Foo, Inc.";
     private static final String KEY_ENTERPRISE_PRIVACY = "enterprise_privacy";
-    private static final String FINANCED_PREFERENCE_TITLE = "Financed device info";
-    private static final ComponentName DEVICE_OWNER_COMPONENT =
-            new ComponentName("com.android.foo", "bar");
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
     @Mock
-    private DevicePolicyManager mDevicePolicyManager;
+    private PrivacyPreferenceControllerHelper mPrivacyPreferenceControllerHelper;
-    private FakeFeatureFactory mFeatureFactory;
-
     private EnterprisePrivacyPreferenceController mController;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-        mFeatureFactory = FakeFeatureFactory.setupForTest();
+        mController = new EnterprisePrivacyPreferenceController(
-        mController = new EnterprisePrivacyPreferenceController(mContext);
+                mContext, mPrivacyPreferenceControllerHelper);
-
-        when((Object) mContext.getSystemService(DevicePolicyManager.class))
-                .thenReturn(mDevicePolicyManager);
-        when(mDevicePolicyManager.isDeviceManaged()).thenReturn(true);
-        when(mDevicePolicyManager.getDeviceOwnerComponentOnAnyUser())
-                .thenReturn(DEVICE_OWNER_COMPONENT);
-        when(mDevicePolicyManager.getDeviceOwnerType(DEVICE_OWNER_COMPONENT))
-                .thenReturn(DEVICE_OWNER_TYPE_DEFAULT);
     }
 
     @Test
     public void testUpdateState() {
         final Preference preference = new Preference(mContext, null, 0, 0);
 
-        when(mContext.getString(R.string.enterprise_privacy_settings_summary_generic))
-                .thenReturn(MANAGED_GENERIC);
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.getDeviceOwnerOrganizationName())
-                .thenReturn(null);
         mController.updateState(preference);
-        assertThat(preference.getSummary()).isEqualTo(MANAGED_GENERIC);
 
-        when(mContext.getResources().getString(
+        verify(mPrivacyPreferenceControllerHelper).updateState(preference);
-                R.string.enterprise_privacy_settings_summary_with_name, MANAGING_ORGANIZATION))
-                .thenReturn(MANAGED_WITH_NAME);
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.getDeviceOwnerOrganizationName())
-                .thenReturn(MANAGING_ORGANIZATION);
-        mController.updateState(preference);
-        assertThat(preference.getSummary()).isEqualTo(MANAGED_WITH_NAME);
     }
 
     @Test
-    public void testUpdateState_verifyPreferenceTitleIsUpdatedForFinancedDevice() {
+    public void testIsAvailable_noDeviceOwner_returnsFalse() {
-        final Preference preference = new Preference(mContext, null, 0, 0);
+        when(mPrivacyPreferenceControllerHelper.hasDeviceOwner()).thenReturn(false);
-        when(mContext.getResources().getString(
-                R.string.enterprise_privacy_settings_summary_with_name, MANAGING_ORGANIZATION))
-                .thenReturn(MANAGED_WITH_NAME);
-        when(mContext.getString(R.string.financed_privacy_settings))
-                .thenReturn(FINANCED_PREFERENCE_TITLE);
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.getDeviceOwnerOrganizationName())
-                .thenReturn(MANAGING_ORGANIZATION);
-        when(mDevicePolicyManager.getDeviceOwnerType(DEVICE_OWNER_COMPONENT))
-                .thenReturn(DEVICE_OWNER_TYPE_FINANCED);
 
-        mController.updateState(preference);
-
-        assertThat(preference.getTitle()).isEqualTo(FINANCED_PREFERENCE_TITLE);
-        assertThat(preference.getSummary()).isEqualTo(MANAGED_WITH_NAME);
-    }
-
-    @Test
-    public void testIsAvailable() {
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(false);
         assertThat(mController.isAvailable()).isFalse();
+    }
+
+    @Test
+    public void testIsAvailable_deviceOwner_financedDevice_returnsFalse() {
+        when(mPrivacyPreferenceControllerHelper.hasDeviceOwner()).thenReturn(true);
+        when(mPrivacyPreferenceControllerHelper.isFinancedDevice()).thenReturn(true);
+
+        assertThat(mController.isAvailable()).isFalse();
+    }
+
+    @Test
+    public void testIsAvailable_deviceOwner_enterpriseDevice_returnsTrue() {
+        when(mPrivacyPreferenceControllerHelper.hasDeviceOwner()).thenReturn(true);
+        when(mPrivacyPreferenceControllerHelper.isFinancedDevice()).thenReturn(false);
 
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(true);
         assertThat(mController.isAvailable()).isTrue();
     }
 

tests/robotests/src/com/android/settings/enterprise/FinancedPrivacyPreferenceControllerTest.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * 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 com.android.settings.enterprise;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+
+import androidx.preference.Preference;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Answers;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public class FinancedPrivacyPreferenceControllerTest {
+
+    private static final String PREF_KEY_FINANCED_PRIVACY = "financed_privacy";
+
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+    private Context mContext;
+    @Mock
+    private PrivacyPreferenceControllerHelper mPrivacyPreferenceControllerHelper;
+    private FinancedPrivacyPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mController = new FinancedPrivacyPreferenceController(
+                mContext, mPrivacyPreferenceControllerHelper);
+    }
+
+    @Test
+    public void testUpdateState() {
+        final Preference preference = new Preference(mContext, null, 0, 0);
+
+        mController.updateState(preference);
+
+        verify(mPrivacyPreferenceControllerHelper).updateState(preference);
+    }
+
+    @Test
+    public void testIsAvailable_financedDevice_returnsTrue() {
+        when(mPrivacyPreferenceControllerHelper.isFinancedDevice()).thenReturn(true);
+
+        assertThat(mController.isAvailable()).isTrue();
+    }
+
+    @Test
+    public void testIsAvailable_enterpriseDevice_returnsFalse() {
+        when(mPrivacyPreferenceControllerHelper.isFinancedDevice()).thenReturn(false);
+
+        assertThat(mController.isAvailable()).isFalse();
+    }
+
+    @Test
+    public void testHandlePreferenceTreeClick() {
+        assertThat(mController.handlePreferenceTreeClick(new Preference(mContext, null, 0, 0)))
+                .isFalse();
+    }
+
+    @Test
+    public void testGetPreferenceKey() {
+        assertThat(mController.getPreferenceKey()).isEqualTo(PREF_KEY_FINANCED_PRIVACY);
+    }
+}

tests/robotests/src/com/android/settings/enterprise/PrivacyPreferenceControllerHelperTest.java

@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * 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 com.android.settings.enterprise;
+
+import static android.app.admin.DevicePolicyManager.DEVICE_OWNER_TYPE_DEFAULT;
+import static android.app.admin.DevicePolicyManager.DEVICE_OWNER_TYPE_FINANCED;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.when;
+
+import android.app.admin.DevicePolicyManager;
+import android.content.ComponentName;
+import android.content.Context;
+
+import androidx.preference.Preference;
+
+import com.android.settings.R;
+import com.android.settings.testutils.FakeFeatureFactory;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Answers;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public class PrivacyPreferenceControllerHelperTest {
+
+    private static final String MANAGED_GENERIC = "managed by organization";
+    private static final String MANAGED_WITH_NAME = "managed by Foo, Inc.";
+    private static final String MANAGING_ORGANIZATION = "Foo, Inc.";
+    private static final ComponentName DEVICE_OWNER_COMPONENT =
+            new ComponentName("com.android.foo", "bar");
+
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+    private Context mContext;
+    @Mock
+    private DevicePolicyManager mDevicePolicyManager;
+    private FakeFeatureFactory mFeatureFactory;
+    private PrivacyPreferenceControllerHelper mPrivacyPreferenceControllerHelper;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mFeatureFactory = FakeFeatureFactory.setupForTest();
+
+        when((Object) mContext.getSystemService(DevicePolicyManager.class))
+                .thenReturn(mDevicePolicyManager);
+        mPrivacyPreferenceControllerHelper = new PrivacyPreferenceControllerHelper(mContext);
+
+        when(mDevicePolicyManager.isDeviceManaged()).thenReturn(true);
+        when(mDevicePolicyManager.getDeviceOwnerComponentOnAnyUser())
+                .thenReturn(DEVICE_OWNER_COMPONENT);
+        when(mDevicePolicyManager.getDeviceOwnerType(DEVICE_OWNER_COMPONENT))
+                .thenReturn(DEVICE_OWNER_TYPE_DEFAULT);
+    }
+
+    @Test
+    public void testUpdateState_noDeviceOwnerName_useGenericPreferenceSummary() {
+        final Preference preference = new Preference(mContext, null, 0, 0);
+        when(mContext.getString(R.string.enterprise_privacy_settings_summary_generic))
+                .thenReturn(MANAGED_GENERIC);
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.getDeviceOwnerOrganizationName())
+                .thenReturn(null);
+
+        mPrivacyPreferenceControllerHelper.updateState(preference);
+
+        assertThat(preference.getSummary().toString()).isEqualTo(MANAGED_GENERIC);
+    }
+
+    @Test
+    public void testUpdateState_deviceOwnerName_usePreferenceSummaryWithDeviceOwnerName() {
+        final Preference preference = new Preference(mContext, null, 0, 0);
+        when(mContext.getResources().getString(
+                R.string.enterprise_privacy_settings_summary_with_name, MANAGING_ORGANIZATION))
+                .thenReturn(MANAGED_WITH_NAME);
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.getDeviceOwnerOrganizationName())
+                .thenReturn(MANAGING_ORGANIZATION);
+
+        mPrivacyPreferenceControllerHelper.updateState(preference);
+
+        assertThat(preference.getSummary().toString()).isEqualTo(MANAGED_WITH_NAME);
+    }
+
+    @Test
+    public void hasDeviceOwner_deviceOwner_returnsTrue() {
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(true);
+
+        assertThat(mPrivacyPreferenceControllerHelper.hasDeviceOwner()).isTrue();
+    }
+
+    @Test
+    public void hasDeviceOwner_noDeviceOwner_returnsFalse() {
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(false);
+
+        assertThat(mPrivacyPreferenceControllerHelper.hasDeviceOwner()).isFalse();
+    }
+
+    @Test
+    public void isFinancedDevice_deviceNotManaged_returnsFalse() {
+        when(mDevicePolicyManager.isDeviceManaged()).thenReturn(false);
+
+        assertThat(mPrivacyPreferenceControllerHelper.isFinancedDevice()).isFalse();
+    }
+
+    @Test
+    public void isFinancedDevice_deviceManaged_defaultDeviceOwnerType_returnsFalse() {
+        assertThat(mPrivacyPreferenceControllerHelper.isFinancedDevice()).isFalse();
+    }
+
+    @Test
+    public void isFinancedDevice_deviceManaged_financedDeviceOwnerType_returnsTrue() {
+        when(mDevicePolicyManager.getDeviceOwnerType(DEVICE_OWNER_COMPONENT))
+                .thenReturn(DEVICE_OWNER_TYPE_FINANCED);
+
+        assertThat(mPrivacyPreferenceControllerHelper.isFinancedDevice()).isTrue();
+    }
+}