| # Copyright 2019 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 os |
| import logging |
| import time |
| |
| 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.graphics import graphics_utils |
| from autotest_lib.client.cros.input_playback import keyboard |
| from telemetry.internal.backends.chrome_inspector import devtools_http |
| |
| class desktopui_FilesApp(test.test): |
| """Smoke test of Files app using chrome.automation API.""" |
| version = 1 |
| |
| _FILES_APP_ID = 'hhaomjibdihmijegdhdafkllkbggdgoj' |
| _DOWNLOADS_PATH = '/home/chronos/user/Downloads' |
| |
| # chrome.automation roles |
| _BUTTON = 'button' |
| _STATIC_TEXT = 'staticText' |
| |
| # On screen elements |
| _TEXT_FILE = 'text.txt' |
| _IMAGE_FILE = 'screenshot2_reference.png' |
| _IMAGE_DIMENSIONS = '100 x 100' |
| _DOWNLOADS = 'Downloads' |
| _MY_FILES = 'My files' |
| _NEW_FOLDER = 'New folder' |
| _OPEN_FILE = 'Open' |
| _EDIT_IMAGE = 'Edit' |
| |
| |
| def cleanup(self): |
| """Remove temporary files created during test.""" |
| for temp_path in self._temp_file_paths: |
| try: |
| if os.path.exists(temp_path): |
| os.remove(temp_path) |
| except OSError: |
| logging.info( |
| 'Failed to delete %s in cleanup. Ignoring', temp_path) |
| |
| |
| def evaluate_javascript(self, code, retries=3): |
| """Executes javascript and returns some result. |
| |
| Occasionally calls to EvaluateJavascript on the autotest_ext will fail |
| to find the extension. Instead of wrapping every call in a try/except, |
| calls will go through this function instead. |
| |
| @param code: The javascript string to execute |
| @param retries: The number of times to retry the code |
| |
| """ |
| for i in range(0, retries): |
| try: |
| result = self.cr.autotest_ext.EvaluateJavaScript(code) |
| return result |
| except KeyError: |
| logging.exception('Could not find autotest_ext') |
| except (devtools_http.DevToolsClientUrlError, |
| devtools_http.DevToolsClientConnectionError): |
| logging.exception('Could not connect to DevTools') |
| time.sleep(1) |
| |
| raise error.TestFail('Could not execute "%s" in %d retries' % |
| (code, retries)) |
| |
| |
| def _wait_for_element_to_be_visible(self, role, name, timeout=10, |
| err_str='element to load'): |
| """ |
| Wait for an element to appear on screen. |
| |
| @param role: The chrome.automation role we want to look for |
| @param name: The chrome.automation name we want to look for |
| @param timeout: How long to wait |
| @param err_str: The error string to pass to the TimeoutException |
| |
| """ |
| find_js = "root.find({attributes: {role: '%s', name: '%s'}});" %\ |
| (role, name) |
| |
| def finished_loading(): |
| """Check if an element has finished loading.""" |
| visible = self.evaluate_javascript(find_js) |
| return visible is not None |
| utils.poll_for_condition(condition=finished_loading, timeout=timeout, |
| desc=err_str) |
| |
| |
| def _click_element(self, role, name): |
| """Click an element by role/name combination. |
| |
| @param role: The chrome.automation role we want to look for |
| @param name: The chrome.automation name we want to look for |
| |
| """ |
| click_js = """ |
| element = root.find({attributes: {role: '%s', |
| name: '%s'}}); |
| element.doDefault(); """ % (role, name) |
| self.evaluate_javascript(click_js) |
| |
| |
| def _set_navigation_point_on_element(self, role, name): |
| """Set navigation point to an element by role/name combination. |
| |
| @param role: The chrome.automation role we want to look for |
| @param name: The chrome.automation name we want to look for |
| |
| """ |
| focus_js = """ |
| element = root.find({attributes: {role: '%s', |
| name: '%s'}}); |
| element.setSequentialFocusNavigationStartingPoint(); """ %\ |
| (role, name) |
| self.evaluate_javascript(focus_js) |
| |
| |
| def _launch_app(self, id): |
| """ |
| Launch the app/extension by its ID and check that it opens. |
| |
| @param id: The app ID of the app to launch. |
| |
| """ |
| launch_js = "chrome.autotestPrivate.launchApp('%s', function(){})" % id |
| self.evaluate_javascript(launch_js) |
| self._files_app = None |
| self._foreground_page = None |
| |
| def check_open(): |
| """Check if the app is running.""" |
| try: |
| if self._files_app is None or len(self._files_app) <= 1: |
| self._files_app = \ |
| self.cr.browser.extensions.GetByExtensionId(id) |
| if len(self._files_app) > 1: |
| if self._foreground_page is None: |
| # Figure out which of the pages is the foreground one. |
| for ext in self._files_app: |
| url = ext.EvaluateJavaScript('location.href;') |
| if url.endswith('main.html'): |
| self._foreground_page = ext |
| break |
| loaded_js = """document.body.hasAttribute('loaded');""" |
| try: |
| return self._foreground_page.EvaluateJavaScript( |
| loaded_js) |
| except: |
| return False |
| return False |
| except KeyError: |
| return False |
| |
| try: |
| utils.poll_for_condition(condition=check_open, timeout=60) |
| except utils.TimeoutError: |
| raise error.TestFail('Could not open app: %s' % id) |
| |
| |
| def _load_automation_root(self): |
| """Load the chrome.automation API and get the on screen elements.""" |
| load_cmd = "var root; chrome.automation.getDesktop(r => root = r);" |
| self.evaluate_javascript(load_cmd) |
| |
| |
| def _find_all_by_role(self, role): |
| """ |
| Finds all the visible elements of a certain role type. |
| |
| @param role: The type of role to search for. |
| |
| """ |
| find_all_js = """ |
| var root; |
| chrome.automation.getDesktop(r => root = r); |
| root.findAll({attributes: {role: '%s'}}).map(node => node.name); |
| """ % role |
| roles = self.evaluate_javascript(find_all_js) |
| logging.info(roles) |
| return roles |
| |
| |
| def _open_downloads(self): |
| """Open the Downloads folder in the Files app.""" |
| self._wait_for_element_to_be_visible(self._BUTTON, |
| self._MY_FILES, |
| err_str='Files to load') |
| self._wait_for_element_to_be_visible(self._STATIC_TEXT, |
| self._DOWNLOADS, |
| err_str='Downloads to appear') |
| self._click_element(self._STATIC_TEXT, self._DOWNLOADS) |
| self._wait_for_element_to_be_visible(self._STATIC_TEXT, |
| self._TEXT_FILE, |
| err_str='.txt to show') |
| |
| |
| def _open_more_options(self): |
| """Opens the three dot menu of the Files app.""" |
| self._click_element(self._BUTTON, 'More\u2026') |
| self._wait_for_element_to_be_visible(self._STATIC_TEXT, |
| self._NEW_FOLDER, |
| err_str='New folder item') |
| |
| |
| def _open_image_preview(self): |
| """Open the image for a preview.""" |
| self._open_downloads() |
| |
| # Select the image file |
| self._click_element(self._STATIC_TEXT, self._IMAGE_FILE) |
| self._wait_for_element_to_be_visible(self._BUTTON, |
| self._OPEN_FILE, |
| err_str='Open button to appear') |
| # Launch image preview |
| with keyboard.Keyboard() as k: |
| self._set_navigation_point_on_element(self._STATIC_TEXT, |
| self._IMAGE_FILE) |
| k.press_key('tab') |
| k.press_key('space') |
| self._wait_for_element_to_be_visible(self._STATIC_TEXT, |
| self._IMAGE_DIMENSIONS, |
| err_str='Image info to appear') |
| |
| |
| def _setup(self): |
| """Populate DUT with assets and load automation APIs.""" |
| text_dest_path = os.path.join(self._DOWNLOADS_PATH, self._TEXT_FILE) |
| image_src_path = os.path.join(self.bindir, 'assets', self._IMAGE_FILE) |
| image_dest_path = os.path.join(self._DOWNLOADS_PATH, self._IMAGE_FILE) |
| |
| utils.write_one_line(text_dest_path, 'blahblah') |
| self._temp_file_paths.append(text_dest_path) |
| |
| if self._preview_image: |
| utils.force_copy(image_src_path, image_dest_path) |
| self._temp_file_paths.append(image_dest_path) |
| |
| self._load_automation_root() |
| |
| |
| def run_once(self, preview_image=False): |
| """Main entry point of test.""" |
| with chrome.Chrome(autotest_ext=True, |
| disable_default_apps=False) as cr: |
| # Setup |
| self.cr = cr |
| self._preview_image = preview_image |
| self._temp_file_paths = [] # Accumulate temp file paths for cleanup |
| self._setup() |
| |
| try: |
| # Files app testing |
| self._launch_app(self._FILES_APP_ID) |
| self._open_downloads() |
| self._open_more_options() |
| if self._preview_image: |
| self._open_image_preview() |
| except (ValueError, utils.TimeoutError): |
| logging.exception('Failed to verify Files app is available.') |
| try: |
| graphics_utils.take_screenshot(self.resultsdir, 'failure') |
| except: |
| logging.info('Failed to take screenshot') |
| raise |
| finally: |
| logging.info('Extra logging for debugging') |
| self._find_all_by_role(self._BUTTON) |
| self._find_all_by_role(self._STATIC_TEXT) |
