diff options
Diffstat (limited to 'tests/src/com')
3 files changed, 191 insertions, 12 deletions
diff --git a/tests/src/com/android/dialer/filterednumber/BlockedNumbersMigratorTest.java b/tests/src/com/android/dialer/filterednumber/BlockedNumbersMigratorTest.java new file mode 100644 index 000000000..565c206d8 --- /dev/null +++ b/tests/src/com/android/dialer/filterednumber/BlockedNumbersMigratorTest.java @@ -0,0 +1,160 @@ +/* + * Copyright (C) 2016 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.dialer.filterednumber; + +import android.content.ContentUris; +import android.content.ContentValues; +import android.provider.BlockedNumberContract; +import android.provider.BlockedNumberContract.BlockedNumbers; +import android.test.AndroidTestCase; +import android.test.mock.MockContentResolver; + +import com.android.contacts.common.compat.CompatUtils; +import com.android.contacts.common.test.mocks.MockContentProvider; +import com.android.dialer.compat.FilteredNumberCompat; +import com.android.dialer.database.FilteredNumberContract; +import com.android.dialer.database.FilteredNumberContract.FilteredNumber; +import com.android.dialer.database.FilteredNumberContract.FilteredNumberColumns; + +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; + +public class BlockedNumbersMigratorTest extends AndroidTestCase { + + private static final String NUMBER = "6502530000"; + private static final String NUMBER1 = "6502530001"; + private static final String NUMBER2 = "6502530002"; + + @Mock private BlockedNumbersMigrator.Listener mListener; + private final MockContentResolver mContentResolver = new MockContentResolver(); + private final MockContentProvider mContentProvider = new MockContentProvider(); + private BlockedNumbersMigrator mMigrator; + + @Override + public void setUp() throws Exception { + super.setUp(); + MockitoAnnotations.initMocks(this); + FilteredNumberCompat.setIsEnabledForTest(true); + mContentResolver.addProvider(FilteredNumberContract.AUTHORITY, mContentProvider); + mContentResolver.addProvider(BlockedNumberContract.AUTHORITY, mContentProvider); + mMigrator = new BlockedNumbersMigrator(mContentResolver); + } + + public void testConstructor_NullContentResolver() { + try { + new BlockedNumbersMigrator(null); + fail(); + } catch (NullPointerException e) {} + } + + public void testMigrate_M() { + if (CompatUtils.isNCompatible()) { + return; + } + assertFalse(mMigrator.migrate(mListener)); + } + + public void testMigrate_N_Disabled() { + if (!CompatUtils.isNCompatible()) { + return; + } + FilteredNumberCompat.setIsEnabledForTest(false); + assertFalse(mMigrator.migrate(mListener)); + } + + public void testMigrate_N_NullListener() { + if (!CompatUtils.isNCompatible()) { + return; + } + try { + mMigrator.migrate(null); + fail(); + } catch (NullPointerException e) {} + } + + public void testMigrate_N() throws InterruptedException { + if (!CompatUtils.isNCompatible()) { + return; + } + mContentProvider.expectQuery(FilteredNumber.CONTENT_URI) + .withProjection(FilteredNumberColumns.NUMBER).returnRow(NUMBER).returnRow(NUMBER1) + .returnRow(NUMBER2); + + setUpNewBlockedNumberExpectations(mContentProvider, NUMBER, 0); + setUpNewBlockedNumberExpectations(mContentProvider, NUMBER1, 1); + setUpNewBlockedNumberExpectations(mContentProvider, NUMBER2, 2); + + MigrationListener listener = new MigrationListener(); + assertTrue(mMigrator.migrate(listener)); + listener.waitForCallback(); + assertTrue(FilteredNumberCompat.hasMigratedToNewBlocking()); + mContentProvider.verify(); + } + + public void testMigrate_N_AlreadyBlocked() throws InterruptedException { + if (!CompatUtils.isNCompatible()) { + return; + } + mContentProvider.expectQuery(FilteredNumber.CONTENT_URI) + .withProjection(FilteredNumberColumns.NUMBER).returnRow(NUMBER); + mContentProvider.expectQuery(BlockedNumbers.CONTENT_URI) + .withProjection(BlockedNumbers.COLUMN_ID) + .withSelection(BlockedNumbers.COLUMN_ORIGINAL_NUMBER + " = ?", NUMBER).returnRow(0); + // No expectation for insert into BlockedNumbers.CONTENT_URI because it's already there + + MigrationListener listener = new MigrationListener(); + assertTrue(mMigrator.migrate(listener)); + listener.waitForCallback(); + assertTrue(FilteredNumberCompat.hasMigratedToNewBlocking()); + mContentProvider.verify(); + } + + private void setUpNewBlockedNumberExpectations(MockContentProvider contentProvider, + String number, int returnId) { + contentProvider.expectQuery(BlockedNumbers.CONTENT_URI) + .withProjection(BlockedNumbers.COLUMN_ID) + .withSelection(BlockedNumbers.COLUMN_ORIGINAL_NUMBER + " = ?", number).returnEmptyCursor(); + contentProvider.expectInsert(BlockedNumbers.CONTENT_URI, + createBlockedNumberInsertValues(number), + ContentUris.withAppendedId(BlockedNumbers.CONTENT_URI, returnId)); + } + + private ContentValues createBlockedNumberInsertValues(String number) { + ContentValues values = new ContentValues(); + values.put(BlockedNumbers.COLUMN_ORIGINAL_NUMBER, number); + return values; + } + + private static class MigrationListener implements BlockedNumbersMigrator.Listener { + + private final CountDownLatch mOnCompleteCalled = new CountDownLatch(1); + + @Override + public void onComplete() { + mOnCompleteCalled.countDown(); + } + + public void waitForCallback() throws InterruptedException { + if (!mOnCompleteCalled.await(5000, TimeUnit.MILLISECONDS)) { + throw new IllegalStateException("Waiting on callback timed out."); + } + } + } +} diff --git a/tests/src/com/android/dialer/filterednumber/MigrateBlockedNumbersDialogFragmentInstrumentationTest.java b/tests/src/com/android/dialer/filterednumber/MigrateBlockedNumbersDialogFragmentInstrumentationTest.java index 4cf648a62..16b6f3fac 100644 --- a/tests/src/com/android/dialer/filterednumber/MigrateBlockedNumbersDialogFragmentInstrumentationTest.java +++ b/tests/src/com/android/dialer/filterednumber/MigrateBlockedNumbersDialogFragmentInstrumentationTest.java @@ -18,6 +18,7 @@ package com.android.dialer.filterednumber; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; import android.app.AlertDialog; import android.app.DialogFragment; @@ -25,7 +26,7 @@ import android.content.DialogInterface; import android.test.ActivityInstrumentationTestCase2; import com.android.dialer.DialtactsActivity; -import com.android.dialer.filterednumber.MigrateBlockedNumbersDialogFragment.Listener; +import com.android.dialer.filterednumber.BlockedNumbersMigrator.Listener; import org.mockito.Mock; import org.mockito.MockitoAnnotations; @@ -39,6 +40,7 @@ public class MigrateBlockedNumbersDialogFragmentInstrumentationTest extends private static final String SHOW_TAG = "ShowTag"; + @Mock private BlockedNumbersMigrator mBlockedNumbersMigrator; @Mock private Listener mListener; private DialtactsActivity mActivity; private DialogFragment mMigrateDialogFragment; @@ -52,7 +54,8 @@ public class MigrateBlockedNumbersDialogFragmentInstrumentationTest extends super.setUp(); MockitoAnnotations.initMocks(this); mActivity = getActivity(); - mMigrateDialogFragment = MigrateBlockedNumbersDialogFragment.newInstance(mListener); + mMigrateDialogFragment = MigrateBlockedNumbersDialogFragment + .newInstance(mBlockedNumbersMigrator, mListener); getInstrumentation().runOnMainSync(new Runnable() { @Override public void run() { @@ -67,7 +70,7 @@ public class MigrateBlockedNumbersDialogFragmentInstrumentationTest extends } public void testDialogPositiveButtonPress() { - doNothing().when(mListener).onComplete(); + when(mBlockedNumbersMigrator.migrate(mListener)).thenReturn(true); getInstrumentation().runOnMainSync(new Runnable() { @Override public void run() { @@ -78,6 +81,6 @@ public class MigrateBlockedNumbersDialogFragmentInstrumentationTest extends getInstrumentation().waitForIdleSync(); // Dialog was dismissed assertNull(mMigrateDialogFragment.getDialog()); - verify(mListener).onComplete(); + verify(mBlockedNumbersMigrator).migrate(mListener); } } diff --git a/tests/src/com/android/dialer/filterednumber/MigrateBlockedNumbersDialogFragmentTest.java b/tests/src/com/android/dialer/filterednumber/MigrateBlockedNumbersDialogFragmentTest.java index c8c782055..1b419cee8 100644 --- a/tests/src/com/android/dialer/filterednumber/MigrateBlockedNumbersDialogFragmentTest.java +++ b/tests/src/com/android/dialer/filterednumber/MigrateBlockedNumbersDialogFragmentTest.java @@ -19,7 +19,10 @@ package com.android.dialer.filterednumber; import android.test.AndroidTestCase; import android.test.suitebuilder.annotation.SmallTest; -import com.android.dialer.filterednumber.MigrateBlockedNumbersDialogFragment.Listener; +import com.android.dialer.filterednumber.BlockedNumbersMigrator.Listener; + +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; /** @@ -28,18 +31,31 @@ import com.android.dialer.filterednumber.MigrateBlockedNumbersDialogFragment.Lis @SmallTest public class MigrateBlockedNumbersDialogFragmentTest extends AndroidTestCase { - public void testNewInstance_NullMigrationListener() { + @Mock private BlockedNumbersMigrator mBlockedNumbersMigrator; + @Mock private Listener mListener; + + @Override + public void setUp() throws Exception { + super.setUp(); + MockitoAnnotations.initMocks(this); + } + + public void testNewInstance_NullMigrator() { + try { + MigrateBlockedNumbersDialogFragment.newInstance(null, mListener); + fail(); + } catch (NullPointerException e) {} + } + + public void testNewInstance_NullListener() { try { - MigrateBlockedNumbersDialogFragment.newInstance(null); + MigrateBlockedNumbersDialogFragment.newInstance(mBlockedNumbersMigrator, null); fail(); } catch (NullPointerException e) {} } public void testNewInstance_WithListener() { - assertNotNull(MigrateBlockedNumbersDialogFragment.newInstance( - new Listener() { - @Override - public void onComplete() {} - })); + assertNotNull(MigrateBlockedNumbersDialogFragment.newInstance(mBlockedNumbersMigrator, + mListener)); } } |