~launchpad-pqm/launchpad/devel

# Copyright 2009, 2011 Canonical Ltd.  This software is licensed under the

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

"""Unit tests for ISourcePackage implementations."""

__metaclass__ = type

from lazr.lifecycle.event import (

    ObjectCreatedEvent,

    ObjectDeletedEvent,

    )

from storm.locals import Store

import transaction

from zope.component import getUtility

from zope.security.checker import canAccess

from zope.security.interfaces import Unauthorized

from zope.security.management import checkPermission

from lp.app.interfaces.launchpad import ILaunchpadCelebrities

from lp.code.model.seriessourcepackagebranch import (

    SeriesSourcePackageBranchSet,

    )

from lp.registry.interfaces.distribution import NoPartnerArchive

from lp.registry.interfaces.pocket import PackagePublishingPocket

from lp.registry.interfaces.series import SeriesStatus

from lp.registry.model.distributionsourcepackage import (

    DistributionSourcePackage,

    )

from lp.registry.model.packaging import Packaging

from lp.soyuz.enums import (

    ArchivePurpose,

    PackagePublishingStatus,

    )

from lp.soyuz.interfaces.component import IComponentSet

from lp.testing import (

    EventRecorder,

    person_logged_in,

    TestCaseWithFactory,

    WebServiceTestCase,

    )

from lp.testing.layers import DatabaseFunctionalLayer

from lp.testing.views import create_initialized_view

class TestSourcePackage(TestCaseWithFactory):

    layer = DatabaseFunctionalLayer

    def test_path(self):

        sourcepackage = self.factory.makeSourcePackage()

        self.assertEqual(

            '%s/%s/%s' % (

                sourcepackage.distribution.name,

                sourcepackage.distroseries.name,

                sourcepackage.sourcepackagename.name),

            sourcepackage.path)

    def test_getBranch_no_branch(self):

        # If there's no official branch for that pocket of a source package,

        # getBranch returns None.

        sourcepackage = self.factory.makeSourcePackage()

        branch = sourcepackage.getBranch(PackagePublishingPocket.RELEASE)

        self.assertIs(None, branch)

    def test_getBranch_exists(self):

        # If there is a SeriesSourcePackageBranch entry for that source

        # package and pocket, then return the branch.

        sourcepackage = self.factory.makeSourcePackage()

        registrant = self.factory.makePerson()

        branch = self.factory.makePackageBranch(sourcepackage=sourcepackage)

        SeriesSourcePackageBranchSet.new(

            sourcepackage.distroseries, PackagePublishingPocket.RELEASE,

            sourcepackage.sourcepackagename, branch, registrant)

        official_branch = sourcepackage.getBranch(

            PackagePublishingPocket.RELEASE)

        self.assertEqual(branch, official_branch)

    def test_setBranch(self):

        # We can set the official branch for a pocket of a source package.

        sourcepackage = self.factory.makeSourcePackage()

        pocket = PackagePublishingPocket.RELEASE

        registrant = self.factory.makePerson()

        branch = self.factory.makePackageBranch(sourcepackage=sourcepackage)

        with person_logged_in(sourcepackage.distribution.owner):

            sourcepackage.setBranch(pocket, branch, registrant)

        self.assertEqual(branch, sourcepackage.getBranch(pocket))

        # A DSP was created for the official branch.

        new_dsp = DistributionSourcePackage._get(

            sourcepackage.distribution, sourcepackage.sourcepackagename)

        self.assertIsNot(None, new_dsp)

    def test_change_branch_once_set(self):

        # We can change the official branch for a a pocket of a source package

        # even after it has already been set.

        sourcepackage = self.factory.makeSourcePackage()

        pocket = PackagePublishingPocket.RELEASE

        registrant = self.factory.makePerson()

        branch = self.factory.makePackageBranch(sourcepackage=sourcepackage)

        new_branch = self.factory.makePackageBranch(

            sourcepackage=sourcepackage)

        with person_logged_in(sourcepackage.distribution.owner):

            sourcepackage.setBranch(pocket, branch, registrant)

            sourcepackage.setBranch(pocket, new_branch, registrant)

        self.assertEqual(new_branch, sourcepackage.getBranch(pocket))

    def test_unsetBranch(self):

        # Setting the official branch for a pocket to 'None' breaks the link

        # between the branch and pocket.

        sourcepackage = self.factory.makeSourcePackage()

        pocket = PackagePublishingPocket.RELEASE

        registrant = self.factory.makePerson()

        branch = self.factory.makePackageBranch(sourcepackage=sourcepackage)

        with person_logged_in(sourcepackage.distribution.owner):

            sourcepackage.setBranch(pocket, branch, registrant)

            sourcepackage.setBranch(pocket, None, registrant)

        self.assertIs(None, sourcepackage.getBranch(pocket))

    def test_unsetBranch_delete_unpublished_dsp(self):

        # Setting the official branch for a pocket to 'None' deletes the

        # official DSP record if there is no SPPH.

        sourcepackage = self.factory.makeSourcePackage()

        pocket = PackagePublishingPocket.RELEASE

        registrant = self.factory.makePerson()

        branch = self.factory.makePackageBranch(sourcepackage=sourcepackage)

        with person_logged_in(sourcepackage.distribution.owner):

            sourcepackage.setBranch(pocket, branch, registrant)

            sourcepackage.setBranch(pocket, None, registrant)

        new_dsp = DistributionSourcePackage._get(

            sourcepackage.distribution, sourcepackage.sourcepackagename)

        self.assertIs(None, new_dsp)

    def test_linked_branches(self):

        # ISourcePackage.linked_branches is a mapping of pockets to branches.

        sourcepackage = self.factory.makeSourcePackage()

        pocket = PackagePublishingPocket.RELEASE

        registrant = self.factory.makePerson()

        branch = self.factory.makePackageBranch(sourcepackage=sourcepackage)

        with person_logged_in(sourcepackage.distribution.owner):

            sourcepackage.setBranch(pocket, branch, registrant)

        self.assertEqual(

            [(pocket, branch)], list(sourcepackage.linked_branches))

    def test_getSuiteSourcePackage(self):

        # ISourcePackage.getSuiteSourcePackage returns the suite source

        # package object for the given pocket.

        sourcepackage = self.factory.makeSourcePackage()

        pocket = PackagePublishingPocket.RELEASE

        ssp = sourcepackage.getSuiteSourcePackage(pocket)

        self.assertEqual(sourcepackage, ssp.sourcepackage)

        self.assertEqual(pocket, ssp.pocket)

    def test_path_to_release_pocket(self):

        # ISourcePackage.getPocketPath returns the path to a pocket. For the

        # RELEASE pocket, it's the same as the package path.

        sourcepackage = self.factory.makeSourcePackage()

        pocket = PackagePublishingPocket.RELEASE

        self.assertEqual(

            sourcepackage.path, sourcepackage.getPocketPath(pocket))

    def test_path_to_non_release_pocket(self):

        # ISourcePackage.getPocketPath returns the path to a pocket. For a

        # non-RELEASE pocket, it's the same as the package path, except with

        # series-pocket for the middle component.

        sourcepackage = self.factory.makeSourcePackage()

        pocket = PackagePublishingPocket.SECURITY

        path = '%s/%s-%s/%s' % (

            sourcepackage.distribution.name,

            sourcepackage.distroseries.name,

            pocket.name.lower(),

            sourcepackage.name)

        self.assertEqual(path, sourcepackage.getPocketPath(pocket))

    def test_development_version(self):

        # ISourcePackage.development_version gets the development version of

        # the source package.

        distribution = self.factory.makeDistribution()

        dev_series = self.factory.makeDistroSeries(

            distribution=distribution, status=SeriesStatus.DEVELOPMENT)

        other_series = self.factory.makeDistroSeries(

            distribution=distribution, status=SeriesStatus.OBSOLETE)

        self.assertEqual(dev_series, distribution.currentseries)

        dev_sourcepackage = self.factory.makeSourcePackage(

            distroseries=dev_series)

        other_sourcepackage = self.factory.makeSourcePackage(

            distroseries=other_series,

            sourcepackagename=dev_sourcepackage.sourcepackagename)

        self.assertEqual(

            dev_sourcepackage, other_sourcepackage.development_version)

        self.assertEqual(

            dev_sourcepackage, dev_sourcepackage.development_version)

    def test_distribution_sourcepackage(self):

        # ISourcePackage.distribution_sourcepackage is the distribution source

        # package for the ISourcePackage.

        sourcepackage = self.factory.makeSourcePackage()

        distribution = sourcepackage.distribution

        distribution_sourcepackage = distribution.getSourcePackage(

            sourcepackage.sourcepackagename)

        self.assertEqual(

            distribution_sourcepackage,

            sourcepackage.distribution_sourcepackage)

    def test_default_archive(self):

        # The default archive of a source package is the primary archive of

        # its distribution.

        sourcepackage = self.factory.makeSourcePackage()

        distribution = sourcepackage.distribution

        self.assertEqual(

            distribution.main_archive, sourcepackage.get_default_archive())

    def test_default_archive_partner(self):

        # If the source package was most recently uploaded to a partner

        # component, then its default archive is the partner archive for the

        # distribution.

        sourcepackage = self.factory.makeSourcePackage()

        partner = getUtility(IComponentSet)['partner']

        self.factory.makeSourcePackagePublishingHistory(

            sourcepackagename=sourcepackage.sourcepackagename,

            distroseries=sourcepackage.distroseries,

            component=partner,

            status=PackagePublishingStatus.PUBLISHED)

        distribution = sourcepackage.distribution

        expected_archive = self.factory.makeArchive(

            distribution=distribution,

            purpose=ArchivePurpose.PARTNER)

        self.assertEqual(

            expected_archive, sourcepackage.get_default_archive())

    def test_default_archive_specified_component(self):

        # If the component is explicitly specified as partner, then we return

        # the partner archive.

        sourcepackage = self.factory.makeSourcePackage()

        partner = getUtility(IComponentSet)['partner']

        distribution = sourcepackage.distribution

        expected_archive = self.factory.makeArchive(

            distribution=distribution,

            purpose=ArchivePurpose.PARTNER)

        self.assertEqual(

            expected_archive,

            sourcepackage.get_default_archive(component=partner))

    def test_default_archive_partner_doesnt_exist(self):

        # If the default archive ought to be the partner archive (because the

        # last published upload was to a partner component) then

        # default_archive will raise an exception.

        sourcepackage = self.factory.makeSourcePackage()

        partner = getUtility(IComponentSet)['partner']

        self.factory.makeSourcePackagePublishingHistory(

            sourcepackagename=sourcepackage.sourcepackagename,

            distroseries=sourcepackage.distroseries,

            component=partner,

            status=PackagePublishingStatus.PUBLISHED)

        self.assertRaises(

            NoPartnerArchive, sourcepackage.get_default_archive)

    def test_source_package_summary_no_releases_returns_None(self):

        sourcepackage = self.factory.makeSourcePackage()

        self.assertEqual(sourcepackage.summary, None)

    def test_source_package_summary_with_releases_returns_None(self):

        sourcepackage = self.factory.makeSourcePackage()

        self.factory.makeSourcePackageRelease(

            sourcepackagename=sourcepackage.sourcepackagename)

        self.assertEqual(sourcepackage.summary, None)

    def test_source_package_summary_with_binaries_returns_list(self):

        sp = getUtility(

            ILaunchpadCelebrities).ubuntu['warty'].getSourcePackage(

            'mozilla-firefox')

        expected_summary = (

            u'mozilla-firefox: Mozilla Firefox Web Browser\n'

            u'mozilla-firefox-data: No summary available for '

            u'mozilla-firefox-data in ubuntu warty.')

        self.assertEqual(''.join(expected_summary), sp.summary)

    def test_deletePackaging(self):

        """Ensure deletePackaging completely removes packaging."""

        packaging = self.factory.makePackagingLink()

        packaging_id = packaging.id

        store = Store.of(packaging)

        with person_logged_in(packaging.owner):

            packaging.sourcepackage.deletePackaging()

        result = store.find(Packaging, Packaging.id == packaging_id)

        self.assertIs(None, result.one())

    def test_setPackaging__new(self):

        """setPackaging() creates a Packaging link."""

        sourcepackage = self.factory.makeSourcePackage()

        productseries = self.factory.makeProductSeries()

        sourcepackage.setPackaging(

            productseries, owner=self.factory.makePerson())

        packaging = sourcepackage.direct_packaging

        self.assertEqual(packaging.productseries, productseries)

    def test_setPackaging__change_existing_entry(self):

        """setPackaging() changes existing Packaging links."""

        sourcepackage = self.factory.makeSourcePackage()

        productseries = self.factory.makeProductSeries()

        other_series = self.factory.makeProductSeries()

        owner = self.factory.makePerson()

        with EventRecorder() as recorder:

            with person_logged_in(owner):

                sourcepackage.setPackaging(productseries, owner=owner)

                sourcepackage.setPackaging(other_series, owner=owner)

                packaging = sourcepackage.direct_packaging

                self.assertEqual(packaging.productseries, other_series)

        # The first call of setPackaging() created an ObjectCreatedEvent;

        # the second call created an ObjectDeletedEvent for the deletion

        # of the old packaging link, and another ObjectCreatedEvent

        # for the new Packaging.

        event1, event2, event3 = recorder.events

        self.assertIsInstance(event1, ObjectCreatedEvent)

        self.assertIsInstance(event2, ObjectDeletedEvent)

        self.assertIsInstance(event3, ObjectCreatedEvent)

    def test_setPackaging__change_existing_entry_different_users(self):

        """An ordinary user cannot change a Packaging defined by

        somebody else.

        """

        sourcepackage = self.factory.makeSourcePackage()

        productseries = self.factory.makeProductSeries()

        other_series = self.factory.makeProductSeries()

        owner = self.factory.makePerson()

        other_user = self.factory.makePerson()

        sourcepackage.setPackaging(productseries, owner=owner)

        with person_logged_in(other_user):

            self.assertRaises(

                Unauthorized, sourcepackage.setPackaging,

                other_series, owner=other_user)

    def test_setPackagingReturnSharingDetailPermissions__ordinary_user(self):

        """An ordinary user can create a packaging link but he cannot

        set the series' branch or translation syncronisation settings,

        or the translation usage settings of the product.

        """

        sourcepackage = self.factory.makeSourcePackage()

        productseries = self.factory.makeProductSeries()

        packaging_owner = self.factory.makePerson()

        with person_logged_in(packaging_owner):

            permissions = (

                sourcepackage.setPackagingReturnSharingDetailPermissions(

                    productseries, packaging_owner))

            self.assertEqual(productseries, sourcepackage.productseries)

            self.assertFalse(

                packaging_owner.canWrite(productseries, 'branch'))

            self.assertFalse(

                packaging_owner.canWrite(

                    productseries, 'translations_autoimport_mode'))

            self.assertFalse(

                packaging_owner.canWrite(

                    productseries.product, 'translations_usage'))

            expected = {

                'user_can_change_product_series': True,

                'user_can_change_branch': False,

                'user_can_change_translation_usage': False,

                'user_can_change_translations_autoimport_mode': False,

                }

            self.assertEqual(expected, permissions)

    def test_getSharingDetailPermissions__ordinary_user(self):

        """An ordinary user cannot set the series' branch or translation

        synchronisation settings, or the translation usage settings of the

        product.

        """

        packaging = self.factory.makePackagingLink()

        sourcepackage = packaging.sourcepackage

        productseries = packaging.productseries

        with person_logged_in(packaging.owner):

            permissions = sourcepackage.getSharingDetailPermissions()

            self.assertEqual(productseries, sourcepackage.productseries)

            self.assertFalse(

                packaging.owner.canWrite(productseries, 'branch'))

            self.assertFalse(

                packaging.owner.canWrite(

                    productseries, 'translations_autoimport_mode'))

            self.assertFalse(

                packaging.owner.canWrite(

                    productseries.product, 'translations_usage'))

            expected = {

                'user_can_change_product_series': True,

                'user_can_change_branch': False,

                'user_can_change_translation_usage': False,

                'user_can_change_translations_autoimport_mode': False,

                }

            self.assertEqual(expected, permissions)

    def makeDistinctOwnerProductSeries(self):

        # Ensure productseries owner is distinct from product owner.

        return self.factory.makeProductSeries(

            owner=self.factory.makePerson())

    def test_getSharingDetailPermissions__series_owner(self):

        """A product series owner can create a packaging link, and he can

        set the series' branch or translation syncronisation settings,

        but he cannot set the translation usage settings of the product.

        """

        productseries = self.makeDistinctOwnerProductSeries()

        series_owner = productseries.owner

        # Ensure productseries owner is distinct from product owner.

        productseries = self.factory.makeProductSeries(

            owner=series_owner)

        with person_logged_in(series_owner):

            packaging = self.factory.makePackagingLink(

                productseries=productseries, owner=series_owner)

            sourcepackage = packaging.sourcepackage

            permissions = sourcepackage.getSharingDetailPermissions()

            self.assertEqual(productseries, sourcepackage.productseries)

            self.assertTrue(series_owner.canWrite(productseries, 'branch'))

            self.assertTrue(

                series_owner.canWrite(

                    productseries, 'translations_autoimport_mode'))

            self.assertFalse(

                series_owner.canWrite(

                    productseries.product, 'translations_usage'))

            expected = {

                'user_can_change_product_series': True,

                'user_can_change_branch': True,

                'user_can_change_translation_usage': False,

                'user_can_change_translations_autoimport_mode': True,

                }

            self.assertEqual(expected, permissions)

    def test_getSharingDetailPermissions__product_owner(self):

        """A product owner can create a packaging link, and he can set the

        series' branch and the translation syncronisation settings, and the

        translation usage settings of the product.

        """

        productseries = self.makeDistinctOwnerProductSeries()

        product = productseries.product

        with person_logged_in(product.owner):

            packaging = self.factory.makePackagingLink(

                productseries=productseries, owner=product.owner)

            sourcepackage = packaging.sourcepackage

            permissions = sourcepackage.getSharingDetailPermissions()

            self.assertEqual(productseries, sourcepackage.productseries)

            self.assertTrue(product.owner.canWrite(productseries, 'branch'))

            self.assertTrue(

                product.owner.canWrite(

                    productseries, 'translations_autoimport_mode'))

            self.assertTrue(

                product.owner.canWrite(

                    productseries.product, 'translations_usage'))

            expected = {

                'user_can_change_product_series': True,

                'user_can_change_branch': True,

                'user_can_change_translation_usage': True,

                'user_can_change_translations_autoimport_mode': True,

                }

            self.assertEqual(expected, permissions)

    def test_getSharingDetailPermissions_change_product(self):

        """Test user_can_change_product_series.

        Until a Packaging is created, anyone can change product series.

        Afterward, random people cannot change product series.

        """

        sourcepackage = self.factory.makeSourcePackage()

        person1 = self.factory.makePerson()

        person2 = self.factory.makePerson()

        def can_change_product_series():

            return sourcepackage.getSharingDetailPermissions()[

                    'user_can_change_product_series']

        with person_logged_in(person1):

            self.assertTrue(can_change_product_series())

        with person_logged_in(person2):

            self.assertTrue(can_change_product_series())

        self.factory.makePackagingLink(

            sourcepackage=sourcepackage, owner=person1)

        with person_logged_in(person1):

            self.assertTrue(can_change_product_series())

        with person_logged_in(person2):

            self.assertFalse(can_change_product_series())

    def test_getSharingDetailPermissions_no_product_series(self):

        sourcepackage = self.factory.makeSourcePackage()

        expected = {

            'user_can_change_product_series': True,

            'user_can_change_branch': False,

            'user_can_change_translation_usage': False,

            'user_can_change_translations_autoimport_mode': False}

        with person_logged_in(self.factory.makePerson()):

            self.assertEqual(

                expected, sourcepackage.getSharingDetailPermissions())

    def test_getSharingDetailPermissions_no_user(self):

        sourcepackage = self.factory.makeSourcePackage()

        expected = {

            'user_can_change_product_series': False,

            'user_can_change_branch': False,

            'user_can_change_translation_usage': False,

            'user_can_change_translations_autoimport_mode': False}

        self.assertEqual(

            expected, sourcepackage.getSharingDetailPermissions())

    def test_drivers_are_distroseries(self):

        # SP.drivers returns the drivers for the distroseries.

        distroseries = self.factory.makeDistroSeries()

        sourcepackage = self.factory.makeSourcePackage(

            distroseries=distroseries)

        self.assertNotEqual([], distroseries.drivers)

        self.assertEqual(sourcepackage.drivers, distroseries.drivers)

    def test_personHasDriverRights_true(self):

        # A distroseries driver has driver permissions on source packages.

        distroseries = self.factory.makeDistroSeries()

        sourcepackage = self.factory.makeSourcePackage(

            distroseries=distroseries)

        driver = distroseries.drivers[0]

        self.assertTrue(sourcepackage.personHasDriverRights(driver))

    def test_personHasDriverRights_false(self):

        # A non-owner/driver/admin does not have driver rights.

        distroseries = self.factory.makeDistroSeries()

        sourcepackage = self.factory.makeSourcePackage(

            distroseries=distroseries)

        non_priv_user = self.factory.makePerson()

        self.assertFalse(sourcepackage.personHasDriverRights(non_priv_user))

    def test_owner_is_distroseries_owner(self):

        # The source package owner differs to the ditroseries owner.

        distroseries = self.factory.makeDistroSeries()

        sourcepackage = self.factory.makeSourcePackage(

            distroseries=distroseries)

        self.assertIsNot(None, sourcepackage.owner)

        self.assertEqual(distroseries.owner, sourcepackage.owner)

        self.assertTrue(

            sourcepackage.personHasDriverRights(distroseries.owner))

class TestSourcePackageWebService(WebServiceTestCase):

    def test_setPackaging(self):

        """setPackaging is accessible and works."""

        sourcepackage = self.factory.makeSourcePackage()

        self.assertIs(None, sourcepackage.direct_packaging)

        productseries = self.factory.makeProductSeries()

        transaction.commit()

        ws_sourcepackage = self.wsObject(sourcepackage)

        ws_productseries = self.wsObject(productseries)

        ws_sourcepackage.setPackaging(productseries=ws_productseries)

        transaction.commit()

        self.assertEqual(

            productseries, sourcepackage.direct_packaging.productseries)

    def test_deletePackaging(self):

        """Deleting a packaging should work."""

        packaging = self.factory.makePackagingLink()

        sourcepackage = packaging.sourcepackage

        transaction.commit()

        self.wsObject(sourcepackage, user=packaging.owner).deletePackaging()

        transaction.commit()

        self.assertIs(None, sourcepackage.direct_packaging)

    def test_deletePackaging_with_no_packaging(self):

        """Deleting when there's no packaging should be a no-op."""

        sourcepackage = self.factory.makeSourcePackage()

        transaction.commit()

        self.wsObject(sourcepackage).deletePackaging()

        transaction.commit()

        self.assertIs(None, sourcepackage.direct_packaging)

class TestSourcePackageSecurity(TestCaseWithFactory):

    """Tests for source package security."""

    layer = DatabaseFunctionalLayer

    def test_admins_have_launchpad_Edit(self):

        admin = self.factory.makeAdministrator()

        sourcepackage = self.factory.makeSourcePackage()

        with person_logged_in(admin):

            self.assertTrue(

                checkPermission('launchpad.Edit', sourcepackage),

                "Administrators should have launchpad.Edit on source "

                "packages.")

    def test_distro_owner_have_launchpad_Edit(self):

        sourcepackage = self.factory.makeSourcePackage()

        with person_logged_in(sourcepackage.distribution.owner):

            self.assertTrue(

                checkPermission('launchpad.Edit', sourcepackage),

                "Distribution owner should have launchpad.Edit on source "

                "packages.")

    def test_uploader_has_launchpad_edit(self):

        sourcepackage = self.factory.makeSourcePackage()

        uploader = self.factory.makePerson()

        archive = sourcepackage.get_default_archive()

        with person_logged_in(sourcepackage.distribution.main_archive.owner):

            archive.newPackageUploader(uploader, sourcepackage.name)

        with person_logged_in(uploader):

            self.assertTrue(

                checkPermission('launchpad.Edit', sourcepackage),

                "Uploader to the package should have launchpad.Edit on "

                "source packages.")

    def test_uploader_has_launchpad_edit_on_obsolete_series(self):

        obsolete_series = self.factory.makeDistroSeries(

            status=SeriesStatus.OBSOLETE)

        sourcepackage = self.factory.makeSourcePackage(

            distroseries=obsolete_series)

        uploader = self.factory.makePerson()

        archive = sourcepackage.get_default_archive()

        with person_logged_in(sourcepackage.distribution.main_archive.owner):

            archive.newPackageUploader(uploader, sourcepackage.name)

        with person_logged_in(uploader):

            self.assertTrue(

                checkPermission('launchpad.Edit', sourcepackage),

                "Uploader to the package should have launchpad.Edit on "

                "source packages in an OBSOLETE series.")

    def test_uploader_have_launchpad_edit_on_current_series(self):

        current_series = self.factory.makeDistroSeries(

            status=SeriesStatus.CURRENT)

        sourcepackage = self.factory.makeSourcePackage(

            distroseries=current_series)

        uploader = self.factory.makePerson()

        archive = sourcepackage.get_default_archive()

        with person_logged_in(sourcepackage.distribution.main_archive.owner):

            archive.newPackageUploader(uploader, sourcepackage.name)

        with person_logged_in(uploader):

            self.assertTrue(

                checkPermission('launchpad.Edit', sourcepackage),

                "Uploader to the package should have launchpad.Edit on "

                "source packages in a CURRENT series.")

    def test_uploader_have_launchpad_edit_on_supported_series(self):

        supported_series = self.factory.makeDistroSeries(

            status=SeriesStatus.SUPPORTED)

        sourcepackage = self.factory.makeSourcePackage(

            distroseries=supported_series)

        uploader = self.factory.makePerson()

        archive = sourcepackage.get_default_archive()

        with person_logged_in(sourcepackage.distribution.main_archive.owner):

            archive.newPackageUploader(uploader, sourcepackage.name)

        with person_logged_in(uploader):

            self.assertTrue(

                checkPermission('launchpad.Edit', sourcepackage),

                "Uploader to the package should have launchpad.Edit on "

                "source packages in a SUPPORTED series.")

    def test_john_doe_cannot_edit(self):

        sourcepackage = self.factory.makeSourcePackage()

        john_doe = self.factory.makePerson()

        with person_logged_in(john_doe):

            self.failIf(

                checkPermission('launchpad.Edit', sourcepackage),

                "Random user shouldn't have launchpad.Edit on source "

                "packages.")

    def test_cannot_setBranch(self):

        sourcepackage = self.factory.makeSourcePackage()

        self.failIf(

            canAccess(sourcepackage, 'setBranch'),

            "setBranch should only be available to admins and uploaders")

class TestSourcePackageViews(TestCaseWithFactory):

    """Tests for source package view classes."""

    layer = DatabaseFunctionalLayer