#!/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 mox
import sys
import unittest
import urllib

import constants
sys.path.append(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.lib import cros_build_lib


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

  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):
    """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).AndReturn(return_status)
    return_status.getcode().AndReturn(200)
    return_status.read().AndReturn(return_status.json)
    self.mox.ReplayAll()
    self.assertEqual(validation_pool.ValidationPool._IsTreeOpen(),
                     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)

  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.mox.CreateMock(cros_patch.GerritPatch)
    patch2 = self.mox.CreateMock(cros_patch.GerritPatch)

    patch1.id = 'ChangeId1'
    patch2.id = 'ChangeId2'
    patch1.url = 'fake_url/1'
    patch2.url = 'fake_url/2'
    build_root = 'fakebuildroot'

    pool = validation_pool.ValidationPool(False, 1, 'build_name', True, False)
    pool.changes = [patch1, patch2]

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

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

    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.mox.CreateMock(cros_patch.GerritPatch)
    patch2 = self.mox.CreateMock(cros_patch.GerritPatch)

    patch1.id = 'ChangeId1'
    patch2.id = 'ChangeId2'
    patch2.project = 'fake_project'
    patch1.url = 'fake_url/1'
    patch2.url = 'fake_url/2'
    build_root = 'fakebuildroot'

    pool = validation_pool.ValidationPool(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).AndReturn(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.mox.CreateMock(cros_patch.GerritPatch)
    patch2 = self.mox.CreateMock(cros_patch.GerritPatch)

    patch1.id = 'ChangeId1'
    patch2.id = 'ChangeId2'
    patch2.project = 'fake_project'
    patch1.url = 'fake_url/1'
    patch2.url = 'fake_url/2'
    build_root = 'fakebuildroot'

    pool = validation_pool.ValidationPool(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).AndReturn(True)
    patch2.Apply(build_root, trivial=True)

    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.mox.CreateMock(cros_patch.GerritPatch)
    patch2 = self.mox.CreateMock(cros_patch.GerritPatch)
    patch3 = self.mox.CreateMock(cros_patch.GerritPatch)
    patch4 = self.mox.CreateMock(cros_patch.GerritPatch)

    patch1.id = 'ChangeId1'
    patch2.id = 'ChangeId2'
    patch3.id = 'ChangeId3'
    patch4.id = 'ChangeId4'
    patch1.url = 'fake_url/1'
    patch2.url = 'fake_url/2'
    patch3.url = 'fake_url/3'
    patch4.url = 'fake_url/4'
    build_root = 'fakebuildroot'

    pool = validation_pool.ValidationPool(False, 1, 'build_name', True, False)
    pool.changes = [patch1, patch2, patch3, patch4]
    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)

    # 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,
            type=cros_patch.ApplyPatchException.TYPE_REBASE_TO_PATCH_INFLIGHT))

    patch1.HandleCouldNotApply(None, pool.build_log, dryrun=False)

    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.mox.CreateMock(cros_patch.GerritPatch)
    patch2 = self.mox.CreateMock(cros_patch.GerritPatch)

    patch1.id = 'ChangeId1'
    patch2.id = 'ChangeId2'
    patch1.url = 'fake_url/1'
    patch2.url = 'fake_url/2'
    build_root = 'fakebuildroot'

    pool = validation_pool.ValidationPool(False, 1, 'build_name', True, False)
    pool.changes = [patch1, patch2]
    pool.build_log = 'log'

    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)

    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.mox.CreateMock(cros_patch.GerritPatch)
    patch2 = self.mox.CreateMock(cros_patch.GerritPatch)
    patch3 = self.mox.CreateMock(cros_patch.GerritPatch)
    patch4 = self.mox.CreateMock(cros_patch.GerritPatch)
    patch5 = self.mox.CreateMock(cros_patch.GerritPatch)

    patch1.id = 'ChangeId1'
    patch2.id = 'ChangeId2'
    patch3.id = 'ChangeId3'
    patch4.id = 'ChangeId4'
    patch5.id = 'ChangeId5'
    patch1.url = 'fake_url/1'
    patch2.url = 'fake_url/2'
    patch3.url = 'fake_url/3'
    patch4.url = 'fake_url/4'
    patch5.url = 'fake_url/5'

    build_root = 'fakebuildroot'

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

    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)
    patch1.Apply(build_root, trivial=True)
    patch3.Apply(build_root, trivial=True)
    patch5.Apply(build_root, trivial=True)
    patch4.Apply(build_root, trivial=True)

    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.mox.CreateMock(cros_patch.GerritPatch)
    patch2 = self.mox.CreateMock(cros_patch.GerritPatch)

    patch1.id = 'ChangeId1'
    patch2.id = 'ChangeId2'
    patch1.url = 'fake_url/1'
    patch2.url = 'fake_url/2'
    build_root = 'fakebuildroot'

    pool = validation_pool.ValidationPool(False, 1, 'build_name', True, False)
    pool.changes = [patch1, patch2]

    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)
    patch2.Apply(build_root, trivial=True)

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

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

    patch1.id = 'ChangeId1'
    patch2.id = 'ChangeId2'
    build_root = 'fakebuildroot'

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

    patch1.Submit(helper, dryrun=False)
    helper.IsChangeCommitted(patch1.id).AndReturn(True)
    patch2.Submit(helper, dryrun=False)
    helper.IsChangeCommitted(patch2.id).AndReturn(True)

    self.mox.ReplayAll()
    pool.SubmitPool()
    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.mox.CreateMock(cros_patch.GerritPatch)
    patch2 = self.mox.CreateMock(cros_patch.GerritPatch)
    patch3 = self.mox.CreateMock(cros_patch.GerritPatch)
    helper = self.mox.CreateMock(gerrit_helper.GerritHelper)

    patch1.id = 'ChangeId1'
    patch2.id = 'ChangeId2'
    patch3.id = 'ChangeId3'
    build_root = 'fakebuildroot'

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

    patch1.Submit(helper, dryrun=False)
    helper.IsChangeCommitted(patch1.id).AndReturn(False)
    patch1.HandleCouldNotSubmit(helper, pool.build_log, dryrun=False)
    patch2.Submit(helper, dryrun=False).AndRaise(
        cros_build_lib.RunCommandError('Failed to submit', 'cmd', 1))
    patch2.HandleCouldNotSubmit(helper, pool.build_log, dryrun=False)
    patch3.Submit(helper, dryrun=False)
    helper.IsChangeCommitted(patch3.id).AndReturn(True)

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


if __name__ == '__main__':
  unittest.main()