def Check(self, urls=None, first_run=True):
    """Run reachability check.

    Args:
      urls: iterable(str), The list of urls to check connection to. Defaults to
        DefaultUrls() (above) if not supplied.
      first_run: bool, True if first time this has been run this invocation.

    Returns:
      A tuple of (check_base.Result, fixer) where fixer is a function that can
        be used to fix a failed check, or  None if the check passed or failed
        with no applicable fix.
    """
    if urls is None:
      urls = DefaultUrls()

    failures = []
    for url in urls:
      fail = self._CheckURL(url)
      if fail:
        failures.append(fail)
    if failures:
      fail_message = self._ConstructMessageFromFailures(failures, first_run)
      result = check_base.Result(passed=False, message=fail_message,
                                 failures=failures)
      fixer = http_proxy_setup.ChangeGcloudProxySettings
      return result, fixer

    pass_message = 'Reachability Check {0}.'.format('passed' if first_run else
                                                    'now passes')
    result = check_base.Result(passed=True, message='No URLs to check.'
                               if not urls else pass_message)
    return result, None
Ejemplo n.º 2
0
    def Check(self, first_run=True):
        """Run hidden property check.

    Args:
      first_run: bool, True if first time this has been run this invocation.

    Returns:
      A tuple of (check_base.Result, fixer) where fixer is a function that can
        be used to fix a failed check, or None if the check passed or failed
        with no applicable fix.
    """
        failures = []
        for prop in _AllProperties():
            if prop.is_internal:
                continue
            if prop.is_hidden:
                fail = self._CheckHiddenProperty(prop)
                if fail:
                    failures.append(fail)
        if failures:
            fail_message = self._ConstructMessageFromFailures(
                failures, first_run)
            result = check_base.Result(passed=False,
                                       message=fail_message,
                                       failures=failures)
            return result, None

        pass_message = 'Hidden Property Check {0}.'.format(
            'passed' if first_run else 'now passes')
        result = check_base.Result(passed=True, message=pass_message)
        return result, None
 def testNoNetworkIssues(self):
   self.run_check_mock.return_value = check_base.Result(passed=True), None
   self.assertTrue(network_diagnostics.NetworkDiagnostic().RunChecks())
   self.assertEqual(1, self.run_check_mock.call_count)
   self.assertFalse(self.fixer_mock.called)
   self.AssertErrContains(
       'Network diagnostic passed (1/1 checks passed).')
 def testEmptyUrlList(self):
   self.http_request_mock.return_value = 'dummy_response', 'dummy_content'
   expected_result = check_base.Result(passed=True,
                                       message='No URLs to check.')
   actual_result, actual_fixer = self.reachability_checker.Check([])
   self.AssertResultEqual(expected_result, actual_result)
   self.assertEqual(None, actual_fixer)
 def testGoodConnectionNoUrls(self):
   self.http_request_mock.return_value = 'dummy_response', 'dummy_content'
   expected_result = check_base.Result(
       passed=True, message='Reachability Check passed.')
   actual_result, actual_fixer = self.reachability_checker.Check()
   self.AssertResultEqual(expected_result, actual_result)
   self.assertEqual(None, actual_fixer)
 def testGoodConnection(self):
     self.http_request_mock.return_value = 'dummy_response', 'dummy_content'
     expected_result = check_base.Result(
         passed=True, message='Reachability Check passed.')
     actual_result, actual_fixer = self.reachability_checker.Check(
         ['https://www.googleapis.com'])
     self.AssertResultEqual(expected_result, actual_result)
     self.assertIsNone(actual_fixer)
 def testNetworkIssuesProxyChangesMadeIssuesFixed(self):
   self.run_check_mock.side_effect = [
       (self._FAIL_RESULT, self.fixer_mock),
       (check_base.Result(passed=True), None)]
   self.fixer_mock.return_value = True
   self.assertTrue(network_diagnostics.NetworkDiagnostic().RunChecks())
   self.assertEqual(2, self.run_check_mock.call_count)
   self.assertEqual(1, self.fixer_mock.call_count)
   self.AssertErrContains(
       'Network diagnostic passed (1/1 checks passed).')
    def testIgnoreInternalProperty(self):
        self.StartEnvPatch({'CLOUDSDK_METRICS_COMMAND_NAME': 'MOCK'})
        hidden_prop_checker = property_diagnostics.HiddenPropertiesChecker(
            False)

        expected_result = check_base.Result(
            passed=True, message='Hidden Property Check passed.')
        actual_result, actual_fixer = hidden_prop_checker.Check()
        self.AssertResultEqual(expected_result, actual_result)
        self.assertIsNone(actual_fixer)
    def testIgnoreWhitelistedProperty(self):
        self.StartEnvPatch({'CLOUDSDK_CORE_ENABLE_GRI': 'MOCK'})
        self.StartPropertyPatch(property_diagnostics.HiddenPropertiesChecker,
                                '_WHITELIST',
                                return_value={'core/enable_gri'})
        hidden_prop_checker = property_diagnostics.HiddenPropertiesChecker(
            False)

        expected_result = check_base.Result(
            passed=True, message='Hidden Property Check passed.')
        actual_result, actual_fixer = hidden_prop_checker.Check()
        self.AssertResultEqual(expected_result, actual_result)
        self.assertIsNone(actual_fixer)
def CheckFailResult(urls, first_run=True,
                    exception=http_client.ResponseNotReady()):
  message = 'Reachability Check {0}.\n'.format('failed' if first_run else
                                               'still does not pass')
  def CreateFailure(url, err):
    msg = 'Cannot reach {0} ({1})'.format(url, type(err).__name__)
    return check_base.Failure(message=msg, exception=err)
  failures = [CreateFailure(url, exception) for url in urls]
  for failure in failures:
    message += '    {0}\n'.format(failure.message)
  if first_run:
    message += ('Network connection problems may be due to proxy or firewall '
                'settings.\n')
  return check_base.Result(passed=False, message=message, failures=failures)
    def testIgnoreUserWhitelistedProperty(self):
        self.StartEnvPatch({
            'CLOUDSDK_CORE_ENABLE_GRI':
            'MOCK',
            'CLOUDSDK_DIAGNOSTICS_HIDDEN_PROPERTY_WHITELIST':
            'core/enable_gri'
        })
        hidden_prop_checker = property_diagnostics.HiddenPropertiesChecker(
            False)

        expected_result = check_base.Result(
            passed=True, message='Hidden Property Check passed.')
        actual_result, actual_fixer = hidden_prop_checker.Check()
        self.AssertResultEqual(expected_result, actual_result)
        self.assertIsNone(actual_fixer)
def CheckFailResult(props):
    message = 'Hidden Property Check failed.\n'
    message += 'The following hidden properties have been set:\n'

    def CreateFailure(prop):
        msg = '[{0}]'.format(prop)
        return check_base.Failure(message=msg)

    failures = [CreateFailure(prop) for prop in props]
    for failure in failures:
        message += '    {0}\n'.format(failure.message)
    message += ('Properties files\n'
                '    User: {}\n'
                '    Installation: {}\n'.format(
                    named_configs.ConfigurationStore.ActiveConfig().file_path,
                    config.Paths().installation_properties_path))
    return check_base.Result(passed=False, message=message, failures=failures)