1# Copyright 2019 - The Android Open Source Project
2#
3# Licensed under the Apache License, Version 2.0 (the "License");
4# you may not use this file except in compliance with the License.
5# You may obtain a copy of the License at
6#
7#     http://www.apache.org/licenses/LICENSE-2.0
8#
9# Unless required by applicable law or agreed to in writing, software
10# distributed under the License is distributed on an "AS IS" BASIS,
11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12# See the License for the specific language governing permissions and
13# limitations under the License.
14"""Tests for create."""
15
16import os
17import subprocess
18import unittest
19
20from unittest import mock
21
22from acloud import errors
23from acloud.create import avd_spec
24from acloud.create import create
25from acloud.create import gce_local_image_remote_instance
26from acloud.internal import constants
27from acloud.internal.lib import driver_test_lib
28from acloud.internal.lib import utils
29from acloud.public import config
30from acloud.setup import gcp_setup_runner
31from acloud.setup import host_setup_runner
32from acloud.setup import setup
33
34
35# pylint: disable=invalid-name,protected-access,too-many-statements
36class CreateTest(driver_test_lib.BaseDriverTest):
37    """Test create functions."""
38
39    def testGetAvdCreatorClass(self):
40        """Test GetAvdCreatorClass."""
41        # Checking wrong avd arg.
42        avd_type = "unknown type"
43        ins_type = "unknown ins"
44        image_source = "unknown image"
45        with self.assertRaises(errors.UnsupportedInstanceImageType):
46            create.GetAvdCreatorClass(avd_type, ins_type, image_source)
47
48        # Checking right avd arg.
49        avd_creator_class = create.GetAvdCreatorClass(
50            constants.TYPE_GCE,
51            constants.INSTANCE_TYPE_REMOTE,
52            constants.IMAGE_SRC_LOCAL)
53        self.assertEqual(avd_creator_class,
54                         gce_local_image_remote_instance.GceLocalImageRemoteInstance)
55
56    # pylint: disable=protected-access
57    def testCheckForAutoconnect(self):
58        """Test CheckForAutoconnect."""
59        args = mock.MagicMock()
60        args.autoconnect = True
61        args.no_prompt = False
62
63        self.Patch(utils, "InteractWithQuestion", return_value="Y")
64        self.Patch(utils, "FindExecutable", return_value=None)
65
66        # Checking autoconnect should be false if ANDROID_BUILD_TOP is not set.
67        self.Patch(os.environ, "get", return_value=None)
68        create._CheckForAutoconnect(args)
69        self.assertEqual(args.autoconnect, False)
70
71        # checking autoconnect should be True after user make adb from src.
72        args.autoconnect = True
73        self.Patch(subprocess, "check_call", return_value=True)
74        self.Patch(os.environ, "get", return_value="/fake_dir2")
75        create._CheckForAutoconnect(args)
76        self.assertEqual(args.autoconnect, True)
77
78        # checking autoconnect should be False if adb is not built.
79        self.Patch(utils, "InteractWithQuestion", return_value="N")
80        create._CheckForAutoconnect(args)
81        self.assertEqual(args.autoconnect, False)
82
83    # pylint: disable=protected-access,no-member
84    def testCheckForSetup(self):
85        """Test _CheckForSetup."""
86        args = mock.MagicMock()
87        args.autoconnect = constants.INS_KEY_WEBRTC
88        args.local_instance = None
89        args.args.config_file = "fake_path"
90        self.Patch(gcp_setup_runner.GcpTaskRunner,
91                   "ShouldRun",
92                   return_value=False)
93        self.Patch(host_setup_runner.HostBasePkgInstaller,
94                   "ShouldRun",
95                   return_value=False)
96        self.Patch(host_setup_runner.LocalCAHostSetup,
97                   "ShouldRun",
98                   return_value=False)
99        self.Patch(host_setup_runner.CuttlefishHostSetup,
100                   "ShouldRun",
101                   return_value=False)
102        self.Patch(config, "AcloudConfigManager")
103        self.Patch(config.AcloudConfigManager, "Load")
104        self.Patch(setup, "Run")
105        self.Patch(utils, "InteractWithQuestion", return_value="Y")
106
107        # Checking Setup.Run should not be called if all runner's ShouldRun func
108        # return False
109        create._CheckForSetup(args)
110        gcp_setup_runner.GcpTaskRunner.ShouldRun.assert_called_once()
111        host_setup_runner.HostBasePkgInstaller.ShouldRun.assert_called_once()
112        host_setup_runner.LocalCAHostSetup.ShouldRun.assert_called_once()
113        setup.Run.assert_not_called()
114
115        # Checking Setup.Run should be called if runner's ShouldRun func return
116        # True
117        self.Patch(gcp_setup_runner.GcpTaskRunner,
118                   "ShouldRun",
119                   return_value=True)
120        create._CheckForSetup(args)
121        setup.Run.assert_called_once()
122
123        # Should or not run gcp_setup or install packages.
124        # Test with remote instance remote image case.
125        self.Patch(gcp_setup_runner.GcpTaskRunner,
126                   "ShouldRun")
127        self.Patch(host_setup_runner.AvdPkgInstaller,
128                   "ShouldRun")
129        self.Patch(host_setup_runner.CuttlefishHostSetup,
130                   "ShouldRun")
131        args.local_instance = None
132        args.local_image = None
133        create._CheckForSetup(args)
134        self.assertEqual(gcp_setup_runner.GcpTaskRunner.ShouldRun.call_count, 1)
135        self.assertEqual(host_setup_runner.AvdPkgInstaller.ShouldRun.call_count, 0)
136        self.assertEqual(
137            host_setup_runner.CuttlefishHostSetup.ShouldRun.call_count, 0)
138        gcp_setup_runner.GcpTaskRunner.ShouldRun.reset_mock()
139        host_setup_runner.AvdPkgInstaller.ShouldRun.reset_mock()
140        host_setup_runner.CuttlefishHostSetup.ShouldRun.reset_mock()
141
142        # Test with remote instance local image case.
143        args.local_instance = None
144        args.local_image = ""
145        create._CheckForSetup(args)
146        self.assertEqual(gcp_setup_runner.GcpTaskRunner.ShouldRun.call_count, 1)
147        self.assertEqual(host_setup_runner.AvdPkgInstaller.ShouldRun.call_count, 0)
148        self.assertEqual(
149            host_setup_runner.CuttlefishHostSetup.ShouldRun.call_count, 0)
150        gcp_setup_runner.GcpTaskRunner.ShouldRun.reset_mock()
151        host_setup_runner.AvdPkgInstaller.ShouldRun.reset_mock()
152        host_setup_runner.CuttlefishHostSetup.ShouldRun.reset_mock()
153
154        # Test with local instance remote image case.
155        args.local_instance = 0
156        args.local_image = None
157        create._CheckForSetup(args)
158        self.assertEqual(gcp_setup_runner.GcpTaskRunner.ShouldRun.call_count, 1)
159        self.assertEqual(host_setup_runner.AvdPkgInstaller.ShouldRun.call_count, 1)
160        self.assertEqual(
161            host_setup_runner.CuttlefishHostSetup.ShouldRun.call_count, 1)
162        gcp_setup_runner.GcpTaskRunner.ShouldRun.reset_mock()
163        host_setup_runner.AvdPkgInstaller.ShouldRun.reset_mock()
164        host_setup_runner.CuttlefishHostSetup.ShouldRun.reset_mock()
165
166        # Test with local instance local image case.
167        args.local_instance = 0
168        args.local_image = ""
169        create._CheckForSetup(args)
170        self.assertEqual(gcp_setup_runner.GcpTaskRunner.ShouldRun.call_count, 0)
171        self.assertEqual(host_setup_runner.AvdPkgInstaller.ShouldRun.call_count, 1)
172        self.assertEqual(
173            host_setup_runner.CuttlefishHostSetup.ShouldRun.call_count, 1)
174        gcp_setup_runner.GcpTaskRunner.ShouldRun.reset_mock()
175        host_setup_runner.AvdPkgInstaller.ShouldRun.reset_mock()
176        host_setup_runner.CuttlefishHostSetup.ShouldRun.reset_mock()
177
178    # pylint: disable=no-member
179    def testRun(self):
180        """Test Run."""
181        args = mock.MagicMock()
182        spec = mock.MagicMock()
183        spec.avd_type = constants.TYPE_GCE
184        spec.instance_type = constants.INSTANCE_TYPE_REMOTE
185        spec.image_source = constants.IMAGE_SRC_LOCAL
186        self.Patch(avd_spec, "AVDSpec", return_value=spec)
187        self.Patch(config, "GetAcloudConfig")
188        self.Patch(create, "PreRunCheck")
189        self.Patch(gce_local_image_remote_instance.GceLocalImageRemoteInstance,
190                   "Create")
191
192        # Checking PreRunCheck func should be called if not skip_pre_run_check
193        args.skip_pre_run_check = False
194        create.Run(args)
195        create.PreRunCheck.assert_called_once()
196
197        # Checking PreRunCheck func should not be called if skip_pre_run_check
198        args.skip_pre_run_check = True
199        self.Patch(create, "PreRunCheck")
200        create.Run(args)
201        create.PreRunCheck.assert_not_called()
202
203
204if __name__ == "__main__":
205    unittest.main()
206