| # Copyright 2018 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 logging |
| import os |
| import time |
| |
| from commands import * |
| |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib.cros import chromedriver |
| from selenium.webdriver.common.keys import Keys |
| from autotest_lib.client.cros.graphics import graphics_utils |
| from selenium.webdriver.common.action_chains import ActionChains |
| from selenium.common.exceptions import WebDriverException |
| |
| TIMEOUT_TO_COPY = 1800 # in Secs. This timeout is for files beyond 1GB |
| SEARCH_BUTTON_ID = "search-button" |
| SEARCH_BOX_CSS = "div#search-box" |
| PAPER_CONTAINTER = "paper-input-container" |
| DELETE_BUTTON_ID = "delete-button" |
| FILE_LIST_ID = "file-list" |
| LABLE_ENTRY_CSS = "span.label.entry-name" |
| CR_DIALOG_CLASS = "cr-dialog-ok" |
| USER_LOCATION = "/home/chronos/user" |
| # Using graphics_utils to simulate below keys |
| OPEN_FILES_APPLICATION_KEYS = ["KEY_RIGHTSHIFT", "KEY_LEFTALT", "KEY_M"] |
| SWITCH_TO_APP_KEY_COMBINATION = ["KEY_LEFTALT", 'KEY_TAB'] |
| SELECT_ALL_KEY_COMBINATION = ["KEY_LEFTCTRL", "KEY_A"] |
| PASTE_KEY_COMBINATION = ["KEY_LEFTCTRL", "KEY_V"] |
| GOOGLE_DRIVE = 'My Drive' |
| |
| |
| class files_CopyFileToGoogleDriveUI(graphics_utils.GraphicsTest): |
| |
| """Copy a file from Downloads folder to Google drive""" |
| |
| version = 1 |
| TIME_DELAY = 5 |
| _WAIT_TO_LOAD = 5 |
| |
| def initialize(self): |
| """Autotest initialize function""" |
| super(files_CopyFileToGoogleDriveUI, self).initialize( |
| raise_error_on_hang=True) |
| |
| def cleanup(self): |
| """Autotest cleanup function""" |
| if self._GSC: |
| keyvals = self._GSC.get_memory_difference_keyvals() |
| for key, val in keyvals.iteritems(): |
| self.output_perf_value( |
| description=key, |
| value=val, |
| units='bytes', |
| higher_is_better=False) |
| self.write_perf_keyval(keyvals) |
| super(files_CopyFileToGoogleDriveUI, self).cleanup() |
| # If test fails then script will collect the screen shot to know at |
| # which instance failure occurred. |
| if not self.success: |
| graphics_utils.take_screenshot(os.path.join(self.debugdir), |
| "chrome") |
| |
| def switch_to_app(self, driver, title): |
| """Switching to application using title |
| |
| @param driver: chrome driver object |
| @param title: Title of the application |
| @return: True if the app is detected otherwise False |
| """ |
| windows = driver.window_handles |
| logging.debug("Windows opened: %s", windows) |
| # Checking current window initially.. |
| logging.debug("Current window is %s", driver.title) |
| if driver.title.strip().lower() == title.lower(): |
| return True |
| # Switching to all opened windows to find out the required window |
| for window in windows: |
| try: |
| logging.debug("Switching to window") |
| driver.switch_to_window(window) |
| logging.debug("Switched to window: %s", driver.title) |
| time.sleep(2) |
| if driver.title.strip().lower() == title.lower(): |
| logging.info("%s application opened!", title) |
| return True |
| except WebDriverException as we: |
| logging.debug("Webdriver exception occurred. Exception: %s", |
| str(we)) |
| except Exception as e: |
| logging.debug("Exception: %s", str(e)) |
| return False |
| |
| def open_files_application(self, driver): |
| """Open and switch to files application using graphics_utils.py |
| |
| @param driver: chrome driver object |
| """ |
| logging.info("Opening files application") |
| graphics_utils.press_keys(OPEN_FILES_APPLICATION_KEYS) |
| time.sleep(self._WAIT_TO_LOAD) |
| try: |
| self.switch_to_files(driver) |
| except Exception as e: |
| logging.error("Exception when switching files application.. %s", |
| str(e)) |
| logging.error("Failed to find files application. Trying again.") |
| graphics_utils.press_keys(OPEN_FILES_APPLICATION_KEYS) |
| time.sleep(self._WAIT_TO_LOAD) |
| self.switch_to_files(driver) |
| |
| def switch_to_files(self, driver, title="Downloads"): |
| """Switch to files application |
| |
| @param driver: chrome driver object |
| @param title: Title of the Files application |
| """ |
| logging.debug("Switching/Focus on the Files app") |
| if self.switch_to_app(driver, title): |
| logging.info("Focused on Files application") |
| graphics_utils.press_keys(SWITCH_TO_APP_KEY_COMBINATION) |
| time.sleep(1) |
| else: |
| raise error.TestFail("Failed to open on Files application") |
| |
| def check_folder_opened(self, driver, title): |
| """Check the selected folder is opened or not |
| |
| @param driver: chrome driver object |
| @param title: Folder name |
| @return: Returns True if expected folder is opened otherwise False |
| """ |
| logging.info("Actual files application title is %s", driver.title) |
| logging.info("Expected files application title is %s", title) |
| if driver.title == title: |
| return True |
| return False |
| |
| def open_folder(self, driver, folder): |
| """Open given folder |
| |
| @param driver: chrome driver object |
| @param folder: Directory name |
| """ |
| folder_webelements = driver.find_elements_by_css_selector( |
| LABLE_ENTRY_CSS) |
| for element in folder_webelements: |
| try: |
| logging.debug("Found folder name: %s", element.text.strip()) |
| if folder == element.text.strip(): |
| element.click() |
| time.sleep(3) |
| if self.check_folder_opened(driver, element.text.strip()): |
| logging.info("Folder is opened!") |
| return |
| except Exception as e: |
| logging.error("Exception when getting Files application " |
| "folders %s", str(e)) |
| raise error.TestError("Folder :%s is not opened or found", folder) |
| |
| def list_files(self, driver): |
| """List files in the folder |
| |
| @param driver: chrome driver object |
| @return: Returns list of files |
| """ |
| return driver.find_element_by_id( |
| FILE_LIST_ID).find_elements_by_tag_name('li') |
| |
| def search_file(self, driver, file_name): |
| """Search given file in Files application |
| |
| @param driver: chrome driver object |
| @param file_name: Required file |
| """ |
| driver.find_element_by_id(SEARCH_BUTTON_ID).click() |
| search_box_element = driver.find_element_by_css_selector( |
| SEARCH_BOX_CSS) |
| search_box_element.find_element_by_css_selector( |
| PAPER_CONTAINTER).find_element_by_tag_name('input').clear() |
| search_box_element.find_element_by_css_selector( |
| PAPER_CONTAINTER).find_element_by_tag_name('input').send_keys( |
| file_name) |
| |
| def copy_file(self, driver, source, destination, file_name, clean=True): |
| """Copy file from one directory to another |
| |
| @param driver: chrome driver object |
| @param source: Directory name from where to copy |
| @param destination: Directory name to where to copy |
| @param file_name: File to copy |
| @param clean: Cleans destination if True otherwise nothing |
| """ |
| self.open_folder(driver, source) |
| self.search_file(driver, file_name) |
| files = self.list_files(driver) |
| action_chains = ActionChains(driver) |
| |
| for item in files: |
| logging.info("Selecting file to copy in %s", file_name) |
| item.click() |
| file_size = item.text.split()[1].strip() |
| file_size_units = item.text.split()[2].strip() |
| logging.debug("Select copy") |
| action_chains.move_to_element(item) \ |
| .click(item).key_down(Keys.CONTROL) \ |
| .send_keys("c") \ |
| .key_up(Keys.CONTROL) \ |
| .perform() |
| self.open_folder(driver, destination) |
| if clean: |
| drive_files = self.list_files(driver) |
| if len(drive_files) != 0: |
| logging.info("Removing existing files from %s", |
| destination) |
| drive_files[0].click() |
| logging.debug("Select all files/dirs") |
| graphics_utils.press_keys(SELECT_ALL_KEY_COMBINATION) |
| time.sleep(0.2) |
| driver.find_element_by_id(DELETE_BUTTON_ID).click() |
| driver.find_element_by_class_name(CR_DIALOG_CLASS).click() |
| time.sleep(self.TIME_DELAY) |
| logging.debug("Pressing control+v to paste the file in required " |
| "location") |
| graphics_utils.press_keys(PASTE_KEY_COMBINATION) |
| time.sleep(self.TIME_DELAY) |
| # Take dummy values initially |
| required_file_size = "0" |
| required_file_size_units = "KB" |
| required_file = None |
| # wait till the data copied |
| start_time = time.time() |
| while required_file_size != file_size and \ |
| required_file_size_units != file_size_units and \ |
| (time.time() - start_time <= TIMEOUT_TO_COPY): |
| drive_files_during_copy = self.list_files(driver) |
| if len(drive_files_during_copy) == 0: |
| raise error.TestError("File copy not started!") |
| for i_item in drive_files_during_copy: |
| if i_item.text.strip().split()[0].strip() == file_name: |
| logging.info("File found %s", i_item.text.split()[ |
| 0].strip()) |
| required_file = file |
| if not required_file: |
| raise error.TestError("No such file/directory in drive, " |
| "%s", required_file) |
| logging.info(required_file.text.split()) |
| required_file_size = required_file.text.split()[1] |
| required_file_size_units = required_file.text.split()[2] |
| time.sleep(5) |
| logging.debug("%s %s data copied" % (required_file_size, |
| required_file_size_units)) |
| # Validation starts here |
| found = False |
| drive_files_after_copy = self.list_files(driver) |
| for copied_file in drive_files_after_copy: |
| logging.debug("File in destination: %s", |
| copied_file.text.strip()) |
| if copied_file.find_element_by_class_name( |
| 'entry-name').text.strip() == file_name: |
| found = True |
| break |
| |
| if found: |
| logging.info("Copied the file successfully!") |
| else: |
| raise error.TestFail("File not transferred successfully!") |
| |
| def catch_info_or_error_messages(self, driver): |
| """Logic to catch the error |
| |
| @param driver: chrome driver object |
| """ |
| errors = [] |
| try: |
| driver.find_element_by_css_selector( |
| 'div.button-frame').find_element_by_class_name('open').click() |
| except Exception as e: |
| logging.info("Error in open error messages") |
| logging.info(str(e)) |
| error_elements = driver.find_elements_by_css_selector( |
| 'div.progress-frame') |
| if len(error_elements) != 0: |
| for error_element in error_elements: |
| info_text = error_element.find_element_by_tag_name( |
| 'label').text |
| if info_text != "": |
| errors.append(info_text) |
| return errors |
| |
| def create_file(self, filename): |
| """Create a file""" |
| status, output = getstatusoutput('dd if=/dev/zero of=%s bs=%s ' |
| 'count=1 iflag=fullblock' % |
| (filename, 1024)) |
| if status: |
| raise error.TestError("Failed to create file") |
| |
| def run_once(self, username=None, password=None, source="Downloads", |
| file_name='test.dat'): |
| """Copy file to Google Drive in Files application |
| |
| @param username: Real user(Not default autotest user) |
| @param password: Password for the user. |
| @param source: From where to copy file |
| @param file_name: File name |
| """ |
| self.success = False # Used to capture the screenshot if the TC fails |
| with chromedriver.chromedriver(username=username, |
| password=password, |
| disable_default_apps=False, |
| gaia_login=True) as cr_instance: |
| driver = cr_instance.driver |
| self.open_files_application(driver) |
| self.create_file(os.path.join(os.path.join(USER_LOCATION, |
| source), file_name)) |
| self.copy_file(driver, source, GOOGLE_DRIVE, file_name) |
| errors = self.catch_info_or_error_messages(driver) |
| if len(errors): |
| raise error.TestFail("Test failed with the following" |
| " errors. %s", errors) |
| self.success = True |
