From 60fb1dc7afe8fe6079785724a21bbffbdb4eac88 Mon Sep 17 00:00:00 2001 From: Brandon Maxwell Date: Fri, 26 Feb 2016 16:59:46 -0800 Subject: Updating AsyncQueryHandler with FilteredNumCompat + FilteredNumberAsyncQueryHandler needs to make use of the FilteredNumberCompat class to unsure that it is blocking/unblocking/checking the proper solution, based on which is enabled. + This CL updates the queryHandler to the FilteredNumberCompat class for the hasBlockedNumbers, isBlockedNumber, and blockNumber operations. Bug=26664600 Change-Id: I5ecf6e340a97e94bf696a0e6c4a7e922b791a6f5 --- .../FilteredNumberAsyncQueryHandlerTest.java | 217 +++++++++++++++++---- 1 file changed, 174 insertions(+), 43 deletions(-) (limited to 'tests/src') diff --git a/tests/src/com/android/dialer/database/FilteredNumberAsyncQueryHandlerTest.java b/tests/src/com/android/dialer/database/FilteredNumberAsyncQueryHandlerTest.java index 6bb478e2a..88f38fd62 100644 --- a/tests/src/com/android/dialer/database/FilteredNumberAsyncQueryHandlerTest.java +++ b/tests/src/com/android/dialer/database/FilteredNumberAsyncQueryHandlerTest.java @@ -18,11 +18,16 @@ package com.android.dialer.database; import android.content.ContentValues; import android.net.Uri; +import android.provider.BlockedNumberContract; +import android.provider.BlockedNumberContract.BlockedNumbers; import android.test.InstrumentationTestCase; import android.test.mock.MockContentResolver; +import android.test.suitebuilder.annotation.SmallTest; +import com.android.contacts.common.compat.CompatUtils; import com.android.contacts.common.test.mocks.MockContentProvider; import com.android.contacts.common.test.mocks.MockContentProvider.Query; +import com.android.dialer.compat.FilteredNumberCompat; import com.android.dialer.database.FilteredNumberAsyncQueryHandler.OnBlockNumberListener; import com.android.dialer.database.FilteredNumberAsyncQueryHandler.OnCheckBlockedListener; import com.android.dialer.database.FilteredNumberAsyncQueryHandler.OnHasBlockedNumbersListener; @@ -33,14 +38,19 @@ import com.android.dialer.database.FilteredNumberContract.FilteredNumberTypes; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; +@SmallTest public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase { private static final String E164_NUMBER = "+16502530000"; private static final String NUMBER = "6502530000"; private static final String COUNTRY_ISO = "US"; private static final Integer ID = 1; - private static final Uri BLOCKED_NUMBER_URI = + private static final Uri BLOCKED_NUMBER_URI_N = CompatUtils.isNCompatible() ? + Uri.withAppendedPath(BlockedNumberContract.AUTHORITY_URI, "blocked") : null; + private static final Uri BLOCKED_NUMBER_URI_M = Uri.withAppendedPath(FilteredNumberContract.AUTHORITY_URI, "filtered_numbers_table"); + private static final Uri BLOCKED_NUMBER_URI = CompatUtils.isNCompatible() ? BLOCKED_NUMBER_URI_N + : BLOCKED_NUMBER_URI_M; private static final Uri EXPECTED_URI = Uri.fromParts("android", "google", "dialer"); private final MockContentResolver mContentResolver = new MockContentResolver(); @@ -49,40 +59,39 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase @Override public void setUp() throws Exception { super.setUp(); - mContentResolver.addProvider(FilteredNumberContract.AUTHORITY, mContentProvider); + FilteredNumberCompat.setIsEnabledForTest(true); + if (CompatUtils.isNCompatible()) { + mContentResolver.addProvider(BlockedNumberContract.AUTHORITY, mContentProvider); + } else { + mContentResolver.addProvider(FilteredNumberContract.AUTHORITY, mContentProvider); + } } - public void testIsBlockedNumber_NoResults() throws Throwable { - newIsBlockedNumberExpectedQueryM().returnEmptyCursor(); - final CheckBlockedListener listener = new CheckBlockedListener(); + public void testHasBlockedNumbers_Disabled() throws Throwable { + if (!CompatUtils.isNCompatible()) { + return; + } + FilteredNumberCompat.setIsEnabledForTest(false); + final MockContentResolver resolver = new MockContentResolver(); + MockContentProvider disabledProvider = new MockContentProvider(); + resolver.addProvider(FilteredNumberContract.AUTHORITY, disabledProvider); + disabledProvider.expectQuery(BLOCKED_NUMBER_URI_M).withProjection(FilteredNumberColumns._ID) + .withSelection(FilteredNumberColumns.TYPE + "=" + + FilteredNumberTypes.BLOCKED_NUMBER, null).returnRow(ID); + final HasBlockedNumbersListener listener = new HasBlockedNumbersListener(); runTestOnUiThread(new Runnable() { @Override public void run() { - new FilteredNumberAsyncQueryHandler(mContentResolver) - .isBlockedNumber(listener, NUMBER, COUNTRY_ISO); + new FilteredNumberAsyncQueryHandler(resolver).hasBlockedNumbers(listener); } }); - assertNull(listener.waitForCallback()); - mContentProvider.verify(); - } - - public void testIsBlockedNumber() throws Throwable { - newIsBlockedNumberExpectedQueryM().returnRow(ID, FilteredNumberTypes.BLOCKED_NUMBER); - final CheckBlockedListener listener = new CheckBlockedListener(); - runTestOnUiThread(new Runnable() { - @Override - public void run() { - new FilteredNumberAsyncQueryHandler(mContentResolver) - .isBlockedNumber(listener, NUMBER, COUNTRY_ISO); - } - }); - assertEquals(ID, listener.waitForCallback()); - mContentProvider.verify(); + assertTrue(listener.waitForCallback()); + disabledProvider.verify(); } public void testHasBlockedNumbers_NoResults() throws Throwable { - newHasBlockedNumbersExpectedQueryM().returnEmptyCursor(); + newHasBlockedNumbersExpectedQuery().returnEmptyCursor(); final HasBlockedNumbersListener listener = new HasBlockedNumbersListener(); runTestOnUiThread(new Runnable() { @Override @@ -95,7 +104,7 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase } public void testHasBlockedNumbers() throws Throwable { - newHasBlockedNumbersExpectedQueryM().returnRow(ID); + newHasBlockedNumbersExpectedQuery().returnRow(ID); final HasBlockedNumbersListener listener = new HasBlockedNumbersListener(); runTestOnUiThread(new Runnable() { @Override @@ -107,24 +116,90 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase mContentProvider.verify(); } - private Query newIsBlockedNumberExpectedQueryM() { - return mContentProvider.expectQuery(BLOCKED_NUMBER_URI) + public void testIsBlockedNumber_Disabled() throws Throwable { + if (!CompatUtils.isNCompatible()) { + return; + } + FilteredNumberCompat.setIsEnabledForTest(false); + final MockContentResolver resolver = new MockContentResolver(); + MockContentProvider disabledProvider = new MockContentProvider(); + resolver.addProvider(FilteredNumberContract.AUTHORITY, disabledProvider); + disabledProvider.expectQuery(BLOCKED_NUMBER_URI_M) .withProjection(FilteredNumberColumns._ID, FilteredNumberColumns.TYPE) - .withSelection(FilteredNumberColumns.NORMALIZED_NUMBER + " = ?", E164_NUMBER); + .withSelection(FilteredNumberColumns.NORMALIZED_NUMBER + " = ?", E164_NUMBER) + .returnRow(ID, FilteredNumberTypes.BLOCKED_NUMBER); + final CheckBlockedListener listener = new CheckBlockedListener(); + runTestOnUiThread(new Runnable() { + @Override + public void run() { + new FilteredNumberAsyncQueryHandler(resolver) + .isBlockedNumber(listener, NUMBER, COUNTRY_ISO); + } + }); + assertEquals(ID, listener.waitForCallback()); + mContentProvider.verify(); } - private Query newHasBlockedNumbersExpectedQueryM() { - return mContentProvider.expectQuery(BLOCKED_NUMBER_URI).withProjection( - FilteredNumberColumns._ID) - .withSelection(FilteredNumberColumns.TYPE + "=" - + FilteredNumberTypes.BLOCKED_NUMBER, null); + public void testIsBlockedNumber_NoResults() throws Throwable { + newIsBlockedNumberExpectedQuery().returnEmptyCursor(); + final CheckBlockedListener listener = new CheckBlockedListener(); + + runTestOnUiThread(new Runnable() { + @Override + public void run() { + new FilteredNumberAsyncQueryHandler(mContentResolver) + .isBlockedNumber(listener, NUMBER, COUNTRY_ISO); + } + }); + assertNull(listener.waitForCallback()); + mContentProvider.verify(); + } + + public void testIsBlockedNumber() throws Throwable { + if (CompatUtils.isNCompatible()) { + newIsBlockedNumberExpectedQuery().returnRow(ID); + } else { + newIsBlockedNumberExpectedQuery().returnRow(ID, FilteredNumberTypes.BLOCKED_NUMBER); + } + final CheckBlockedListener listener = new CheckBlockedListener(); + runTestOnUiThread(new Runnable() { + @Override + public void run() { + new FilteredNumberAsyncQueryHandler(mContentResolver) + .isBlockedNumber(listener, NUMBER, COUNTRY_ISO); + } + }); + assertEquals(ID, listener.waitForCallback()); + mContentProvider.verify(); + } + + public void testBlockNumber_Disabled() throws Throwable { + if (!CompatUtils.isNCompatible()) { + return; + } + FilteredNumberCompat.setIsEnabledForTest(false); + final MockContentResolver resolver = new MockContentResolver(); + MockContentProvider disabledProvider = new MockContentProvider(); + resolver.addProvider(FilteredNumberContract.AUTHORITY, disabledProvider); + + disabledProvider.expectInsert(BLOCKED_NUMBER_URI_M, newBlockNumberContentValuesM(), + EXPECTED_URI); + final BlockNumberListener listener = new BlockNumberListener(); + runTestOnUiThread(new Runnable() { + @Override + public void run() { + new FilteredNumberAsyncQueryHandler(resolver).blockNumber(listener, E164_NUMBER, + NUMBER, COUNTRY_ISO); + } + }); + assertSame(EXPECTED_URI, listener.waitForCallback()); + disabledProvider.verify(); } public void testBlockNumber() throws Throwable { mContentProvider.expectInsert(BLOCKED_NUMBER_URI, newBlockNumberContentValues(), EXPECTED_URI); - final BlockingArgumentCaptorOnBlockNumberListener listener = - new BlockingArgumentCaptorOnBlockNumberListener(); + final BlockNumberListener listener = new BlockNumberListener(); runTestOnUiThread(new Runnable() { @Override public void run() { @@ -132,16 +207,14 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase E164_NUMBER, NUMBER, COUNTRY_ISO); } }); - assertTrue(listener.onBlockCompleteCalled.await(5000, TimeUnit.MILLISECONDS)); - assertSame(EXPECTED_URI, listener.uri); + assertSame(EXPECTED_URI, listener.waitForCallback()); mContentProvider.verify(); } public void testBlockNumber_NullNormalizedNumber() throws Throwable { mContentProvider.expectInsert(BLOCKED_NUMBER_URI, newBlockNumberContentValues(), EXPECTED_URI); - final BlockingArgumentCaptorOnBlockNumberListener listener = - new BlockingArgumentCaptorOnBlockNumberListener(); + final BlockNumberListener listener = new BlockNumberListener(); runTestOnUiThread(new Runnable() { @Override public void run() { @@ -149,12 +222,63 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase NUMBER, COUNTRY_ISO); } }); - assertTrue(listener.onBlockCompleteCalled.await(5000, TimeUnit.MILLISECONDS)); - assertSame(EXPECTED_URI, listener.uri); + assertSame(EXPECTED_URI, listener.waitForCallback()); mContentProvider.verify(); } + private Query newIsBlockedNumberExpectedQuery() { + if (CompatUtils.isNCompatible()) { + return newIsBlockedNumberExpectedQueryN(); + } + return newIsBlockedNumberExpectedQueryM(); + } + + private Query newIsBlockedNumberExpectedQueryN() { + return mContentProvider.expectQuery(BLOCKED_NUMBER_URI) + .withProjection(BlockedNumbers.COLUMN_ID) + .withSelection(BlockedNumbers.COLUMN_E164_NUMBER + " = ?", E164_NUMBER); + } + + private Query newIsBlockedNumberExpectedQueryM() { + return mContentProvider.expectQuery(BLOCKED_NUMBER_URI) + .withProjection(FilteredNumberColumns._ID, FilteredNumberColumns.TYPE) + .withSelection(FilteredNumberColumns.NORMALIZED_NUMBER + " = ?", E164_NUMBER); + } + + private Query newHasBlockedNumbersExpectedQuery() { + if (CompatUtils.isNCompatible()) { + return newHasBlockedNumbersExpectedQueryN(); + } + return newHasBlockedNumbersExpectedQueryM(); + } + + private Query newHasBlockedNumbersExpectedQueryN() { + return mContentProvider.expectQuery(BLOCKED_NUMBER_URI) + .withProjection(BlockedNumbers.COLUMN_ID) + .withSelection(null, null); + } + + private Query newHasBlockedNumbersExpectedQueryM() { + return mContentProvider.expectQuery(BLOCKED_NUMBER_URI).withProjection( + FilteredNumberColumns._ID) + .withSelection(FilteredNumberColumns.TYPE + "=" + + FilteredNumberTypes.BLOCKED_NUMBER, null); + } + private ContentValues newBlockNumberContentValues() { + if (CompatUtils.isNCompatible()) { + return newBlockNumberContentValuesN(); + } + return newBlockNumberContentValuesM(); + } + + private ContentValues newBlockNumberContentValuesN() { + ContentValues contentValues = new ContentValues(); + contentValues.put(BlockedNumbers.COLUMN_ORIGINAL_NUMBER, NUMBER); + return contentValues; + } + + private ContentValues newBlockNumberContentValuesM() { ContentValues contentValues = new ContentValues(); contentValues.put(FilteredNumberColumns.NORMALIZED_NUMBER, E164_NUMBER); contentValues.put(FilteredNumberColumns.NUMBER, NUMBER); @@ -208,11 +332,11 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase } } - private class BlockingArgumentCaptorOnBlockNumberListener implements OnBlockNumberListener { + private class BlockNumberListener implements OnBlockNumberListener { public final CountDownLatch onBlockCompleteCalled; public Uri uri; - public BlockingArgumentCaptorOnBlockNumberListener() { + public BlockNumberListener() { onBlockCompleteCalled = new CountDownLatch(1); } @@ -221,5 +345,12 @@ public class FilteredNumberAsyncQueryHandlerTest extends InstrumentationTestCase this.uri = uri; onBlockCompleteCalled.countDown(); } + + public Uri waitForCallback() throws InterruptedException { + if (!onBlockCompleteCalled.await(5000, TimeUnit.MILLISECONDS)) { + throw new IllegalStateException("Waiting on callback timed out."); + } + return uri; + } } } -- cgit v1.2.3