| # 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') |
