Merge lp:~james-w/launchpad/more-matchers into lp:launchpad

[James Westby]

[r=lifeless][no-qa] Add some more matchers, particularly soyuz-specific ones.

Hi,

This ports some Soyuz custom assertion methods to matchers.

I did this so that tests can make use of them without having to
subclass what is a fairly heavyweight test class.

I could have added a new TestCase subclass with the custom assertion
methods only and slotted it in to the existing hierarchy, but matchers
are better.

Lint:

./lib/lp/testing/factory.py
      32: redefinition of unused 'os' from line 31

Thanks,

James

[lp:~james-w/launchpad/more-matchers]

11332. By James Westby on 2010-08-08

Dummy revision to force diff regeneration.

11333. By James Westby on 2010-08-08

Fix the docstrings given that it's not publications that superseded publications.

[Robert Collins (lifeless)]

PublishedStateIsNot is a little weird to export, being a mismatch - might want to think about the clarity for users there.

PublishedStateIs would add more debug value if it included all the failing elements, not just the first.

Typo 'supecseded'

This could be a regular method, not inline.
+ def spr_title(spr):

DateIsInPast would be good to do upstream - its not launchpad domain specific at all.

Please consider these tweaks and recommendations.

review: Approve

[lp:~james-w/launchpad/more-matchers]

11334. By James Westby on 2010-08-09

Rename PublishedStateIsNot to PublishedStateIsWrong as the first sounds like a matcher.

11335. By James Westby on 2010-08-09

Use a normal function, not an inline one for title_of.

11336. By James Westby on 2010-08-09

Fix matcher import.

11337. By James Westby on 2010-08-09

Allow publishing records in the superseded check.

[Graham Binns (gmb)]

Trying to run this through EC2 I got a mass of conflicts:

Warning: criss-cross merge encountered. See bzr help criss-cross.
[...]
Text conflict in lib/lp/archivepublisher/tests/test_dominator.py
Text conflict in lib/lp/archiveuploader/tests/nascentupload-ddebs.txt
Text conflict in lib/lp/soyuz/doc/build-files.txt
Text conflict in lib/lp/soyuz/doc/publishing.txt
Text conflict in lib/lp/soyuz/doc/sourcepackagerelease.txt
Text conflict in lib/lp/soyuz/scripts/tests/test_changeoverride.py
Text conflict in lib/lp/soyuz/scripts/tests/test_copypackage.py
Text conflict in lib/lp/soyuz/tests/test_publish_archive_indexes.py
Text conflict in lib/lp/soyuz/tests/test_publishing.py
Text conflict in lib/lp/testing/factory.py
Text conflict in lib/lp/testing/matchers.py
Text conflict in lib/lp/testing/tests/test_factory.py
Text conflict in lib/lp/testing/tests/test_matchers.py

Please resolve these and then ping me and I'll be happy to re-try the landing.

[Robert Collins (lifeless)]

This clearly needs more work to be usable :(.

[Brad Crittenden (bac)]

This branch depends on two pre-requisite branches that have been marked as 'Work In Progress', so this one cannot progress until they do. I am therefore marking this branch WIP too.

Unmerged revisions

11337. By James Westby on 2010-08-09

Allow publishing records in the superseded check.

11336. By James Westby on 2010-08-09

Fix matcher import.

11335. By James Westby on 2010-08-09

Use a normal function, not an inline one for title_of.

11334. By James Westby on 2010-08-09

Rename PublishedStateIsNot to PublishedStateIsWrong as the first sounds like a matcher.

11333. By James Westby on 2010-08-08

Fix the docstrings given that it's not publications that superseded publications.

11332. By James Westby on 2010-08-08

Dummy revision to force diff regeneration.

11331. By James Westby on 2010-08-08

Clean up some lint.

11330. By James Westby on 2010-08-08

Replace checkSuperseded with the new matcher.

11329. By James Westby on 2010-08-08

Add an IsSupersededBy matcher.

11328. By James Westby on 2010-08-08

Have test_publishing use the new matcher.

=== added directory 'lib/lp/soyuz/testing'
=== added file 'lib/lp/soyuz/testing/__init__.py'
=== added file 'lib/lp/soyuz/testing/matchers.py'
--- lib/lp/soyuz/testing/matchers.py	1970-01-01 00:00:00 +0000
+++ lib/lp/soyuz/testing/matchers.py	2010-08-09 15:59:49 +0000
@@ -0,0 +1,137 @@
+# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+__metaclass__ = type
+
+__all__ = [
+    'IsSupersededBy',
+    'PublishedStateIs',
+    'PublishedStateIsWrong',
+]
+
+from zope.security.proxy import isinstance
+
+from testtools.matchers import Annotate, Equals, Matcher, Mismatch
+
+from lp.soyuz.interfaces.publishing import PackagePublishingStatus
+from lp.soyuz.model.publishing import (
+    BinaryPackagePublishingHistory, SourcePackagePublishingHistory)
+from lp.testing.matchers import DateIsInPast
+
+
+class PublishedStateIsWrong(Mismatch):
+
+    def __init__(self, publication, status):
+        """Create a PublishedStateIsWrong Mismatch.
+
+        :param publication: the publication that has the wrong state.
+        :param status: the status that the publication should have had.
+        """
+        self.publication = publication
+        self.status = status
+
+    def describe(self):
+        return "Publication '%s' was '%s' instead of '%s'." % (
+            self.publication.displayname, self.publication.status.name,
+            self.status.name)
+
+
+class PublishedStateIs(Matcher):
+    """Check the state of publication(s) is a certain value."""
+
+    def __init__(self, status):
+        """Create a PublishedState matcher.
+
+        :param status: the status the publication(s) should have.
+        """
+        self.status = status
+
+    def __str__(self):
+        return "Published state is %s" % (self.status.name, )
+
+    def match(self, publications):
+        """Match the status of publication(s) against the expected.
+
+        :param publications: a publication or iterable of publications
+            of which to check the status.
+        :return: An instance of `PublishedStateIsNot` if any of the
+            publications have a different status, otherwise None if they
+            all match.
+        """
+        try:
+            list(publications)
+        except TypeError:
+            publications = [publications]
+        for publication in publications:
+            if publication.status != self.status:
+                return PublishedStateIsWrong(publication, self.status)
+        return None
+
+
+def title_of(obj):
+    if obj is None:
+        return None
+    else:
+        return obj.title
+
+
+class IsSupersededBy(Matcher):
+    """Check that superseded publishing record(s) have correct values.
+
+    A superseded publishing record should have:
+        status = PackagePublishingStatus.SUPERSEDED
+        datesuperseded in the past
+        superseded_by a particular object or None
+    """
+
+    def __init__(self, superseded_by):
+        """Create an IsSupersededBy Matcher.
+
+        :param superseded_by: the object (`SourcePackageRelease` for
+            source publications, or `PackageBuild` for binary publications)
+            that should have superseded the checked publications, or
+            None if they shouldn't have been superseded by another
+            object. You can also pass a `SourcePackagePublishingHistory`
+            or `BinaryPackagePublishingHistory` to have their associated
+            `SourcePackageRelease` or `PackageBuild` used instead.
+        """
+        self.superseded_by = superseded_by
+
+    def __str__(self):
+        by = None
+        if self.superseded_by is not None:
+            by = "'%s'" % self.superseded_by.displayname
+        return "Is correctly superseded (by %s)." % by
+
+    def match(self, publications):
+        mismatch = PublishedStateIs(
+            PackagePublishingStatus.SUPERSEDED).match(publications)
+        if mismatch is not None:
+            return mismatch
+        try:
+            list(publications)
+        except TypeError:
+            publications = [publications]
+        for publication in publications:
+            matcher = Annotate(
+                "'%s' has a datesuperseded in the future." % (
+                    publication.displayname, ),
+                DateIsInPast())
+            mismatch = matcher.match(publication.datesuperseded)
+            if mismatch is not None:
+                return mismatch
+            superseded_by = self.superseded_by
+            if superseded_by is not None:
+                if isinstance(superseded_by, BinaryPackagePublishingHistory):
+                    superseded_by = superseded_by.binarypackagerelease.build
+                elif isinstance(superseded_by, SourcePackagePublishingHistory):
+                    superseded_by = superseded_by.sourcepackagerelease
+            matcher = Annotate(
+                "'%s' has the wrong supersededby, expected '%s', got '%s'"
+                % (publication.displayname, title_of(superseded_by),
+                    title_of(publication.supersededby)),
+                Equals(superseded_by))
+            mismatch = matcher.match(publication.supersededby)
+            if mismatch is not None:
+                return mismatch
+        return None

=== added directory 'lib/lp/soyuz/testing/tests'
=== added file 'lib/lp/soyuz/testing/tests/__init__.py'
=== added file 'lib/lp/soyuz/testing/tests/test_matchers.py'
--- lib/lp/soyuz/testing/tests/test_matchers.py	1970-01-01 00:00:00 +0000
+++ lib/lp/soyuz/testing/tests/test_matchers.py	2010-08-09 15:59:49 +0000
@@ -0,0 +1,244 @@
+# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+__metaclass__ = type
+
+from datetime import datetime, timedelta
+
+import pytz
+
+from testtools.matchers import AnnotatedMismatch
+
+from canonical.testing.layers import DatabaseFunctionalLayer
+from lp.soyuz.interfaces.publishing import PackagePublishingStatus
+from lp.soyuz.testing.matchers import (
+    IsSupersededBy, PublishedStateIs, PublishedStateIsWrong)
+from lp.testing import celebrity_logged_in, TestCaseWithFactory
+from lp.testing.matchers import DateIsNotInPast
+
+
+class PublishedStateIsNotTests(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def test_describe_binary(self):
+        bpph = self.factory.makeBinaryPackagePublishingHistory(
+            status = PackagePublishingStatus.PENDING)
+        status = PackagePublishingStatus.PUBLISHED
+        mismatch = PublishedStateIsWrong(bpph, status)
+        self.assertEqual(
+            "Publication '%s' was '%s' instead of '%s'." % (
+                bpph.displayname, bpph.status.name, status.name),
+            mismatch.describe())
+
+    def test_describe_source(self):
+        spph = self.factory.makeSourcePackagePublishingHistory(
+            status = PackagePublishingStatus.PENDING)
+        status = PackagePublishingStatus.PUBLISHED
+        mismatch = PublishedStateIsWrong(spph, status)
+        self.assertEqual(
+            "Publication '%s' was '%s' instead of '%s'." % (
+                spph.displayname, spph.status.name, status.name),
+            mismatch.describe())
+
+
+class PublishedStateIsTests(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def test_str(self):
+        status = PackagePublishingStatus.PUBLISHED
+        matcher = PublishedStateIs(status)
+        self.assertEqual(
+            "Published state is %s" % (status.name, ),
+            str(matcher))
+
+    def getMatcherResultSingle(self, status):
+        spph = self.factory.makeSourcePackagePublishingHistory(
+            status=PackagePublishingStatus.PENDING)
+        matcher = PublishedStateIs(status)
+        return matcher.match(spph), spph
+
+    def getMatcherResultList(self, status):
+        pubs = [
+            self.factory.makeSourcePackagePublishingHistory(
+                status=status),
+            self.factory.makeSourcePackagePublishingHistory(
+                status=PackagePublishingStatus.PENDING),
+        ]
+        matcher = PublishedStateIs(status)
+        return matcher.match(pubs), pubs
+
+    def test_match_single(self):
+        mismatch, publication = self.getMatcherResultSingle(
+            PackagePublishingStatus.PENDING)
+        self.assertIs(None, mismatch)
+
+    def test_match_list(self):
+        mismatch, publications = self.getMatcherResultList(
+            PackagePublishingStatus.PENDING)
+        self.assertIs(None, mismatch)
+
+    def test_mismatch_single(self):
+        mismatch, publication = self.getMatcherResultSingle(
+            PackagePublishingStatus.PUBLISHED)
+        self.assertIsInstance(mismatch, PublishedStateIsWrong)
+
+    def test_mismatch_list(self):
+        mismatch, publications = self.getMatcherResultList(
+            PackagePublishingStatus.PUBLISHED)
+        self.assertIsInstance(mismatch, PublishedStateIsWrong)
+
+    def test_mismatch_sets_publication_single(self):
+        mismatch, publication = self.getMatcherResultSingle(
+            PackagePublishingStatus.PUBLISHED)
+        self.assertEqual(publication, mismatch.publication)
+
+    def test_mismatch_sets_publication_list(self):
+        mismatch, publications = self.getMatcherResultList(
+            PackagePublishingStatus.PUBLISHED)
+        self.assertIsInstance(mismatch, PublishedStateIsWrong)
+        self.assertEqual(publications[1], mismatch.publication)
+
+    def test_mismatch_sets_status(self):
+        status = PackagePublishingStatus.PUBLISHED
+        mismatch, publication = self.getMatcherResultSingle(status)
+        self.assertEqual(status, mismatch.status)
+
+
+class IsSupersededByTests(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def test_str_with_superseded_by(self):
+        pub = self.factory.makeSourcePackagePublishingHistory()
+        matcher = IsSupersededBy(pub)
+        self.assertEqual(
+            "Is correctly superseded (by '%s')." % pub.displayname,
+            str(matcher))
+
+    def test_str_with_None(self):
+        matcher = IsSupersededBy(None)
+        self.assertEqual(
+            "Is correctly superseded (by None).", str(matcher))
+
+    def makeSupersededPublishing(self, superseded_by=None,
+                                 datesuperseded=None):
+        pub = self.factory.makeSourcePackagePublishingHistory(
+            status=PackagePublishingStatus.PUBLISHED)
+        pub.supersede(dominant=superseded_by)
+        if datesuperseded is not None:
+            with celebrity_logged_in('admin'):
+                pub.datesuperseded = datesuperseded
+        return pub
+
+    def test_match_single_superseded_by_not_None(self):
+        superseded_by = self.factory.makeSourcePackagePublishingHistory()
+        matcher = IsSupersededBy(superseded_by.sourcepackagerelease)
+        past = datetime.now(pytz.UTC) - timedelta(days=4)
+        pub = self.makeSupersededPublishing(
+            superseded_by=superseded_by, datesuperseded=past)
+        mismatch = matcher.match(pub)
+        self.assertIs(None, mismatch)
+
+    def test_match_single_superseded_by_None(self):
+        matcher = IsSupersededBy(None)
+        past = datetime.now(pytz.UTC) - timedelta(days=4)
+        pub = self.makeSupersededPublishing(
+            superseded_by=None, datesuperseded=past)
+        mismatch = matcher.match(pub)
+        self.assertIs(None, mismatch)
+
+    def test_match_list_superseded_by_not_None(self):
+        superseded_by = self.factory.makeSourcePackagePublishingHistory()
+        matcher = IsSupersededBy(superseded_by.sourcepackagerelease)
+        past = datetime.now(pytz.UTC) - timedelta(days=4)
+        pubs = [
+            self.makeSupersededPublishing(
+                superseded_by=superseded_by, datesuperseded=past),
+            self.makeSupersededPublishing(
+                superseded_by=superseded_by, datesuperseded=past),
+        ]
+        mismatch = matcher.match(pubs)
+        self.assertIs(None, mismatch)
+
+    def test_match_list_superseded_by_None(self):
+        matcher = IsSupersededBy(None)
+        past = datetime.now(pytz.UTC) - timedelta(days=4)
+        pubs = [
+            self.makeSupersededPublishing(
+                superseded_by=None, datesuperseded=past),
+            self.makeSupersededPublishing(
+                superseded_by=None, datesuperseded=past),
+        ]
+        mismatch = matcher.match(pubs)
+        self.assertIs(None, mismatch)
+
+    def test_mismatch_single_wrong_status(self):
+        matcher = IsSupersededBy(None)
+        past = datetime.now(pytz.UTC) - timedelta(days=4)
+        pub = self.makeSupersededPublishing(
+            superseded_by=None, datesuperseded=past)
+        with celebrity_logged_in('admin'):
+            pub.status = PackagePublishingStatus.PUBLISHED
+        mismatch = matcher.match(pub)
+        self.assertIsInstance(mismatch, PublishedStateIsWrong)
+
+    def test_mismatch_list_wrong_status(self):
+        matcher = IsSupersededBy(None)
+        past = datetime.now(pytz.UTC) - timedelta(days=4)
+        pubs = [
+            self.makeSupersededPublishing(
+                superseded_by=None, datesuperseded=past),
+            self.makeSupersededPublishing(
+                superseded_by=None, datesuperseded=past),
+        ]
+        with celebrity_logged_in('admin'):
+            pubs[1].status = PackagePublishingStatus.PUBLISHED
+        mismatch = matcher.match(pubs)
+        self.assertIsInstance(mismatch, PublishedStateIsWrong)
+
+    def test_mismatch_single_wrong_date(self):
+        matcher = IsSupersededBy(None)
+        future = datetime.now(pytz.UTC) + timedelta(days=4)
+        pub = self.makeSupersededPublishing(
+            superseded_by=None, datesuperseded=future)
+        mismatch = matcher.match(pub)
+        self.assertIsInstance(mismatch, AnnotatedMismatch)
+        self.assertIsInstance(mismatch.mismatch, DateIsNotInPast)
+
+    def test_mismatch_list_wrong_date(self):
+        matcher = IsSupersededBy(None)
+        past = datetime.now(pytz.UTC) - timedelta(days=4)
+        future = datetime.now(pytz.UTC) + timedelta(days=4)
+        pubs = [
+            self.makeSupersededPublishing(
+                superseded_by=None, datesuperseded=past),
+            self.makeSupersededPublishing(
+                superseded_by=None, datesuperseded=future),
+        ]
+        mismatch = matcher.match(pubs)
+        self.assertIsInstance(mismatch, AnnotatedMismatch)
+        self.assertIsInstance(mismatch.mismatch, DateIsNotInPast)
+
+    def test_mismatch_single_wrong_superseded_by(self):
+        superseded_by = self.factory.makeSourcePackagePublishingHistory()
+        matcher = IsSupersededBy(None)
+        past = datetime.now(pytz.UTC) - timedelta(days=4)
+        pub = self.makeSupersededPublishing(
+            superseded_by=superseded_by, datesuperseded=past)
+        mismatch = matcher.match(pub)
+        self.assertIsInstance(mismatch, AnnotatedMismatch)
+
+    def test_mismatch_list_wrong_superseded_by(self):
+        superseded_by = self.factory.makeSourcePackagePublishingHistory()
+        matcher = IsSupersededBy(None)
+        past = datetime.now(pytz.UTC) - timedelta(days=4)
+        pubs = [
+            self.makeSupersededPublishing(
+                superseded_by=None, datesuperseded=past),
+            self.makeSupersededPublishing(
+                superseded_by=superseded_by, datesuperseded=past),
+        ]
+        mismatch = matcher.match(pubs)
+        self.assertIsInstance(mismatch, AnnotatedMismatch)

=== modified file 'lib/lp/soyuz/tests/test_publishing.py'
--- lib/lp/soyuz/tests/test_publishing.py	2010-08-09 15:59:47 +0000
+++ lib/lp/soyuz/tests/test_publishing.py	2010-08-09 15:59:49 +0000
@@ -12,7 +12,7 @@
 
 import pytz
 from zope.component import getUtility
-from zope.security.proxy import isinstance, removeSecurityProxy
+from zope.security.proxy import removeSecurityProxy
 
 from canonical.config import config
 from canonical.database.constants import UTC_NOW
@@ -29,8 +29,6 @@
 from lp.registry.interfaces.sourcepackage import SourcePackageUrgency
 from lp.registry.interfaces.sourcepackagename import ISourcePackageNameSet
 from lp.soyuz.model.processor import ProcessorFamily
-from lp.soyuz.model.publishing import (
-    BinaryPackagePublishingHistory)
 from lp.soyuz.interfaces.archive import ArchivePurpose
 from lp.soyuz.interfaces.archivearch import IArchiveArchSet
 from lp.soyuz.interfaces.binarypackagerelease import BinaryPackageFormat
@@ -38,8 +36,10 @@
 from lp.soyuz.interfaces.publishing import (
     IPublishingSet, PackagePublishingPriority, PackagePublishingStatus)
 from lp.soyuz.interfaces.queue import PackageUploadStatus
+from lp.soyuz.testing.matchers import IsSupersededBy, PublishedStateIs
 from canonical.launchpad.scripts import FakeLogger
 from lp.testing import TestCaseWithFactory
+from lp.testing.matchers import DateIsInPast
 from lp.testing.factory import LaunchpadObjectFactory
 from lp.testing.sampledata import UBUNTU_DEVELOPER_ADMIN_NAME
 from lp.testing.fakemethod import FakeMethod
@@ -499,17 +499,14 @@
 
     def checkPublication(self, pub, status):
         """Assert the publication has the given status."""
-        self.assertEqual(
-            pub.status, status, "%s is not %s (%s)" % (
-            pub.displayname, status.name, pub.status.name))
+        self.checkPublications(pub, status)
 
     def checkPublications(self, pubs, status):
         """Assert the given publications have the given status.
 
         See `checkPublication`.
         """
-        for pub in pubs:
-            self.checkPublication(pub, status)
+        self.assertThat(pubs, PublishedStateIs(status))
 
     def checkPastDate(self, date, lag=None):
         """Assert given date is older than 'now'.
@@ -517,24 +514,10 @@
         Optionally the user can pass a 'lag' which will be added to 'now'
         before comparing.
         """
-        UTC = pytz.timezone("UTC")
-        limit = datetime.datetime.now(UTC)
-        if lag is not None:
-            limit = limit + lag
-        self.assertTrue(date < limit, "%s >= %s" % (date, limit))
+        self.assertThat(date, DateIsInPast(lag=lag))
 
     def checkSuperseded(self, pubs, supersededby=None):
-        self.checkPublications(pubs, PackagePublishingStatus.SUPERSEDED)
-        for pub in pubs:
-            self.checkPastDate(pub.datesuperseded)
-            if supersededby is not None:
-                if isinstance(pub, BinaryPackagePublishingHistory):
-                    dominant = supersededby.binarypackagerelease.build
-                else:
-                    dominant = supersededby.sourcepackagerelease
-                self.assertEquals(dominant, pub.supersededby)
-            else:
-                self.assertIs(None, pub.supersededby)
+        self.assertThat(pubs, IsSupersededBy(supersededby))
 
 
 class TestNativePublishing(TestNativePublishingBase):

=== modified file 'lib/lp/testing/factory.py'
--- lib/lp/testing/factory.py	2010-08-09 15:59:47 +0000
+++ lib/lp/testing/factory.py	2010-08-09 15:59:49 +0000
@@ -2243,7 +2243,7 @@
     def makeSourcePackageName(self, name=None):
         """Make an `ISourcePackageName`."""
         if name is None:
-            name = self.getUniqueString()
+            name = self.getUniqueString('sourcepackagename')
         return getUtility(ISourcePackageNameSet).new(name)
 
     def getOrMakeSourcePackageName(self, name=None):

=== modified file 'lib/lp/testing/matchers.py'
--- lib/lp/testing/matchers.py	2010-08-09 15:59:47 +0000
+++ lib/lp/testing/matchers.py	2010-08-09 15:59:49 +0000
@@ -3,6 +3,8 @@
 
 __metaclass__ = type
 __all__ = [
+    'DateIsInPast',
+    'DateIsNotInPast',
     'DoesNotCorrectlyProvide',
     'DoesNotProvide',
     'DoesNotStartWith',
@@ -14,6 +16,9 @@
     'StartsWith',
     ]
 
+from datetime import datetime
+
+import pytz
 from zope.interface.verify import verifyObject
 from zope.interface.exceptions import (
     BrokenImplementation, BrokenMethodImplementation, DoesNotImplement)
@@ -123,15 +128,15 @@
         self.query_collector = query_collector
 
     def describe(self):
-        return "queries do not match: %s" % (self.count_mismatch.describe(),)
+        return "queries do not match: %s" % (self.count_mismatch.describe(), )
 
     def get_details(self):
         result = []
         for query in self.query_collector.queries:
             result.append(unicode(query).encode('utf8'))
         return {'queries': Content(ContentType('text', 'plain',
-            {'charset': 'utf8'}), lambda:['\n'.join(result)])}
- 
+            {'charset': 'utf8'}), lambda: ['\n'.join(result)])}
+
 
 class IsNotProxied(Mismatch):
     """An object is not proxied."""
@@ -213,3 +218,56 @@
         if not matchee.startswith(self.expected):
             return DoesNotStartWith(matchee, self.expected)
         return None
+
+
+class DateIsNotInPast(Mismatch):
+
+    def __init__(self, date, limit):
+        """Create a DateIsNotInPast Mismatch.
+
+        :param date: the date that was checked.
+        :param limit: the date that it should have been before.
+        """
+        self.date = date
+        self.limit = limit
+
+    def describe(self):
+        return "%s >= %s" % (self.date, self.limit)
+
+
+class DateIsInPast(Matcher):
+    """A matcher that checks a datetime is in the past."""
+
+    def __init__(self, current_date=None, lag=None):
+        """Create a DateIsInPast Matcher.
+
+        :param current_date: the `datetime.datetime` that the date should be
+            before, or None for the current time when the check is done.
+        :param lag: a `datetime.timedelta` to add to the current time
+            before comparing, or None for no change.
+        """
+        self.current_date = current_date
+        self.lag = lag
+
+    def __str__(self):
+        if self.current_date is None:
+            start_str = 'UTC_NOW'
+            if self.lag is not None:
+                start_str += ' plus %s' % self.lag
+        else:
+            start = self.current_date
+            if self.lag is not None:
+                start += self.lag
+            start_str = str(start)
+        return "Date is before %s." % start_str
+
+    def match(self, date):
+        if self.current_date is None:
+            limit = datetime.now(pytz.UTC)
+        else:
+            limit = self.current_date
+        if self.lag is not None:
+            limit += self.lag
+        if date >= limit:
+            return DateIsNotInPast(date, limit)
+        return None

=== modified file 'lib/lp/testing/tests/test_factory.py'
--- lib/lp/testing/tests/test_factory.py	2010-08-09 15:59:47 +0000
+++ lib/lp/testing/tests/test_factory.py	2010-08-09 15:59:49 +0000
@@ -20,6 +20,7 @@
 from lp.registry.interfaces.distribution import IDistribution
 from lp.registry.interfaces.distroseries import IDistroSeries
 from lp.registry.interfaces.sourcepackage import SourcePackageFileType
+from lp.registry.interfaces.sourcepackagename import ISourcePackageName
 from lp.registry.interfaces.suitesourcepackage import ISuiteSourcePackage
 from lp.services.worlddata.interfaces.language import ILanguage
 from lp.soyuz.interfaces.binarypackagebuild import IBinaryPackageBuild
@@ -401,6 +402,15 @@
         # And name is constructed from code as 'Language %(code)s'.
         self.assertEquals('Test language', language.englishname)
 
+    # makeSourcePackageName
+    def test_makeSourcePackageName_returns_proxied_ISPN(self):
+        spn = self.factory.makeSourcePackageName()
+        self.assertThat(spn, ProvidesAndIsProxied(ISourcePackageName))
+
+    def test_makeSourcePackageName_created_has_useful_prefix(self):
+        spn = self.factory.makeSourcePackageName()
+        self.assertThat(spn.name, StartsWith("sourcepackagename"))
+
     # makeSourcePackagePublishingHistory
     def test_makeSourcePackagePublishingHistory_returns_ISPPH(self):
         spph = self.factory.makeSourcePackagePublishingHistory()

=== modified file 'lib/lp/testing/tests/test_matchers.py'
--- lib/lp/testing/tests/test_matchers.py	2010-08-09 15:59:47 +0000
+++ lib/lp/testing/tests/test_matchers.py	2010-08-09 15:59:49 +0000
@@ -3,6 +3,9 @@
 
 __metaclass__ = type
 
+from datetime import datetime, timedelta
+
+import pytz
 from zope.interface import implements, Interface
 from zope.interface.verify import verifyObject
 from zope.interface.exceptions import BrokenImplementation
@@ -11,8 +14,9 @@
 
 from lp.testing import TestCase
 from lp.testing.matchers import (
-    DoesNotCorrectlyProvide, DoesNotProvide, DoesNotStartWith, HasQueryCount,
-    IsNotProxied, IsProxied, Provides, ProvidesAndIsProxied, StartsWith)
+    DateIsInPast, DateIsNotInPast, DoesNotCorrectlyProvide, DoesNotProvide,
+    DoesNotStartWith, HasQueryCount, IsNotProxied, IsProxied, Provides,
+    ProvidesAndIsProxied, StartsWith)
 from lp.testing._webservice import QueryCollector
 
 from testtools.matchers import Is, Not, LessThan
@@ -208,7 +212,7 @@
         self.assertEqual(["('foo', 'bar')\n('baaz', 'quux')"],
             lines)
         self.assertEqual(
-            "queries do not match: %s" % (LessThan(2).match(2).describe(),),
+            "queries do not match: %s" % (LessThan(2).match(2).describe(), ),
             mismatch.describe())
 
 
@@ -243,3 +247,95 @@
         matcher = StartsWith("bar")
         mismatch = matcher.match("foo")
         self.assertEqual("bar", mismatch.expected)
+
+
+class DateIsNotInPastTests(TestCase):
+
+    def test_describe(self):
+        date = datetime(2008, 01, 01, 01, 01, 01, 01, pytz.UTC)
+        limit = datetime(2000, 02, 02, 02, 02, 02, 02, pytz.UTC)
+        mismatch = DateIsNotInPast(date, limit)
+        self.assertEqual("%s >= %s" % (date, limit), mismatch.describe())
+
+
+class DateIsInPastTests(TestCase):
+
+    def test_str_now_no_lag(self):
+        matcher = DateIsInPast()
+        self.assertEqual("Date is before UTC_NOW.", str(matcher))
+
+    def test_str_now_with_lag(self):
+        lag = timedelta(seconds=60)
+        matcher = DateIsInPast(lag=lag)
+        self.assertEqual(
+            "Date is before UTC_NOW plus %s." % lag, str(matcher))
+
+    def test_str_current_date_no_lag(self):
+        date = datetime(2008, 01, 01, 01, 01, 01, 01, pytz.UTC)
+        matcher = DateIsInPast(current_date=date)
+        self.assertEqual("Date is before %s." % date, str(matcher))
+
+    def test_str_current_date_with_lag(self):
+        date = datetime(2008, 01, 01, 01, 01, 01, 01, pytz.UTC)
+        lag = timedelta(seconds=60)
+        matcher = DateIsInPast(current_date=date, lag=lag)
+        self.assertEqual("Date is before %s." % (date + lag, ), str(matcher))
+
+    def test_match_now_no_lag(self):
+        date = datetime.now(pytz.UTC) - timedelta(days=3)
+        matcher = DateIsInPast()
+        self.assertEqual(None, matcher.match(date))
+
+    def test_match_now_with_lag(self):
+        date = datetime.now(pytz.UTC) + timedelta(days=3)
+        lag = timedelta(days=4)
+        matcher = DateIsInPast(lag=lag)
+        self.assertEqual(None, matcher.match(date))
+
+    def test_current_date_no_lag(self):
+        current_date = datetime(2008, 01, 01, 01, 01, 01, 01, pytz.UTC)
+        date = current_date - timedelta(days=3)
+        matcher = DateIsInPast(current_date=current_date)
+        self.assertEqual(None, matcher.match(date))
+
+    def test_current_date_with_lag(self):
+        current_date = datetime(2008, 01, 01, 01, 01, 01, 01, pytz.UTC)
+        date = current_date + timedelta(days=3)
+        lag = timedelta(days=4)
+        matcher = DateIsInPast(current_date=current_date, lag=lag)
+        self.assertEqual(None, matcher.match(date))
+
+    def test_mismatch_now_no_lag(self):
+        date = datetime.now(pytz.UTC) + timedelta(days=3)
+        matcher = DateIsInPast()
+        self.assertIsInstance(matcher.match(date), DateIsNotInPast)
+
+    def test_mismatch_now_with_lag(self):
+        date = datetime.now(pytz.UTC) + timedelta(days=3)
+        lag = timedelta(days=2)
+        matcher = DateIsInPast(lag=lag)
+        self.assertIsInstance(matcher.match(date), DateIsNotInPast)
+
+    def test_mismatch_current_date_no_lag(self):
+        current_date = datetime(2008, 01, 01, 01, 01, 01, 01, pytz.UTC)
+        date = current_date + timedelta(days=3)
+        matcher = DateIsInPast(current_date=current_date)
+        self.assertIsInstance(matcher.match(date), DateIsNotInPast)
+
+    def test_mismatch_current_date_with_lag(self):
+        current_date = datetime(2008, 01, 01, 01, 01, 01, 01, pytz.UTC)
+        date = current_date + timedelta(days=3)
+        lag = timedelta(days=2)
+        matcher = DateIsInPast(current_date=current_date, lag=lag)
+        self.assertIsInstance(matcher.match(date), DateIsNotInPast)
+
+    def test_mismatch_sets_date(self):
+        date = datetime.now(pytz.UTC) + timedelta(days=3)
+        matcher = DateIsInPast()
+        self.assertEqual(date, matcher.match(date).date)
+
+    def test_mismatch_sets_limit(self):
+        current_date = datetime.now(pytz.UTC)
+        date = current_date + timedelta(days=3)
+        matcher = DateIsInPast(current_date=current_date)
+        self.assertEqual(current_date, matcher.match(date).limit)