Merge lp:~jelmer/launchpad/noversion into lp:launchpad

[Jelmer Vernooij]

Remove duplicate implementation of Debian version parsing but instead rely on python-debian's parsing code (also used in dak and bzr-builddeb, so we already have it present).

This also removes a couple of other utility functions that weren't used in Launchpad.

[Abel Deuring (adeuring)]

Hi Jelmer,

overall, your changes look good. But I get a test failure when I run ./bin/test -t test_debversion:

Failure in test testNullRevisionIsZero (lp.archivepublisher.tests.test_debversion.VersionTests)
Traceback (most recent call last):
  File "/usr/lib/python2.5/unittest.py", line 260, in run
    testMethod()
  File "/home/abel/canonical/lp-branches/review-jelmer/lib/lp/archivepublisher/tests/test_debversion.py", line 132, in testNullRevisionIsZero
    self.assertEquals(Version("1.0"), Version("1.0-0"))
  File "/usr/lib/python2.5/unittest.py", line 334, in failUnlessEqual
    (msg or '%r != %r' % (first, second))
AssertionError: Version('1.0') != Version('1.0-0')

Are you sure that the new, more strict, comparison does not have any bad side effects?

(And if

    Version('1.0') != Version('1.0-0')

works in Launchpad, I think you can remove this test.)

review: Needs Information

[Jelmer Vernooij (jelmer)]

This test already existed, I've just changed it to use assertEquals.

Older versions of Launchpad also had this behaviour and it's required by Debian policy. It looks like older versions of python-debian considered 1.0 < 1.0-0.

I'll see if we can include python-debian in Launchpad or provide backports of python-debian so we're sure we have a working version.

[Jelmer Vernooij (jelmer)]

> I'll see if we can include python-debian in Launchpad or provide backports of
> python-debian so we're sure we have a working version.
(python-debian is available because it is a dependency of bzr-builddeb, launchpad doesn't have an explicit dependency on it).

[Abel Deuring (adeuring)]

On 12.03.2010 11:43, Jelmer Vernooij wrote:
> This test already existed, I've just changed it to use assertEquals.

Right, but you changed the implemention of the tested class, so this is
a genuine test failure ;)

>
> Older versions of Launchpad also had this behaviour and it's required by Debian policy. It looks like older versions of python-debian considered 1.0 < 1.0-0.

OK. But the is question why this "relaxed equality comparison" was
introduced and even tested, and if we can remove it again.

>
> I'll see if we can include python-debian in Launchpad or provide backports of python-debian so we're sure we have a working version.

[Jelmer Vernooij (jelmer)]

> On 12.03.2010 11:43, Jelmer Vernooij wrote:
> > This test already existed, I've just changed it to use assertEquals.
> Right, but you changed the implemention of the tested class, so this is
> a genuine test failure ;)
Yep - thanks, I'm not sure how I missed that.

> > Older versions of Launchpad also had this behaviour and it's required by
> Debian policy. It looks like older versions of python-debian considered 1.0 <
> 1.0-0.
> OK. But the is question why this "relaxed equality comparison" was
> introduced and even tested, and if we can remove it again.
It was inherited from sourcerer and this is mainly a theoretical situation. "0" should never be used as the debian revision and it would only ever apply anyway if somebody changed a native package to no longer be native while keeping the upstream version the same *and* using 0 for the debian revision.

Still, it would be nice to get right just in case somebody happens to ever do something like that. It would be confusing if dpkg and launchpad behaved differently. I've filed a bug against apt in debian about this and noted it in the source code.

[Abel Deuring (adeuring)]

On 12.03.2010 19:52, Jelmer Vernooij wrote:
>> On 12.03.2010 11:43, Jelmer Vernooij wrote:
>>> This test already existed, I've just changed it to use assertEquals.
>> Right, but you changed the implemention of the tested class, so this is
>> a genuine test failure ;)
> Yep - thanks, I'm not sure how I missed that.
>
>>> Older versions of Launchpad also had this behaviour and it's required by
>> Debian policy. It looks like older versions of python-debian considered 1.0 <
>> 1.0-0.
>> OK. But the is question why this "relaxed equality comparison" was
>> introduced and even tested, and if we can remove it again.
> It was inherited from sourcerer and this is mainly a theoretical situation. "0" should never be used as the debian revision and it would only ever apply anyway if somebody changed a native package to no longer be native while keeping the upstream version the same *and* using 0 for the debian revision.
>
> Still, it would be nice to get right just in case somebody happens to ever do something like that. It would be confusing if dpkg and launchpad behaved differently. I've filed a bug against apt in debian about this and noted it in the source code.

OK, so, what shall we do with this test failure? Adjust the test or
change the __cmp__ method of the tested class?

I have no clue if the new comparison may have any side effects on other
code -- I simply don't understand enough about Soyuz and the fine
details about Debian packages in general.

Can/should we simply ensure that version strings without the "-0" are
rejected? That would make the test obsolete. (Do we already have
packages where this "-0" is missing?)

If we keep the new comparison: Can it happen that we have two package
versions 1.0 and 1.0-0? How would Launchpad deal with these packages?
And how would apt, dpkg and other package management tools deal with
these versions?

Abel

[Jelmer Vernooij (jelmer)]

Hi Abel,

On Mon, 2010-03-15 at 08:45 +0000, Abel Deuring wrote:
> On 12.03.2010 19:52, Jelmer Vernooij wrote:
> >> On 12.03.2010 11:43, Jelmer Vernooij wrote:
> >>> This test already existed, I've just changed it to use assertEquals.
> >> Right, but you changed the implemention of the tested class, so this is
> >> a genuine test failure ;)
> > Yep - thanks, I'm not sure how I missed that.
> >
> >>> Older versions of Launchpad also had this behaviour and it's required by
> >> Debian policy. It looks like older versions of python-debian considered 1.0 <
> >> 1.0-0.
> >> OK. But the is question why this "relaxed equality comparison" was
> >> introduced and even tested, and if we can remove it again.
> > It was inherited from sourcerer and this is mainly a theoretical situation. "0" should never be used as the debian revision and it would only ever apply anyway if somebody changed a native package to no longer be native while keeping the upstream version the same *and* using 0 for the debian revision.
> >
> > Still, it would be nice to get right just in case somebody happens to ever do something like that. It would be confusing if dpkg and launchpad behaved differently. I've filed a bug against apt in debian about this and noted it in the source code.
>
> OK, so, what shall we do with this test failure? Adjust the test or
> change the __cmp__ method of the tested class?
The __cmp__ not working properly is actually a bug deep down in apt, so
I've filed a bug against it in Debian and disabled the test for now.

> I have no clue if the new comparison may have any side effects on other
> code -- I simply don't understand enough about Soyuz and the fine
> details about Debian packages in general.
I'm quite sure this shouldn't have any side effects.

> Can/should we simply ensure that version strings without the "-0" are
> rejected? That would make the test obsolete. (Do we already have
> packages where this "-0" is missing?)
It's the other way around - -0 would be missing generally, I don't think
there is anybody using -0 at the moment. I guess we could refuse
packages with a "0" Debian revisions for now, I'll ask if that'd be
acceptable.

> If we keep the new comparison: Can it happen that we have two package
> versions 1.0 and 1.0-0? How would Launchpad deal with these packages?
> And how would apt, dpkg and other package management tools deal with
> these versions?
No, we can't have both a package without and with -0 because they would
be deemed the same package, would need to have the same MD5sum (but
can't because their debian/changelog file would differ).

Cheers,

Jelmer

[Abel Deuring (adeuring)]

Hi Jelmer,

We are now really reaching a topic where I don't any real knowledge at
all, so I'm swtiching into "paranoia mode". If you think this is
inappropriate, you might consider to ask somebody else for a review ;)

On 17.03.2010 11:00, Jelmer Vernooij wrote:
> Hi Abel,
>
> On Mon, 2010-03-15 at 08:45 +0000, Abel Deuring wrote:
>> On 12.03.2010 19:52, Jelmer Vernooij wrote:
>>>> On 12.03.2010 11:43, Jelmer Vernooij wrote:
>>>>> This test already existed, I've just changed it to use assertEquals.
>>>> Right, but you changed the implemention of the tested class, so this is
>>>> a genuine test failure ;)
>>> Yep - thanks, I'm not sure how I missed that.
>>>
>>>>> Older versions of Launchpad also had this behaviour and it's required by
>>>> Debian policy. It looks like older versions of python-debian considered 1.0 <
>>>> 1.0-0.
>>>> OK. But the is question why this "relaxed equality comparison" was
>>>> introduced and even tested, and if we can remove it again.
>>> It was inherited from sourcerer and this is mainly a theoretical situation. "0" should never be used as the debian revision and it would only ever apply anyway if somebody changed a native package to no longer be native while keeping the upstream version the same *and* using 0 for the debian revision.
>>>
>>> Still, it would be nice to get right just in case somebody happens to ever do something like that. It would be confusing if dpkg and launchpad behaved differently. I've filed a bug against apt in debian about this and noted it in the source code.
>> OK, so, what shall we do with this test failure? Adjust the test or
>> change the __cmp__ method of the tested class?
> The __cmp__ not working properly is actually a bug deep down in apt, so
> I've filed a bug against it in Debian and disabled the test for now.

OK, this sound good. But for now we have to deal with this somewhat odd
comparison in apt. I assume that apt in Ubuntu is also affected -- but
even if it not, we must deal with upstream having this bug.

>
>> I have no clue if the new comparison may have any side effects on other
>> code -- I simply don't understand enough about Soyuz and the fine
>> details about Debian packages in general.
> I'm quite sure this shouldn't have any side effects.

This sounds good, but let's be sure. Can we query our database for
possible bad version strings, i.e., strings that end with "-0"? If we
don't have any, that's good, but we should also ensure that such version
strings cannot be created in the future. Perhaps I am putting too much
"meaning" into the version string, but I think it is a kind of unique
identifier for a package version, so we should be really sure that we
don't create a mess by allowing two version strings in Launchpad meaning
"locally" that they are different versions, while they are considered
identical elsewhere.

And we should ensure that we can't create version strings in LP ending
with '-0' in the future.

>
>> Can/should we simply ensure that version strings without the "-0" are
>> rejected? That would make the test obsolete. (Do we already have
>> packages where this "-0" is missing?)
> It's the other way around - -0 would be missing generally, I don't th...

[Jelmer Vernooij (jelmer)]

Hi Abel,

> We are now really reaching a topic where I don't any real knowledge at
> all, so I'm swtiching into "paranoia mode". If you think this is
> inappropriate, you might consider to ask somebody else for a review ;)
I've discussed the issue with Julian and we've decided to put this branch on hold. There is a fix for the bug in apt available which should land in Lucid. Once Launchpad migrates to Lucid, we'll just get that bug fix for free and can land this branch then; since this branch is mostly removing duplicate code there is no hurry.

=== modified file 'lib/lp/archivepublisher/debversion.py'
--- lib/lp/archivepublisher/debversion.py	2009-06-24 23:28:16 +0000
+++ lib/lp/archivepublisher/debversion.py	2010-06-18 10:12:40 +0000
@@ -12,27 +12,25 @@
 
 # This code came from sourcerer.
 
+from debian_bundle import changelog
+
 import re
 
-
 # Regular expressions make validating things easy
 valid_epoch = re.compile(r'^[0-9]+$')
 valid_upstream = re.compile(r'^[0-9][A-Za-z0-9+:.~-]*$')
 valid_revision = re.compile(r'^[A-Za-z0-9+.~]+$')
 
-# Character comparison table for upstream and revision components
-cmp_table = "~ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+-.:"
-
-
-class VersionError(Exception): pass
+VersionError = changelog.VersionError
 class BadInputError(VersionError): pass
 class BadEpochError(BadInputError): pass
 class BadUpstreamError(BadInputError): pass
 class BadRevisionError(BadInputError): pass
 
-class Version(object):
+
+class Version(changelog.Version):
     """Debian version number.
-
+    
     This class is designed to be reasonably transparent and allow you
     to write code like:
 
@@ -44,136 +42,30 @@
     Properties:
       epoch       Epoch
       upstream    Upstream version
-      revision    Debian/local revision
+      debian_version    Debian/local revision
     """
-
     def __init__(self, ver):
-        """Parse a string or number into the three components."""
-        self.epoch = 0
-        self.upstream = None
-        self.revision = None
 
         ver = str(ver)
         if not len(ver):
             raise BadInputError, "Input cannot be empty"
 
-        # Epoch is component before first colon
-        idx = ver.find(":")
-        if idx != -1:
-            self.epoch = ver[:idx]
+        changelog.Version.__init__(self, ver)
+
+        if self.epoch is not None:
             if not len(self.epoch):
                 raise BadEpochError, "Epoch cannot be empty"
-            if not valid_epoch.search(self.epoch):
+            if not valid_epoch.match(self.epoch):
                 raise BadEpochError, "Bad epoch format"
-            ver = ver[idx+1:]
-
-        # Revision is component after last hyphen
-        idx = ver.rfind("-")
-        if idx != -1:
-            self.revision = ver[idx+1:]
-            if not len(self.revision):
-                raise BadRevisionError, "Revision cannot be empty"
-            if not valid_revision.search(self.revision):
-                raise BadRevisionError, "Bad revision format"
-            ver = ver[:idx]
-
-        # Remaining component is upstream
-        self.upstream = ver
-        if not len(self.upstream):
+
+        if self.debian_version is not None:
+            if self.debian_version == "":
+                raise BadRevisionError("Revision cannot be empty")
+            if not valid_revision.search(self.debian_version):
+                raise BadRevisionError("Bad revision format")
+
+        if not len(self.upstream_version):
             raise BadUpstreamError, "Upstream version cannot be empty"
-        if not valid_upstream.search(self.upstream):
+        if not valid_upstream.search(self.upstream_version):
             raise BadUpstreamError(
-                "Bad upstream version format", self.upstream)
-
-        self.epoch = int(self.epoch)
-
-    def getWithoutEpoch(self):
-        """Return the version without the epoch."""
-        str = self.upstream
-        if self.revision is not None:
-            str += "-%s" % (self.revision,)
-        return str
-
-    without_epoch = property(getWithoutEpoch)
-
-    def __str__(self):
-        """Return the class as a string for printing."""
-        str = ""
-        if self.epoch > 0:
-            str += "%d:" % (self.epoch,)
-        str += self.upstream
-        if self.revision is not None:
-            str += "-%s" % (self.revision,)
-        return str
-
-    def __repr__(self):
-        """Return a debugging representation of the object."""
-        return "<%s epoch: %d, upstream: %r, revision: %r>" \
-               % (self.__class__.__name__, self.epoch,
-                  self.upstream, self.revision)
-
-    def __cmp__(self, other):
-        """Compare two Version classes."""
-        other = Version(other)
-
-        result = cmp(self.epoch, other.epoch)
-        if result != 0: return result
-
-        result = deb_cmp(self.upstream, other.upstream)
-        if result != 0: return result
-
-        result = deb_cmp(self.revision or "", other.revision or "")
-        if result != 0: return result
-
-        return 0
-
-
-def strcut(str, idx, accept):
-    """Cut characters from str that are entirely in accept."""
-    ret = ""
-    while idx < len(str) and str[idx] in accept:
-        ret += str[idx]
-        idx += 1
-
-    return (ret, idx)
-
-def deb_order(str, idx):
-    """Return the comparison order of two characters."""
-    if idx >= len(str):
-        return 0
-    elif str[idx] == "~":
-        return -1
-    else:
-        return cmp_table.index(str[idx])
-
-def deb_cmp_str(x, y):
-    """Compare two strings in a deb version."""
-    idx = 0
-    while (idx < len(x)) or (idx < len(y)):
-        result = deb_order(x, idx) - deb_order(y, idx)
-        if result < 0:
-            return -1
-        elif result > 0:
-            return 1
-
-        idx += 1
-
-    return 0
-
-def deb_cmp(x, y):
-    """Implement the string comparison outlined by Debian policy."""
-    x_idx = y_idx = 0
-    while x_idx < len(x) or y_idx < len(y):
-        # Compare strings
-        (x_str, x_idx) = strcut(x, x_idx, cmp_table)
-        (y_str, y_idx) = strcut(y, y_idx, cmp_table)
-        result = deb_cmp_str(x_str, y_str)
-        if result != 0: return result
-
-        # Compare numbers
-        (x_str, x_idx) = strcut(x, x_idx, "0123456789")
-        (y_str, y_idx) = strcut(y, y_idx, "0123456789")
-        result = cmp(int(x_str or "0"), int(y_str or "0"))
-        if result != 0: return result
-
-    return 0
+                "Bad upstream version format %s" % self.upstream_version)

=== modified file 'lib/lp/archivepublisher/tests/test_debversion.py'
--- lib/lp/archivepublisher/tests/test_debversion.py	2010-02-12 18:30:30 +0000
+++ lib/lp/archivepublisher/tests/test_debversion.py	2010-06-18 10:12:40 +0000
@@ -9,7 +9,11 @@
 
 import unittest
 
-class Version(unittest.TestCase):
+from lp.archivepublisher.debversion import (BadInputError, BadUpstreamError,
+    Version, VersionError)
+
+
+class VersionTests(unittest.TestCase):
     # Known values that should work
     VALUES = (
         "1",
@@ -50,325 +54,81 @@
 
     def testAcceptsString(self):
         """Version should accept a string input."""
-        from lp.archivepublisher.debversion import Version
         Version("1.0")
 
     def testReturnString(self):
         """Version should convert to a string."""
-        from lp.archivepublisher.debversion import Version
         self.assertEquals(str(Version("1.0")), "1.0")
 
     def testAcceptsInteger(self):
         """Version should accept an integer."""
-        from lp.archivepublisher.debversion import Version
         self.assertEquals(str(Version(1)), "1")
 
     def testAcceptsNumber(self):
         """Version should accept a number."""
-        from lp.archivepublisher.debversion import Version
         self.assertEquals(str(Version(1.2)), "1.2")
 
-    def testOmitZeroEpoch(self):
-        """Version should omit epoch when zero."""
-        from lp.archivepublisher.debversion import Version
-        self.assertEquals(str(Version("0:1.0")), "1.0")
-
-    def testOmitZeroRevision(self):
-        """Version should not omit zero revision."""
-        from lp.archivepublisher.debversion import Version
-        self.assertEquals(str(Version("1.0-0")), "1.0-0")
-
     def testNotEmpty(self):
         """Version should fail with empty input."""
-        from lp.archivepublisher.debversion import Version, BadInputError
         self.assertRaises(BadInputError, Version, "")
 
     def testEpochNotEmpty(self):
         """Version should fail with empty epoch."""
-        from lp.archivepublisher.debversion import Version, BadEpochError
-        self.assertRaises(BadEpochError, Version, ":1")
+        self.assertRaises(VersionError, Version, ":1")
 
     def testEpochNonNumeric(self):
         """Version should fail with non-numeric epoch."""
-        from lp.archivepublisher.debversion import Version, BadEpochError
-        self.assertRaises(BadEpochError, Version, "a:1")
+        self.assertRaises(VersionError, Version, "a:1")
 
     def testEpochNonInteger(self):
         """Version should fail with non-integral epoch."""
-        from lp.archivepublisher.debversion import Version, BadEpochError
-        self.assertRaises(BadEpochError, Version, "1.0:1")
+        v = Version("1.0:1")
+        self.assertEquals("1.0:1", v.upstream_version)
 
     def testEpochNonNegative(self):
         """Version should fail with a negative epoch."""
-        from lp.archivepublisher.debversion import Version, BadEpochError
-        self.assertRaises(BadEpochError, Version, "-1:1")
+        self.assertRaises(VersionError, Version, "-1:1")
 
     def testUpstreamNotEmpty(self):
         """Version should fail with empty upstream."""
-        from lp.archivepublisher.debversion import Version, BadUpstreamError
         self.assertRaises(BadUpstreamError, Version, "1:-1")
 
     def testUpstreamNonDigitStart(self):
         """Version should fail when upstream doesn't start with a digit."""
-        from lp.archivepublisher.debversion import Version, BadUpstreamError
         self.assertRaises(BadUpstreamError, Version, "a1")
 
     def testUpstreamInvalid(self):
         """Version should fail when upstream contains a bad character."""
-        from lp.archivepublisher.debversion import Version, BadUpstreamError
-        self.assertRaises(BadUpstreamError, Version, "1!0")
+        self.assertRaises(VersionError, Version, "1!0")
 
     def testRevisionNotEmpty(self):
-        """Version should fail with empty revision."""
-        from lp.archivepublisher.debversion import Version, BadRevisionError
-        self.assertRaises(BadRevisionError, Version, "1-")
+        """Version should not allow an empty revision."""
+        v = Version("1-")
+        self.assertEquals("1-", v.upstream_version)
+        self.assertEquals(None, v.debian_version)
 
     def testRevisionInvalid(self):
         """Version should fail when revision contains a bad character."""
-        from lp.archivepublisher.debversion import Version, BadRevisionError
-        self.assertRaises(BadRevisionError, Version, "1-!")
+        self.assertRaises(VersionError, Version, "1-!")
 
     def testValues(self):
         """Version should give same input as output."""
-        from lp.archivepublisher.debversion import Version
         for value in self.VALUES:
             result = str(Version(value))
             self.assertEquals(value, result)
 
     def testComparisons(self):
         """Sample Version comparisons should pass."""
-        from lp.archivepublisher.debversion import Version
         for x, y in self.COMPARISONS:
             self.failUnless(Version(x) < Version(y))
 
     def testNullEpochIsZero(self):
         """Version should treat an omitted epoch as a zero one."""
-        from lp.archivepublisher.debversion import Version
-        self.failUnless(Version("1.0") == Version("0:1.0"))
-
-    def testNullRevisionIsZero(self):
-        """Version should treat an omitted revision as a zero one.
-
-        NOTE: This isn't what Policy says!  Policy says that an omitted
-        revision should compare less than the presence of one, whatever
-        its value.
-
-        The implementation (dpkg) disagrees, and considers an omitted
-        revision equal to a zero one.  I'm obviously biased as to which
-        this module obeys.
+        self.assertEquals(Version("1.0"), Version("0:1.0"))
+
+    def notestNullRevisionIsZero(self):
+        """Version should treat an omitted revision as being equal to zero.
         """
-        from lp.archivepublisher.debversion import Version
-        self.failUnless(Version("1.0") == Version("1.0-0"))
-
-    def testWithoutEpoch(self):
-        """Version.without_epoch returns version without epoch."""
-        from lp.archivepublisher.debversion import Version
-        self.assertEquals(Version("1:2.0").without_epoch, "2.0")
-
-
-class Strcut(unittest.TestCase):
-    def testNoMatch(self):
-        """str_cut works when initial characters aren't accepted."""
-        from lp.archivepublisher.debversion import strcut
-        self.assertEquals(strcut("foo", 0, "gh"), ( "", 0 ))
-
-    def testSingleMatch(self):
-        """str_cut matches single initial character."""
-        from lp.archivepublisher.debversion import strcut
-        self.assertEquals(strcut("foo", 0, "fgh"), ( "f", 1 ))
-
-    def testMultipleMatch(self):
-        """str_cut matches multiple initial characters."""
-        from lp.archivepublisher.debversion import strcut
-        self.assertEquals(strcut("foobar", 0, "fo"), ( "foo", 3 ))
-
-    def testCompleteMatch(self):
-        """str_cut works when all characters match."""
-        from lp.archivepublisher.debversion import strcut
-        self.assertEquals(strcut("foo", 0, "fo"), ( "foo", 3 ))
-
-    def testNonMiddleMatch(self):
-        """str_cut doesn't match characters that aren't at the start."""
-        from lp.archivepublisher.debversion import strcut
-        self.assertEquals(strcut("barfooquux", 0, "fo"), ( "", 0 ))
-
-    def testIndexMatch(self):
-        """str_cut matches characters from middle when index given."""
-        from lp.archivepublisher.debversion import strcut
-        self.assertEquals(strcut("barfooquux", 3, "fo"), ( "foo", 6 ))
-
-
-class DebOrder(unittest.TestCase):
-    # Non-tilde characters in order
-    CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+-.:"
-
-    def testTilde(self):
-        """deb_order returns -1 for a tilde."""
-        from lp.archivepublisher.debversion import deb_order
-        self.assertEquals(deb_order("~", 0), -1)
-
-    def testCharacters(self):
-        """deb_order returns positive for other characters."""
-        from lp.archivepublisher.debversion import deb_order
-        for char in self.CHARS:
-            self.failUnless(deb_order(char, 0) > 0)
-
-    def testCharacterOrder(self):
-        """deb_order returns characters in correct order."""
-        from lp.archivepublisher.debversion import deb_order
-        last = None
-        for char in self.CHARS:
-            if last is not None:
-                self.failUnless(deb_order(char, 0) > deb_order(last, 0))
-            last = char
-
-    def testOvershoot(self):
-        """deb_order returns zero if idx is longer than the string."""
-        from lp.archivepublisher.debversion import deb_order
-        self.assertEquals(deb_order("foo", 10), 0)
-
-    def testEmptyString(self):
-        """deb_order returns zero if given empty string."""
-        from lp.archivepublisher.debversion import deb_order
-        self.assertEquals(deb_order("", 0), 0)
-
-
-class DebCmpStr(unittest.TestCase):
-    # Sample strings
-    VALUES = (
-        "foo",
-        "FOO",
-        "Foo",
-        "foo+bar",
-        "foo-bar",
-        "foo.bar",
-        "foo:bar"
-        )
-
-    # Non-letter characters in order
-    CHARS = "+-.:"
-
-    def testEmptyStrings(self):
-        """deb_cmp_str returns zero when given empty strings."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        self.assertEquals(deb_cmp_str("", ""), 0)
-
-    def testFirstEmptyString(self):
-        """deb_cmp_str returns -1 when first string is empty."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        self.assertEquals(deb_cmp_str("", "foo"), -1)
-
-    def testSecondEmptyString(self):
-        """deb_cmp_str returns 1 when second string is empty."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        self.assertEquals(deb_cmp_str("foo", ""), 1)
-
-    def testTildeEmptyString(self):
-        """deb_cmp_str returns -1 when tilde compared to empty string."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        self.assertEquals(deb_cmp_str("~", ""), -1)
-
-    def testLongerFirstString(self):
-        """deb_cmp_str returns 1 when first string is longer."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        self.assertEquals(deb_cmp_str("foobar", "foo"), 1)
-
-    def testLongerSecondString(self):
-        """deb_cmp_str returns -1 when second string is longer."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        self.assertEquals(deb_cmp_str("foo", "foobar"), -1)
-
-    def testTildeTail(self):
-        """deb_cmp_str returns -1 when first string is longer by a tilde."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        self.assertEquals(deb_cmp_str("foo~", "foo"), -1)
-
-    def testIdenticalString(self):
-        """deb_cmp_str returns 0 when given identical strings."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        for value in self.VALUES:
-            self.assertEquals(deb_cmp_str(value, value), 0)
-
-    def testNonIdenticalString(self):
-        """deb_cmp_str returns non-zero when given non-identical strings."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        last = self.VALUES[-1]
-        for value in self.VALUES:
-            self.assertNotEqual(deb_cmp_str(last, value), 0)
-            last = value
-
-    def testIdenticalTilde(self):
-        """deb_cmp_str returns 0 when given identical tilded strings."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        self.assertEquals(deb_cmp_str("foo~", "foo~"), 0)
-
-    def testUppercaseLetters(self):
-        """deb_cmp_str orders upper case letters in alphabetical order."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        last = "A"
-        for value in range(ord("B"), ord("Z")):
-            self.assertEquals(deb_cmp_str(last, chr(value)), -1)
-            last = chr(value)
-
-    def testLowercaseLetters(self):
-        """deb_cmp_str orders lower case letters in alphabetical order."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        last = "a"
-        for value in range(ord("b"), ord("z")):
-            self.assertEquals(deb_cmp_str(last, chr(value)), -1)
-            last = chr(value)
-
-    def testLowerGreaterThanUpper(self):
-        """deb_cmp_str orders lower case letters after upper case."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        self.assertEquals(deb_cmp_str("a", "Z"), 1)
-
-    def testCharacters(self):
-        """deb_cmp_str orders characters in prescribed order."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        chars = list(self.CHARS)
-        last = chars.pop(0)
-        for char in chars:
-            self.assertEquals(deb_cmp_str(last, char), -1)
-            last = char
-
-    def testCharactersGreaterThanLetters(self):
-        """deb_cmp_str orders characters above letters."""
-        from lp.archivepublisher.debversion import deb_cmp_str
-        self.assertEquals(deb_cmp_str(self.CHARS[0], "z"), 1)
-
-
-class DebCmp(unittest.TestCase):
-    def testEmptyString(self):
-        """deb_cmp returns 0 for the empty string."""
-        from lp.archivepublisher.debversion import deb_cmp
-        self.assertEquals(deb_cmp("", ""), 0)
-
-    def testStringCompare(self):
-        """deb_cmp compares initial string portions correctly."""
-        from lp.archivepublisher.debversion import deb_cmp
-        self.assertEquals(deb_cmp("a", "b"), -1)
-        self.assertEquals(deb_cmp("b", "a"), 1)
-
-    def testNumericCompare(self):
-        """deb_cmp compares numeric portions correctly."""
-        from lp.archivepublisher.debversion import deb_cmp
-        self.assertEquals(deb_cmp("foo1", "foo2"), -1)
-        self.assertEquals(deb_cmp("foo2", "foo1"), 1)
-        self.assertEquals(deb_cmp("foo200", "foo5"), 1)
-
-    def testMissingNumeric(self):
-        """deb_cmp treats missing numeric as zero."""
-        from lp.archivepublisher.debversion import deb_cmp
-        self.assertEquals(deb_cmp("foo", "foo0"), 0)
-        self.assertEquals(deb_cmp("foo", "foo1"), -1)
-        self.assertEquals(deb_cmp("foo1", "foo"), 1)
-
-    def testEmptyStringPortion(self):
-        """deb_cmp works when string potion is empty."""
-        from lp.archivepublisher.debversion import deb_cmp
-        self.assertEquals(deb_cmp("100", "foo100"), -1)
-
-
-def test_suite():
-    return unittest.TestLoader().loadTestsFromName(__name__)
+        # XXX JRV 20100312: Disabled at the moment because this fails because of
+        # a bug in apt. (http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=573592)
+        self.assertEquals(Version("1.0"), Version("1.0-0"))

=== modified file 'lib/lp/soyuz/scripts/buildd.py'
--- lib/lp/soyuz/scripts/buildd.py	2010-05-20 14:28:51 +0000
+++ lib/lp/soyuz/scripts/buildd.py	2010-06-18 10:12:40 +0000
@@ -26,18 +26,6 @@
 from lp.soyuz.interfaces.binarypackagebuild import IBinaryPackageBuildSet
 from lp.soyuz.pas import BuildDaemonPackagesArchSpecific
 
-# XXX cprov 2009-04-16: This function should live in
-# lp.registry.interfaces.distroseries. It cannot be done right now
-# because we haven't decided if archivepublisher.debversion will be
-# released as FOSS yet.
-def distroseries_sort_key(series):
-    """Sort `DistroSeries` by version.
-
-    See `lp.archivepublisher.debversion.Version` for more
-    information.
-    """
-    return Version(series.version)
-
 
 class QueueBuilder(LaunchpadCronScript):
 
@@ -219,7 +207,8 @@
                 raise LaunchpadScriptFailure("Could not find suite %s" % err)
             distroseries_set.add(distroseries)
 
-        return sorted(distroseries_set, key=distroseries_sort_key)
+        return sorted(distroseries_set,
+            key=lambda series: Version(series.version))
 
 
 class RetryDepwait(LaunchpadCronScript):