# 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.
|
|
"""
|
This module allows tests to interact with the Chrome Web Store (CWS)
|
using ChromeDriver. They should inherit from the webstore_test class,
|
and should override the run() method.
|
"""
|
|
import logging
|
import time
|
|
from autotest_lib.client.bin import test
|
from autotest_lib.client.common_lib import error
|
from autotest_lib.client.common_lib.cros import chromedriver
|
from autotest_lib.client.common_lib.global_config import global_config
|
from selenium.webdriver.common.by import By
|
from selenium.webdriver.support import expected_conditions
|
from selenium.webdriver.support.ui import WebDriverWait
|
|
# How long to wait, in seconds, for an app to launch. This is larger
|
# than it needs to be, because it might be slow on older Chromebooks
|
_LAUNCH_DELAY = 4
|
|
# How long to wait before entering the password when logging in to the CWS
|
_ENTER_PASSWORD_DELAY = 2
|
|
# How long to wait before entering payment info
|
_PAYMENT_DELAY = 5
|
|
def enum(*enumNames):
|
"""
|
Creates an enum. Returns an enum object with a value for each enum
|
name, as well as from_string and to_string mappings.
|
|
@param enumNames: The strings representing the values of the enum
|
"""
|
enums = dict(zip(enumNames, range(len(enumNames))))
|
reverse = dict((value, key) for key, value in enums.iteritems())
|
enums['from_string'] = enums
|
enums['to_string'] = reverse
|
return type('Enum', (), enums)
|
|
# TODO: staging and PNL don't work in these tests (crbug/396660)
|
TestEnv = enum('staging', 'pnl', 'prod', 'sandbox')
|
|
ItemType = enum(
|
'hosted_app',
|
'packaged_app',
|
'chrome_app',
|
'extension',
|
'theme',
|
)
|
|
# NOTE: paid installs don't work right now
|
InstallType = enum(
|
'free',
|
'free_trial',
|
'paid',
|
)
|
|
def _labeled_button(label):
|
"""
|
Returns a button with the class webstore-test-button-label and the
|
specified label
|
|
@param label: The label on the button
|
"""
|
return ('//div[contains(@class,"webstore-test-button-label") '
|
'and text()="' + label + '"]')
|
|
def _install_type_click_xpath(item_type, install_type):
|
"""
|
Returns the XPath of the button to install an item of the given type.
|
|
@param item_type: The type of the item to install
|
@param install_type: The type of installation being used
|
"""
|
if install_type == InstallType.free:
|
return _labeled_button('Free')
|
elif install_type == InstallType.free_trial:
|
# Both of these cases return buttons that say "Add to Chrome",
|
# but they are actually different buttons with only one being
|
# visible at a time.
|
if item_type == ItemType.hosted_app:
|
return ('//div[@id="cxdialog-install-paid-btn" and '
|
'@aria-label="Add to Chrome"]')
|
else:
|
return _labeled_button('Add to Chrome')
|
else:
|
return ('//div[contains(@aria-label,"Buy for") '
|
'and not(contains(@style,"display: none"))]')
|
|
def _get_chrome_flags(test_env):
|
"""
|
Returns the Chrome flags for the given test environment.
|
"""
|
flags = ['--apps-gallery-install-auto-confirm-for-tests=accept']
|
if test_env == TestEnv.prod:
|
return flags
|
|
url_middle = {
|
TestEnv.staging: 'staging.corp',
|
TestEnv.sandbox: 'staging.sandbox',
|
TestEnv.pnl: 'prod-not-live.corp'
|
}[test_env]
|
download_url_middle = {
|
TestEnv.staging: 'download-staging.corp',
|
TestEnv.sandbox: 'download-staging.sandbox',
|
TestEnv.pnl: 'omaha.sandbox'
|
}[test_env]
|
flags.append('--apps-gallery-url=https://webstore-' + url_middle +
|
'.google.com')
|
flags.append('--apps-gallery-update-url=https://' + download_url_middle +
|
'.google.com/service/update2/crx')
|
logging.info('Using flags %s', flags)
|
return flags
|
|
|
class webstore_test(test.test):
|
"""
|
The base class for tests that interact with the web store.
|
|
Subclasses must define run(), but should not override run_once().
|
Subclasses should use methods in this module such as install_item,
|
but they can also use the driver directly if they need to.
|
"""
|
|
def initialize(self, test_env=TestEnv.sandbox,
|
account='cwsbotdeveloper1@gmail.com'):
|
"""
|
Initialize the test.
|
|
@param test_env: The test environment to use
|
"""
|
super(webstore_test, self).initialize()
|
|
self.username = account
|
self.password = global_config.get_config_value(
|
'CLIENT', 'webstore_test_password', type=str)
|
|
self.test_env = test_env
|
self._chrome_flags = _get_chrome_flags(test_env)
|
self.webstore_url = {
|
TestEnv.staging:
|
'https://webstore-staging.corp.google.com',
|
TestEnv.sandbox:
|
'https://webstore-staging.sandbox.google.com/webstore',
|
TestEnv.pnl:
|
'https://webstore-prod-not-live.corp.google.com/webstore',
|
TestEnv.prod:
|
'https://chrome.google.com/webstore'
|
}[test_env]
|
|
|
def build_url(self, page):
|
"""
|
Builds a webstore URL for the specified page.
|
|
@param page: the page to build a URL for
|
"""
|
return self.webstore_url + page + "?gl=US"
|
|
|
def detail_page(self, item_id):
|
"""
|
Returns the URL of the detail page for the given item
|
|
@param item_id: The item ID
|
"""
|
return self.build_url("/detail/" + item_id)
|
|
|
def wait_for(self, xpath):
|
"""
|
Waits until the element specified by the given XPath is visible
|
|
@param xpath: The xpath of the element to wait for
|
"""
|
self._wait.until(expected_conditions.visibility_of_element_located(
|
(By.XPATH, xpath)))
|
|
|
def run_once(self, **kwargs):
|
with chromedriver.chromedriver(
|
username=self.username,
|
password=self.password,
|
extra_chrome_flags=self._chrome_flags) \
|
as chromedriver_instance:
|
self.driver = chromedriver_instance.driver
|
self.driver.implicitly_wait(15)
|
self._wait = WebDriverWait(self.driver, 20)
|
logging.info('Running test on test environment %s',
|
TestEnv.to_string[self.test_env])
|
self.run(**kwargs)
|
|
|
def run(self):
|
"""
|
Runs the test. Should be overridden by subclasses.
|
"""
|
raise error.TestError('The test needs to override run()')
|
|
|
def install_item(self, item_id, item_type, install_type):
|
"""
|
Installs an item from the CWS.
|
|
@param item_id: The ID of the item to install
|
(a 32-char string of letters)
|
@param item_type: The type of the item to install
|
@param install_type: The type of installation
|
(free, free trial, or paid)
|
"""
|
logging.info('Installing item %s of type %s with install_type %s',
|
item_id, ItemType.to_string[item_type],
|
InstallType.to_string[install_type])
|
|
# We need to go to the CWS home page before going to the detail
|
# page due to a bug in the CWS
|
self.driver.get(self.webstore_url)
|
self.driver.get(self.detail_page(item_id))
|
|
install_type_click_xpath = _install_type_click_xpath(
|
item_type, install_type)
|
if item_type == ItemType.extension or item_type == ItemType.theme:
|
post_install_xpath = (
|
'//div[@aria-label="Added to Chrome" '
|
' and not(contains(@style,"display: none"))]')
|
else:
|
post_install_xpath = _labeled_button('Launch app')
|
|
# In this case we need to sign in again
|
if install_type != InstallType.free:
|
button_xpath = _labeled_button('Sign in to add')
|
logging.info('Clicking button %s', button_xpath)
|
self.driver.find_element_by_xpath(button_xpath).click()
|
time.sleep(_ENTER_PASSWORD_DELAY)
|
password_field = self.driver.find_element_by_xpath(
|
'//input[@id="Passwd"]')
|
password_field.send_keys(self.password)
|
self.driver.find_element_by_xpath('//input[@id="signIn"]').click()
|
|
logging.info('Clicking %s', install_type_click_xpath)
|
self.driver.find_element_by_xpath(install_type_click_xpath).click()
|
|
if install_type == InstallType.paid:
|
handle = self.driver.current_window_handle
|
iframe = self.driver.find_element_by_xpath(
|
'//iframe[contains(@src, "sandbox.google.com/checkout")]')
|
self.driver.switch_to_frame(iframe)
|
self.driver.find_element_by_id('purchaseButton').click()
|
time.sleep(_PAYMENT_DELAY) # Wait for animation to finish
|
self.driver.find_element_by_id('finishButton').click()
|
self.driver.switch_to_window(handle)
|
|
self.wait_for(post_install_xpath)
|
|
|
def launch_app(self, app_id):
|
"""
|
Launches an app. Verifies that it launched by verifying that
|
a new tab/window was opened.
|
|
@param app_id: The ID of the app to run
|
"""
|
logging.info('Launching app %s', app_id)
|
num_handles_before = len(self.driver.window_handles)
|
self.driver.get(self.webstore_url)
|
self.driver.get(self.detail_page(app_id))
|
launch_button = self.driver.find_element_by_xpath(
|
_labeled_button('Launch app'))
|
launch_button.click();
|
time.sleep(_LAUNCH_DELAY) # Wait for the app to launch
|
num_handles_after = len(self.driver.window_handles)
|
if num_handles_after <= num_handles_before:
|
raise error.TestError('App failed to launch')
|
