# Copyright 2017 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.

"""Module containing unit tests for failure_message_lib."""

from __future__ import print_function

import mock

from chromite.lib import constants
from chromite.lib import cros_test_lib
from chromite.lib import failure_message_lib
from chromite.lib import hwtest_results
from chromite.lib import patch_unittest
from chromite.lib import portage_util
from chromite.lib import triage_lib


DEFAULT_BUILD_SCRIPT_FAILURE_EXTRA_INFO = (
    '{\"shortname\": \"./security_test_image\"}')
DEFAULT_PACKAGE_BUILD_FAILURE_EXTRA_INFO = (
    '{\"shortname\": \"./build_image\", \"failed_packages\":'
    '[\"chromeos-base/chromeos-chrome\", \"chromeos-base/chromeos-init\"]}')


class StageFailureHelper(object):
  """Helper method to create StageFailure instances for test."""

  @classmethod
  def CreateStageFailure(
      cls, failure_id=1, build_stage_id=1, outer_failure_id=None,
      exception_type='StepFailure', exception_message='exception message',
      exception_category=constants.EXCEPTION_CATEGORY_UNKNOWN,
      extra_info=None, timestamp=None, stage_name='stage_1', board='board_1',
      stage_status=constants.BUILDER_STATUS_PASSED, build_id=1,
      master_build_id=None, builder_name='builder_name_1',
      waterfall='waterfall', build_number='build_number_1',
      build_config='config_1', build_status=constants.BUILDER_STATUS_PASSED,
      important=True, buildbucket_id='bb_id'):
    return failure_message_lib.StageFailure(
        failure_id, build_stage_id, outer_failure_id, exception_type,
        exception_message, exception_category, extra_info, timestamp,
        stage_name, board, stage_status, build_id, master_build_id,
        builder_name, waterfall, build_number, build_config, build_status,
        important, buildbucket_id)

  @classmethod
  def GetStageFailure(
      cls,
      failure_id=1,
      build_stage_id=1,
      outer_failure_id=None,
      exception_type='StepFailure',
      exception_message='exception msg',
      exception_category=constants.EXCEPTION_CATEGORY_UNKNOWN,
      extra_info=None,
      stage_name='Paygen',
      build_config=None):
    return cls.CreateStageFailure(
        failure_id, build_stage_id, outer_failure_id, exception_type,
        exception_message, exception_category, extra_info, None, stage_name,
        None, None, None, None, None, None, None, build_config, None, None,
        None)


class StageFailureTests(cros_test_lib.TestCase):
  """Tests for StageFailure."""

  def testGetStageFailureFromMessage(self):
    """Test GetStageFailureFromMessage."""
    failure_message = FailureMessageHelper.GetStageFailureMessage()
    stage_failure = failure_message_lib.StageFailure.GetStageFailureFromMessage(
        failure_message)

    self.assertEqual(stage_failure.id, 1)
    self.assertEqual(stage_failure.exception_type, 'StepFailure')
    self.assertEqual(stage_failure.exception_category,
                     constants.EXCEPTION_CATEGORY_UNKNOWN)


class FailureMessageHelper(object):
  """Helper class to help create stage failure message instances for test."""

  @classmethod
  def GetStageFailureMessage(
      cls,
      failure_id=1,
      build_stage_id=1,
      outer_failure_id=None,
      exception_type='StepFailure',
      exception_message='exception msg',
      exception_category=constants.EXCEPTION_CATEGORY_UNKNOWN,
      extra_info=None,
      stage_name='Paygen'):
    stage_failure = StageFailureHelper.GetStageFailure(
        failure_id, build_stage_id, outer_failure_id, exception_type,
        exception_message, exception_category, extra_info, stage_name)

    return failure_message_lib.StageFailureMessage(stage_failure)

  @classmethod
  def GetBuildScriptFailureMessage(
      cls,
      failure_id=2,
      build_stage_id=0,
      outer_failure_id=None,
      exception_type='BuildScriptFailure',
      exception_message='exception msg',
      exception_category=constants.EXCEPTION_CATEGORY_BUILD,
      extra_info=DEFAULT_BUILD_SCRIPT_FAILURE_EXTRA_INFO,
      stage_name='InitSDK',):
    stage_failure = StageFailureHelper.GetStageFailure(
        failure_id, build_stage_id, outer_failure_id, exception_type,
        exception_message, exception_category, extra_info, stage_name)

    return failure_message_lib.BuildScriptFailureMessage(stage_failure)

  @classmethod
  def GetPackageBuildFailureMessage(
      cls,
      failure_id=3,
      build_stage_id=0,
      outer_failure_id=None,
      exception_type='PackageBuildFailure',
      exception_message='exception msg',
      exception_category=constants.EXCEPTION_CATEGORY_BUILD,
      extra_info=DEFAULT_PACKAGE_BUILD_FAILURE_EXTRA_INFO,
      stage_name='BuildImage',):
    stage_failure = StageFailureHelper.GetStageFailure(
        failure_id, build_stage_id, outer_failure_id, exception_type,
        exception_message, exception_category, extra_info, stage_name)

    return failure_message_lib.PackageBuildFailureMessage(stage_failure)

  @classmethod
  def GetCompoundFailureMessage(
      cls,
      failure_id=4,
      build_stage_id=0,
      outer_failure_id=None,
      exception_type='BackgroundFailure',
      exception_message='exception msg',
      exception_category=constants.EXCEPTION_CATEGORY_UNKNOWN,
      extra_info=None,
      stage_name='Archive',
      stage_prefix_name='Archive'):
    stage_failure = StageFailureHelper.GetStageFailure(
        failure_id, build_stage_id, outer_failure_id, exception_type,
        exception_message, exception_category, extra_info, stage_name)

    return failure_message_lib.CompoundFailureMessage(
        stage_failure, extra_info=extra_info,
        stage_prefix_name=stage_prefix_name)

  @classmethod
  def GetTestFailureMessage(
      cls,
      failure_id=5,
      build_stage_id=0,
      outer_failure_id=None,
      exception_type='TestFailure',
      exception_message='** HWTest failed (code 1) **',
      exception_category=constants.EXCEPTION_CATEGORY_TEST,
      extra_info=None,
      stage_name='HWTest'):
    stage_failure = StageFailureHelper.GetStageFailure(
        failure_id, build_stage_id, outer_failure_id, exception_type,
        exception_message, exception_category, extra_info, stage_name)

    return failure_message_lib.StageFailureMessage(stage_failure)

  @classmethod
  def GetBuildFailureMessageWithMixedMsgs(cls):
    f_1 = cls.GetStageFailureMessage(failure_id=1, outer_failure_id=4)
    f_2 = cls.GetBuildScriptFailureMessage(failure_id=2, outer_failure_id=4)
    f_3 = cls.GetPackageBuildFailureMessage(failure_id=3, outer_failure_id=4)
    f_4 = cls.GetStageFailureMessage(failure_id=4)
    f_5 = cls.GetStageFailureMessage(failure_id=5)
    f_6 = cls.GetBuildScriptFailureMessage(failure_id=6)
    f_7 = cls.GetPackageBuildFailureMessage(failure_id=7)

    return (failure_message_lib.FailureMessageManager.ReconstructMessages(
        [f_1, f_2, f_3, f_4, f_5, f_6, f_7]))


class StageFailureMessageTests(cros_test_lib.TestCase):
  """Tests for StageFailureMessage."""

  def testDecodeExtraInfoWithNoneExtraInfo(self):
    """Test _DecodeExtraInfo with None extra_info."""
    failure_message = FailureMessageHelper.GetStageFailureMessage()

    self.assertEqual(failure_message.extra_info, {})

  def testDecodeExtraInfoWithNoneValidExtraInfo(self):
    """Test _DecodeExtraInfo with valid extra_info."""
    failure_message = FailureMessageHelper.GetStageFailureMessage(
        extra_info=DEFAULT_BUILD_SCRIPT_FAILURE_EXTRA_INFO)

    self.assertEqual(failure_message.extra_info['shortname'],
                     "./security_test_image")

  def testDecodeExtraInfoWithNoneInvalidExtraInfo(self):
    """Test _DecodeExtraInfo with invalid extra_info."""
    failure_message = FailureMessageHelper.GetStageFailureMessage(
        extra_info='{\"shortname\": \"./security_test_image\"')

    self.assertEqual(failure_message.extra_info, {})

  def testExtractStagePrefixName(self):
    """Test _ExtractStagePrefixName."""
    prefix_name_map = {
        'HWTest [arc-bvt-cq]': 'HWTest',
        'HWTest': 'HWTest',
        'ImageTest': 'ImageTest',
        'ImageTest [amd64-generic]': 'ImageTest',
        'VMTest (attempt 1)': 'VMTest',
        'VMTest [amd64-generic] (attempt 1)': 'VMTest'
    }

    for k, v in prefix_name_map.iteritems():
      failure_message = FailureMessageHelper.GetStageFailureMessage(
          stage_name=k)
      self.assertEqual(failure_message.stage_prefix_name, v)


class BuildScriptFailureMessageTests(cros_test_lib.TestCase):
  """Tests for BuildScriptFailureMessage."""

  def testGetShortname(self):
    """Test GetShortname."""
    failure_message = FailureMessageHelper.GetBuildScriptFailureMessage()

    self.assertEqual(failure_message.GetShortname(), "./security_test_image")


class PackageBuildFailureMessageTests(cros_test_lib.TestCase):
  """Tests for PackageBuildFailureMessage."""

  def testGetShortname(self):
    """Test GetShortname."""
    failure_message = FailureMessageHelper.GetPackageBuildFailureMessage()

    self.assertEqual(failure_message.GetShortname(),
                     "./build_image")

  def testGetFailedPackages(self):
    """Test GetFailedPackages."""
    failure_message = FailureMessageHelper.GetPackageBuildFailureMessage()

    self.assertItemsEqual(
        ['chromeos-base/chromeos-chrome', 'chromeos-base/chromeos-init'],
        failure_message.GetFailedPackages())


class CompoundFailureMessageTests(cros_test_lib.TestCase):
  """Tests for CompoundFailureMessage."""

  def testGetCompoundFailureMessage(self):
    """Test GetCompoundFailureMessage."""
    failure_message = FailureMessageHelper.GetPackageBuildFailureMessage()
    new_failure_message = (
        failure_message_lib.CompoundFailureMessage.GetFailureMessage(
            failure_message))
    self.assertEqual(new_failure_message.inner_failures, [])

  def testHasEmptyList(self):
    """Test HasEmptyList."""
    failure_message = FailureMessageHelper.GetCompoundFailureMessage()
    self.assertTrue(failure_message.HasEmptyList())

    failure_message.inner_failures.append(
        FailureMessageHelper.GetPackageBuildFailureMessage())
    self.assertFalse(failure_message.HasEmptyList())

  def testHasExceptionCategory(self):
    """Test HasExceptionCategory."""
    failure_message = FailureMessageHelper.GetCompoundFailureMessage()
    self.assertFalse(failure_message.HasExceptionCategory(
        constants.EXCEPTION_CATEGORY_BUILD))

    failure_message.inner_failures.append(
        FailureMessageHelper.GetPackageBuildFailureMessage())
    self.assertTrue(failure_message.HasExceptionCategory(
        constants.EXCEPTION_CATEGORY_BUILD))
    self.assertFalse(failure_message.HasExceptionCategory(
        constants.EXCEPTION_CATEGORY_LAB))

  def testMatchesExceptionCategory(self):
    """Test MatchesExceptionCategory."""
    failure_message = FailureMessageHelper.GetCompoundFailureMessage()
    self.assertFalse(failure_message.MatchesExceptionCategory(
        constants.EXCEPTION_CATEGORY_BUILD))

    failure_message.inner_failures.append(
        FailureMessageHelper.GetPackageBuildFailureMessage())
    self.assertTrue(failure_message.MatchesExceptionCategory(
        constants.EXCEPTION_CATEGORY_BUILD))
    self.assertFalse(failure_message.MatchesExceptionCategory(
        constants.EXCEPTION_CATEGORY_LAB))

    failure_message.inner_failures.append(
        FailureMessageHelper.GetStageFailureMessage())
    self.assertFalse(failure_message.MatchesExceptionCategory(
        constants.EXCEPTION_CATEGORY_BUILD))
    self.assertFalse(failure_message.MatchesExceptionCategory(
        constants.EXCEPTION_CATEGORY_LAB))


class FailureMessageManagerTests(cros_test_lib.TestCase):
  """Tests for FailureMessageManager."""

  def testCreateMessageForBuildScriptFailureMessage(self):
    """Test CreateMessage for BuildScriptFailureMessage."""
    stage_failure = StageFailureHelper.GetStageFailure(
        1, 1, 0, 'BuildScriptFailure', 'exception msg', 'build',
        '{\"shortname\": \"./security_test_image\"', 'InitSDK')
    failure_message = failure_message_lib.FailureMessageManager.CreateMessage(
        stage_failure)

    self.assertTrue(isinstance(failure_message,
                               failure_message_lib.BuildScriptFailureMessage))

  def testCreateMessageForPackageBuildFailureMessage(self):
    """Test CreateMessage for PackageBuildFailureMessage."""
    stage_failure = StageFailureHelper.GetStageFailure(
        1, 1, 0, 'PackageBuildFailure', 'exception msg', 'build',
        DEFAULT_PACKAGE_BUILD_FAILURE_EXTRA_INFO, 'BuildImage')
    failure_message = failure_message_lib.FailureMessageManager.CreateMessage(
        stage_failure)

    self.assertTrue(isinstance(failure_message,
                               failure_message_lib.PackageBuildFailureMessage))

  def testCreateMessageForStageFailureMessage(self):
    """Test CreateMessage for StageFailureMessage."""
    stage_failure = StageFailureHelper.GetStageFailure(
        1, 1, None, 'TestFailure', 'exception msg', 'build', None, 'VMTest')
    failure_message = failure_message_lib.FailureMessageManager.CreateMessage(
        stage_failure)

    self.assertTrue(isinstance(failure_message,
                               failure_message_lib.StageFailureMessage))

  def testReconstructMessagesOnMixedMsgs(self):
    """Test ReconstructMessages on mixed messages."""
    failures = FailureMessageHelper.GetBuildFailureMessageWithMixedMsgs()

    self.assertEqual(len(failures), 4)
    failure_ids = [f.failure_id for f in failures]
    self.assertItemsEqual(failure_ids, [4, 5, 6, 7])

    for f in failures:
      if f.failure_id == 4:
        self.assertTrue(isinstance(
            f, failure_message_lib.CompoundFailureMessage))
        inner_failures = f.inner_failures
        inner_failure_ids = [n_f.failure_id for n_f in inner_failures]
        self.assertItemsEqual([1, 2, 3], inner_failure_ids)

  def testReconstructMessagesOnEmptyMsgs(self):
    """Test ReconstructMessages on empty messages."""
    failures = failure_message_lib.FailureMessageManager.ReconstructMessages([])

    self.assertEqual(failures, [])

  def testConstructStageFailureMessagesOnNonCompoundFailures(self):
    """Test ConstructStageFailureMessages on non-compound failures."""
    entry_1 = StageFailureHelper.GetStageFailure(failure_id=1)
    entry_2 = StageFailureHelper.GetStageFailure(failure_id=2)
    entry_3 = StageFailureHelper.GetStageFailure(failure_id=3)
    failure_entries = [entry_1, entry_2, entry_3]

    failures = (
        failure_message_lib.FailureMessageManager.ConstructStageFailureMessages(
            failure_entries))

    self.assertEqual(len(failures), 3)
    failure_ids = [f.failure_id for f in failures]
    self.assertItemsEqual(failure_ids, [1, 2, 3])

  def testConstructStageFailureMessagesOnCompoundFailures(self):
    """Test ConstructStageFailureMessages on compound failures."""
    entry_1 = StageFailureHelper.GetStageFailure(failure_id=1)
    entry_2 = StageFailureHelper.GetStageFailure(
        failure_id=2, outer_failure_id=1)
    entry_3 = StageFailureHelper.GetStageFailure(
        failure_id=3, outer_failure_id=1)
    failure_entries = [entry_1, entry_2, entry_3]

    failures = (
        failure_message_lib.FailureMessageManager.ConstructStageFailureMessages(
            failure_entries))

    self.assertEqual(len(failures), 1)
    f = failures[0]
    self.assertEqual(f.failure_id, 1)
    self.assertTrue(isinstance(f, failure_message_lib.CompoundFailureMessage))
    inner_failure_ids = [n_f.failure_id for n_f in f.inner_failures]
    self.assertItemsEqual([2, 3], inner_failure_ids)

class BuildFailureMessageTests(patch_unittest.MockPatchBase):
  """Tests for BuildFailureMessage."""

  def ConstructBuildFailureMessage(self, message_summary="message_summary",
                                   failure_messages=None, internal=True,
                                   reason='reason', builder='builder'):
    return failure_message_lib.BuildFailureMessage(
        message_summary, failure_messages, internal, reason, builder)

  def _GetBuildFailureMessageWithMixedMsgs(self):
    failure_messages = (
        FailureMessageHelper.GetBuildFailureMessageWithMixedMsgs())
    build_failure = self.ConstructBuildFailureMessage(
        failure_messages=failure_messages)

    return build_failure

  def testBuildFailureMessageToStr(self):
    """Test BuildFailureMessageToStr."""
    build_failure = self._GetBuildFailureMessageWithMixedMsgs()

    self.assertIsNotNone(build_failure.BuildFailureMessageToStr())

  def testGetFailingStages(self):
    """Test GetFailingStages."""
    build_failure = self._GetBuildFailureMessageWithMixedMsgs()
    failing_stages = build_failure.GetFailingStages()

    self.assertItemsEqual(failing_stages, ['Paygen', 'InitSDK', 'BuildImage'])

  def testMatchesExceptionCategoryOnMixedFailuresReturnsFalse(self):
    """Test MatchesExceptionCategory on mixed failures returns False."""
    build_failure = self._GetBuildFailureMessageWithMixedMsgs()

    self.assertFalse(build_failure.MatchesExceptionCategory(
        constants.EXCEPTION_CATEGORY_BUILD))

  def testMatchesExceptionCategoryOnBuildFailuresReturnsTrue(self):
    """Test MatchesExceptionCategory on build failures returns True."""
    failure_messages = [FailureMessageHelper.GetBuildScriptFailureMessage(),
                        FailureMessageHelper.GetPackageBuildFailureMessage()]
    build_failure = self.ConstructBuildFailureMessage(
        failure_messages=failure_messages)

    self.assertTrue(build_failure.MatchesExceptionCategory(
        constants.EXCEPTION_CATEGORY_BUILD))

  def testMatchesExceptionCategoryOnCompoundFailuresReturnsTrue(self):
    """Test MatchesExceptionCategory on CompoundFailures returns True."""
    f_1 = FailureMessageHelper.GetBuildScriptFailureMessage(
        failure_id=1, outer_failure_id=3)
    f_2 = FailureMessageHelper.GetPackageBuildFailureMessage(
        failure_id=2, outer_failure_id=3)
    f_3 = FailureMessageHelper.GetStageFailureMessage(failure_id=3)
    f_4 = FailureMessageHelper.GetBuildScriptFailureMessage(failure_id=4)
    failures = (failure_message_lib.FailureMessageManager.ReconstructMessages(
        [f_1, f_2, f_3, f_4]))
    build_failure = self.ConstructBuildFailureMessage(
        failure_messages=failures)

    self.assertTrue(build_failure.MatchesExceptionCategory(
        constants.EXCEPTION_CATEGORY_BUILD))

  def testMatchesExceptionCategoryOnCompoundFailuresReturnsFalse(self):
    """Test MatchesExceptionCategory on CompoundFailures returns False."""
    f_1 = FailureMessageHelper.GetStageFailureMessage(
        failure_id=1, outer_failure_id=3)
    f_2 = FailureMessageHelper.GetPackageBuildFailureMessage(
        failure_id=2, outer_failure_id=3)
    f_3 = FailureMessageHelper.GetStageFailureMessage(failure_id=3)
    f_4 = FailureMessageHelper.GetBuildScriptFailureMessage(failure_id=4)
    failures = (failure_message_lib.FailureMessageManager.ReconstructMessages(
        [f_1, f_2, f_3, f_4]))
    build_failure = self.ConstructBuildFailureMessage(
        failure_messages=failures)

    self.assertFalse(build_failure.MatchesExceptionCategory(
        constants.EXCEPTION_CATEGORY_BUILD))

  def testHasExceptionCategoryOnMixedFailures(self):
    """Test HasExceptionCategory on mixed failures."""
    build_failure = self._GetBuildFailureMessageWithMixedMsgs()

    self.assertTrue(build_failure.HasExceptionCategory(
        constants.EXCEPTION_CATEGORY_BUILD))
    self.assertTrue(build_failure.HasExceptionCategory(
        constants.EXCEPTION_CATEGORY_UNKNOWN))
    self.assertFalse(build_failure.HasExceptionCategory(
        constants.EXCEPTION_CATEGORY_INFRA))
    self.assertFalse(build_failure.HasExceptionCategory(
        constants.EXCEPTION_CATEGORY_LAB))

  def testHasExceptionCategoryOnCompoundFailures(self):
    """Test HasExceptionCategory on CompoundFailures."""
    f_1 = FailureMessageHelper.GetBuildScriptFailureMessage(
        failure_id=1, outer_failure_id=3)
    f_2 = FailureMessageHelper.GetPackageBuildFailureMessage(
        failure_id=2, outer_failure_id=3)
    f_3 = FailureMessageHelper.GetStageFailureMessage(failure_id=3)
    failures = (failure_message_lib.FailureMessageManager.ReconstructMessages(
        [f_1, f_2, f_3]))
    build_failure = self.ConstructBuildFailureMessage(
        failure_messages=failures)

    self.assertTrue(build_failure.HasExceptionCategory(
        constants.EXCEPTION_CATEGORY_BUILD))
    self.assertTrue(build_failure.HasExceptionCategory(
        constants.EXCEPTION_CATEGORY_UNKNOWN))
    self.assertFalse(build_failure.HasExceptionCategory(
        constants.EXCEPTION_CATEGORY_INFRA))
    self.assertFalse(build_failure.HasExceptionCategory(
        constants.EXCEPTION_CATEGORY_LAB))

  def testMatchesFailureTypeOnMixedMsgs(self):
    """Test MatchesFailureType on mixed messages."""
    build_failure = self._GetBuildFailureMessageWithMixedMsgs()

    self.assertFalse(build_failure.MatchesFailureType(
        'BuildScriptFailure'))
    self.assertFalse(build_failure.MatchesFailureType(
        'PackageBuildFailure'))

  def testMatchesFailureTypeOnSingleTypeMsgs(self):
    """Test MatchesFailureType on single type messages."""
    f_1 = FailureMessageHelper.GetBuildScriptFailureMessage(
        failure_id=1, outer_failure_id=3)
    f_2 = FailureMessageHelper.GetBuildScriptFailureMessage(
        failure_id=2, outer_failure_id=3)
    f_3 = FailureMessageHelper.GetStageFailureMessage(failure_id=3)
    failures = (failure_message_lib.FailureMessageManager.ReconstructMessages(
        [f_1, f_2, f_3]))
    build_failure = self.ConstructBuildFailureMessage(
        failure_messages=failures)

    self.assertTrue(build_failure.MatchesFailureType(
        'BuildScriptFailure'))
    self.assertFalse(build_failure.MatchesFailureType(
        'PackageBuildFailure'))
    self.assertTrue(build_failure.HasFailureType(
        'StepFailure'))
    self.assertFalse(build_failure.HasFailureType(
        'BackgroundFailure'))

  def testHasFailureTypeOnMixedMsgs(self):
    """Test HasFailureType on mixed messages."""
    build_failure = self._GetBuildFailureMessageWithMixedMsgs()

    self.assertTrue(build_failure.HasFailureType(
        'BuildScriptFailure'))
    self.assertTrue(build_failure.HasFailureType(
        'PackageBuildFailure'))
    self.assertTrue(build_failure.HasFailureType(
        'StepFailure'))
    self.assertFalse(build_failure.HasFailureType(
        'BackgroundFailure'))

  def testIsPackageBuildFailureOnMixedMsgs(self):
    """Test IsPackageBuildFailure on mixed messages."""
    build_failure = self._GetBuildFailureMessageWithMixedMsgs()

    self.assertFalse(build_failure.IsPackageBuildFailure())

  def testIsPackageBuildFailureOnPackageBuildFailures(self):
    """Test IsPackageBuildFailure on PackageBuildFailures."""
    f_1 = FailureMessageHelper.GetPackageBuildFailureMessage(failure_id=1)
    f_2 = FailureMessageHelper.GetPackageBuildFailureMessage(failure_id=2)
    f_3 = FailureMessageHelper.GetPackageBuildFailureMessage(failure_id=3)
    failures = (failure_message_lib.FailureMessageManager.ReconstructMessages(
        [f_1, f_2, f_3]))
    build_failure = self.ConstructBuildFailureMessage(
        failure_messages=failures)

    self.assertTrue(build_failure.IsPackageBuildFailure())

  def _GetMockChanges(self):
    mock_change_1 = self.MockPatch(
        project='chromiumos/overlays/chromiumos-overlay')
    mock_change_2 = self.MockPatch(
        project='chromiumos/overlays/chromiumos-overlay')
    mock_change_3 = self.MockPatch(project='chromiumos/chromite')
    mock_change_4 = self.MockPatch(project='chromeos/chromeos-admin')
    return [mock_change_1, mock_change_2, mock_change_3, mock_change_4]

  def _CreateBuildFailure(self):
    f_1 = FailureMessageHelper.GetPackageBuildFailureMessage(failure_id=1)
    f_2 = FailureMessageHelper.GetPackageBuildFailureMessage(failure_id=2)
    f_3 = FailureMessageHelper.GetPackageBuildFailureMessage(failure_id=3)
    failures = (failure_message_lib.FailureMessageManager.ReconstructMessages(
        [f_1, f_2, f_3]))
    return self.ConstructBuildFailureMessage(
        failure_messages=failures)

  def testFindPackageBuildFailureSuspectsReturnsSuspects(self):
    """Test FindPackageBuildFailureSuspects which returns suspects."""
    changes = self._GetMockChanges()
    f_1 = FailureMessageHelper.GetPackageBuildFailureMessage(failure_id=1)
    build_failure = self.ConstructBuildFailureMessage(failure_messages=[f_1])

    self.PatchObject(portage_util, 'FindWorkonProjects',
                     return_value='chromiumos/overlays/chromiumos-overlay')
    suspects, no_assignee_packages = (
        build_failure.FindPackageBuildFailureSuspects(changes, f_1))
    self.assertItemsEqual([changes[0], changes[1]], suspects)
    self.assertFalse(no_assignee_packages)

    self.PatchObject(portage_util, 'FindWorkonProjects',
                     return_value='chromiumos/chromite')
    suspects, no_assignee_packages = (
        build_failure.FindPackageBuildFailureSuspects(changes, f_1))
    self.assertItemsEqual([changes[2]], suspects)
    self.assertFalse(no_assignee_packages)

  def testFindPackageBuildFailureSuspectsNoSuspects(self):
    """Test FindPackageBuildFailureSuspects which returns empty suspects."""
    changes = self._GetMockChanges()
    f_1 = FailureMessageHelper.GetPackageBuildFailureMessage(failure_id=1)
    build_failure = self.ConstructBuildFailureMessage(failure_messages=[f_1])
    self.PatchObject(portage_util, 'FindWorkonProjects',
                     return_value='chromiumos/third_party/kernel')
    suspects, no_assignee_packages = (
        build_failure.FindPackageBuildFailureSuspects(changes, f_1))

    self.assertEqual(suspects, set())
    self.assertTrue(no_assignee_packages)

  def testFindPackageBuildFailureSuspectsNoFailedPackages(self):
    """Test FindPackageBuildFailureSuspects without FailedPackages."""
    changes = self._GetMockChanges()
    f_1 = FailureMessageHelper.GetPackageBuildFailureMessage(
        failure_id=1, extra_info=None)
    build_failure = self.ConstructBuildFailureMessage(failure_messages=[f_1])

    self.PatchObject(portage_util, 'FindWorkonProjects',
                     return_value='chromiumos/overlays/chromiumos-overlay')
    suspects, no_assignee_packages = (
        build_failure.FindPackageBuildFailureSuspects(changes, f_1))

    self.assertEqual(suspects, set())
    self.assertFalse(no_assignee_packages)

  def testFindSuspectedChangesOnPackageBuildFailuresNotBlameEverything(self):
    """Test FindSuspectedChanges on PackageBuildFailures not BlameEverything."""
    changes = self._GetMockChanges()
    f_1 = FailureMessageHelper.GetPackageBuildFailureMessage(failure_id=1)
    build_failure = self.ConstructBuildFailureMessage(failure_messages=[f_1])
    mock_find = self.PatchObject(failure_message_lib.BuildFailureMessage,
                                 'FindPackageBuildFailureSuspects',
                                 return_value=({changes[2]}, False))

    suspects = build_failure.FindSuspectedChanges(
        changes, mock.Mock(), mock.Mock(), True)
    expected = triage_lib.SuspectChanges({
        changes[0]: constants.SUSPECT_REASON_OVERLAY_CHANGE,
        changes[1]: constants.SUSPECT_REASON_OVERLAY_CHANGE,
        changes[2]: constants.SUSPECT_REASON_BUILD_FAIL})
    self.assertEqual(suspects, expected)
    mock_find.assert_called_once_with(changes, f_1)

    mock_find.reset_mock()
    suspects = build_failure.FindSuspectedChanges(
        changes, mock.Mock(), mock.Mock(), False)
    expected = expected = triage_lib.SuspectChanges({
        changes[2]: constants.SUSPECT_REASON_BUILD_FAIL})
    self.assertEqual(suspects, expected)
    mock_find.assert_called_once_with(changes, f_1)

  def testFindSuspectedChangesOnPackageBuildFailuresBlameEverything(self):
    """Test FindSuspectedChanges on PackageBuildFailures and BlameEverything."""
    changes = self._GetMockChanges()
    f_1 = FailureMessageHelper.GetPackageBuildFailureMessage(failure_id=1)
    build_failure = self.ConstructBuildFailureMessage(failure_messages=[f_1])
    mock_find = self.PatchObject(failure_message_lib.BuildFailureMessage,
                                 'FindPackageBuildFailureSuspects',
                                 return_value=({changes[2]}, True))
    suspects = build_failure.FindSuspectedChanges(
        changes, mock.Mock(), mock.Mock(), True)
    expected = triage_lib.SuspectChanges({
        changes[0]: constants.SUSPECT_REASON_UNKNOWN,
        changes[1]: constants.SUSPECT_REASON_UNKNOWN,
        changes[2]: constants.SUSPECT_REASON_BUILD_FAIL,
        changes[3]: constants.SUSPECT_REASON_UNKNOWN})

    self.assertEqual(suspects, expected)
    mock_find.assert_called_once_with(changes, f_1)
    mock_find.reset_mock()

    suspects = build_failure.FindSuspectedChanges(
        changes, mock.Mock(), mock.Mock(), False)
    expected = triage_lib.SuspectChanges({
        changes[2]: constants.SUSPECT_REASON_BUILD_FAIL})
    self.assertEqual(suspects, expected)
    mock_find.assert_called_once_with(changes, f_1)

  def testFindSuspectedChangesOnHWTestFailuresNotBlameEverything(self):
    """Test FindSuspectedChanges on HWTestFailures do not blame everything."""
    changes = self._GetMockChanges()
    f_1 = FailureMessageHelper.GetTestFailureMessage(failure_id=1)
    build_failure = self.ConstructBuildFailureMessage(failure_messages=[f_1])
    mock_find = self.PatchObject(hwtest_results.HWTestResultManager,
                                 'FindHWTestFailureSuspects',
                                 return_value=({changes[2]}, False))

    build_root = mock.Mock()
    failed_hwtests = mock.Mock()

    suspects = build_failure.FindSuspectedChanges(
        changes, build_root, failed_hwtests, True)
    expected = triage_lib.SuspectChanges({
        changes[0]: constants.SUSPECT_REASON_OVERLAY_CHANGE,
        changes[1]: constants.SUSPECT_REASON_OVERLAY_CHANGE,
        changes[2]: constants.SUSPECT_REASON_TEST_FAIL})
    self.assertEqual(suspects, expected)
    mock_find.assert_called_once_with(changes, build_root, failed_hwtests)

    mock_find.reset_mock()
    suspects = build_failure.FindSuspectedChanges(
        changes, build_root, failed_hwtests, False)
    expected = expected = triage_lib.SuspectChanges({
        changes[2]: constants.SUSPECT_REASON_TEST_FAIL})
    self.assertEqual(suspects, expected)
    mock_find.assert_called_once_with(changes, build_root, failed_hwtests)

  def testFindSuspectedChangesOnHWTestFailuresBlameEverything(self):
    """Test FindSuspectedChanges on HWTestFailures and blame everything."""
    changes = self._GetMockChanges()
    f_1 = FailureMessageHelper.GetTestFailureMessage(failure_id=1)
    build_failure = self.ConstructBuildFailureMessage(failure_messages=[f_1])
    mock_find = self.PatchObject(hwtest_results.HWTestResultManager,
                                 'FindHWTestFailureSuspects',
                                 return_value=({changes[2]}, True))
    build_root = mock.Mock()
    failed_hwtests = mock.Mock()

    suspects = build_failure.FindSuspectedChanges(
        changes, build_root, failed_hwtests, True)
    expected = triage_lib.SuspectChanges({
        changes[0]: constants.SUSPECT_REASON_UNKNOWN,
        changes[1]: constants.SUSPECT_REASON_UNKNOWN,
        changes[2]: constants.SUSPECT_REASON_TEST_FAIL,
        changes[3]: constants.SUSPECT_REASON_UNKNOWN})
    self.assertEqual(suspects, expected)
    mock_find.assert_called_once_with(changes, build_root, failed_hwtests)
    mock_find.reset_mock()

    suspects = build_failure.FindSuspectedChanges(
        changes, build_root, failed_hwtests, False)
    expected = triage_lib.SuspectChanges({
        changes[2]: constants.SUSPECT_REASON_TEST_FAIL})
    self.assertEqual(suspects, expected)
    mock_find.assert_called_once_with(changes, build_root, failed_hwtests)

  def testFindSuspectedChangesOnUnknownFailures(self):
    """Test FindSuspectedChanges on unknown failures."""
    changes = self._GetMockChanges()
    f_1 = FailureMessageHelper.GetStageFailureMessage(failure_id=1)
    build_failure = self.ConstructBuildFailureMessage(failure_messages=[f_1])
    mock_find_build_failure = self.PatchObject(
        failure_message_lib.BuildFailureMessage,
        'FindPackageBuildFailureSuspects',
        return_value=({changes[2]}, True))
    mock_find_hwtest_failure = self.PatchObject(
        hwtest_results.HWTestResultManager,
        'FindHWTestFailureSuspects',
        return_value=({changes[2]}, False))
    build_root = mock.Mock()
    failed_hwtests = mock.Mock()

    suspects = build_failure.FindSuspectedChanges(
        changes, build_root, failed_hwtests, True)
    expected = triage_lib.SuspectChanges({
        changes[0]: constants.SUSPECT_REASON_UNKNOWN,
        changes[1]: constants.SUSPECT_REASON_UNKNOWN,
        changes[2]: constants.SUSPECT_REASON_UNKNOWN,
        changes[3]: constants.SUSPECT_REASON_UNKNOWN})
    self.assertEqual(suspects, expected)
    mock_find_build_failure.assert_not_called()
    mock_find_hwtest_failure.assert_not_called()

    suspects = build_failure.FindSuspectedChanges(
        changes, build_root, failed_hwtests, False)
    expected = triage_lib.SuspectChanges()
    self.assertEqual(suspects, expected)
    mock_find_build_failure.assert_not_called()
    mock_find_hwtest_failure.assert_not_called()