sdk/platform-tools/systrace/catapult/telemetry/telemetry/internal/backends/chrome/android_browser_finder_unittest.py

   1 # Copyright 2013 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import os
   6 import unittest
   7
   8 import mock
   9 from pyfakefs import fake_filesystem_unittest
  10
  11 from telemetry.core import android_platform
  12 from telemetry.internal.backends.chrome import android_browser_finder
  13 from telemetry.internal.platform import android_platform_backend
  14 from telemetry.internal.util import binary_manager
  15 from telemetry.testing import options_for_unittests
  16
  17
  18 def FakeFetchPath(dependency, arch, os_name, os_version=None):
  19   return os.path.join(
  20       'dependency_dir', dependency, '%s_%s_%s.apk' % (
  21         os_name, os_version, arch))
  22
  23
  24 class AndroidBrowserFinderTest(fake_filesystem_unittest.TestCase):
  25   def setUp(self):
  26     self.finder_options = options_for_unittests.GetCopy()
  27     # Mock out what's needed for testing with exact APKs
  28     self.setUpPyfakefs()
  29     self._fetch_path_patcher = mock.patch(
  30         'telemetry.internal.backends.chrome.android_browser_finder.binary_manager.FetchPath',  # pylint: disable=line-too-long
  31         FakeFetchPath)
  32     self._fetch_path_mock = self._fetch_path_patcher.start()
  33     self._get_package_name_patcher = mock.patch(
  34         'devil.android.apk_helper.GetPackageName')
  35     self._get_package_name_mock = self._get_package_name_patcher.start()
  36     self.fake_platform = mock.Mock(spec=android_platform.AndroidPlatform)
  37     self.fake_platform.CanLaunchApplication.return_value = True
  38     self.fake_platform._platform_backend = mock.create_autospec(
  39         android_platform_backend, spec_set=True)
  40     self.fake_platform.GetOSVersionName.return_value = 'L23ds5'
  41     self.fake_platform.GetArchName.return_value = 'armeabi-v7a'
  42     # The android_browser_finder converts the os version name to 'k' or 'l'
  43     self.expected_reference_build = FakeFetchPath(
  44         'chrome_stable', 'armeabi-v7a', 'android', 'l')
  45
  46   def tearDown(self):
  47     self.tearDownPyfakefs()
  48     self._get_package_name_patcher.stop()
  49     self._fetch_path_patcher.stop()
  50
  51   def testNoPlatformReturnsEmptyList(self):
  52     fake_platform = None
  53     possible_browsers = android_browser_finder._FindAllPossibleBrowsers(
  54         self.finder_options, fake_platform)
  55     self.assertEqual([], possible_browsers)
  56
  57   def testCanLaunchAlwaysTrueReturnsAllExceptExactAndReference(self):
  58     if not self.finder_options.chrome_root:
  59       self.skipTest('--chrome-root is not specified, skip the test')
  60     all_types = set(
  61         android_browser_finder.FindAllBrowserTypes(self.finder_options))
  62     expected_types = all_types - set(('exact', 'reference'))
  63     possible_browsers = android_browser_finder._FindAllPossibleBrowsers(
  64         self.finder_options, self.fake_platform)
  65     self.assertEqual(
  66         expected_types,
  67         set([b.browser_type for b in possible_browsers]))
  68
  69   def testCanLaunchAlwaysTrueReturnsAllExceptExact(self):
  70     if not self.finder_options.chrome_root:
  71       self.skipTest('--chrome-root is not specified, skip the test')
  72     self.fs.CreateFile(self.expected_reference_build)
  73     all_types = set(
  74         android_browser_finder.FindAllBrowserTypes(self.finder_options))
  75     expected_types = all_types - set(('exact',))
  76     possible_browsers = android_browser_finder._FindAllPossibleBrowsers(
  77         self.finder_options, self.fake_platform)
  78     self.assertEqual(
  79         expected_types,
  80         set([b.browser_type for b in possible_browsers]))
  81
  82   def testCanLaunchAlwaysTrueWithExactApkReturnsAll(self):
  83     if not self.finder_options.chrome_root:
  84       self.skipTest('--chrome-root is not specified, skip the test')
  85     self.fs.CreateFile(
  86         '/foo/ContentShell.apk')
  87     self.fs.CreateFile(self.expected_reference_build)
  88     self.finder_options.browser_executable = '/foo/ContentShell.apk'
  89     self._get_package_name_mock.return_value = 'org.chromium.content_shell_apk'
  90
  91     expected_types = set(
  92         android_browser_finder.FindAllBrowserTypes(self.finder_options))
  93     possible_browsers = android_browser_finder._FindAllPossibleBrowsers(
  94         self.finder_options, self.fake_platform)
  95     self.assertEqual(
  96         expected_types,
  97         set([b.browser_type for b in possible_browsers]))
  98
  99   def testErrorWithUnknownExactApk(self):
 100     self.fs.CreateFile(
 101         '/foo/ContentShell.apk')
 102     self.finder_options.browser_executable = '/foo/ContentShell.apk'
 103     self._get_package_name_mock.return_value = 'org.unknown.app'
 104
 105     self.assertRaises(Exception,
 106         android_browser_finder._FindAllPossibleBrowsers,
 107         self.finder_options, self.fake_platform)
 108
 109   def testErrorWithNonExistantExactApk(self):
 110     self.finder_options.browser_executable = '/foo/ContentShell.apk'
 111     self._get_package_name_mock.return_value = 'org.chromium.content_shell_apk'
 112
 113     self.assertRaises(Exception,
 114         android_browser_finder._FindAllPossibleBrowsers,
 115         self.finder_options, self.fake_platform)
 116
 117   def testNoErrorWithUnrecognizedApkName(self):
 118     if not self.finder_options.chrome_root:
 119       self.skipTest('--chrome-root is not specified, skip the test')
 120     self.fs.CreateFile(
 121         '/foo/unknown.apk')
 122     self.finder_options.browser_executable = '/foo/unknown.apk'
 123
 124     possible_browsers = android_browser_finder._FindAllPossibleBrowsers(
 125         self.finder_options, self.fake_platform)
 126     self.assertNotIn('exact', [b.browser_type for b in possible_browsers])
 127
 128   def testCanLaunchExactWithUnrecognizedApkNameButKnownPackageName(self):
 129     if not self.finder_options.chrome_root:
 130       self.skipTest('--chrome-root is not specified, skip the test')
 131     self.fs.CreateFile(
 132         '/foo/MyFooBrowser.apk')
 133     self._get_package_name_mock.return_value = 'org.chromium.chrome'
 134     self.finder_options.browser_executable = '/foo/MyFooBrowser.apk'
 135
 136     possible_browsers = android_browser_finder._FindAllPossibleBrowsers(
 137         self.finder_options, self.fake_platform)
 138     self.assertIn('exact', [b.browser_type for b in possible_browsers])
 139
 140   def testNoErrorWithMissingReferenceBuild(self):
 141     if not self.finder_options.chrome_root:
 142       self.skipTest('--chrome-root is not specified, skip the test')
 143     possible_browsers = android_browser_finder._FindAllPossibleBrowsers(
 144       self.finder_options, self.fake_platform)
 145     self.assertNotIn('reference', [b.browser_type for b in possible_browsers])
 146
 147   def testNoErrorWithReferenceBuildCloudStorageError(self):
 148     if not self.finder_options.chrome_root:
 149       self.skipTest('--chrome-root is not specified, skip the test')
 150     with mock.patch(
 151         'telemetry.internal.backends.chrome.android_browser_finder.binary_manager.FetchPath',  # pylint: disable=line-too-long
 152         side_effect=binary_manager.CloudStorageError):
 153       possible_browsers = android_browser_finder._FindAllPossibleBrowsers(
 154         self.finder_options, self.fake_platform)
 155     self.assertNotIn('reference', [b.browser_type for b in possible_browsers])
 156
 157   def testNoErrorWithReferenceBuildNoPathFoundError(self):
 158     if not self.finder_options.chrome_root:
 159       self.skipTest('--chrome-root is not specified, skip the test')
 160     self._fetch_path_mock.side_effect = binary_manager.NoPathFoundError
 161     possible_browsers = android_browser_finder._FindAllPossibleBrowsers(
 162       self.finder_options, self.fake_platform)
 163     self.assertNotIn('reference', [b.browser_type for b in possible_browsers])
 164
 165
 166 class FakePossibleBrowser(object):
 167   def __init__(self, last_modification_time):
 168     self._last_modification_time = last_modification_time
 169
 170   def last_modification_time(self):
 171     return self._last_modification_time
 172
 173
 174 class SelectDefaultBrowserTest(unittest.TestCase):
 175   def testEmptyListGivesNone(self):
 176     self.assertIsNone(android_browser_finder.SelectDefaultBrowser([]))
 177
 178   def testSinglePossibleReturnsSame(self):
 179     possible_browsers = [FakePossibleBrowser(last_modification_time=1)]
 180     self.assertIs(
 181       possible_browsers[0],
 182       android_browser_finder.SelectDefaultBrowser(possible_browsers))
 183
 184   def testListGivesNewest(self):
 185     possible_browsers = [
 186         FakePossibleBrowser(last_modification_time=2),
 187         FakePossibleBrowser(last_modification_time=3),  # newest
 188         FakePossibleBrowser(last_modification_time=1),
 189         ]
 190     self.assertIs(
 191       possible_browsers[1],
 192       android_browser_finder.SelectDefaultBrowser(possible_browsers))