NetworkPolicyManagerServiceTest.java revision 9599cc5f21152860af9d18015b1398b50743da76 
1/*
2 * Copyright (C) 2011 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;
18
19import static android.net.NetworkPolicyManager.POLICY_NONE;
20import static android.net.NetworkPolicyManager.POLICY_REJECT_PAID_BACKGROUND;
21import static android.net.NetworkPolicyManager.RULE_ALLOW_ALL;
22import static android.net.NetworkPolicyManager.RULE_REJECT_PAID;
23import static org.easymock.EasyMock.capture;
24import static org.easymock.EasyMock.createMock;
25import static org.easymock.EasyMock.eq;
26import static org.easymock.EasyMock.expect;
27import static org.easymock.EasyMock.expectLastCall;
28
29import android.app.IActivityManager;
30import android.app.IProcessObserver;
31import android.content.Intent;
32import android.content.pm.PackageManager;
33import android.net.ConnectivityManager;
34import android.net.INetworkPolicyListener;
35import android.os.Binder;
36import android.os.IPowerManager;
37import android.test.AndroidTestCase;
38import android.test.mock.MockPackageManager;
39import android.test.suitebuilder.annotation.LargeTest;
40import android.test.suitebuilder.annotation.Suppress;
41
42import com.android.server.net.NetworkPolicyManagerService;
43
44import org.easymock.Capture;
45import org.easymock.EasyMock;
46
47import java.util.concurrent.Future;
48
49/**
50 * Tests for {@link NetworkPolicyManagerService}.
51 */
52@LargeTest
53public class NetworkPolicyManagerServiceTest extends AndroidTestCase {
54    private static final String TAG = "NetworkPolicyManagerServiceTest";
55
56    private BroadcastInterceptingContext mServiceContext;
57
58    private IActivityManager mActivityManager;
59    private IPowerManager mPowerManager;
60    private INetworkPolicyListener mPolicyListener;
61
62    private NetworkPolicyManagerService mService;
63    private IProcessObserver mProcessObserver;
64
65    private Binder mStubBinder = new Binder();
66
67    private static final int UID_A = 800;
68    private static final int UID_B = 801;
69
70    private static final int PID_1 = 400;
71    private static final int PID_2 = 401;
72    private static final int PID_3 = 402;
73
74    @Override
75    public void setUp() throws Exception {
76        super.setUp();
77
78        // intercept various broadcasts, and pretend that uids have packages
79        mServiceContext = new BroadcastInterceptingContext(getContext()) {
80            @Override
81            public PackageManager getPackageManager() {
82                return new MockPackageManager() {
83                    @Override
84                    public String[] getPackagesForUid(int uid) {
85                        return new String[] { "com.example" };
86                    }
87                };
88            }
89        };
90
91        mActivityManager = createMock(IActivityManager.class);
92        mPowerManager = createMock(IPowerManager.class);
93        mPolicyListener = createMock(INetworkPolicyListener.class);
94
95        mService = new NetworkPolicyManagerService(
96                mServiceContext, mActivityManager, mPowerManager);
97
98        // RemoteCallbackList needs a binder to use as key
99        expect(mPolicyListener.asBinder()).andReturn(mStubBinder).atLeastOnce();
100        replay();
101        mService.registerListener(mPolicyListener);
102        verifyAndReset();
103
104        // catch the registered IProcessObserver during systemReady()
105        final Capture<IProcessObserver> processObserver = new Capture<IProcessObserver>();
106        mActivityManager.registerProcessObserver(capture(processObserver));
107        expectLastCall().atLeastOnce();
108
109        // expect to answer screen status during systemReady()
110        expect(mPowerManager.isScreenOn()).andReturn(true).atLeastOnce();
111
112        replay();
113        mService.systemReady();
114        verifyAndReset();
115
116        mProcessObserver = processObserver.getValue();
117
118    }
119
120    @Override
121    public void tearDown() throws Exception {
122        mServiceContext = null;
123
124        mActivityManager = null;
125        mPowerManager = null;
126        mPolicyListener = null;
127
128        mService = null;
129        mProcessObserver = null;
130
131        super.tearDown();
132    }
133
134    @Suppress
135    public void testPolicyChangeTriggersBroadcast() throws Exception {
136        mService.setUidPolicy(UID_A, POLICY_NONE);
137
138        // change background policy and expect broadcast
139        final Future<Intent> backgroundChanged = mServiceContext.nextBroadcastIntent(
140                ConnectivityManager.ACTION_BACKGROUND_DATA_SETTING_CHANGED);
141
142        mService.setUidPolicy(UID_A, POLICY_REJECT_PAID_BACKGROUND);
143
144        backgroundChanged.get();
145    }
146
147    public void testPidForegroundCombined() throws Exception {
148        // push all uid into background
149        mProcessObserver.onForegroundActivitiesChanged(PID_1, UID_A, false);
150        mProcessObserver.onForegroundActivitiesChanged(PID_2, UID_A, false);
151        mProcessObserver.onForegroundActivitiesChanged(PID_3, UID_B, false);
152        assertFalse(mService.isUidForeground(UID_A));
153        assertFalse(mService.isUidForeground(UID_B));
154
155        // push one of the shared pids into foreground
156        mProcessObserver.onForegroundActivitiesChanged(PID_2, UID_A, true);
157        assertTrue(mService.isUidForeground(UID_A));
158        assertFalse(mService.isUidForeground(UID_B));
159
160        // and swap another uid into foreground
161        mProcessObserver.onForegroundActivitiesChanged(PID_2, UID_A, false);
162        mProcessObserver.onForegroundActivitiesChanged(PID_3, UID_B, true);
163        assertFalse(mService.isUidForeground(UID_A));
164        assertTrue(mService.isUidForeground(UID_B));
165
166        // push both pid into foreground
167        mProcessObserver.onForegroundActivitiesChanged(PID_1, UID_A, true);
168        mProcessObserver.onForegroundActivitiesChanged(PID_2, UID_A, true);
169        assertTrue(mService.isUidForeground(UID_A));
170
171        // pull one out, should still be foreground
172        mProcessObserver.onForegroundActivitiesChanged(PID_1, UID_A, false);
173        assertTrue(mService.isUidForeground(UID_A));
174
175        // pull final pid out, should now be background
176        mProcessObserver.onForegroundActivitiesChanged(PID_2, UID_A, false);
177        assertFalse(mService.isUidForeground(UID_A));
178    }
179
180    public void testScreenChangesRules() throws Exception {
181        // push strict policy for foreground uid, verify ALLOW rule
182        expectRulesChanged(UID_A, RULE_ALLOW_ALL);
183        replay();
184        mProcessObserver.onForegroundActivitiesChanged(PID_1, UID_A, true);
185        mService.setUidPolicy(UID_A, POLICY_REJECT_PAID_BACKGROUND);
186        verifyAndReset();
187
188        // now turn screen off and verify REJECT rule
189        expect(mPowerManager.isScreenOn()).andReturn(false).atLeastOnce();
190        expectRulesChanged(UID_A, RULE_REJECT_PAID);
191        replay();
192        mServiceContext.sendBroadcast(new Intent(Intent.ACTION_SCREEN_OFF));
193        verifyAndReset();
194
195        // and turn screen back on, verify ALLOW rule restored
196        expect(mPowerManager.isScreenOn()).andReturn(true).atLeastOnce();
197        expectRulesChanged(UID_A, RULE_ALLOW_ALL);
198        replay();
199        mServiceContext.sendBroadcast(new Intent(Intent.ACTION_SCREEN_ON));
200        verifyAndReset();
201    }
202
203    public void testPolicyNone() throws Exception {
204        // POLICY_NONE should RULE_ALLOW in foreground
205        expectRulesChanged(UID_A, RULE_ALLOW_ALL);
206        replay();
207        mService.setUidPolicy(UID_A, POLICY_NONE);
208        mProcessObserver.onForegroundActivitiesChanged(PID_1, UID_A, true);
209        verifyAndReset();
210
211        // POLICY_NONE should RULE_ALLOW in background
212        expectRulesChanged(UID_A, RULE_ALLOW_ALL);
213        replay();
214        mProcessObserver.onForegroundActivitiesChanged(PID_1, UID_A, false);
215        verifyAndReset();
216    }
217
218    public void testPolicyReject() throws Exception {
219        // POLICY_REJECT should RULE_ALLOW in background
220        expectRulesChanged(UID_A, RULE_REJECT_PAID);
221        replay();
222        mService.setUidPolicy(UID_A, POLICY_REJECT_PAID_BACKGROUND);
223        verifyAndReset();
224
225        // POLICY_REJECT should RULE_ALLOW in foreground
226        expectRulesChanged(UID_A, RULE_ALLOW_ALL);
227        replay();
228        mProcessObserver.onForegroundActivitiesChanged(PID_1, UID_A, true);
229        verifyAndReset();
230
231        // POLICY_REJECT should RULE_REJECT in background
232        expectRulesChanged(UID_A, RULE_REJECT_PAID);
233        replay();
234        mProcessObserver.onForegroundActivitiesChanged(PID_1, UID_A, false);
235        verifyAndReset();
236    }
237
238    public void testPolicyRejectAddRemove() throws Exception {
239        // POLICY_NONE should have RULE_ALLOW in background
240        expectRulesChanged(UID_A, RULE_ALLOW_ALL);
241        replay();
242        mService.setUidPolicy(UID_A, POLICY_NONE);
243        mProcessObserver.onForegroundActivitiesChanged(PID_1, UID_A, false);
244        verifyAndReset();
245
246        // adding POLICY_REJECT should cause RULE_REJECT
247        expectRulesChanged(UID_A, RULE_REJECT_PAID);
248        replay();
249        mService.setUidPolicy(UID_A, POLICY_REJECT_PAID_BACKGROUND);
250        verifyAndReset();
251
252        // removing POLICY_REJECT should return us to RULE_ALLOW
253        expectRulesChanged(UID_A, RULE_ALLOW_ALL);
254        replay();
255        mService.setUidPolicy(UID_A, POLICY_NONE);
256        verifyAndReset();
257    }
258
259    private void expectRulesChanged(int uid, int policy) throws Exception {
260        mPolicyListener.onRulesChanged(eq(uid), eq(policy));
261        expectLastCall().atLeastOnce();
262    }
263
264    private void replay() {
265        EasyMock.replay(mActivityManager, mPowerManager, mPolicyListener);
266    }
267
268    private void verifyAndReset() {
269        EasyMock.verify(mActivityManager, mPowerManager, mPolicyListener);
270        EasyMock.reset(mActivityManager, mPowerManager, mPolicyListener);
271    }
272}
273