Rename Robo tests to BackupManagerServiceTest (2ab9c4c9) · Commits · e / os / android_frameworks_base

services/robotests/src/com/android/server/backup/BackupManagerServiceRoboTest.java→services/robotests/src/com/android/server/backup/BackupManagerServiceTest.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -75,7 +75,7 @@ import org.robolectric.shadows.ShadowSystemClock;
		)
		@SystemLoaderClasses({RefactoredBackupManagerService.class, TransportManager.class})
		@Presubmit
		public class BackupManagerServiceRoboTest {
		public class BackupManagerServiceTest {
		private static final String TAG = "BMSTest";

		@Mock private TransportManager mTransportManager;

services/tests/servicestests/src/com/android/server/backup/BackupManagerServiceTest.java

deleted100644 → 0

+0 −325

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 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.server.backup;

		import static org.mockito.ArgumentMatchers.any;
		import static org.mockito.ArgumentMatchers.anyString;
		import static org.mockito.ArgumentMatchers.eq;
		import static org.mockito.Mockito.doNothing;
		import static org.mockito.Mockito.doThrow;
		import static org.mockito.Mockito.spy;
		import static org.mockito.Mockito.verify;
		import static org.testng.Assert.expectThrows;

		import android.content.ComponentName;
		import android.content.Context;
		import android.content.ContextWrapper;
		import android.content.Intent;
		import android.os.HandlerThread;
		import android.platform.test.annotations.Presubmit;
		import android.support.test.InstrumentationRegistry;
		import android.support.test.filters.SmallTest;
		import android.support.test.runner.AndroidJUnit4;
		import android.util.Log;

		import org.junit.After;
		import org.junit.Before;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.mockito.Mock;
		import org.mockito.MockitoAnnotations;

		import java.io.File;

		@SmallTest
		@Presubmit
		@RunWith(AndroidJUnit4.class)
		// TODO: Migrate this to Robolectric and merge with BackupManagerServiceRoboTest (and remove 'Robo')
		public class BackupManagerServiceTest {
		private static final String TAG = "BMSTest";
		private static final ComponentName TRANSPORT_COMPONENT =
		new ComponentName(
		"com.google.android.gms",
		"com.google.android.gms.backup.BackupTransportService");
		private static final String TRANSPORT_NAME = TRANSPORT_COMPONENT.flattenToShortString();

		@Mock private TransportManager mTransportManager;
		private Context mContext;
		private HandlerThread mBackupThread;
		private int mPackageUid;
		private File mBaseStateDir;
		private File mDataDir;

		@Before
		public void setUp() throws Exception {
		MockitoAnnotations.initMocks(this);

		Context baseContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
		mContext = spy(new ContextWrapper(baseContext));

		mBackupThread = new HandlerThread("backup-test");
		mBackupThread.setUncaughtExceptionHandler(
		(t, e) -> Log.e(TAG, "Uncaught exception in test thread " + t.getName(), e));
		mBackupThread.start();

		File cacheDir = mContext.getCacheDir();
		mBaseStateDir = new File(cacheDir, "base_state_dir");
		mDataDir = new File(cacheDir, "data_dir");

		mPackageUid =
		mContext.getPackageManager().getPackageUid(TRANSPORT_COMPONENT.getPackageName(), 0);
		}

		@After
		public void tearDown() throws Exception {
		mBackupThread.quit();
		mBaseStateDir.delete();
		mDataDir.delete();
		}

		@Test
		public void testConstructor_callsTransportManagerSetTransportBoundListener() throws Exception {
		createBackupManagerService();

		verify(mTransportManager)
		.setOnTransportRegisteredListener(any());
		}

		@Test
		public void
		testUpdateTransportAttributes_whenTransportUidEqualsToCallingUid_callsThroughToTransportManager()
		throws Exception {
		grantBackupPermission();
		RefactoredBackupManagerService backupManagerService = createBackupManagerService();
		Intent configurationIntent = new Intent();
		Intent dataManagementIntent = new Intent();

		backupManagerService.updateTransportAttributes(
		mPackageUid,
		TRANSPORT_COMPONENT,
		TRANSPORT_NAME,
		configurationIntent,
		"currentDestinationString",
		dataManagementIntent,
		"dataManagementLabel");

		verify(mTransportManager)
		.updateTransportAttributes(
		eq(TRANSPORT_COMPONENT),
		eq(TRANSPORT_NAME),
		eq(configurationIntent),
		eq("currentDestinationString"),
		eq(dataManagementIntent),
		eq("dataManagementLabel"));
		}

		@Test
		public void testUpdateTransportAttributes_whenTransportUidNotEqualToCallingUid_throwsException()
		throws Exception {
		grantBackupPermission();
		RefactoredBackupManagerService backupManagerService = createBackupManagerService();

		expectThrows(
		SecurityException.class,
		() ->
		backupManagerService.updateTransportAttributes(
		mPackageUid + 1,
		TRANSPORT_COMPONENT,
		TRANSPORT_NAME,
		new Intent(),
		"currentDestinationString",
		new Intent(),
		"dataManagementLabel"));
		}

		@Test
		public void testUpdateTransportAttributes_whenTransportComponentNull_throwsException() {
		grantBackupPermission();
		RefactoredBackupManagerService backupManagerService = createBackupManagerService();

		expectThrows(
		RuntimeException.class,
		() ->
		backupManagerService.updateTransportAttributes(
		mPackageUid,
		null,
		TRANSPORT_NAME,
		new Intent(),
		"currentDestinationString",
		new Intent(),
		"dataManagementLabel"));
		}

		@Test
		public void testUpdateTransportAttributes_whenNameNull_throwsException() {
		grantBackupPermission();
		RefactoredBackupManagerService backupManagerService = createBackupManagerService();

		expectThrows(
		RuntimeException.class,
		() ->
		backupManagerService.updateTransportAttributes(
		mPackageUid,
		TRANSPORT_COMPONENT,
		null,
		new Intent(),
		"currentDestinationString",
		new Intent(),
		"dataManagementLabel"));
		}

		@Test
		public void testUpdateTransportAttributes_whenCurrentDestinationStringNull_throwsException() {
		grantBackupPermission();
		RefactoredBackupManagerService backupManagerService = createBackupManagerService();

		expectThrows(
		RuntimeException.class,
		() ->
		backupManagerService.updateTransportAttributes(
		mPackageUid,
		TRANSPORT_COMPONENT,
		TRANSPORT_NAME,
		new Intent(),
		null,
		new Intent(),
		"dataManagementLabel"));
		}

		@Test
		public void
		testUpdateTransportAttributes_whenDataManagementArgumentsNullityDontMatch_throwsException() {
		grantBackupPermission();
		RefactoredBackupManagerService backupManagerService = createBackupManagerService();

		expectThrows(
		RuntimeException.class,
		() ->
		backupManagerService.updateTransportAttributes(
		mPackageUid,
		TRANSPORT_COMPONENT,
		TRANSPORT_NAME,
		new Intent(),
		"currentDestinationString",
		null,
		"dataManagementLabel"));

		expectThrows(
		RuntimeException.class,
		() ->
		backupManagerService.updateTransportAttributes(
		mPackageUid,
		TRANSPORT_COMPONENT,
		TRANSPORT_NAME,
		new Intent(),
		"currentDestinationString",
		new Intent(),
		null));
		}

		@Test
		public void
		testUpdateTransportAttributes_whenDataManagementArgumentsNull_callsThroughToTransportManager() {
		grantBackupPermission();
		RefactoredBackupManagerService backupManagerService = createBackupManagerService();
		Intent configurationIntent = new Intent();

		backupManagerService.updateTransportAttributes(
		mPackageUid,
		TRANSPORT_COMPONENT,
		TRANSPORT_NAME,
		configurationIntent,
		"currentDestinationString",
		null,
		null);

		verify(mTransportManager)
		.updateTransportAttributes(
		eq(TRANSPORT_COMPONENT),
		eq(TRANSPORT_NAME),
		eq(configurationIntent),
		eq("currentDestinationString"),
		eq(null),
		eq(null));
		}

		@Test
		public void
		testUpdateTransportAttributes_whenPermissionGranted_callsThroughToTransportManager() {
		grantBackupPermission();
		RefactoredBackupManagerService backupManagerService = createBackupManagerService();
		Intent configurationIntent = new Intent();
		Intent dataManagementIntent = new Intent();

		backupManagerService.updateTransportAttributes(
		mPackageUid,
		TRANSPORT_COMPONENT,
		TRANSPORT_NAME,
		configurationIntent,
		"currentDestinationString",
		dataManagementIntent,
		"dataManagementLabel");

		verify(mTransportManager)
		.updateTransportAttributes(
		eq(TRANSPORT_COMPONENT),
		eq(TRANSPORT_NAME),
		eq(configurationIntent),
		eq("currentDestinationString"),
		eq(dataManagementIntent),
		eq("dataManagementLabel"));
		}

		@Test
		public void testUpdateTransportAttributes_whenPermissionDenied_throwsSecurityException() {
		denyBackupPermission();
		RefactoredBackupManagerService backupManagerService = createBackupManagerService();

		expectThrows(
		SecurityException.class,
		() ->
		backupManagerService.updateTransportAttributes(
		mPackageUid,
		TRANSPORT_COMPONENT,
		TRANSPORT_NAME,
		new Intent(),
		"currentDestinationString",
		new Intent(),
		"dataManagementLabel"));
		}

		private RefactoredBackupManagerService createBackupManagerService() {
		return new RefactoredBackupManagerService(
		mContext,
		new Trampoline(mContext),
		mBackupThread,
		mBaseStateDir,
		mDataDir,
		mTransportManager);
		}

		private void grantBackupPermission() {
		doNothing().when(mContext).enforceCallingOrSelfPermission(any(), anyString());
		}

		private void denyBackupPermission() {
		doThrow(new SecurityException())
		.when(mContext)
		.enforceCallingOrSelfPermission(
		eq(android.Manifest.permission.BACKUP), anyString());
		}
		}