#!/usr/bin/python

# Copyright (c) 2011 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 that contains unittests for validation_pool module."""

import logging
import mox
import sys
import unittest
import urllib
import copy
import itertools

import constants
sys.path.insert(0, constants.SOURCE_ROOT)

from chromite.buildbot import gerrit_helper
from chromite.buildbot import patch as cros_patch
from chromite.buildbot import validation_pool
from chromite.buildbot import patch_unittest
from chromite.lib import cros_build_lib

_CountingSource = itertools.count()

# pylint: disable=W0212,R0904
class TestValidationPool(mox.MoxTestBase):
  """Tests methods in validation_pool.ValidationPool."""

  def setUp(self):
    mox.MoxTestBase.setUp(self)
    self.mox.StubOutWithMock(validation_pool, '_RunCommand')

  @property
  def test_json(self):
    return copy.deepcopy(patch_unittest.FAKE_PATCH_JSON)

  def MockPatch(self, change_id, patch_number=None):
    patch = self.mox.CreateMock(cros_patch.GerritPatch)

    patch.id = 'ChangeId%i' % (change_id,)
    patch.gerrit_number = change_id
    patch.patch_number = (patch_number if patch_number is not None else
                          _CountingSource.next())
    patch.url = 'fake_url/%i' % (change_id,)
    patch.apply_error_message = None
    patch.project = 'chromiumos/chromite'
    return patch

  def GetPool(self, *args):
    pool = validation_pool.ValidationPool(*args)
    self.mox.StubOutWithMock(pool, '_SendNotification')
    self.mox.StubOutWithMock(pool.gerrit_helper, '_SqlQuery')
    self.mox.StubOutWithMock(pool.gerrit_helper, 'FindContentMergingProjects')
    return pool

  @staticmethod
  def SetPoolsContentMergingProjects(pool, *projects):
    pool.gerrit_helper.FindContentMergingProjects().AndReturn(
        frozenset(projects))

  def _TreeStatusFile(self, message, general_state):
    """Returns a file-like object with the status message writtin in it."""
    my_response = self.mox.CreateMockAnything()
    my_response.json = '{"message": "%s", "general_state": "%s"}' % (
        message, general_state)
    return my_response

  def _TreeStatusTestHelper(self, tree_status, general_state, expected_return,
                            retries_500=0, max_timeout=0):
    """Tests whether we return the correct value based on tree_status."""
    return_status = self._TreeStatusFile(tree_status, general_state)
    self.mox.StubOutWithMock(urllib, 'urlopen')
    status_url = 'https://chromiumos-status.appspot.com/current?format=json'
    for _ in range(retries_500):
      urllib.urlopen(status_url).AndReturn(return_status)
      return_status.getcode().AndReturn(500)

    urllib.urlopen(status_url).MultipleTimes().AndReturn(return_status)
    return_status.getcode().MultipleTimes().AndReturn(200)
    return_status.read().MultipleTimes().AndReturn(return_status.json)
    self.mox.ReplayAll()
    self.assertEqual(validation_pool.ValidationPool._IsTreeOpen(max_timeout),
                     expected_return)
    self.mox.VerifyAll()

  def testTreeIsOpen(self):
    """Tests that we return True is the tree is open."""
    self._TreeStatusTestHelper('Tree is open (flaky bug on flaky builder)',
                               'open', True)

  def testTreeIsClosed(self):
    """Tests that we return false is the tree is closed."""
    self._TreeStatusTestHelper('Tree is closed (working on a patch)', 'closed',
                               False, max_timeout=5)

  def testTreeIsOpenWithTimeout(self):
    """Tests that we return True even if we get some failures."""
    self._TreeStatusTestHelper('Tree is open (flaky test)', 'open',
                               True, retries_500=2, max_timeout=10)

  def testTreeIsThrottled(self):
    """Tests that we return false is the tree is throttled."""
    self._TreeStatusTestHelper('Tree is throttled (waiting to cycle)',
                               'throttled', True)

  def testTreeStatusWithNetworkFailures(self):
    """Checks for non-500 errors.."""
    self._TreeStatusTestHelper('Tree is open (flaky bug on flaky builder)',
                               'open', True, retries_500=2)

  def testSimpleDepApplyPoolIntoRepo(self):
    """Test that we can apply changes correctly and respect deps.

    This tests a simple out-of-order change where change1 depends on change2
    but tries to get applied before change2.  What should happen is that
    we should notice change2 is a dep of change1 and apply it first.
    """
    patch1 = self.MockPatch(1)
    patch2 = self.MockPatch(2)

    build_root = 'fakebuildroot'

    pool = self.GetPool(False, 1, 'build_name', True, False)
    pool.changes = [patch1, patch2]
    self.SetPoolsContentMergingProjects(pool)

    patch1.GerritDependencies(build_root).AndReturn(['ChangeId2'])
    patch1.PaladinDependencies(build_root).AndReturn([])

    patch2.Apply(build_root, trivial=True)
    pool.HandleApplied(patch2)
    patch1.Apply(build_root, trivial=True)
    pool.HandleApplied(patch1)

    self.mox.ReplayAll()
    self.assertTrue(pool.ApplyPoolIntoRepo(build_root))
    self.mox.VerifyAll()

  def testSimpleNoApplyPoolIntoRepo(self):
    """Test that we don't try to apply a change without met dependencies.

    Patch2 is in the validation pool that depends on Patch1 (which is not)
    Nothing should get applied.
    """
    patch1 = self.MockPatch(1)
    patch2 = self.MockPatch(2)
    patch2.project = 'fake_project'
    build_root = 'fakebuildroot'

    pool = self.GetPool(False, 1, 'build_name', True, False)
    pool.changes = [patch2]
    helper = self.mox.CreateMock(gerrit_helper.GerritHelper)
    pool.gerrit_helper = helper
    patch2.GerritDependencies(build_root).AndReturn(['ChangeId1'])
    patch2.PaladinDependencies(build_root).AndReturn([])
    helper.IsChangeCommitted(patch1.id, must_match=False).AndReturn(False)
    pool._SendNotification(patch2, mox.StrContains('dependent change'))
    helper.RemoveCommitReady(patch2, dryrun=False)

    self.mox.ReplayAll()
    self.assertFalse(pool.ApplyPoolIntoRepo(build_root))
    self.mox.VerifyAll()

  def testSimpleDepApplyWhenAlreadySubmitted(self):
    """Test that we apply a change with dependency already committed."""
    patch1 = self.MockPatch(1)
    patch2 = self.MockPatch(2)
    patch2.project = 'fake_project'
    build_root = 'fakebuildroot'

    pool = self.GetPool(False, 1, 'build_name', True, False)
    pool.changes = [patch2]
    patch2.project = '3way-project'
    self.SetPoolsContentMergingProjects(pool, '3way-project')

    self.mox.StubOutWithMock(pool.gerrit_helper, 'IsChangeCommitted')
    pool.gerrit_helper.IsChangeCommitted(
        patch1.id, must_match=False).AndReturn(True)

    patch2.GerritDependencies(build_root).AndReturn(['ChangeId1'])
    patch2.PaladinDependencies(build_root).AndReturn([])
    patch2.Apply(build_root, trivial=False)
    pool.HandleApplied(patch2)

    self.mox.ReplayAll()
    self.assertTrue(pool.ApplyPoolIntoRepo(build_root))
    self.mox.VerifyAll()

  def testSimpleDepFailedApplyPoolIntoRepo(self):
    """Test that can apply changes correctly when one change fails to apply.

    This tests a simple change order where 1 depends on 2 and 1 fails to apply.
    Only 1 should get tried as 2 will abort once it sees that 1 can't be
    applied.  3 with no dependencies should go through fine.

    Since patch1 fails to apply, we should also get a call to handle the
    failure.
    """
    patch1 = self.MockPatch(1)
    patch2 = self.MockPatch(2)
    patch3 = self.MockPatch(3)
    patch4 = self.MockPatch(4)
    build_root = 'fakebuildroot'

    pool = self.GetPool(False, 1, 'build_name', True, False)
    pool.changes = [patch1, patch2, patch3, patch4]
    self.mox.StubOutWithMock(pool.gerrit_helper, 'RemoveCommitReady')
    self.SetPoolsContentMergingProjects(pool)
    pool.build_log = 'log'

    patch1.GerritDependencies(build_root).AndReturn([])
    patch1.PaladinDependencies(build_root).AndReturn([])
    patch1.Apply(build_root, trivial=True).AndRaise(
        cros_patch.ApplyPatchException(patch1))

    patch2.GerritDependencies(build_root).AndReturn(['ChangeId1'])
    patch2.PaladinDependencies(build_root).AndReturn([])
    patch3.GerritDependencies(build_root).AndReturn([])
    patch3.PaladinDependencies(build_root).AndReturn([])
    patch3.Apply(build_root, trivial=True)
    pool.HandleApplied(patch3)

    # This one should be handled later (not where patch1 is handled.
    patch4.GerritDependencies(build_root).AndReturn([])
    patch4.PaladinDependencies(build_root).AndReturn([])
    patch4.Apply(build_root, trivial=True).AndRaise(
        cros_patch.ApplyPatchException(
            patch1,
            patch_type=\
                cros_patch.ApplyPatchException.TYPE_REBASE_TO_PATCH_INFLIGHT))

    pool.HandleCouldNotApply(patch1)

    self.mox.ReplayAll()
    self.assertTrue(pool.ApplyPoolIntoRepo(build_root))
    self.assertTrue(patch4 in pool.changes_that_failed_to_apply_earlier)
    self.mox.VerifyAll()

  def testSimpleApplyButMissingChangeIDIntoRepo(self):
    """Test that applies changes correctly with a dep with missing changeid."""
    patch1 = self.MockPatch(1)
    patch2 = self.MockPatch(2)
    build_root = 'fakebuildroot'

    pool = self.GetPool(False, 1, 'build_name', True, False)
    self.mox.StubOutWithMock(pool, 'HandleCouldNotApply')

    pool.changes = [patch1, patch2]
    pool.build_log = 'log'
    self.SetPoolsContentMergingProjects(pool)

    patch1.GerritDependencies(build_root).AndRaise(
        cros_patch.MissingChangeIDException('Could not find changeid'))

    patch2.GerritDependencies(build_root).AndReturn([])
    patch2.PaladinDependencies(build_root).AndReturn([])
    patch2.Apply(build_root, trivial=True)

    pool.HandleApplied(patch2)
    pool.HandleCouldNotApply(patch1)

    self.mox.ReplayAll()
    self.assertTrue(pool.ApplyPoolIntoRepo(build_root))
    self.assertEqual([patch2.id], [x.id for x in pool.changes])
    self.mox.VerifyAll()

  def testMoreComplexDepApplyPoolIntoRepo(self):
    """More complex deps test.

    This tests a total of 2 change chains where the first change we see
    only has a partial chain with the 3rd change having the whole chain i.e.
    1->2, 3->1->2, 4->nothing.  Since we get these in the order 1,2,3,4 the
    order we should apply is 2,1,3,4.

    This test also checks the patch order to verify that Apply re-orders
    correctly based on the chain.
    """
    patch1 = self.MockPatch(1)
    patch2 = self.MockPatch(2)
    patch3 = self.MockPatch(3)
    patch4 = self.MockPatch(4)
    patch5 = self.MockPatch(5)

    build_root = 'fakebuildroot'

    pool = self.GetPool(False, 1, 'build_name', True, False)
    pool.changes = [patch1, patch2, patch3, patch4, patch5]

    self.SetPoolsContentMergingProjects(pool)

    patch1.GerritDependencies(build_root).AndReturn(['ChangeId2'])
    patch1.PaladinDependencies(build_root).AndReturn([])
    patch3.GerritDependencies(build_root).AndReturn(['ChangeId1', 'ChangeId2'])
    patch3.PaladinDependencies(build_root).AndReturn([])
    patch4.GerritDependencies(build_root).AndReturn([])
    patch4.PaladinDependencies(build_root).AndReturn(['ChangeId5'])

    patch2.Apply(build_root, trivial=True)
    pool.HandleApplied(patch2)
    patch1.Apply(build_root, trivial=True)
    pool.HandleApplied(patch1)
    patch3.Apply(build_root, trivial=True)
    pool.HandleApplied(patch3)
    patch5.Apply(build_root, trivial=True)
    pool.HandleApplied(patch5)
    patch4.Apply(build_root, trivial=True)
    pool.HandleApplied(patch4)

    self.mox.ReplayAll()
    self.assertTrue(pool.ApplyPoolIntoRepo(build_root))
    # Check order.
    self.assertEquals([x.id for x in pool.changes],
                      [y.id for y in [patch2, patch1, patch3, patch5, patch4]])
    self.mox.VerifyAll()

  def testNoDepsApplyPoolIntoRepo(self):
    """Simple apply of two changes with no dependent CL's."""
    patch1 = self.MockPatch(1)
    patch2 = self.MockPatch(2)
    build_root = 'fakebuildroot'

    pool = self.GetPool(False, 1, 'build_name', True, False)
    pool.changes = [patch1, patch2]
    self.SetPoolsContentMergingProjects(pool)

    patch1.GerritDependencies(build_root).AndReturn([])
    patch1.PaladinDependencies(build_root).AndReturn([])
    patch2.GerritDependencies(build_root).AndReturn([])
    patch2.PaladinDependencies(build_root).AndReturn([])

    patch1.Apply(build_root, trivial=True)
    pool.HandleApplied(patch1)

    patch2.Apply(build_root, trivial=True)
    pool.HandleApplied(patch2)

    self.mox.ReplayAll()
    self.assertTrue(pool.ApplyPoolIntoRepo(build_root))
    self.mox.VerifyAll()

  def testSubmitPoolWithSomeFailures(self):
    """Tests submitting a pool when some changes fail to be submitted.

    Tests what happens when we try to submit 3 patches with 2 patches failing
    to submit correctly (one with submit failure and the other not showing up
    as submitted in Gerrit.
    """
    self.mox.StubOutWithMock(validation_pool.ValidationPool, '_IsTreeOpen')
    patch1 = self.MockPatch(1)
    patch2 = self.MockPatch(2)
    patch3 = self.MockPatch(3)

    helper = self.mox.CreateMock(gerrit_helper.GerritHelper)

    build_root = 'fakebuildroot'

    validation_pool.ValidationPool._IsTreeOpen().AndReturn(True)
    pool = self.GetPool(False, 1, 'build_name', True, False)
    pool.changes = [patch1, patch2, patch3]
    pool.gerrit_helper = helper
    pool.dryrun = False

    self.mox.StubOutWithMock(pool, 'SubmitChange')
    self.mox.StubOutWithMock(helper, 'RemoveCommitReady')
    pool.SubmitChange(patch1)
    helper.IsChangeCommitted(patch1.id, False).AndReturn(False)
    pool.HandleCouldNotSubmit(patch1)
    pool.SubmitChange(patch2).AndRaise(
        cros_build_lib.RunCommandError('Failed to submit', 'cmd', 1))
    pool.HandleCouldNotSubmit(patch2)
    pool.SubmitChange(patch3)
    helper.IsChangeCommitted(patch3.id, False).AndReturn(True)

    self.mox.ReplayAll()
    self.assertRaises(validation_pool.FailedToSubmitAllChangesException,
                      validation_pool.ValidationPool.SubmitPool, (pool))
    self.mox.VerifyAll()

  def testSimpleSubmitPool(self):
    """Tests the ability to submit a list of changes."""
    self.mox.StubOutWithMock(validation_pool.ValidationPool, '_IsTreeOpen')
    helper = self.mox.CreateMock(gerrit_helper.GerritHelper)

    patch1 = self.MockPatch(1)
    patch2 = self.MockPatch(2)
    build_root = 'fakebuildroot'

    validation_pool.ValidationPool._IsTreeOpen().AndReturn(True)
    pool = self.GetPool(False, 1, 'build_name', True, False)
    pool.changes = [patch1, patch2]
    pool.gerrit_helper = helper
    pool.dryrun = False

    self.mox.StubOutWithMock(pool, 'SubmitChange')
    pool.SubmitChange(patch1)
    helper.IsChangeCommitted(patch1.id, False).AndReturn(True)
    pool.SubmitChange(patch2)
    helper.IsChangeCommitted(patch2.id, False).AndReturn(True)

    self.mox.ReplayAll()
    pool.SubmitPool()
    self.mox.VerifyAll()

  def testSubmitNonManifestChanges(self):
    """Simple test to make sure we can submit non-manifest changes."""
    self.mox.StubOutWithMock(validation_pool.ValidationPool, '_IsTreeOpen')
    patch1 = self.MockPatch(1)
    patch2 = self.MockPatch(2)
    helper = self.mox.CreateMock(gerrit_helper.GerritHelper)
    build_root = 'fakebuildroot'

    validation_pool.ValidationPool._IsTreeOpen().AndReturn(True)
    pool = self.GetPool(False, 1, 'build_name', True, False)
    pool.non_manifest_changes = [patch1, patch2]
    pool.gerrit_helper = helper
    pool.dryrun = False

    self.mox.StubOutWithMock(pool, 'SubmitChange')
    pool.SubmitChange(patch1)
    helper.IsChangeCommitted(patch1.id, False).AndReturn(True)
    pool.SubmitChange(patch2)
    helper.IsChangeCommitted(patch2.id, False).AndReturn(True)

    self.mox.ReplayAll()
    pool.SubmitNonManifestChanges()
    self.mox.VerifyAll()

  def testGerritSubmit(self):
    """Tests submission review string looks correct."""
    pool = self.GetPool(False, 1, 'build_name', True, False)

    my_patch = cros_patch.GerritPatch(self.test_json, False)
    validation_pool._RunCommand(
        'ssh -p 29418 gerrit.chromium.org gerrit review '
        '--submit 1112,2'.split(), False).AndReturn(None)
    self.mox.ReplayAll()
    pool.SubmitChange(my_patch)
    self.mox.VerifyAll()

  def testGerritHandleApplied(self):
    """Tests review string looks correct."""
    pool = self.GetPool(False, 1, 'build_name', True, False)

    my_patch = cros_patch.GerritPatch(self.test_json, False)
    pool._SendNotification(my_patch, mox.IgnoreArg())

    self.mox.ReplayAll()
    pool.HandleApplied(my_patch)
    self.mox.VerifyAll()

  def testGerritHandleApplyError(self):
    """Tests review string looks correct."""
    pool = self.GetPool(False, 1, 'build_name', True, False)
    pool.gerrit_helper._SqlQuery(mox.IgnoreArg(), dryrun=mox.IgnoreArg(),
                                 is_command=True).AndReturn(None)

    my_patch = cros_patch.GerritPatch(self.test_json, False)
    pool._SendNotification(my_patch, mox.IgnoreArg())

    self.mox.ReplayAll()
    pool.HandleCouldNotApply(my_patch)
    self.mox.VerifyAll()

  def testGerritHandleSubmitError(self):
    """Tests review string looks correct."""
    pool = self.GetPool(False, 1, 'build_name', True, False)
    pool.gerrit_helper._SqlQuery(mox.IgnoreArg(), dryrun=mox.IgnoreArg(),
                                 is_command=True).AndReturn(None)

    my_patch = cros_patch.GerritPatch(self.test_json, False)
    pool._SendNotification(my_patch, mox.IgnoreArg())

    self.mox.ReplayAll()
    pool.HandleCouldNotSubmit(my_patch)
    self.mox.VerifyAll()

  def testGerritHandleVerifyError(self):
    """Tests review string looks correct."""
    pool = self.GetPool(False, 1, 'build_name', True, False)
    pool.gerrit_helper._SqlQuery(mox.IgnoreArg(), dryrun=mox.IgnoreArg(),
                                 is_command=True).AndReturn(None)

    my_patch = cros_patch.GerritPatch(self.test_json, False)
    pool._SendNotification(my_patch, mox.IgnoreArg())

    self.mox.ReplayAll()
    pool.HandleCouldNotVerify(my_patch)
    self.mox.VerifyAll()


if __name__ == '__main__':
  logging_format = '%(asctime)s - %(filename)s - %(levelname)-8s: %(message)s'
  date_format = '%H:%M:%S'
  logging.basicConfig(level=logging.DEBUG, format=logging_format,

                      datefmt=date_format)
  unittest.main()