1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License 15 */ 16 17 package com.android.server.telecom.tests; 18 19 import android.content.ContentResolver; 20 import android.content.IContentProvider; 21 import android.net.Uri; 22 import android.test.suitebuilder.annotation.SmallTest; 23 24 import com.android.server.telecom.Call; 25 import com.android.server.telecom.Timeouts; 26 import com.android.server.telecom.callfiltering.CallFilterResultCallback; 27 import com.android.server.telecom.callfiltering.CallFilteringResult; 28 import com.android.server.telecom.callfiltering.IncomingCallFilter; 29 import com.android.server.telecom.TelecomSystem; 30 31 import org.junit.Before; 32 import org.junit.Test; 33 import org.junit.runner.RunWith; 34 import org.junit.runners.JUnit4; 35 import org.mockito.Mock; 36 37 import java.util.ArrayList; 38 import java.util.Collections; 39 import java.util.List; 40 41 import static org.junit.Assert.assertEquals; 42 import static org.mockito.Matchers.any; 43 import static org.mockito.Matchers.eq; 44 import static org.mockito.Mockito.atMost; 45 import static org.mockito.Mockito.timeout; 46 import static org.mockito.Mockito.verify; 47 import static org.mockito.Mockito.when; 48 49 @RunWith(JUnit4.class) 50 public class IncomingCallFilterTest extends TelecomTestCase { 51 @Mock private CallFilterResultCallback mResultCallback; 52 @Mock private Call mCall; 53 private final TelecomSystem.SyncRoot mLock = new TelecomSystem.SyncRoot() {}; 54 55 @Mock private IncomingCallFilter.CallFilter mFilter1; 56 @Mock private IncomingCallFilter.CallFilter mFilter2; 57 @Mock private IncomingCallFilter.CallFilter mFilter3; 58 59 @Mock private Timeouts.Adapter mTimeoutsAdapter; 60 61 private static final Uri TEST_HANDLE = Uri.parse("tel:1235551234"); 62 private static final long LONG_TIMEOUT = 1000000; 63 private static final long SHORT_TIMEOUT = 100; 64 65 private static final CallFilteringResult RESULT1 = 66 new CallFilteringResult( 67 true, // shouldAllowCall 68 false, // shouldReject 69 true, // shouldAddToCallLog 70 true // shouldShowNotification 71 ); 72 73 private static final CallFilteringResult RESULT2 = 74 new CallFilteringResult( 75 false, // shouldAllowCall 76 true, // shouldReject 77 false, // shouldAddToCallLog 78 true // shouldShowNotification 79 ); 80 81 private static final CallFilteringResult RESULT3 = 82 new CallFilteringResult( 83 false, // shouldAllowCall 84 true, // shouldReject 85 true, // shouldAddToCallLog 86 false // shouldShowNotification 87 ); 88 89 private static final CallFilteringResult DEFAULT_RESULT = RESULT1; 90 91 @Override 92 @Before 93 public void setUp() throws Exception { 94 super.setUp(); 95 mContext = mComponentContextFixture.getTestDouble().getApplicationContext(); 96 when(mCall.getHandle()).thenReturn(TEST_HANDLE); 97 setTimeoutLength(LONG_TIMEOUT); 98 } 99 100 @SmallTest 101 @Test 102 public void testSingleFilter() { 103 IncomingCallFilter testFilter = new IncomingCallFilter(mContext, mResultCallback, mCall, 104 mLock, mTimeoutsAdapter, Collections.singletonList(mFilter1)); 105 testFilter.performFiltering(); 106 verify(mFilter1).startFilterLookup(mCall, testFilter); 107 108 testFilter.onCallFilteringComplete(mCall, RESULT1); 109 waitForHandlerAction(testFilter.getHandler(), SHORT_TIMEOUT * 2); 110 verify(mResultCallback).onCallFilteringComplete(eq(mCall), eq(RESULT1)); 111 } 112 113 @SmallTest 114 @Test 115 public void testMultipleFilters() { 116 List<IncomingCallFilter.CallFilter> filters = 117 new ArrayList<IncomingCallFilter.CallFilter>() {{ 118 add(mFilter1); 119 add(mFilter2); 120 add(mFilter3); 121 }}; 122 IncomingCallFilter testFilter = new IncomingCallFilter(mContext, mResultCallback, mCall, 123 mLock, mTimeoutsAdapter, filters); 124 testFilter.performFiltering(); 125 verify(mFilter1).startFilterLookup(mCall, testFilter); 126 verify(mFilter2).startFilterLookup(mCall, testFilter); 127 verify(mFilter3).startFilterLookup(mCall, testFilter); 128 129 testFilter.onCallFilteringComplete(mCall, RESULT1); 130 testFilter.onCallFilteringComplete(mCall, RESULT2); 131 testFilter.onCallFilteringComplete(mCall, RESULT3); 132 waitForHandlerAction(testFilter.getHandler(), SHORT_TIMEOUT * 2); 133 verify(mResultCallback).onCallFilteringComplete(eq(mCall), eq( 134 new CallFilteringResult( 135 false, // shouldAllowCall 136 true, // shouldReject 137 false, // shouldAddToCallLog 138 false // shouldShowNotification 139 ))); 140 } 141 142 @SmallTest 143 @Test 144 public void testFilterTimeout() throws Exception { 145 setTimeoutLength(SHORT_TIMEOUT); 146 IncomingCallFilter testFilter = new IncomingCallFilter(mContext, mResultCallback, mCall, 147 mLock, mTimeoutsAdapter, Collections.singletonList(mFilter1)); 148 testFilter.performFiltering(); 149 verify(mResultCallback, timeout((int) SHORT_TIMEOUT * 2)).onCallFilteringComplete(eq(mCall), 150 eq(DEFAULT_RESULT)); 151 testFilter.onCallFilteringComplete(mCall, RESULT1); 152 waitForHandlerAction(testFilter.getHandler(), SHORT_TIMEOUT * 2); 153 // verify that we don't report back again with the result 154 verify(mResultCallback, atMost(1)).onCallFilteringComplete(any(Call.class), 155 any(CallFilteringResult.class)); 156 } 157 158 @SmallTest 159 @Test 160 public void testFilterTimeoutDoesntTrip() throws Exception { 161 setTimeoutLength(SHORT_TIMEOUT); 162 IncomingCallFilter testFilter = new IncomingCallFilter(mContext, mResultCallback, mCall, 163 mLock, mTimeoutsAdapter, Collections.singletonList(mFilter1)); 164 testFilter.performFiltering(); 165 testFilter.onCallFilteringComplete(mCall, RESULT1); 166 waitForHandlerAction(testFilter.getHandler(), SHORT_TIMEOUT * 2); 167 Thread.sleep(SHORT_TIMEOUT); 168 verify(mResultCallback, atMost(1)).onCallFilteringComplete(any(Call.class), 169 any(CallFilteringResult.class)); 170 } 171 172 @SmallTest 173 @Test 174 public void testToString() { 175 assertEquals("[Allow, logged, notified]", RESULT1.toString()); 176 assertEquals("[Reject, notified]", RESULT2.toString()); 177 assertEquals("[Reject, logged]", RESULT3.toString()); 178 } 179 180 private void setTimeoutLength(long length) throws Exception { 181 when(mTimeoutsAdapter.getCallScreeningTimeoutMillis(any(ContentResolver.class))) 182 .thenReturn(length); 183 } 184 } 185
