IncomingCallFilterTest.java revision 6d4b66df3d918e3f17263ff40ca3ba0ec5a46719 
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
17package com.android.server.telecom.tests;
18
19import android.content.ContentResolver;
20import android.content.IContentProvider;
21import android.net.Uri;
22import android.test.suitebuilder.annotation.SmallTest;
23
24import com.android.server.telecom.Call;
25import com.android.server.telecom.Timeouts;
26import com.android.server.telecom.callfiltering.CallFilterResultCallback;
27import com.android.server.telecom.callfiltering.CallFilteringResult;
28import com.android.server.telecom.callfiltering.IncomingCallFilter;
29import com.android.server.telecom.TelecomSystem;
30
31import org.mockito.Mock;
32
33import java.util.ArrayList;
34import java.util.Collections;
35import java.util.List;
36
37import static org.mockito.Matchers.any;
38import static org.mockito.Matchers.eq;
39import static org.mockito.Mockito.atMost;
40import static org.mockito.Mockito.timeout;
41import static org.mockito.Mockito.verify;
42import static org.mockito.Mockito.when;
43
44public class IncomingCallFilterTest extends TelecomTestCase {
45    @Mock private CallFilterResultCallback mResultCallback;
46    @Mock private Call mCall;
47    private final TelecomSystem.SyncRoot mLock = new TelecomSystem.SyncRoot() {};
48
49    @Mock private IncomingCallFilter.CallFilter mFilter1;
50    @Mock private IncomingCallFilter.CallFilter mFilter2;
51    @Mock private IncomingCallFilter.CallFilter mFilter3;
52
53    @Mock private Timeouts.Adapter mTimeoutsAdapter;
54
55    private static final Uri TEST_HANDLE = Uri.parse("tel:1235551234");
56    private static final long LONG_TIMEOUT = 1000000;
57    private static final long SHORT_TIMEOUT = 100;
58
59    private static final CallFilteringResult RESULT1 =
60            new CallFilteringResult(
61                    true, // shouldAllowCall
62                    false, // shouldReject
63                    true, // shouldAddToCallLog
64                    true // shouldShowNotification
65            );
66
67    private static final CallFilteringResult RESULT2 =
68            new CallFilteringResult(
69                    false, // shouldAllowCall
70                    true, // shouldReject
71                    false, // shouldAddToCallLog
72                    true // shouldShowNotification
73            );
74
75    private static final CallFilteringResult RESULT3 =
76            new CallFilteringResult(
77                    false, // shouldAllowCall
78                    true, // shouldReject
79                    true, // shouldAddToCallLog
80                    false // shouldShowNotification
81            );
82
83    private static final CallFilteringResult DEFAULT_RESULT = RESULT1;
84
85    public void setUp() throws Exception {
86        super.setUp();
87        mContext = mComponentContextFixture.getTestDouble().getApplicationContext();
88        when(mCall.getHandle()).thenReturn(TEST_HANDLE);
89        setTimeoutLength(LONG_TIMEOUT);
90    }
91
92    @SmallTest
93    public void testSingleFilter() {
94        IncomingCallFilter testFilter = new IncomingCallFilter(mContext, mResultCallback, mCall,
95                mLock, mTimeoutsAdapter, Collections.singletonList(mFilter1));
96        testFilter.performFiltering();
97        verify(mFilter1).startFilterLookup(mCall, testFilter);
98
99        testFilter.onCallFilteringComplete(mCall, RESULT1);
100        waitForHandlerAction(testFilter.getHandler(), SHORT_TIMEOUT * 2);
101        verify(mResultCallback).onCallFilteringComplete(eq(mCall), eq(RESULT1));
102    }
103
104    @SmallTest
105    public void testMultipleFilters() {
106        List<IncomingCallFilter.CallFilter> filters =
107                new ArrayList<IncomingCallFilter.CallFilter>() {{
108                    add(mFilter1);
109                    add(mFilter2);
110                    add(mFilter3);
111                }};
112        IncomingCallFilter testFilter = new IncomingCallFilter(mContext, mResultCallback, mCall,
113                mLock, mTimeoutsAdapter, filters);
114        testFilter.performFiltering();
115        verify(mFilter1).startFilterLookup(mCall, testFilter);
116        verify(mFilter2).startFilterLookup(mCall, testFilter);
117        verify(mFilter3).startFilterLookup(mCall, testFilter);
118
119        testFilter.onCallFilteringComplete(mCall, RESULT1);
120        testFilter.onCallFilteringComplete(mCall, RESULT2);
121        testFilter.onCallFilteringComplete(mCall, RESULT3);
122        waitForHandlerAction(testFilter.getHandler(), SHORT_TIMEOUT * 2);
123        verify(mResultCallback).onCallFilteringComplete(eq(mCall), eq(
124                new CallFilteringResult(
125                        false, // shouldAllowCall
126                        true, // shouldReject
127                        false, // shouldAddToCallLog
128                        false // shouldShowNotification
129                )));
130    }
131
132    @SmallTest
133    public void testFilterTimeout() throws Exception {
134        setTimeoutLength(SHORT_TIMEOUT);
135        IncomingCallFilter testFilter = new IncomingCallFilter(mContext, mResultCallback, mCall,
136                mLock, mTimeoutsAdapter, Collections.singletonList(mFilter1));
137        testFilter.performFiltering();
138        verify(mResultCallback, timeout((int) SHORT_TIMEOUT * 2)).onCallFilteringComplete(eq(mCall),
139                eq(DEFAULT_RESULT));
140        testFilter.onCallFilteringComplete(mCall, RESULT1);
141        waitForHandlerAction(testFilter.getHandler(), SHORT_TIMEOUT * 2);
142        // verify that we don't report back again with the result
143        verify(mResultCallback, atMost(1)).onCallFilteringComplete(any(Call.class),
144                any(CallFilteringResult.class));
145    }
146
147    @SmallTest
148    public void testFilterTimeoutDoesntTrip() throws Exception {
149        setTimeoutLength(SHORT_TIMEOUT);
150        IncomingCallFilter testFilter = new IncomingCallFilter(mContext, mResultCallback, mCall,
151                mLock, mTimeoutsAdapter, Collections.singletonList(mFilter1));
152        testFilter.performFiltering();
153        testFilter.onCallFilteringComplete(mCall, RESULT1);
154        waitForHandlerAction(testFilter.getHandler(), SHORT_TIMEOUT * 2);
155        Thread.sleep(SHORT_TIMEOUT);
156        verify(mResultCallback, atMost(1)).onCallFilteringComplete(any(Call.class),
157                any(CallFilteringResult.class));
158    }
159
160    @SmallTest
161    public void testToString() {
162        assertEquals("[Allow, logged, notified]", RESULT1.toString());
163        assertEquals("[Reject, notified]", RESULT2.toString());
164        assertEquals("[Reject, logged]", RESULT3.toString());
165    }
166
167    private void setTimeoutLength(long length) throws Exception {
168        when(mTimeoutsAdapter.getCallScreeningTimeoutMillis(any(ContentResolver.class)))
169                .thenReturn(length);
170    }
171}
172