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