blob: c82a40bee485b604ce190e5a143d6fda0978428f [file] [log] [blame]
#
# Copyright (C) 2018 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import os
import os.path
import zipfile
import common
import test_utils
from add_img_to_target_files import (
AddCareMapForAbOta, AddPackRadioImages,
CheckAbOtaImages, GetCareMap)
from rangelib import RangeSet
OPTIONS = common.OPTIONS
class AddImagesToTargetFilesTest(test_utils.ReleaseToolsTestCase):
def setUp(self):
OPTIONS.input_tmp = common.MakeTempDir()
@staticmethod
def _create_images(images, prefix):
"""Creates images under OPTIONS.input_tmp/prefix."""
path = os.path.join(OPTIONS.input_tmp, prefix)
if not os.path.exists(path):
os.mkdir(path)
for image in images:
image_path = os.path.join(path, image + '.img')
with open(image_path, 'wb') as image_fp:
image_fp.write(image.encode())
images_path = os.path.join(OPTIONS.input_tmp, 'IMAGES')
if not os.path.exists(images_path):
os.mkdir(images_path)
return images, images_path
def test_CheckAbOtaImages_imageExistsUnderImages(self):
"""Tests the case with existing images under IMAGES/."""
images, _ = self._create_images(['aboot', 'xbl'], 'IMAGES')
CheckAbOtaImages(None, images)
def test_CheckAbOtaImages_imageExistsUnderRadio(self):
"""Tests the case with some image under RADIO/."""
images, _ = self._create_images(['system', 'vendor'], 'IMAGES')
radio_path = os.path.join(OPTIONS.input_tmp, 'RADIO')
if not os.path.exists(radio_path):
os.mkdir(radio_path)
with open(os.path.join(radio_path, 'modem.img'), 'wb') as image_fp:
image_fp.write('modem'.encode())
CheckAbOtaImages(None, images + ['modem'])
def test_CheckAbOtaImages_missingImages(self):
images, _ = self._create_images(['aboot', 'xbl'], 'RADIO')
self.assertRaises(
AssertionError, CheckAbOtaImages, None, images + ['baz'])
def test_AddPackRadioImages(self):
images, images_path = self._create_images(['foo', 'bar'], 'RADIO')
AddPackRadioImages(None, images)
for image in images:
self.assertTrue(
os.path.exists(os.path.join(images_path, image + '.img')))
def test_AddPackRadioImages_with_suffix(self):
images, images_path = self._create_images(['foo', 'bar'], 'RADIO')
images_with_suffix = [image + '.img' for image in images]
AddPackRadioImages(None, images_with_suffix)
for image in images:
self.assertTrue(
os.path.exists(os.path.join(images_path, image + '.img')))
def test_AddPackRadioImages_zipOutput(self):
images, _ = self._create_images(['foo', 'bar'], 'RADIO')
# Set up the output zip.
output_file = common.MakeTempFile(suffix='.zip')
with zipfile.ZipFile(output_file, 'w') as output_zip:
AddPackRadioImages(output_zip, images)
with zipfile.ZipFile(output_file, 'r') as verify_zip:
for image in images:
self.assertIn('IMAGES/' + image + '.img', verify_zip.namelist())
def test_AddPackRadioImages_imageExists(self):
images, images_path = self._create_images(['foo', 'bar'], 'RADIO')
# Additionally create images under IMAGES/ so that they should be skipped.
images, images_path = self._create_images(['foo', 'bar'], 'IMAGES')
AddPackRadioImages(None, images)
for image in images:
self.assertTrue(
os.path.exists(os.path.join(images_path, image + '.img')))
def test_AddPackRadioImages_missingImages(self):
images, _ = self._create_images(['foo', 'bar'], 'RADIO')
AddPackRadioImages(None, images)
self.assertRaises(AssertionError, AddPackRadioImages, None,
images + ['baz'])
@staticmethod
def _test_AddCareMapForAbOta():
"""Helper function to set up the test for test_AddCareMapForAbOta()."""
OPTIONS.info_dict = {
'extfs_sparse_flag' : '-s',
'system_image_size' : 65536,
'vendor_image_size' : 40960,
'system_verity_block_device': '/dev/block/system',
'vendor_verity_block_device': '/dev/block/vendor',
'system.build.prop': common.PartitionBuildProps.FromDictionary(
'system', {
'ro.system.build.fingerprint':
'google/sailfish/12345:user/dev-keys'}
),
'vendor.build.prop': common.PartitionBuildProps.FromDictionary(
'vendor', {
'ro.vendor.build.fingerprint':
'google/sailfish/678:user/dev-keys'}
),
}
# Prepare the META/ folder.
meta_path = os.path.join(OPTIONS.input_tmp, 'META')
if not os.path.exists(meta_path):
os.mkdir(meta_path)
system_image = test_utils.construct_sparse_image([
(0xCAC1, 6),
(0xCAC3, 4),
(0xCAC1, 8)])
vendor_image = test_utils.construct_sparse_image([
(0xCAC2, 12)])
image_paths = {
'system' : system_image,
'vendor' : vendor_image,
}
return image_paths
def _verifyCareMap(self, expected, file_name):
"""Parses the care_map.pb; and checks the content in plain text."""
text_file = common.MakeTempFile(prefix="caremap-", suffix=".txt")
# Calls an external binary to convert the proto message.
cmd = ["care_map_generator", "--parse_proto", file_name, text_file]
common.RunAndCheckOutput(cmd)
with open(text_file) as verify_fp:
plain_text = verify_fp.read()
self.assertEqual('\n'.join(expected), plain_text)
@test_utils.SkipIfExternalToolsUnavailable()
def test_AddCareMapForAbOta(self):
image_paths = self._test_AddCareMapForAbOta()
AddCareMapForAbOta(None, ['system', 'vendor'], image_paths)
care_map_file = os.path.join(OPTIONS.input_tmp, 'META', 'care_map.pb')
expected = ['system', RangeSet("0-5 10-15").to_string_raw(),
"ro.system.build.fingerprint",
"google/sailfish/12345:user/dev-keys",
'vendor', RangeSet("0-9").to_string_raw(),
"ro.vendor.build.fingerprint",
"google/sailfish/678:user/dev-keys"]
self._verifyCareMap(expected, care_map_file)
@test_utils.SkipIfExternalToolsUnavailable()
def test_AddCareMapForAbOta_withNonCareMapPartitions(self):
"""Partitions without care_map should be ignored."""
image_paths = self._test_AddCareMapForAbOta()
AddCareMapForAbOta(
None, ['boot', 'system', 'vendor', 'vbmeta'], image_paths)
care_map_file = os.path.join(OPTIONS.input_tmp, 'META', 'care_map.pb')
expected = ['system', RangeSet("0-5 10-15").to_string_raw(),
"ro.system.build.fingerprint",
"google/sailfish/12345:user/dev-keys",
'vendor', RangeSet("0-9").to_string_raw(),
"ro.vendor.build.fingerprint",
"google/sailfish/678:user/dev-keys"]
self._verifyCareMap(expected, care_map_file)
@test_utils.SkipIfExternalToolsUnavailable()
def test_AddCareMapForAbOta_withAvb(self):
"""Tests the case for device using AVB."""
image_paths = self._test_AddCareMapForAbOta()
OPTIONS.info_dict = {
'extfs_sparse_flag': '-s',
'system_image_size': 65536,
'vendor_image_size': 40960,
'avb_system_hashtree_enable': 'true',
'avb_vendor_hashtree_enable': 'true',
'system.build.prop': common.PartitionBuildProps.FromDictionary(
'system', {
'ro.system.build.fingerprint':
'google/sailfish/12345:user/dev-keys'}
),
'vendor.build.prop': common.PartitionBuildProps.FromDictionary(
'vendor', {
'ro.vendor.build.fingerprint':
'google/sailfish/678:user/dev-keys'}
),
}
AddCareMapForAbOta(None, ['system', 'vendor'], image_paths)
care_map_file = os.path.join(OPTIONS.input_tmp, 'META', 'care_map.pb')
expected = ['system', RangeSet("0-5 10-15").to_string_raw(),
"ro.system.build.fingerprint",
"google/sailfish/12345:user/dev-keys",
'vendor', RangeSet("0-9").to_string_raw(),
"ro.vendor.build.fingerprint",
"google/sailfish/678:user/dev-keys"]
self._verifyCareMap(expected, care_map_file)
@test_utils.SkipIfExternalToolsUnavailable()
def test_AddCareMapForAbOta_noFingerprint(self):
"""Tests the case for partitions without fingerprint."""
image_paths = self._test_AddCareMapForAbOta()
OPTIONS.info_dict = {
'extfs_sparse_flag' : '-s',
'system_image_size' : 65536,
'vendor_image_size' : 40960,
'system_verity_block_device': '/dev/block/system',
'vendor_verity_block_device': '/dev/block/vendor',
}
AddCareMapForAbOta(None, ['system', 'vendor'], image_paths)
care_map_file = os.path.join(OPTIONS.input_tmp, 'META', 'care_map.pb')
expected = ['system', RangeSet("0-5 10-15").to_string_raw(), "unknown",
"unknown", 'vendor', RangeSet("0-9").to_string_raw(), "unknown",
"unknown"]
self._verifyCareMap(expected, care_map_file)
@test_utils.SkipIfExternalToolsUnavailable()
def test_AddCareMapForAbOta_withThumbprint(self):
"""Tests the case for partitions with thumbprint."""
image_paths = self._test_AddCareMapForAbOta()
OPTIONS.info_dict = {
'extfs_sparse_flag': '-s',
'system_image_size': 65536,
'vendor_image_size': 40960,
'system_verity_block_device': '/dev/block/system',
'vendor_verity_block_device': '/dev/block/vendor',
'system.build.prop': common.PartitionBuildProps.FromDictionary(
'system', {
'ro.system.build.thumbprint':
'google/sailfish/123:user/dev-keys'}
),
'vendor.build.prop': common.PartitionBuildProps.FromDictionary(
'vendor', {
'ro.vendor.build.thumbprint':
'google/sailfish/456:user/dev-keys'}
),
}
AddCareMapForAbOta(None, ['system', 'vendor'], image_paths)
care_map_file = os.path.join(OPTIONS.input_tmp, 'META', 'care_map.pb')
expected = ['system', RangeSet("0-5 10-15").to_string_raw(),
"ro.system.build.thumbprint",
"google/sailfish/123:user/dev-keys",
'vendor', RangeSet("0-9").to_string_raw(),
"ro.vendor.build.thumbprint",
"google/sailfish/456:user/dev-keys"]
self._verifyCareMap(expected, care_map_file)
@test_utils.SkipIfExternalToolsUnavailable()
def test_AddCareMapForAbOta_skipPartition(self):
image_paths = self._test_AddCareMapForAbOta()
# Remove vendor_image_size to invalidate the care_map for vendor.img.
del OPTIONS.info_dict['vendor_image_size']
AddCareMapForAbOta(None, ['system', 'vendor'], image_paths)
care_map_file = os.path.join(OPTIONS.input_tmp, 'META', 'care_map.pb')
expected = ['system', RangeSet("0-5 10-15").to_string_raw(),
"ro.system.build.fingerprint",
"google/sailfish/12345:user/dev-keys"]
self._verifyCareMap(expected, care_map_file)
@test_utils.SkipIfExternalToolsUnavailable()
def test_AddCareMapForAbOta_skipAllPartitions(self):
image_paths = self._test_AddCareMapForAbOta()
# Remove the image_size properties for all the partitions.
del OPTIONS.info_dict['system_image_size']
del OPTIONS.info_dict['vendor_image_size']
AddCareMapForAbOta(None, ['system', 'vendor'], image_paths)
self.assertFalse(
os.path.exists(os.path.join(OPTIONS.input_tmp, 'META', 'care_map.pb')))
def test_AddCareMapForAbOta_verityNotEnabled(self):
"""No care_map.pb should be generated if verity not enabled."""
image_paths = self._test_AddCareMapForAbOta()
OPTIONS.info_dict = {}
AddCareMapForAbOta(None, ['system', 'vendor'], image_paths)
care_map_file = os.path.join(OPTIONS.input_tmp, 'META', 'care_map.pb')
self.assertFalse(os.path.exists(care_map_file))
def test_AddCareMapForAbOta_missingImageFile(self):
"""Missing image file should be considered fatal."""
image_paths = self._test_AddCareMapForAbOta()
image_paths['vendor'] = ''
self.assertRaises(AssertionError, AddCareMapForAbOta, None,
['system', 'vendor'], image_paths)
@test_utils.SkipIfExternalToolsUnavailable()
def test_AddCareMapForAbOta_zipOutput(self):
"""Tests the case with ZIP output."""
image_paths = self._test_AddCareMapForAbOta()
output_file = common.MakeTempFile(suffix='.zip')
with zipfile.ZipFile(output_file, 'w') as output_zip:
AddCareMapForAbOta(output_zip, ['system', 'vendor'], image_paths)
care_map_name = "META/care_map.pb"
temp_dir = common.MakeTempDir()
with zipfile.ZipFile(output_file, 'r') as verify_zip:
self.assertTrue(care_map_name in verify_zip.namelist())
verify_zip.extract(care_map_name, path=temp_dir)
expected = ['system', RangeSet("0-5 10-15").to_string_raw(),
"ro.system.build.fingerprint",
"google/sailfish/12345:user/dev-keys",
'vendor', RangeSet("0-9").to_string_raw(),
"ro.vendor.build.fingerprint",
"google/sailfish/678:user/dev-keys"]
self._verifyCareMap(expected, os.path.join(temp_dir, care_map_name))
@test_utils.SkipIfExternalToolsUnavailable()
def test_AddCareMapForAbOta_zipOutput_careMapEntryExists(self):
"""Tests the case with ZIP output which already has care_map entry."""
image_paths = self._test_AddCareMapForAbOta()
output_file = common.MakeTempFile(suffix='.zip')
with zipfile.ZipFile(output_file, 'w') as output_zip:
# Create an existing META/care_map.pb entry.
common.ZipWriteStr(output_zip, 'META/care_map.pb',
'dummy care_map.pb')
# Request to add META/care_map.pb again.
AddCareMapForAbOta(output_zip, ['system', 'vendor'], image_paths)
# The one under OPTIONS.input_tmp must have been replaced.
care_map_file = os.path.join(OPTIONS.input_tmp, 'META', 'care_map.pb')
expected = ['system', RangeSet("0-5 10-15").to_string_raw(),
"ro.system.build.fingerprint",
"google/sailfish/12345:user/dev-keys",
'vendor', RangeSet("0-9").to_string_raw(),
"ro.vendor.build.fingerprint",
"google/sailfish/678:user/dev-keys"]
self._verifyCareMap(expected, care_map_file)
# The existing entry should be scheduled to be replaced.
self.assertIn('META/care_map.pb', OPTIONS.replace_updated_files_list)
def test_GetCareMap(self):
sparse_image = test_utils.construct_sparse_image([
(0xCAC1, 6),
(0xCAC3, 4),
(0xCAC1, 6)])
OPTIONS.info_dict = {
'extfs_sparse_flag' : '-s',
'system_image_size' : 53248,
}
name, care_map = GetCareMap('system', sparse_image)
self.assertEqual('system', name)
self.assertEqual(RangeSet("0-5 10-12").to_string_raw(), care_map)
def test_GetCareMap_invalidPartition(self):
self.assertRaises(AssertionError, GetCareMap, 'oem', None)
def test_GetCareMap_invalidAdjustedPartitionSize(self):
sparse_image = test_utils.construct_sparse_image([
(0xCAC1, 6),
(0xCAC3, 4),
(0xCAC1, 6)])
OPTIONS.info_dict = {
'extfs_sparse_flag' : '-s',
'system_image_size' : -45056,
}
self.assertRaises(AssertionError, GetCareMap, 'system', sparse_image)
def test_GetCareMap_nonSparseImage(self):
OPTIONS.info_dict = {
'system_image_size' : 53248,
}
# 'foo' is the image filename, which is expected to be not used by
# GetCareMap().
name, care_map = GetCareMap('system', 'foo')
self.assertEqual('system', name)
self.assertEqual(RangeSet("0-12").to_string_raw(), care_map)