• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#!/usr/bin/env python
2#
3# Copyright 2018 - The Android Open Source Project
4#
5# Licensed under the Apache License, Version 2.0 (the "License");
6# you may not use this file except in compliance with the License.
7# You may obtain a copy of the License at
8#
9#     http://www.apache.org/licenses/LICENSE-2.0
10#
11# Unless required by applicable law or agreed to in writing, software
12# distributed under the License is distributed on an "AS IS" BASIS,
13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14# See the License for the specific language governing permissions and
15# limitations under the License.
16
17"""Tests for create_cuttlefish_action.
18
19Tests for acloud.public.actions.create_cuttlefish_action.
20"""
21
22import uuid
23import unittest
24
25from unittest import mock
26
27from acloud.internal.lib import android_build_client
28from acloud.internal.lib import android_compute_client
29from acloud.internal.lib import auth
30from acloud.internal.lib import cvd_compute_client
31from acloud.internal.lib import cvd_compute_client_multi_stage
32from acloud.internal.lib import driver_test_lib
33from acloud.internal.lib import ssh
34from acloud.public.actions import create_cuttlefish_action
35
36
37class CreateCuttlefishActionTest(driver_test_lib.BaseDriverTest):
38    """Test create_cuttlefish_action."""
39
40    IP = ssh.IP(external="127.0.0.1", internal="10.0.0.1")
41    INSTANCE = "fake-instance"
42    IMAGE = "fake-image"
43    BRANCH = "fake-branch"
44    BUILD_ID = "12345"
45    BUILD_TARGET = "fake-build-target"
46    KERNEL_BRANCH = "fake-kernel-branch"
47    KERNEL_BUILD_ID = "54321"
48    KERNEL_BUILD_TARGET = "kernel"
49    SYSTEM_BRANCH = "fake-system-branch"
50    SYSTEM_BUILD_ID = "23456"
51    SYSTEM_BUILD_TARGET = "fake-system-build-target"
52    BOOTLOADER_BRANCH = "fake-bootloader-branch"
53    BOOTLOADER_BUILD_ID = "34567"
54    BOOTLOADER_BUILD_TARGET = "fake-bootloader-build-target"
55    STABLE_HOST_IMAGE_NAME = "fake-stable-host-image-name"
56    STABLE_HOST_IMAGE_PROJECT = "fake-stable-host-image-project"
57    EXTRA_DATA_DISK_GB = 4
58    EXTRA_SCOPES = ["scope1", "scope2"]
59    DEFAULT_ADB_PORT = 6520
60
61    def setUp(self):
62        """Set up the test."""
63        super().setUp()
64        self.build_client = mock.MagicMock()
65        self.Patch(
66            android_build_client,
67            "AndroidBuildClient",
68            return_value=self.build_client)
69        self.compute_client = mock.MagicMock()
70        self.compute_client.openwrt = False
71        self.Patch(
72            cvd_compute_client,
73            "CvdComputeClient",
74            return_value=self.compute_client)
75        self.Patch(
76            cvd_compute_client_multi_stage,
77            "CvdComputeClient",
78            return_value=self.compute_client)
79        self.Patch(
80            android_compute_client,
81            "AndroidComputeClient",
82            return_value=self.compute_client)
83        self.Patch(auth, "CreateCredentials", return_value=mock.MagicMock())
84
85    def _CreateCfg(self):
86        """A helper method that creates a mock configuration object."""
87        cfg = mock.MagicMock()
88        cfg.service_account_name = "fake@service.com"
89        cfg.service_account_private_key_path = "/fake/path/to/key"
90        cfg.zone = "fake_zone"
91        cfg.disk_image_name = "fake_image.tar.gz"
92        cfg.disk_image_mime_type = "fake/type"
93        cfg.ssh_private_key_path = ""
94        cfg.ssh_public_key_path = ""
95        cfg.stable_host_image_name = self.STABLE_HOST_IMAGE_NAME
96        cfg.stable_host_image_project = self.STABLE_HOST_IMAGE_PROJECT
97        cfg.extra_data_disk_size_gb = self.EXTRA_DATA_DISK_GB
98        cfg.kernel_build_target = self.KERNEL_BUILD_TARGET
99        cfg.extra_scopes = self.EXTRA_SCOPES
100        cfg.enable_multi_stage = False
101        return cfg
102
103    def testCreateDevices(self):
104        """Test CreateDevices."""
105        cfg = self._CreateCfg()
106
107        # Mock uuid
108        fake_uuid = mock.MagicMock(hex="1234")
109        self.Patch(uuid, "uuid4", return_value=fake_uuid)
110
111        # Mock compute client methods
112        self.compute_client.GetInstanceIP.return_value = self.IP
113        self.compute_client.GenerateImageName.return_value = self.IMAGE
114        self.compute_client.GenerateInstanceName.return_value = self.INSTANCE
115        self.compute_client.GetHostImageName.return_value = self.STABLE_HOST_IMAGE_NAME
116
117        # Mock build client method
118        self.build_client.GetBuildInfo.side_effect = [
119            android_build_client.BuildInfo(
120                self.BRANCH, self.BUILD_ID, self.BUILD_TARGET, None),
121            android_build_client.BuildInfo(
122                self.KERNEL_BRANCH, self.KERNEL_BUILD_ID,
123                self.KERNEL_BUILD_TARGET, None),
124            android_build_client.BuildInfo(
125                self.SYSTEM_BRANCH, self.SYSTEM_BUILD_ID,
126                self.SYSTEM_BUILD_TARGET, None),
127            android_build_client.BuildInfo(
128                self.BOOTLOADER_BRANCH, self.BOOTLOADER_BUILD_ID,
129                self.BOOTLOADER_BUILD_TARGET, None)]
130
131        # Call CreateDevices
132        report = create_cuttlefish_action.CreateDevices(
133            cfg, self.BUILD_TARGET, self.BUILD_ID, branch=self.BRANCH,
134            kernel_build_id=self.KERNEL_BUILD_ID,
135            system_build_target=self.SYSTEM_BUILD_TARGET,
136            system_branch=self.SYSTEM_BRANCH,
137            system_build_id=self.SYSTEM_BUILD_ID,
138            bootloader_build_target=self.BOOTLOADER_BUILD_TARGET,
139            bootloader_branch=self.BOOTLOADER_BRANCH,
140            bootloader_build_id=self.BOOTLOADER_BUILD_ID)
141
142        # Verify
143        self.compute_client.CreateInstance.assert_called_with(
144            instance=self.INSTANCE,
145            image_name=self.STABLE_HOST_IMAGE_NAME,
146            image_project=self.STABLE_HOST_IMAGE_PROJECT,
147            build_target=self.BUILD_TARGET,
148            branch=self.BRANCH,
149            build_id=self.BUILD_ID,
150            kernel_branch=self.KERNEL_BRANCH,
151            kernel_build_id=self.KERNEL_BUILD_ID,
152            kernel_build_target=self.KERNEL_BUILD_TARGET,
153            system_branch=self.SYSTEM_BRANCH,
154            system_build_id=self.SYSTEM_BUILD_ID,
155            system_build_target=self.SYSTEM_BUILD_TARGET,
156            bootloader_branch=self.BOOTLOADER_BRANCH,
157            bootloader_build_id=self.BOOTLOADER_BUILD_ID,
158            bootloader_build_target=self.BOOTLOADER_BUILD_TARGET,
159            blank_data_disk_size_gb=self.EXTRA_DATA_DISK_GB,
160            extra_scopes=self.EXTRA_SCOPES)
161
162        self.assertEqual(report.data, {
163            "devices": [
164                {
165                    "branch": self.BRANCH,
166                    "build_id": self.BUILD_ID,
167                    "build_target": self.BUILD_TARGET,
168                    "kernel_branch": self.KERNEL_BRANCH,
169                    "kernel_build_id": self.KERNEL_BUILD_ID,
170                    "kernel_build_target": self.KERNEL_BUILD_TARGET,
171                    "system_branch": self.SYSTEM_BRANCH,
172                    "system_build_id": self.SYSTEM_BUILD_ID,
173                    "system_build_target": self.SYSTEM_BUILD_TARGET,
174                    "bootloader_branch": self.BOOTLOADER_BRANCH,
175                    "bootloader_build_id": self.BOOTLOADER_BUILD_ID,
176                    "bootloader_build_target": self.BOOTLOADER_BUILD_TARGET,
177                    "instance_name": self.INSTANCE,
178                    "ip": self.IP.external + ":" + str(self.DEFAULT_ADB_PORT),
179                },
180            ],
181        })
182        self.assertEqual(report.command, "create_cf")
183        self.assertEqual(report.status, "SUCCESS")
184
185
186if __name__ == "__main__":
187    unittest.main()
188