~asbalderson/jenkins-launchpad-plugin/private-repo

import unittest
from mock import patch
from mock import MagicMock
import tests.util as util
from jlp import get_config_option
from tarmac.exceptions import TarmacMergeError, BranchHasConflicts
from bzrlib.errors import LockFailed
from jlp.launchpadutils import LaunchpadVote
import jlp.commands.autoland as autoland


class TestGetFixesCommitMessage(unittest.TestCase):
    def test_with_bugs(self):
        mp = MagicMock()
        mp.source_branch.linked_bugs_collection = []
        for i in range(4):
            b = MagicMock()
            b.web_link = 'http://' + str(i)
            mp.source_branch.linked_bugs_collection.append(b)
        ret = autoland.get_fixes_commit_message(mp)
        expected = ' Fixes: http://0, http://1, http://2, http://3.'
        self.assertEqual(ret, expected)

    def test_no_bugs(self):
        mp = MagicMock()
        mp.source_branch.linked_bugs_collection = []
        ret = autoland.get_fixes_commit_message(mp)
        expected = ''
        self.assertEqual(ret, expected)


class TestLastMpVote(unittest.TestCase):
    def test_with_no_votes(self):
        mp = MagicMock()
        mp.votes = []
        ret = autoland.get_last_mp_vote(mp)
        self.assertEqual(ret, None)

    def test_with_no_votes_from_jenkins(self):
        mp = MagicMock()
        vote = MagicMock()
        vote.registrant.name = 'random-user'
        mp.votes = [vote]
        ret = autoland.get_last_mp_vote(mp)
        self.assertEqual(ret, None)

    def test_with_jenkins_vote(self):
        mp = MagicMock()
        expected_vote = 'Approved'
        vote = MagicMock()
        vote.registrant.name = 'random-user'
        vote2 = MagicMock()
        vote2.registrant.name = get_config_option('launchpad_login')
        vote2.comment.vote = expected_vote
        mp.votes = [vote, vote2]
        ret = autoland.get_last_mp_vote(mp)
        self.assertEqual(ret, expected_vote)

    def test_with_registered_voter_but_no_vote_yet(self):
        mp = MagicMock()
        vote = MagicMock()
        vote.registrant.name = get_config_option('launchpad_login')
        vote.comment = None
        mp.votes = [vote]
        ret = autoland.get_last_mp_vote(mp)
        self.assertEqual(ret, None)


class TestFormatCommitMessage(unittest.TestCase):
    def setUp(self):
        self.fixes = ' Fixes: http://0, http://1'
        self.approved_by = 'x, y, z'
        self.get_fixes_commit_message = lambda x: self.fixes
        self.get_approved_by_commit_message = lambda x: self.approved_by

        self.get_fixes_patch = patch(
            'jlp.commands.autoland.get_fixes_commit_message',
            new=self.get_fixes_commit_message)
        self.get_approved_by_patch = patch(
            'jlp.commands.autoland.get_approved_by_commit_message',
            new=self.get_approved_by_commit_message)
        self.get_fixes_patch.start()
        self.get_approved_by_patch.start()

    def tearDown(self):
        self.get_fixes_patch.stop()
        self.get_approved_by_patch.stop()

    def test_with_dot(self):
        mp = None
        commit_message = 'this is fixing a bug.'
        ret = autoland.format_commit_message(mp, commit_message)
        expected = commit_message + self.fixes + "\n\n" + \
            "Approved by " + self.approved_by + '.'
        self.assertEqual(ret, expected)

    def test_without_dot(self):
        mp = None
        commit_message = 'this is fixing a bug'
        ret = autoland.format_commit_message(mp, commit_message)
        expected = commit_message + '.' + self.fixes + "\n\n" + \
            "Approved by " + self.approved_by + '.'
        self.assertEqual(ret, expected)

    def test_with_empty_approved(self):
        mp = None
        self.approved_by = ''
        commit_message = 'this is fixing a bug.'
        ret = autoland.format_commit_message(mp, commit_message)
        expected = commit_message + self.fixes
        self.assertEqual(ret, expected)


class TestGetApprovedByCommitMessage(unittest.TestCase):
    def test_approved_by(self):
        mp = MagicMock()
        mp.votes = []
        for i in range(4):
            vote = MagicMock()
            vote.comment.vote = LaunchpadVote.APPROVE
            vote.reviewer.display_name = str(i)
            mp.votes.append(vote)
        ret = autoland.get_approved_by_commit_message(mp)
        expected = '0, 1, 2, 3'
        self.assertEqual(ret, expected)

    def test_approved_by_empty(self):
        mp = MagicMock()
        mp.votes = []
        ret = autoland.get_approved_by_commit_message(mp)
        expected = ''
        self.assertEqual(ret, expected)


class TestAutoland(unittest.TestCase):
    def setUp(self):
        get_launchpad = lambda launchpadlib_dir: MagicMock()
        self.get_launchpad_patch = patch('jlp.commands.autoland.get_launchpad',
                                         new=get_launchpad)
        self.get_launchpad_patch.start()

        self.mp = MagicMock()
        self.mp.source_branch.display_name = 'lp:~team/unity/lp-111222'
        self.mp.target_branch.display_name = 'lp:unity'
        self.vote_subject = 'Re: [Merge] lp:~team/unity/lp-111222 into ' +\
                            'lp:unity'
        self.get_mp_handle_from_url_patch = patch(
            'jlp.commands.autoland.launchpadutils.get_mp_handle_from_url',
            return_value=self.mp)
        self.get_mp_handle_from_url = self.get_mp_handle_from_url_patch.start()

        self.get_branch_from_mp_patch = patch(
            'jlp.commands.autoland.launchpadutils.get_branch_from_mp')
        self.get_branch_from_mp = self.get_branch_from_mp_patch.start()

        self.change_mp_status_patch = patch(
            'jlp.commands.autoland.launchpadutils.change_mp_status')
        self.change_mp_status = self.change_mp_status_patch.start()

    def tearDown(self):
        self.get_launchpad_patch.stop()
        self.get_branch_from_mp_patch.stop()
        self.change_mp_status_patch.stop()
        self.get_mp_handle_from_url_patch.stop()


class TestAutolandForMergeAndCommit(TestAutoland):
    def setUp(self):
        super(TestAutolandForMergeAndCommit, self).setUp()

        target = MagicMock()
        target.bzr_branch.revision_id_to_revno = MagicMock(return_value=100)
        target.bzr_branch.revno = MagicMock(return_value=50)
        branch = MagicMock()
        branch.create = MagicMock(return_value=target)
        self.branch_patch = patch('jlp.commands.autoland.Branch', new=branch)
        self.target = target
        self.Branch = self.branch_patch.start()

    def tearDown(self):
        super(TestAutolandForMergeAndCommit, self).tearDown()
        self.branch_patch.stop()


class TestAutolandMergeAndCommit(TestAutolandForMergeAndCommit):
    @patch('jlp.launchpadutils.close_bugs')
    def test_merge_and_commit_push_error(self, close_bugs_mock):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url']
        with patch('sys.argv', sys_argv):
            self.assertTrue(autoland.autoland() == 0)
            self.assertTrue(self.target.merge.call_count == 1)
            self.assertTrue(self.target.commit.call_count == 1)
            self.assertTrue(close_bugs_mock.call_count == 1)


class TestAutolandVoting(TestAutolandForMergeAndCommit):
    def test_last_vote_was_needs_fixing(self):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url']
        merge_and_commit = lambda x, y: 0
        get_last_mp_vote = lambda x: LaunchpadVote.NEEDS_FIXING
        with patch('sys.argv', sys_argv), \
            patch(
                'jlp.commands.autoland.get_last_mp_vote', get_last_mp_vote), \
                patch(
                    'jlp.commands.autoland.merge_and_commit',
                    merge_and_commit):
            autoland.autoland()
            self.mp.createComment.assert_called_once_with(
                review_type=get_config_option('launchpad_review_type'),
                vote=LaunchpadVote.APPROVE,
                subject=self.vote_subject)

    def test_last_vote_was_approved(self):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url']
        merge_and_commit = lambda y, z: 0
        get_last_mp_vote = lambda x: LaunchpadVote.APPROVE
        with patch('sys.argv', sys_argv), \
            patch('jlp.commands.autoland.get_last_mp_vote',
                  get_last_mp_vote), \
                patch('jlp.commands.autoland.merge_and_commit',
                      merge_and_commit):
            autoland.autoland()
            self.assertEquals(self.mp.createComment.call_count, 0)


class TestAutolandMergeAndCommitWithDescription(TestAutolandForMergeAndCommit):
    def setUp(self):
        super(TestAutolandMergeAndCommitWithDescription, self).setUp()
        self.mp.commit_message = ''
        self.mp.description = 'my description'

    @patch('jlp.launchpadutils.close_bugs')
    def test_merge_and_commit_with_description(self, close_bugs_mock):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url', '-u']
        with patch('sys.argv', sys_argv):
            self.assertTrue(autoland.autoland() == 0)
            self.assertTrue(self.target.merge.call_count == 1)
            self.assertTrue(self.target.commit.call_count == 1)
            self.assertTrue(close_bugs_mock.call_count == 1)


class TestAutolandWithMultipleDputs(TestAutolandForMergeAndCommit):
    def test_multiple_dputs(self):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url', '-p', 'ppa:myppa,ppa:myppa2',
                    '-d', 'quantal,precise']
        dputRunner = MagicMock()
        with patch('sys.argv', sys_argv), \
                patch('jlp.commands.autoland.DputRunner', new=dputRunner):
            self.assertTrue(autoland.autoland() == 0)
            ppas_expected = ['ppa:myppa', 'ppa:myppa2']
            distributions_expected = ['quantal', 'precise']
            self.assertEquals(ppas_expected, dputRunner.call_args[1]['ppas'])
            self.assertEquals(distributions_expected,
                              dputRunner.call_args[1]['distributions'])


class TestAutolandWithReleaseOnly(TestAutolandForMergeAndCommit):
    def test_release_only(self):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url', '-p', 'ppa:myppa',
                    '-d', 'quantal', '--release-only']
        dputRunner = MagicMock()
        with patch('sys.argv', sys_argv), \
                patch('jlp.commands.autoland.DputRunner', new=dputRunner):
            autoland.autoland()
            self.assertTrue(dputRunner.call_args[1]['release_only'])


class TestAutolandWithVersionFormatString(TestAutolandForMergeAndCommit):
    def test_unqouted_string(self):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url', '-p', 'ppa:myppa',
                    '-d', 'quantal', '-f', '{PACKAGE_VERSION}0']
        dputRunner = MagicMock()
        with patch('sys.argv', sys_argv), \
                patch('jlp.commands.autoland.DputRunner', new=dputRunner):
            self.assertTrue(autoland.autoland() == 0)
            version_format_expected = '{PACKAGE_VERSION}0'
            self.assertEquals(version_format_expected,
                              dputRunner.call_args[1]['versionFormat'])

    def test_quoted_string(self):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url', '-p', 'ppa:myppa',
                    '-d', 'quantal', '-f', '"{PACKAGE_VERSION}"']
        dputRunner = MagicMock()
        with patch('sys.argv', sys_argv), \
                patch('jlp.commands.autoland.DputRunner', new=dputRunner):
            self.assertTrue(autoland.autoland() == 0)
            version_format_expected = '{PACKAGE_VERSION}'
            self.assertEquals(version_format_expected,
                              dputRunner.call_args[1]['versionFormat'])


class TestAutolandMergeCommitAndDput(TestAutolandForMergeAndCommit):
    def setUp(self):
        super(TestAutolandMergeCommitAndDput, self).setUp()
        self.dputRunner = MagicMock()
        self.dputRunner_patch = patch(
            'jlp.commands.autoland.DputRunner',
            new=MagicMock(return_value=self.dputRunner))
        self.dputRunner_patch.start()

    def tearDown(self):
        super(TestAutolandMergeCommitAndDput, self).tearDown()
        self.dputRunner_patch.stop()

    @patch('jlp.launchpadutils.close_bugs')
    def test_merge_and_commit_push_error(self, close_bugs_mock):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url', '-p', 'ppa:myppa',
                    '-a', 'packaging_branch', '-b',
                    'http://10.0.0.1:8080/job/unity-daily/17/', '-d',
                    'precise']
        with patch('sys.argv', sys_argv):
            self.assertTrue(autoland.autoland() == 0)
            self.assertTrue(self.target.merge.call_count == 1)
            self.assertTrue(self.target.commit.call_count == 1)
            self.assertTrue(close_bugs_mock.call_count == 1)
            self.assertTrue(self.dputRunner.dput.call_count == 1)


class TestAutolandMergeAndCommitMergeConflict(TestAutoland):
    def setUp(self):
        super(TestAutolandMergeAndCommitMergeConflict, self).setUp()

        source = MagicMock()
        source.bzr_branch.revision_id_to_revno = MagicMock(return_value=100)
        source.bzr_branch.revno = MagicMock(return_value=50)
        source.merge.side_effect = BranchHasConflicts('branchHasConflicts')
        branch = MagicMock()
        branch.create = MagicMock(return_value=source)
        self.branch_patch = patch('jlp.commands.autoland.Branch', new=branch)
        self.Branch = self.branch_patch.start()

    def tearDown(self):
        super(TestAutolandMergeAndCommitMergeConflict, self).tearDown()
        self.branch_patch.stop()

    def test_merge_and_commit_merge_conflict(self):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url']
        with patch('sys.argv', sys_argv):
            self.assertTrue(autoland.autoland() == 1)


class TestAutolandMergeAndCommitPushFailed(TestAutoland):
    def setUp(self):
        super(TestAutolandMergeAndCommitPushFailed, self).setUp()
        source = MagicMock()
        source.bzr_branch.revision_id_to_revno = MagicMock(return_value=100)
        source.bzr_branch.revno = MagicMock(return_value=50)
        source.merge.side_effect = TarmacMergeError('tarmacMergeError')
        branch = MagicMock()
        branch.create = MagicMock(return_value=source)
        self.branch_patch = patch('jlp.commands.autoland.Branch', new=branch)
        self.Branch = self.branch_patch.start()

    def tearDown(self):
        super(TestAutolandMergeAndCommitPushFailed, self).tearDown()
        self.branch_patch.stop()

    def test_merge_and_commit_push_error(self):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url']
        with patch('sys.argv', sys_argv):
            self.assertTrue(autoland.autoland() == 1)


class TestAutolandMergeAndCommitLockFailed(TestAutoland):
    def setUp(self):
        super(TestAutolandMergeAndCommitLockFailed, self).setUp()
        source = MagicMock()
        source.bzr_branch.revision_id_to_revno = MagicMock(return_value=100)
        source.bzr_branch.revno = MagicMock(return_value=50)
        source.merge.side_effect = LockFailed('LockFailed', '')
        branch = MagicMock()
        branch.create = MagicMock(return_value=source)
        self.branch_patch = patch('jlp.commands.autoland.Branch', new=branch)
        self.Branch = self.branch_patch.start()

    def tearDown(self):
        super(TestAutolandMergeAndCommitLockFailed, self).tearDown()
        self.branch_patch.stop()

    def test_merge_and_commit_lock_failed(self):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url']
        with patch('sys.argv', sys_argv):
            self.assertTrue(autoland.autoland() == 1)


class TestAutolandMergeAndCommitUnapprovedChange(TestAutoland):
    def setUp(self):
        super(TestAutolandMergeAndCommitUnapprovedChange, self).setUp()

        source = MagicMock()
        source.bzr_branch.revision_id_to_revno = MagicMock(return_value=100)
        source.bzr_branch.revno = MagicMock(return_value=500)
        branch = MagicMock()
        branch.create = MagicMock(return_value=source)
        self.branch_patch = patch('jlp.commands.autoland.Branch', new=branch)
        self.Branch = self.branch_patch.start()

    def tearDown(self):
        super(TestAutolandMergeAndCommitUnapprovedChange, self).tearDown()
        self.branch_patch.stop()

    def test_merge_and_commit_unapproved_change(self):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url']
        with patch('sys.argv', sys_argv):
            self.assertTrue(autoland.autoland() == 1)
            self.assertTrue(
                self.change_mp_status.call_count == 1)


class TestAutolandInvalidRevid(TestAutoland):
    def setUp(self):
        super(TestAutolandInvalidRevid, self).setUp()
        self.mp.reviewed_revid = None

    def tearDown(self):
        super(TestAutolandInvalidRevid, self).tearDown()

    def test_merge_and_commit_unapproved_change(self):
        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url']
        with patch('sys.argv', sys_argv):
            self.assertTrue(autoland.autoland() == 1)
            self.assertTrue(
                self.change_mp_status.call_count == 1)


class TestAutolandEmptyCommitMessage(TestAutoland):

    def setUp(self):
        super(TestAutolandEmptyCommitMessage, self).setUp()
        self.get_commit_message_patch = patch(
            'jlp.launchpadutils.get_commit_message',
            new=lambda x, y: None)
        self.get_commit_message_patch.start()

    def tearDown(self):
        super(TestAutolandEmptyCommitMessage, self).tearDown()
        self.get_commit_message_patch.stop()

    def test_empty_commit_message(self):
        """Test the 'empty commit message' error."""

        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url']
        with patch('sys.argv', sys_argv):
            self.assertTrue(autoland.autoland() == 1)
            self.assertTrue(
                self.change_mp_status.call_count == 1)

    def test_empty_commit_message_and_description(self):
        """Test the 'empty commit message' error."""

        sys_argv = ['autoland.py', '-r', 'PASSED',
                    '-v', '123', '-m', 'url', '-u']
        with patch('sys.argv', sys_argv):
            self.assertTrue(autoland.autoland() == 1)
            self.assertTrue(
                self.change_mp_status.call_count == 1)


class TestAutoland(unittest.TestCase):

    def setUp(self):
        self.get_launchpad_patch = patch('jlp.commands.autoland.get_launchpad')
        self.get_launchpad_patch.start()

    def tearDown(self):
        self.get_launchpad_patch.stop()

    def test_gibberish(self):
        """Gibberish on the command line produces usage message."""

        sys_argv = ['--oheck']
        with patch('sys.argv', sys_argv), \
                util.captured_stderr() as stderr:
            try:
                autoland.autoland()
            except SystemExit:
                pass
            self.assertTrue("usage" in stderr.getvalue())

    @patch('jlp.commands.autoland.launchpadutils.get_branch_from_mp')
    @patch('jlp.commands.autoland.launchpadutils.change_mp_status')
    def test_test_result_failed(self, change_mp_status_mock, get_branch_mock):
        """Fail autolanding because of failed testing"""

        sys_argv = ['autoland.py', '-r', 'FAILED',
                    '-v', '123', '-m', 'url']
        with patch('sys.argv', sys_argv):
                autoland.autoland()
                self.assertTrue(
                    change_mp_status_mock.call_count == 1)