#!/usr/bin/env python
# Copyright (c) 2012 The Chromium 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 glob
import logging
import optparse
import os
import shutil
import sys
import tempfile
import zipfile


import pyauto_functional  # Must be imported before pyauto
import pyauto
import pyauto_utils


class ImportsTest(pyauto.PyUITest):
  """Import settings from other browsers.

  Import settings tables below show which items get imported on first run and
  via preferences for different browsers and operating systems.

            Bookmarks   History   SearchEngines   Passwords   Homepage
  Firefox:
  Win/FRUI      N          Y            N             N          Y
  Win/Prefs     Y          Y            Y             Y          N
  Mac&Lin/FRUI  Y          Y            Y             Y          Y
  Mac&Lin/Prefs Y          Y            Y             Y          N

  Safari:
  Mac/FRUI      Y          Y            Y             Y          N
  Mac/Prefs     Y          Y            Y             Y          N
  """
  def setUp(self):
    self._to_import = ['ALL']

    if pyauto.PyUITest.IsMac():
      self._firefox_profiles_path = os.path.join(
          os.environ['HOME'], 'Library','Application Support','Firefox')
      self._firefox_test_profile = os.path.abspath(os.path.join(
          pyauto.PyUITest.DataDir(), 'import', 'firefox', 'macwin.zip'))
      self._safari_profiles_path = os.path.join(
          os.environ['HOME'], 'Library', 'Safari')
      # Don't import passwords to avoid Keychain popups. See crbug.com/49378.
      self._to_import = ['HISTORY', 'FAVORITES', 'SEARCH_ENGINES', 'HOME_PAGE']
    elif pyauto.PyUITest.IsWin():
      self._firefox_profiles_path = os.path.join(
          os.getenv('APPDATA'), 'Mozilla', 'Firefox')
      self._firefox_test_profile = os.path.abspath(os.path.join(
          pyauto.PyUITest.DataDir(), 'import', 'firefox', 'macwin.zip'))
    else:  # Linux
      self._firefox_profiles_path = os.path.join(
          os.environ['HOME'], '.mozilla', 'firefox')
      self._firefox_test_profile = os.path.abspath(os.path.join(
          pyauto.PyUITest.DataDir(), 'import', 'firefox', 'linux.zip'))

    # Expected items for tests.
    self._history_items = ['Google', 'Google News', u'Google \ub3c4\uc11c']
    self._bookmark_bar_items = ['Google News', 'Google', u'Google \ub3c4\uc11c']
    self._bookmark_folder_items = []
    self._password_items = ['etouchqa@gmail.com', 'macqa05']
    self._home_page = 'http://news.google.com/'

    self._safari_replacer = None
    self._firefox_replacer = None

    pyauto.PyUITest.setUp(self)

  def tearDown(self):
    pyauto.PyUITest.tearDown(self)
    # Delete any replacers to restore the original profiles.
    if self._safari_replacer:
      del self._safari_replacer
    if self._firefox_replacer:
      del self._firefox_replacer

  def _UnzipProfileToDir(self, profile_zip, dir):
    """Unzip |profile_zip| into directory |dir|.

    Creates |dir| if it doesn't exist.
    """
    if not os.path.isdir(dir):
      os.makedirs(dir)
    zf = zipfile.ZipFile(profile_zip)
    for name in zf.namelist():
      full_path = os.path.join(dir, name)
      if name.endswith('/'):
        if not os.path.isdir(full_path):
          os.makedirs(full_path)
      else:
        zf.extract(name, dir)
      os.chmod(full_path, 0777)

  def _SwapFirefoxProfile(self):
    """Swaps the test Firefox profile with the original one."""
    self._firefox_replacer = pyauto_utils.ExistingPathReplacer(
        self._firefox_profiles_path)
    self._UnzipProfileToDir(self._firefox_test_profile,
                            self._firefox_profiles_path)

  def _SwapSafariProfile(self):
    """Swaps the test Safari profile with the original one."""
    self._safari_replacer = pyauto_utils.ExistingPathReplacer(
        self._safari_profiles_path)
    self._UnzipProfileToDir(
        os.path.join(self.DataDir(), 'import', 'safari', 'mac.zip'),
        self._safari_profiles_path)

  def _CheckForBookmarks(self, bookmark_titles, bookmark_bar, window_index=0):
    """Checks that the given bookmarks exist.

    Args:
      bookmark_titles: A set of bookmark title strings.
      bookmark_bar: True if the bookmarks are part of the bookmark bar.
                    False otherwise.
      window_index: The window index, default is 0.
    """
    bookmarks = self.GetBookmarkModel(window_index)
    if bookmark_bar:
      node = bookmarks.BookmarkBar()
    else:
      node = bookmarks.Other()
    for title in bookmark_titles:
      self.assertTrue([x for x in bookmark_titles \
                       if bookmarks.FindByTitle(title, [node])])

  def _BookmarkDuplicatesExist(self, bookmark_titles):
    """Returns true if any of the bookmark titles are duplicated.

    Args:
      bookmark_titles: A list of bookmark title strings.
    """
    bookmarks = self.GetBookmarkModel()
    for title in bookmark_titles:
      if len(bookmarks.FindByTitle(title)) > 1:
        return True
    return False

  def _CheckForHistory(self, history_titles):
    """Verifies that the given list of history items are in the history.

    Args:
      history_titles: A list of history title strings.
    """
    history = self.GetHistoryInfo().History()

    # History import automation is broken - crbug.com/63001
    return

    for title in history_titles:
      self.assertTrue([x for x in history if x['title'] == title])

  def _CheckForPasswords(self, usernames):
    """Check that password items exist for the given usernames."""
    # Password import automation does not work on Mac. See crbug.com/52124.
    if self.IsMac():
      return
    passwords = self.GetSavedPasswords()
    for username in usernames:
      self.assertTrue([x for x in passwords if x['username_value'] == username])

  def _CheckDefaults(self, bookmarks, history, passwords, home_page,
                     search_engines, window_index=0):
    """Checks the defaults for each of the possible import items.

    All arguments are True if they should be checked, False otherwise."""
    if bookmarks:
      self._CheckForBookmarks(self._bookmark_bar_items, True, window_index)
      self._CheckForBookmarks(self._bookmark_folder_items, False, window_index)
    if history:
      self._CheckForHistory(self._history_items)
    if passwords:
      self._CheckForPasswords(self._password_items)
    if home_page:
      self.assertEqual(self._home_page, self.GetPrefsInfo().Prefs()['homepage'])
    # TODO(alyssad): Test for search engines after a hook is added.
    # See crbug.com/52009.

  def _CanRunFirefoxTests(self):
    """Determine whether we can run firefox imports.

    On windows, checks if firefox is installed. Always True on other platforms.
    """
    if self.IsWin():
      ff_installed = os.path.exists(os.path.join(
          os.getenv('ProgramFiles'), 'Mozilla Firefox', 'firefox.exe'))
      if not ff_installed:
        logging.warn('Firefox not installed.')
      return ff_installed
    # TODO(nirnimesh): Anything else to be done on other platforms?
    return True

  def _ImportFromFirefox(self, bookmarks, history, passwords, home_page,
                         search_engines, window_index=0):
    """Verify importing individual Firefox data through preferences"""
    if not self._CanRunFirefoxTests():
      logging.warn('Not running firefox import tests.')
      return
    self._SwapFirefoxProfile()
    self.ImportSettings('Mozilla Firefox', False, self._to_import, window_index)
    self._CheckDefaults(bookmarks, history, passwords, home_page,
                        search_engines, window_index)

  def _GetProfilePath(self):
    """Get profile paths when multiprofile windows are open.

    Returns:
      profile: Path for multiprofiles.
    """
    profiles_list = self.GetMultiProfileInfo()['profiles']
    profile1_path = profile2_path = default_path = None
    for profile in profiles_list:
      if profile['path'].find('Profile 1') != -1:
        profile1_path = profile['path']
      elif profile['path'].find('Profile 2') != -1:
        profile2_path = profile['path']
      elif profile['path'].find('Default') != -1:
        default_path = profile['path']
    return default_path, profile1_path, profile2_path

  # Tests.
  def testFirefoxImportFromPrefs(self):
    """Verify importing Firefox data through preferences."""
    if not self._CanRunFirefoxTests():
      logging.warn('Not running firefox import tests.')
      return
    if self.IsWinVista():  # Broken on vista. crbug.com/89768
      return
    self._SwapFirefoxProfile()
    self.ImportSettings('Mozilla Firefox', False, self._to_import)
    self._CheckDefaults(bookmarks=True, history=True, passwords=True,
                        home_page=False, search_engines=True)

  def testFirefoxFirstRun(self):
    """Verify importing from Firefox on the first run.

    For Win, only history and homepage will only be imported.
    Mac and Linux can import history, homepage, and bookmarks.
    """
    if not self._CanRunFirefoxTests():
      logging.warn('Not running firefox import tests.')
      return
    self._SwapFirefoxProfile()
    self.ImportSettings('Mozilla Firefox', True, self._to_import)
    non_win = not self.IsWin()
    self._CheckDefaults(bookmarks=non_win, history=True, passwords=True,
                        home_page=non_win, search_engines=True)

  def testImportFirefoxDataTwice(self):
    """Verify importing Firefox data twice.

    Bookmarks should be duplicated, but history and passwords should not.
    """
    if not self._CanRunFirefoxTests():
      logging.warn('Not running firefox import tests.')
      return
    if self.IsWinVista():  # Broken on vista. crbug.com/89768
      return
    self._SwapFirefoxProfile()
    self.ImportSettings('Mozilla Firefox', False, self._to_import)
    num_history_orig = len(self.GetHistoryInfo().History())
    num_passwords_orig = len(self.GetSavedPasswords())

    # Re-import and check for duplicates.
    self.ImportSettings('Mozilla Firefox', False, self._to_import)
    self.assertTrue(self._BookmarkDuplicatesExist(
        self._bookmark_bar_items + self._bookmark_folder_items))
    self.assertEqual(num_history_orig, len(self.GetHistoryInfo().History()))
    self.assertEqual(num_passwords_orig, len(self.GetSavedPasswords()))

  def testImportFirefoxBookmarksFromPrefs(self):
    """Verify importing Firefox bookmarks through preferences."""
    self._ImportFromFirefox(bookmarks=True, history=False, passwords=False,
                            home_page=False, search_engines=False)

  def testImportFirefoxHistoryFromPrefs(self):
    """Verify importing Firefox history through preferences."""
    self._ImportFromFirefox(bookmarks=False, history=True, passwords=False,
                            home_page=False, search_engines=False)

  def testImportFirefoxPasswordsFromPrefs(self):
    """Verify importing Firefox passwords through preferences."""
    if self.IsWinVista():  # Broken on vista. crbug.com/89768
      return
    self._ImportFromFirefox(bookmarks=False, history=False, passwords=True,
                            home_page=False, search_engines=False)

  def testImportFirefoxSearchEnginesFromPrefs(self):
    """Verify importing Firefox search engines through preferences."""
    self._ImportFromFirefox(bookmarks=False, history=False, passwords=False,
                            home_page=False, search_engines=True)

  def testImportFromFirefoxAndSafari(self):
    """Verify importing from Firefox and then Safari."""
    # This test is for Mac only.
    if not self.IsMac():
      return

    self._SwapSafariProfile()
    self._SwapFirefoxProfile()
    self.ImportSettings('Mozilla Firefox', False, self._to_import)
    self.ImportSettings('Safari', False, self._to_import)

    self._CheckDefaults(bookmarks=True, history=True, passwords=True,
                        home_page=False, search_engines=True)
    self.assertTrue(self._BookmarkDuplicatesExist(
        self._bookmark_bar_items + self._bookmark_folder_items))

  def testSafariImportFromPrefs(self):
    """Verify importing Safari data through preferences."""
    # This test is Mac only.
    if not self.IsMac():
      return
    self._SwapSafariProfile()
    self.ImportSettings('Safari', False, self._to_import)
    self._CheckDefaults(bookmarks=True, history=True, passwords=False,
                        home_page=False, search_engines=True)

  def testSafariFirstRun(self):
    """Verify importing Safari data on the first run."""
    # This test is Mac only.
    if not self.IsMac():
      return
    self._SwapSafariProfile()
    self.ImportSettings('Safari', False, self._to_import)
    self._CheckDefaults(bookmarks=True, history=True, passwords=False,
                        home_page=False, search_engines=False)

  def testImportSafariDataTwice(self):
    """Verify importing Safari data twice.

    Bookmarks should be duplicated, but history and passwords should not."""
    # This test is Mac only.
    if not self.IsMac():
      return
    self._SwapSafariProfile()
    self.ImportSettings('Safari', False, self._to_import)
    num_history_orig = len(self.GetHistoryInfo().History())
    num_passwords_orig = len(self.GetSavedPasswords())

    # Re-import and check for duplicates.
    self.ImportSettings('Safari', False, self._to_import)
    self.assertTrue(self._BookmarkDuplicatesExist(
        self._bookmark_bar_items + self._bookmark_folder_items))
    self.assertEqual(num_history_orig, len(self.GetHistoryInfo().History()))
    self.assertEqual(num_passwords_orig, len(self.GetSavedPasswords()))

  def testFireFoxImportBookmarksMultiProfile(self):
    """Verify importing Firefox bookmarks through preferences.

    Bookmarks are imported from Firefox through the preferences for multiple
    profiles."""
    # Create new profile, import bookmarks from firefox.
    self.OpenNewBrowserWindowWithNewProfile()
    self._ImportFromFirefox(bookmarks=True, history=False,
                            passwords=False, home_page=False,
                            search_engines=False, window_index=1)
    # Create new profile, add 'BING', 'DB' as bookmark.
    self.OpenNewBrowserWindowWithNewProfile()
    bookmarks = self.GetBookmarkModel(2)
    bar_id = bookmarks.BookmarkBar()['id']
    self.AddBookmarkURL(bar_id, 0, 'BING', 'http://www.bing.com/', 2)
    self.AddBookmarkURL(bar_id, 0, 'DB', 'http://www.oracle.com/', 2)
    default_path, profile1_path, profile2_path = self._GetProfilePath()
    # Close profile1/profile2 windows.
    self.CloseBrowserWindow(2)
    self.CloseBrowserWindow(1)
    # Launch profile2.
    self.OpenProfileWindow(path=profile2_path)
    # Verify bookmark imported from firefox 'GoogleNews' in
    # profile2 is not present.
    bookmarks = self.GetBookmarkModel(1)
    node = bookmarks.FindByTitle('GoogleNews')
    self.assertEqual(0, len(node))
    # Assert if 'BING' is present.
    node = bookmarks.FindByTitle('BING')
    self.assertEqual(1, len(node))


if __name__ == '__main__':
  pyauto_functional.Main()