1 /*
2  * Copyright (C) 2023 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.pm;
18 
19 import static junit.framework.Assert.assertEquals;
20 
21 import static org.mockito.Mockito.doReturn;
22 import static org.mockito.Mockito.spy;
23 import static org.mockito.Mockito.when;
24 
25 import static java.io.FileDescriptor.err;
26 import static java.io.FileDescriptor.in;
27 import static java.io.FileDescriptor.out;
28 
29 import android.app.PropertyInvalidatedCache;
30 import android.content.Context;
31 import android.os.Binder;
32 import android.os.Handler;
33 import android.os.Looper;
34 import android.os.ResultReceiver;
35 import android.os.ShellCallback;
36 import android.os.UserHandle;
37 import android.platform.test.annotations.Presubmit;
38 import android.util.ArrayMap;
39 
40 import androidx.test.InstrumentationRegistry;
41 import androidx.test.runner.AndroidJUnit4;
42 
43 import com.android.internal.widget.LockPatternUtils;
44 import com.android.server.LocalServices;
45 
46 import org.junit.Before;
47 import org.junit.Test;
48 import org.junit.runner.RunWith;
49 import org.mockito.Mock;
50 import org.mockito.MockitoAnnotations;
51 
52 import java.io.ByteArrayOutputStream;
53 import java.io.PrintStream;
54 import java.io.PrintWriter;
55 
56 /**
57  * Test class for {@link UserManagerServiceShellCommand}.
58  *
59  * runtest atest UserManagerServiceShellCommandTest
60  */
61 @Presubmit
62 @RunWith(AndroidJUnit4.class)
63 public class UserManagerServiceShellCommandTest {
64 
65     private UserManagerServiceShellCommand mCommand;
66     private UserManagerService mUserManagerService;
67     private @Mock LockPatternUtils mLockPatternUtils;
68     private final Binder mBinder = new Binder();
69     private final ShellCallback mShellCallback = new ShellCallback();
70     private final ResultReceiver mResultReceiver = new ResultReceiver(
71             new Handler(Looper.getMainLooper()));
72     private ByteArrayOutputStream mOutStream;
73     private PrintWriter mWriter;
74 
75     @Before
setUp()76     public void setUp() throws Exception {
77         mOutStream = new ByteArrayOutputStream();
78         mWriter = new PrintWriter(new PrintStream(mOutStream));
79         MockitoAnnotations.initMocks(this);
80 
81         if (Looper.myLooper() == null) {
82             Looper.prepare();
83         }
84         // Disable binder caches in this process.
85         PropertyInvalidatedCache.disableForTestMode();
86 
87         LocalServices.removeServiceForTest(UserManagerInternal.class);
88         final Context context = InstrumentationRegistry.getTargetContext();
89 
90         UserManagerService serviceInstance = new UserManagerService(context);
91         mUserManagerService = spy(serviceInstance);
92 
93         ArrayMap<String, UserTypeDetails> userTypes = UserTypeFactory.getUserTypes();
94         UserSystemPackageInstaller userSystemPackageInstaller =
95                 new UserSystemPackageInstaller(mUserManagerService, userTypes);
96         UserManagerServiceShellCommand cmd = new UserManagerServiceShellCommand(mUserManagerService,
97                 userSystemPackageInstaller, mLockPatternUtils, context);
98         mCommand = spy(cmd);
99     }
100 
101     @Test
testMainUser()102     public void testMainUser() {
103         when(mUserManagerService.getMainUserId()).thenReturn(12);
104         doReturn(mWriter).when(mCommand).getOutPrintWriter();
105 
106         assertEquals(0, mCommand.exec(mBinder, in, out, err,
107                 new String[]{"get-main-user"}, mShellCallback, mResultReceiver));
108 
109         mWriter.flush();
110         assertEquals("12", mOutStream.toString().trim());
111     }
112 
113     @Test
testMainUserNull()114     public void testMainUserNull() {
115         when(mUserManagerService.getMainUserId()).thenReturn(UserHandle.USER_NULL);
116         doReturn(mWriter).when(mCommand).getOutPrintWriter();
117 
118         assertEquals(1, mCommand.exec(mBinder, in, out, err,
119                 new String[]{"get-main-user"}, mShellCallback, mResultReceiver));
120         mWriter.flush();
121         assertEquals("None", mOutStream.toString().trim());
122     }
123 
124     @Test
testCanSwitchToHeadlessSystemUser()125     public void testCanSwitchToHeadlessSystemUser() {
126         doReturn(true).when(mUserManagerService).canSwitchToHeadlessSystemUser();
127         doReturn(mWriter).when(mCommand).getOutPrintWriter();
128 
129         assertEquals(0, mCommand.exec(mBinder, in, out, err,
130                 new String[]{"can-switch-to-headless-system-user"},
131                 mShellCallback, mResultReceiver));
132 
133         mWriter.flush();
134         assertEquals("true", mOutStream.toString().trim());
135     }
136 
137 
138     @Test
testIsMainUserPermanentAdmin()139     public void testIsMainUserPermanentAdmin() {
140         doReturn(false).when(mUserManagerService).isMainUserPermanentAdmin();
141         doReturn(mWriter).when(mCommand).getOutPrintWriter();
142 
143         assertEquals(0, mCommand.exec(mBinder, in, out, err,
144                 new String[]{"is-main-user-permanent-admin"}, mShellCallback, mResultReceiver));
145 
146         mWriter.flush();
147         assertEquals("false", mOutStream.toString().trim());
148     }
149 
150 
151 }
152