~launchpad-pqm/launchpad/devel

« back to all changes in this revision

Viewing changes to lib/lp/soyuz/adapters/tests/test_overrides.py

  • Committer: Steve Kowalik
  • Date: 2011-05-11 05:18:49 UTC
  • mto: This revision was merged to the branch mainline in revision 13041.
  • Revision ID: stevenk@ubuntu.com-20110511051849-8qg3sru89c5ydrdw
First shot of generic override adapters, with tests and a random drive-by.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright 2011 Canonical Ltd.  This software is licensed under the
 
2
# GNU Affero General Public License version 3 (see the file LICENSE).
 
3
 
 
4
"""Test generic override methods."""
 
5
 
 
6
from testtools.matchers import Equals
 
7
 
 
8
from canonical.testing.layers import LaunchpadZopelessLayer
 
9
from lp.soyuz.adapters.overrides import (
 
10
    FromExistingOverridePolicy,
 
11
    )
 
12
from lp.soyuz.enums import PackagePublishingStatus
 
13
from lp.testing import (
 
14
    StormStatementRecorder,
 
15
    TestCaseWithFactory,
 
16
    )
 
17
from lp.testing.matchers import HasQueryCount
 
18
 
 
19
 
 
20
class TestOverrides(TestCaseWithFactory):
 
21
 
 
22
    layer = LaunchpadZopelessLayer
 
23
 
 
24
    def test_FromExistingOverridePolicy_both(self):
 
25
        distroseries = self.factory.makeDistroSeries()
 
26
        pocket = self.factory.getAnyPocket()
 
27
        policy = FromExistingOverridePolicy()
 
28
        self.assertRaises(
 
29
            AssertionError, policy.policySpecificChecks,
 
30
            distroseries.main_archive, distroseries, pocket, sources=(),
 
31
            binaries=())
 
32
 
 
33
    def test_no_source_overrides(self):
 
34
        # If the spn is not published in the given archive/distroseries, an
 
35
        # empty list is returned.
 
36
        spn = self.factory.makeSourcePackageName()
 
37
        distroseries = self.factory.makeDistroSeries()
 
38
        pocket = self.factory.getAnyPocket()
 
39
        policy = FromExistingOverridePolicy()
 
40
        overrides = policy.policySpecificChecks(
 
41
            distroseries.main_archive, distroseries, pocket, sources=(spn,))
 
42
        self.assertEqual([], overrides)
 
43
 
 
44
    def test_source_overrides(self):
 
45
        # When the spn is published in the given archive/distroseries, the
 
46
        # overrides for that archive/distroseries are returned.
 
47
        spph = self.factory.makeSourcePackagePublishingHistory()
 
48
        policy = FromExistingOverridePolicy()
 
49
        overrides = policy.policySpecificChecks(
 
50
            spph.distroseries.main_archive, spph.distroseries, spph.pocket,
 
51
            sources=(spph.sourcepackagerelease.sourcepackagename,))
 
52
        expected = [(
 
53
            spph.sourcepackagerelease.sourcepackagename,
 
54
            spph.component, spph.section)]
 
55
        self.assertEqual(expected, overrides)
 
56
 
 
57
    def test_source_overrides_latest_only_is_returned(self):
 
58
        # When the spn is published multiple times in the given
 
59
        # archive/distroseries, the latest publication's overrides are
 
60
        # returned.
 
61
        spn = self.factory.makeSourcePackageName()
 
62
        distroseries = self.factory.makeDistroSeries()
 
63
        published_spr = self.factory.makeSourcePackageRelease(
 
64
            sourcepackagename=spn)
 
65
        published_spph = self.factory.makeSourcePackagePublishingHistory(
 
66
            sourcepackagerelease=published_spr, distroseries=distroseries,
 
67
            status=PackagePublishingStatus.PUBLISHED)
 
68
        spr = self.factory.makeSourcePackageRelease(
 
69
            sourcepackagename=spn)
 
70
        spph = self.factory.makeSourcePackagePublishingHistory(
 
71
            sourcepackagerelease=spr, distroseries=distroseries)
 
72
        policy = FromExistingOverridePolicy()
 
73
        overrides = policy.policySpecificChecks(
 
74
            distroseries.main_archive, distroseries, spph.pocket,
 
75
            sources=(spn,))
 
76
        self.assertEqual([(spn, spph.component, spph.section)], overrides)
 
77
 
 
78
    def test_source_overrides_constant_query_count(self):
 
79
        # The query count is constant, no matter how many sources are
 
80
        # checked.
 
81
        spns = []
 
82
        distroseries = self.factory.makeDistroSeries()
 
83
        pocket = self.factory.getAnyPocket()
 
84
        for i in xrange(10):
 
85
            spph = self.factory.makeSourcePackagePublishingHistory(
 
86
                distroseries=distroseries, archive=distroseries.main_archive,
 
87
                pocket=pocket)
 
88
            spns.append(spph.sourcepackagerelease.sourcepackagename)
 
89
        policy = FromExistingOverridePolicy()
 
90
        with StormStatementRecorder() as recorder:
 
91
            overrides = policy.policySpecificChecks(
 
92
                spph.distroseries.main_archive, spph.distroseries,
 
93
                spph.pocket, sources=spns)
 
94
        self.assertThat(recorder, HasQueryCount(Equals(2)))
 
95
 
 
96
    def test_no_binary_overrides(self):
 
97
        distroseries = self.factory.makeDistroSeries()
 
98
        das = self.factory.makeDistroArchSeries(distroseries=distroseries)
 
99
        distroseries.nominatedarchindep = das
 
100
        bpn = self.factory.makeBinaryPackageName()
 
101
        pocket = self.factory.getAnyPocket()
 
102
        policy = FromExistingOverridePolicy()
 
103
        overrides = policy.policySpecificChecks(
 
104
            distroseries.main_archive, distroseries, pocket,
 
105
            binaries=((bpn, None),))
 
106
        self.assertEqual([], overrides)
 
107
 
 
108
    def test_binary_overrides(self):
 
109
        bpph = self.factory.makeBinaryPackagePublishingHistory()
 
110
        distroseries = bpph.distroarchseries.distroseries
 
111
        distroseries.nominatedarchindep = bpph.distroarchseries
 
112
        policy = FromExistingOverridePolicy()
 
113
        overrides = policy.policySpecificChecks(
 
114
            distroseries.main_archive, distroseries, bpph.pocket,
 
115
            binaries=((bpph.binarypackagerelease.binarypackagename, None),))
 
116
        expected = [(
 
117
            bpph.binarypackagerelease.binarypackagename,
 
118
            bpph.distroarchseries, bpph.component, bpph.section,
 
119
            bpph.priority)]
 
120
        self.assertEqual(expected, overrides)