# Copyright 2014 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import json
import logging
from autotest_lib.client.bin import test, utils
from autotest_lib.client.common_lib import error
from autotest_lib.client.common_lib.cros import chrome
from autotest_lib.client.cros import cros_ui
class login_OobeLocalization(test.test):
"""Tests different region configurations at OOBE."""
version = 1
_LANGUAGE_SELECT = 'language-select'
_KEYBOARD_SELECT = 'keyboard-select'
_FALLBACK_KEYBOARD = 'xkb:us::eng'
# dump_vpd_log reads the VPD cache in lieu of running `vpd -l`.
_VPD_FILENAME = '/var/cache/vpd/full-v2.txt'
# The filtered cache is created from the cache by dump_vpd_log. It is read
# at startup if the device is not owned. (Otherwise /tmp/machine-info is
# created by dump_vpd_log and read. See
# /platform/login_manager/init/machine-info.conf.)
_FILTERED_VPD_FILENAME = '/var/log/vpd_2.0.txt'
# cros-regions.json has information for each region (locale, input method,
# etc.) in JSON format.
_REGIONS_FILENAME = '/usr/share/misc/cros-regions.json'
# input_methods.txt lists supported input methods.
_INPUT_METHODS_FILENAME = ('/usr/share/chromeos-assets/input_methods/'
'input_methods.txt')
def initialize(self):
self._login_keyboards = self._get_login_keyboards()
self._comp_ime_prefix = self._run_with_chrome(
self._get_comp_ime_prefix)
def run_once(self):
for region in self._get_regions():
# Unconfirmed regions may have incorrect data. The 'confirm'
# property is optional when all regions in database are confirmed so
# we have to check explicit 'False'.
if region.get('confirmed', True) is False:
logging.info('Skip unconfirmed region: %s',
region['region_code'])
continue
# TODO(hungte) When OOBE supports cros-regions.json
# (crosbug.com/p/34536) we can remove initial_locale,
# initial_timezone, and keyboard_layout.
self._set_vpd({'region': region['region_code'],
'initial_locale': ','.join(region['locales']),
'initial_timezone': ','.join(region['time_zones']),
'keyboard_layout': ','.join(region['keyboards'])})
self._run_with_chrome(self._run_localization_test, region)
def cleanup(self):
"""Removes cache files so our changes don't persist."""
cros_ui.stop()
utils.run('rm /home/chronos/Local\ State', ignore_status=True)
utils.run('dump_vpd_log --clean')
def _run_with_chrome(self, func, *args):
with chrome.Chrome(auto_login=False) as self._chrome:
utils.poll_for_condition(
self._is_oobe_ready,
exception=error.TestFail('OOBE not ready'))
return func(*args)
def _run_localization_test(self, region):
"""Checks the network screen for the proper dropdown values."""
# Find the language(s), or acceptable alternate value(s).
initial_locale = ','.join(region['locales'])
if not self._verify_initial_options(
self._LANGUAGE_SELECT,
initial_locale,
alternate_values = self._resolve_language(initial_locale),
check_separator = True):
raise error.TestFail(
'Language not found for region "%s".\n'
'Actual value of %s:\n%s' % (
region['region_code'],
self._LANGUAGE_SELECT,
self._dump_options(self._LANGUAGE_SELECT)))
# We expect to see only login keyboards at OOBE.
keyboards = region['keyboards']
keyboards = [kbd for kbd in keyboards if kbd in self._login_keyboards]
# If there are no login keyboards, expect only the fallback keyboard.
keyboards = keyboards or [self._FALLBACK_KEYBOARD]
# Prepend each xkb value with the component extension id.
keyboard_ids = ','.join(
[self._comp_ime_prefix + xkb for xkb in keyboards])
# Find the keyboard layout(s).
if not self._verify_initial_options(
self._KEYBOARD_SELECT,
keyboard_ids):
raise error.TestFail(
'Keyboard not found for region "%s".\n'
'Actual value of %s:\n%s' % (
region['region_code'],
self._KEYBOARD_SELECT,
self._dump_options(self._KEYBOARD_SELECT)))
# Check that the fallback keyboard is present.
if self._FALLBACK_KEYBOARD not in keyboards:
if not self._verify_option_exists(
self._KEYBOARD_SELECT,
self._comp_ime_prefix + self._FALLBACK_KEYBOARD):
raise error.TestFail(
'Fallback keyboard layout not found for region "%s".\n'
'Actual value of %s:\n%s' % (
region['region_code'],
self._KEYBOARD_SELECT,
self._dump_options(self._KEYBOARD_SELECT)))
def _set_vpd(self, vpd_settings):
"""Changes VPD cache on disk.
@param vpd_settings: Dictionary of VPD key-value pairs.
"""
cros_ui.stop()
vpd = {}
with open(self._VPD_FILENAME, 'r+') as vpd_log:
# Read the existing VPD info.
for line in vpd_log:
# Extract "key"="value" pair.
key, _, value = line.replace('"', '').partition('=')
vpd[key] = value
vpd.update(vpd_settings);
# Write the new set of settings to disk.
vpd_log.seek(0)
for key in vpd:
vpd_log.write('"%s"="%s"\n' % (key, vpd[key]))
vpd_log.truncate()
# Remove filtered cache so dump_vpd_log recreates it from the cache we
# just updated.
utils.run('rm ' + self._FILTERED_VPD_FILENAME, ignore_status=True)
utils.run('dump_vpd_log')
# Remove cached files to clear initial locale info.
utils.run('rm /home/chronos/Local\ State', ignore_status=True)
utils.run('rm /home/chronos/.oobe_completed', ignore_status=True)
cros_ui.start()
def _verify_initial_options(self, select_id, values,
alternate_values='', check_separator=False):
"""Verifies that |values| are the initial elements of |select_id|.
@param select_id: ID of the select element to check.
@param values: Comma-separated list of values that should appear,
in order, at the top of the select before any options group.
@param alternate_values: Optional comma-separated list of alternate
values for the corresponding items in values.
@param check_separator: If True, also verifies that an options group
label appears after the initial set of values.
@returns whether the select fits the given constraints.
@raises EvaluateException if the JS expression fails to evaluate.
"""
js_expression = """
(function () {
var select = document.querySelector('#%s');
if (!select || select.selectedIndex)
return false;
var values = '%s'.split(',');
var alternate_values = '%s'.split(',');
for (var i = 0; i < values.length; i++) {
if (select.options[i].value != values[i] &&
(!alternate_values[i] ||
select.options[i].value != alternate_values[i]))
return false;
}
if (%d) {
return select.children[values.length].tagName ==
'OPTGROUP';
}
return true;
})()""" % (select_id,
values,
alternate_values,
check_separator)
return self._chrome.browser.oobe.EvaluateJavaScript(js_expression)
def _verify_option_exists(self, select_id, value):
"""Verifies that |value| exists in |select_id|.
@param select_id: ID of the select element to check.
@param value: A single value to find in the select.
@returns whether the value is found.
@raises EvaluateException if the JS expression fails to evaluate.
"""
js_expression = """
(function () {
return !!document.querySelector(
'#%s option[value=\\'%s\\']');
})()""" % (select_id, value)
return self._chrome.browser.oobe.EvaluateJavaScript(js_expression)
def _get_login_keyboards(self):
"""Returns the set of login xkbs from the input methods file."""
login_keyboards = set()
with open(self._INPUT_METHODS_FILENAME) as input_methods_file:
for line in input_methods_file:
columns = line.strip().split()
# The 5th column will be "login" if this keyboard layout will
# be used on login.
if len(columns) == 5 and columns[4] == 'login':
login_keyboards.add(columns[0])
return login_keyboards
def _get_regions(self):
regions = {}
with open(self._REGIONS_FILENAME, 'r') as regions_file:
return json.load(regions_file).values()
def _get_comp_ime_prefix(self):
"""Finds the xkb values' component extension id prefix, if any.
@returns the prefix if found, or an empty string
"""
return self._chrome.browser.oobe.EvaluateJavaScript("""
var value = document.getElementById('%s').value;
value.substr(0, value.lastIndexOf('xkb:'))""" %
self._KEYBOARD_SELECT)
def _resolve_language(self, locale):
"""Falls back to an existing locale if the given locale matches a
language but not the country. Mirrors
chromium:ui/base/l10n/l10n_util.cc.
"""
lang, _, region = map(str.lower, str(locale).partition('-'))
if not region:
return ''
# Map from other countries to a localized country.
if lang == 'es' and region == 'es':
return 'es-419'
if lang == 'zh':
if region in ('hk', 'mo'):
return 'zh-TW'
return 'zh-CN'
if lang == 'en':
if region in ('au', 'ca', 'nz', 'za'):
return 'en-GB'
return 'en-US'
# No mapping found.
return ''
def _is_oobe_ready(self):
return (self._chrome.browser.oobe and
self._chrome.browser.oobe.EvaluateJavaScript(
"var select = document.getElementById('%s');"
"select && select.children.length >= 2" %
self._LANGUAGE_SELECT))
def _dump_options(self, select_id):
js_expression = """
(function () {
var selector = '#%s';
var divider = ',';
var select = document.querySelector(selector);
if (!select)
return 'document.querySelector(\\'' + selector +
'\\') failed.';
var dumpOptgroup = function(group) {
var result = '';
for (var i = 0; i < group.children.length; i++) {
if (i > 0)
result += divider;
if (group.children[i].value)
result += group.children[i].value;
else
result += '__NO_VALUE__';
}
return result;
};
var result = '';
if (select.selectedIndex != 0) {
result += '(selectedIndex=' + select.selectedIndex +
', selected \' +
select.options[select.selectedIndex].value +
'\)';
}
var children = select.children;
for (var i = 0; i < children.length; i++) {
if (i > 0)
result += divider;
if (children[i].value)
result += children[i].value;
else if (children[i].tagName === 'OPTGROUP')
result += '[' + dumpOptgroup(children[i]) + ']';
else
result += '__NO_VALUE__';
}
return result;
})()""" % select_id
return self._chrome.browser.oobe.EvaluateJavaScript(js_expression)