~launchpad-pqm/launchpad/devel

# Copyright 2010 Canonical Ltd.  This software is licensed under the

# GNU Affero General Public License version 3 (see the file LICENSE).

# pylint: disable-msg=F0401,E1002

"""Tests for the source package recipe view classes and templates."""

__metaclass__ = type

from datetime import (

    datetime,

    timedelta,

    )

from textwrap import dedent

from BeautifulSoup import BeautifulSoup

from mechanize import LinkNotFoundError

from pytz import UTC

from testtools.matchers import Equals

import transaction

from zope.component import getUtility

from zope.security.interfaces import Unauthorized

from zope.security.proxy import removeSecurityProxy

from canonical.database.constants import UTC_NOW

from canonical.launchpad.testing.pages import (

    extract_text,

    find_main_content,

    find_tag_by_id,

    find_tags_by_class,

    get_feedback_messages,

    get_radio_button_text_for_field,

    )

from canonical.launchpad.webapp import canonical_url

from canonical.launchpad.webapp.interfaces import ILaunchpadRoot

from canonical.launchpad.webapp.servers import LaunchpadTestRequest

from canonical.testing.layers import (

    DatabaseFunctionalLayer,

    LaunchpadFunctionalLayer,

    )

from lp.app.interfaces.launchpad import ILaunchpadCelebrities

from lp.buildmaster.enums import BuildStatus

from lp.code.browser.sourcepackagerecipe import (

    SourcePackageRecipeEditView,

    SourcePackageRecipeRequestBuildsView,

    SourcePackageRecipeView,

    )

from lp.code.browser.sourcepackagerecipebuild import (

    SourcePackageRecipeBuildView,

    )

from lp.code.interfaces.sourcepackagerecipe import MINIMAL_RECIPE_TEXT

from lp.code.tests.helpers import recipe_parser_newest_version

from lp.registry.interfaces.person import TeamSubscriptionPolicy

from lp.registry.interfaces.pocket import PackagePublishingPocket

from lp.registry.interfaces.series import SeriesStatus

from lp.services.propertycache import clear_property_cache

from lp.soyuz.model.processor import ProcessorFamily

from lp.testing import (

    ANONYMOUS,

    BrowserTestCase,

    login,

    login_person,

    person_logged_in,

    TestCaseWithFactory,

    time_counter,

    )

from lp.testing.factory import remove_security_proxy_and_shout_at_engineer

from lp.testing.matchers import (

    MatchesPickerText,

    MatchesTagText,

    )

from lp.testing.views import create_initialized_view

class TestCanonicalUrlForRecipe(TestCaseWithFactory):

    layer = DatabaseFunctionalLayer

    def test_canonical_url(self):

        owner = self.factory.makePerson(name='recipe-owner')

        recipe = self.factory.makeSourcePackageRecipe(

            owner=owner, name=u'recipe-name')

        self.assertEqual(

            'http://code.launchpad.dev/~recipe-owner/+recipe/recipe-name',

            canonical_url(recipe))

class TestCaseForRecipe(BrowserTestCase):

    """Create some sample data for recipe tests."""

    def setUp(self):

        """Provide useful defaults."""

        super(TestCaseForRecipe, self).setUp()

        self.chef = self.factory.makePerson(

            displayname='Master Chef', name='chef', password='test')

        self.user = self.chef

        self.ppa = self.factory.makeArchive(

            displayname='Secret PPA', owner=self.chef, name='ppa')

        self.squirrel = self.factory.makeDistroSeries(

            displayname='Secret Squirrel', name='secret', version='100.04',

            distribution=self.ppa.distribution)

        naked_squirrel = remove_security_proxy_and_shout_at_engineer(

            self.squirrel)

        naked_squirrel.nominatedarchindep = self.squirrel.newArch(

            'i386', ProcessorFamily.get(1), False, self.chef,

            supports_virtualized=True)

    def makeRecipe(self):

        """Create and return a specific recipe."""

        chocolate = self.factory.makeProduct(name='chocolate')

        cake_branch = self.factory.makeProductBranch(

            owner=self.chef, name='cake', product=chocolate)

        return self.factory.makeSourcePackageRecipe(

            owner=self.chef, distroseries=self.squirrel, name=u'cake_recipe',

            description=u'This recipe builds a foo for disto bar, with my'

            ' Secret Squirrel changes.', branches=[cake_branch],

            daily_build_archive=self.ppa)

    def checkRelatedBranches(self, related_series_branch_info,

                             related_package_branch_info, browser_contents):

        """Check that the browser contents contain the correct branch info."""

        login(ANONYMOUS)

        soup = BeautifulSoup(browser_contents)

        # The related branches collapsible section needs to be there.

        related_branches = soup.find('fieldset', {'id': 'related-branches'})

        self.assertIsNot(related_branches, None)

        # Check the related package branches.

        root_url = canonical_url(

            getUtility(ILaunchpadRoot), rootsite='code')

        root_url = root_url.rstrip('/')

        branch_table = soup.find(

            'table', {'id': 'related-package-branches-listing'})

        if not related_package_branch_info:

            self.assertIs(branch_table, None)

        else:

            rows = branch_table.tbody.findAll('tr')

            package_branches_info = []

            for row in rows:

                branch_links = row.findAll('a')

                self.assertEqual(2, len(branch_links))

                package_branches_info.append(

                    '%s%s' % (root_url, branch_links[0]['href']))

                package_branches_info.append(branch_links[0].renderContents())

                package_branches_info.append(

                    '%s%s' % (root_url, branch_links[1]['href']))

                package_branches_info.append(branch_links[1].renderContents())

            expected_branch_info = []

            for branch_info in related_package_branch_info:

                branch = branch_info[0]

                distro_series = branch_info[1]

                expected_branch_info.append(

                    canonical_url(branch, rootsite='code'))

                expected_branch_info.append(branch.displayname)

                expected_branch_info.append(

                    canonical_url(distro_series, rootsite='code'))

                expected_branch_info.append(distro_series.name)

            self.assertEqual(package_branches_info, expected_branch_info)

        # Check the related series branches.

        branch_table = soup.find(

            'table', {'id': 'related-series-branches-listing'})

        if not related_series_branch_info:

            self.assertIs(branch_table, None)

        else:

            rows = branch_table.tbody.findAll('tr')

            series_branches_info = []

            for row in rows:

                branch_links = row.findAll('a')

                self.assertEqual(2, len(branch_links))

                series_branches_info.append(

                    '%s%s' % (root_url, branch_links[0]['href']))

                series_branches_info.append(branch_links[0].renderContents())

                series_branches_info.append(branch_links[1]['href'])

                series_branches_info.append(branch_links[1].renderContents())

            expected_branch_info = []

            for branch_info in related_series_branch_info:

                branch = branch_info[0]

                product_series = branch_info[1]

                expected_branch_info.append(

                    canonical_url(branch,

                                  rootsite='code',

                                  path_only_if_possible=True))

                expected_branch_info.append(branch.displayname)

                expected_branch_info.append(

                    canonical_url(product_series,

                                  path_only_if_possible=True))

                expected_branch_info.append(product_series.name)

            self.assertEqual(expected_branch_info, series_branches_info)

def get_message_text(browser, index):

    """Return the text of a message, specified by index."""

    tags = find_tags_by_class(browser.contents, 'message')[index]

    return extract_text(tags)

class TestSourcePackageRecipeAddViewInitalValues(TestCaseWithFactory):

    layer = DatabaseFunctionalLayer

    def test_project_branch_initial_name(self):

        # When a project branch is used, the initial name is the name of the

        # project followed by "-daily"

        widget = self.factory.makeProduct(name='widget')

        branch = self.factory.makeProductBranch(widget)

        with person_logged_in(branch.owner):

            view = create_initialized_view(branch, '+new-recipe')

        self.assertThat('widget-daily', Equals(view.initial_values['name']))

    def test_package_branch_initial_name(self):

        # When a package branch is used, the initial name is the name of the

        # source package followed by "-daily"

        branch = self.factory.makePackageBranch(sourcepackagename='widget')

        with person_logged_in(branch.owner):

            view = create_initialized_view(branch, '+new-recipe')

        self.assertThat('widget-daily', Equals(view.initial_values['name']))

    def test_personal_branch_initial_name(self):

        # When a personal branch is used, the initial name is the name of the

        # branch followed by "-daily". +junk-daily is not valid nor

        # helpful.

        branch = self.factory.makePersonalBranch(name='widget')

        with person_logged_in(branch.owner):

            view = create_initialized_view(branch, '+new-recipe')

        self.assertThat('widget-daily', Equals(view.initial_values['name']))

    def test_initial_name_exists(self):

        # If the initial name exists, a generator is used to find an unused

        # name by appending a numbered suffix on the end.

        owner = self.factory.makePerson()

        self.factory.makeSourcePackageRecipe(owner=owner, name=u'widget-daily')

        widget = self.factory.makeProduct(name='widget')

        branch = self.factory.makeProductBranch(widget)

        with person_logged_in(owner):

            view = create_initialized_view(branch, '+new-recipe')

        self.assertThat('widget-daily-1', Equals(view.initial_values['name']))

    def test_initial_series(self):

        # The initial series are those that are current or in development.

        archive = self.factory.makeArchive()

        experimental = self.factory.makeDistroSeries(

            distribution=archive.distribution,

            status=SeriesStatus.EXPERIMENTAL)

        development = self.factory.makeDistroSeries(

            distribution=archive.distribution,

            status=SeriesStatus.DEVELOPMENT)

        frozen = self.factory.makeDistroSeries(

            distribution=archive.distribution,

            status=SeriesStatus.FROZEN)

        current = self.factory.makeDistroSeries(

            distribution=archive.distribution,

            status=SeriesStatus.CURRENT)

        supported = self.factory.makeDistroSeries(

            distribution=archive.distribution,

            status=SeriesStatus.SUPPORTED)

        obsolete = self.factory.makeDistroSeries(

            distribution=archive.distribution,

            status=SeriesStatus.OBSOLETE)

        future = self.factory.makeDistroSeries(

            distribution=archive.distribution,

            status=SeriesStatus.FUTURE)

        branch = self.factory.makeAnyBranch()

        with person_logged_in(archive.owner):

            view = create_initialized_view(branch, '+new-recipe')

        series = set(view.initial_values['distroseries'])

        initial_series = set([development, current])

        self.assertEqual(initial_series, series.intersection(initial_series))

        other_series = set(

            [experimental, frozen, supported, obsolete, future])

        self.assertEqual(set(), series.intersection(other_series))

class TestSourcePackageRecipeAddView(TestCaseForRecipe):

    layer = DatabaseFunctionalLayer

    def makeBranch(self):

        product = self.factory.makeProduct(

            name='ratatouille', displayname='Ratatouille')

        branch = self.factory.makeBranch(

            owner=self.chef, product=product, name='veggies')

        self.factory.makeSourcePackage(sourcepackagename='ratatouille')

        return branch

    def test_create_new_recipe_not_logged_in(self):

        product = self.factory.makeProduct(

            name='ratatouille', displayname='Ratatouille')

        branch = self.factory.makeBranch(

            owner=self.chef, product=product, name='veggies')

        browser = self.getViewBrowser(branch, no_login=True)

        self.assertRaises(

            Unauthorized, browser.getLink('Create packaging recipe').click)

    def test_create_new_recipe(self):

        branch = self.makeBranch()

        # A new recipe can be created from the branch page.

        browser = self.getUserBrowser(canonical_url(branch), user=self.chef)

        browser.getLink('Create packaging recipe').click()

        browser.getControl(name='field.name').value = 'daily'

        browser.getControl('Description').value = 'Make some food!'

        browser.getControl('Create Recipe').click()

        content = find_main_content(browser.contents)

        self.assertEqual('daily', extract_text(content.h1))

        self.assertThat(

            'Make some food!', MatchesTagText(content, 'edit-description'))

        self.assertThat(

            'Master Chef', MatchesPickerText(content, 'edit-owner'))

        self.assertThat(

            'Secret PPA',

            MatchesPickerText(content, 'edit-daily_build_archive'))

    def test_create_new_recipe_private_branch(self):

        # Recipes can't be created on private branches.

        with person_logged_in(self.chef):

            branch = self.factory.makeBranch(private=True, owner=self.chef)

            branch_url = canonical_url(branch)

        browser = self.getUserBrowser(branch_url, user=self.chef)

        self.assertRaises(

            LinkNotFoundError,

            browser.getLink,

            'Create packaging recipe')

    def test_create_new_recipe_users_teams_as_owner_options(self):

        # Teams that the user is in are options for the recipe owner.

        self.factory.makeTeam(

            name='good-chefs', displayname='Good Chefs', members=[self.chef])

        browser = self.getViewBrowser(

            self.makeBranch(), '+new-recipe', user=self.chef)

        # The options for the owner include the Good Chefs team.

        options = browser.getControl(name='field.owner.owner').displayOptions

        self.assertEquals(

            ['Good Chefs (good-chefs)', 'Master Chef (chef)'],

            sorted([str(option) for option in options]))

    def test_create_new_recipe_team_owner(self):

        # New recipes can be owned by teams that the user is a member of.

        team = self.factory.makeTeam(

            name='good-chefs', displayname='Good Chefs', members=[self.chef])

        browser = self.getViewBrowser(

            self.makeBranch(), '+new-recipe', user=self.chef)

        browser.getControl(name='field.name').value = 'daily'

        browser.getControl('Description').value = 'Make some food!'

        browser.getControl('Other').click()

        browser.getControl(name='field.owner.owner').displayValue = [

            'Good Chefs']

        browser.getControl('Create Recipe').click()

        login(ANONYMOUS)

        recipe = team.getRecipe(u'daily')

        self.assertEqual(team, recipe.owner)

        self.assertEqual('daily', recipe.name)

    def test_create_new_recipe_suggests_user(self):

        """The current user is suggested as a recipe owner, once."""

        branch = self.factory.makeBranch(owner=self.chef)

        text = self.getMainText(branch, '+new-recipe')

        self.assertTextMatchesExpressionIgnoreWhitespace(

            r'Owner: Master Chef \(chef\) Other:', text)

    def test_create_new_recipe_suggests_user_team(self):

        """If current user is a member of branch owner, it is suggested."""

        team = self.factory.makeTeam(

            name='branch-team', displayname='Branch Team',

            members=[self.chef])

        branch = self.factory.makeBranch(owner=team)

        text = self.getMainText(branch, '+new-recipe')

        self.assertTextMatchesExpressionIgnoreWhitespace(

            r'Owner: Master Chef \(chef\)'

            r' Branch Team \(branch-team\) Other:', text)

    def test_create_new_recipe_ignores_non_user_team(self):

        """If current user isn't a member of branch owner, it is ignored."""

        team = self.factory.makeTeam(

            name='branch-team', displayname='Branch Team')

        branch = self.factory.makeBranch(owner=team)

        text = self.getMainText(branch, '+new-recipe')

        self.assertTextMatchesExpressionIgnoreWhitespace(

            r'Owner: Master Chef \(chef\) Other:', text)

    def test_create_recipe_forbidden_instruction(self):

        # We don't allow the "run" instruction in our recipes.  Make sure this

        # is communicated to the user properly.

        product = self.factory.makeProduct(

            name='ratatouille', displayname='Ratatouille')

        branch = self.factory.makeBranch(

            owner=self.chef, product=product, name='veggies')

        browser = self.getViewBrowser(branch, '+new-recipe', user=self.chef)

        browser.getControl('Description').value = 'Make some food!'

        browser.getControl('Recipe text').value = (

            browser.getControl('Recipe text').value + 'run cat /etc/passwd')

        browser.getControl('Create Recipe').click()

        self.assertEqual(

            get_feedback_messages(browser.contents)[1],

            'The bzr-builder instruction "run" is not permitted here.')

    def createRecipe(self, recipe_text, branch=None):

        if branch is None:

            product = self.factory.makeProduct(

                name='ratatouille', displayname='Ratatouille')

            branch = self.factory.makeBranch(

                owner=self.chef, product=product, name='veggies')

        browser = self.getViewBrowser(branch, '+new-recipe', user=self.chef)

        browser.getControl(name='field.name').value = 'daily'

        browser.getControl('Description').value = 'Make some food!'

        browser.getControl('Recipe text').value = recipe_text

        browser.getControl('Create Recipe').click()

        return browser

    def test_create_recipe_usage(self):

        # The error for a recipe with invalid instruction parameters should

        # include instruction usage.

        branch = self.factory.makeBranch(name='veggies')

        self.factory.makeBranch(name='packaging')

        browser = self.createRecipe(

            dedent('''\

                # bzr-builder format 0.2 deb-version 0+{revno}

                %(branch)s

                merge

                ''' % {

                    'branch': branch.bzr_identity,

                }),

            branch=branch)

        self.assertEqual(

            'Error parsing recipe:3:6: '

            'End of line while looking for the branch id.\n'

            'Usage: merge NAME BRANCH [REVISION]',

            get_feedback_messages(browser.contents)[1])

    def test_create_recipe_no_distroseries(self):

        browser = self.getViewBrowser(self.makeBranch(), '+new-recipe')

        browser.getControl(name='field.name').value = 'daily'

        browser.getControl('Description').value = 'Make some food!'

        browser.getControl(name='field.distroseries').value = []

        browser.getControl('Create Recipe').click()

        self.assertEqual(

            'You must specify at least one series for daily builds.',

            get_feedback_messages(browser.contents)[1])

    def test_create_recipe_bad_base_branch(self):

        # If a user tries to create source package recipe with a bad base

        # branch location, they should get an error.

        browser = self.createRecipe(MINIMAL_RECIPE_TEXT % 'foo')

        self.assertEqual(

            get_feedback_messages(browser.contents)[1],

            'foo is not a branch on Launchpad.')

    def test_create_recipe_bad_instruction_branch(self):

        # If a user tries to create source package recipe with a bad

        # instruction branch location, they should get an error.

        product = self.factory.makeProduct(

            name='ratatouille', displayname='Ratatouille')

        branch = self.factory.makeBranch(

            owner=self.chef, product=product, name='veggies')

        recipe = MINIMAL_RECIPE_TEXT % branch.bzr_identity

        recipe += 'nest packaging foo debian'

        browser = self.createRecipe(recipe, branch)

        self.assertEqual(

            get_feedback_messages(browser.contents)[1],

            'foo is not a branch on Launchpad.')

    def test_create_recipe_format_too_new(self):

        # If the recipe's format version is too new, we should notify the

        # user.

        product = self.factory.makeProduct(

            name='ratatouille', displayname='Ratatouille')

        branch = self.factory.makeBranch(

            owner=self.chef, product=product, name='veggies')

        with recipe_parser_newest_version(145.115):

            recipe = dedent(u'''\

                # bzr-builder format 145.115 deb-version {debupstream}-0~{revno}

                %s

                ''') % branch.bzr_identity

            browser = self.createRecipe(recipe, branch)

            self.assertEqual(

                get_feedback_messages(browser.contents)[1],

                'The recipe format version specified is not available.')

    def test_create_dupe_recipe(self):

        # You shouldn't be able to create a duplicate recipe owned by the same

        # person with the same name.

        recipe = self.factory.makeSourcePackageRecipe(owner=self.chef)

        transaction.commit()

        recipe_name = recipe.name

        product = self.factory.makeProduct(

            name='ratatouille', displayname='Ratatouille')

        branch = self.factory.makeBranch(

            owner=self.chef, product=product, name='veggies')

        # A new recipe can be created from the branch page.

        browser = self.getUserBrowser(canonical_url(branch), user=self.chef)

        browser.getLink('Create packaging recipe').click()

        browser.getControl(name='field.name').value = recipe_name

        browser.getControl('Description').value = 'Make some food!'

        browser.getControl('Secret Squirrel').click()

        browser.getControl('Create Recipe').click()

        self.assertEqual(

            get_feedback_messages(browser.contents)[1],

            'There is already a recipe owned by Master Chef with this name.')

    def test_create_recipe_private_branch(self):

        # If a user tries to create source package recipe with a private

        # base branch, they should get an error.

        branch = self.factory.makeAnyBranch(private=True, owner=self.user)

        with person_logged_in(self.user):

            bzr_identity = branch.bzr_identity

        recipe_text = MINIMAL_RECIPE_TEXT % bzr_identity

        browser = self.createRecipe(recipe_text)

        self.assertEqual(

            get_feedback_messages(browser.contents)[1],

            'Recipe may not refer to private branch: %s' % bzr_identity)

    def _test_new_recipe_with_no_related_branches(self, branch):

        # The Related Branches section should not appear if there are no

        # related branches.

        # A new recipe can be created from the branch page.

        browser = self.getUserBrowser(

            canonical_url(branch, view_name='+new-recipe'), user=self.chef)

        # There shouldn't be a related-branches section if there are no

        # related branches..

        soup = BeautifulSoup(browser.contents)

        related_branches = soup.find('fieldset', {'id': 'related-branches'})

        self.assertIs(related_branches, None)

    def test_new_product_branch_with_no_related_branches_recipe(self):

        # We can create a new recipe off a product branch.

        branch = self.factory.makeBranch()

        self._test_new_recipe_with_no_related_branches(branch)

    def test_new_package_branch_with_no_linked_branches_recipe(self):

        # We can create a new recipe off a sourcepackage branch where the

        # sourcepackage has no linked branches.

        branch = self.factory.makePackageBranch()

        self._test_new_recipe_with_no_related_branches(branch)

    def test_new_recipe_with_package_branches(self):

        # The series branches table should not appear if there are none.

        (branch, related_series_branch_info, related_package_branches) = (

            self.factory.makeRelatedBranches(with_series_branches=False))

        browser = self.getUserBrowser(

            canonical_url(branch, view_name='+new-recipe'), user=self.chef)

        soup = BeautifulSoup(browser.contents)

        related_branches = soup.find('fieldset', {'id': 'related-branches'})

        self.assertIsNot(related_branches, None)

        related_branches = soup.find(

            'div', {'id': 'related-package-branches'})

        self.assertIsNot(related_branches, None)

        related_branches = soup.find(

            'div', {'id': 'related-series-branches'})

        self.assertIs(related_branches, None)

    def test_new_recipe_with_series_branches(self):

        # The package branches table should not appear if there are none.

        (branch, related_series_branch_info, related_package_branches) = (

            self.factory.makeRelatedBranches(with_package_branches=False))

        browser = self.getUserBrowser(

            canonical_url(branch, view_name='+new-recipe'), user=self.chef)

        soup = BeautifulSoup(browser.contents)

        related_branches = soup.find('fieldset', {'id': 'related-branches'})

        self.assertIsNot(related_branches, None)

        related_branches = soup.find(

            'div', {'id': 'related-series-branches'})

        self.assertIsNot(related_branches, None)

        related_branches = soup.find(

            'div', {'id': 'related-package-branches'})

        self.assertIs(related_branches, None)

    def test_new_product_branch_recipe_with_related_branches(self):

        # The related branches should be rendered correctly on the page.

        (branch, related_series_branch_info,

            related_package_branch_info) = self.factory.makeRelatedBranches()

        browser = self.getUserBrowser(

            canonical_url(branch, view_name='+new-recipe'), user=self.chef)

        self.checkRelatedBranches(

            related_series_branch_info, related_package_branch_info,

            browser.contents)

    def test_new_sourcepackage_branch_recipe_with_related_branches(self):

        # The related branches should be rendered correctly on the page.

        reference_branch= self.factory.makePackageBranch()

        (branch, ignore, related_package_branch_info) = (

                self.factory.makeRelatedBranches(reference_branch))

        browser = self.getUserBrowser(

            canonical_url(branch, view_name='+new-recipe'), user=self.chef)