Merge ~nacc/git-ubuntu:fix-build-version-check into git-ubuntu:master

[Nish Aravamudan]

I can't seem to find the right twiddles to make this branch depend on the sru-series-versioning, but it's one commit on top.

Unmerged commits

0a277bc... by Nish Aravamudan on 2017-08-01

git ubuntu build: use semantic versioning check not string comparison

It is definitively incorrect to simply string compare the upstream
versions, as that puts, e.g. ubuntu2 after ubuntu16. Use the
now-common-code version_compare to do the comparison.

LP: #1707983

71fee3d... by Nish Aravamudan on 2017-07-26

versioning: add support for SRU series in the versioning logic

This reverts commit 151c31bbbc12b74f5aaff09bb57d85baf341d959.

This changes the versioned parts into a namedtuple and updates the unit
tests accordingly (purely passing the correct type). It also clarifies
when a suffix is being manipulated and when an entire version string is
being manipulated.

With this change, the unit tests now all pass in versioning.py.

ed90707... by Nish Aravamudan on 2017-07-28

versioning: rename before/after lists to befores/afters

This helps clarify they are iterables.

f3863b8... by Nish Aravamudan on 2017-07-28

versioning: add docstring and rename variables

The variable names now reflect their type, as it can be quite confusing.

93206ee... by Nish Aravamudan on 2017-07-28

versioning: clarify internal bump functions bump suffixes

272e775... by Nish Aravamudan on 2017-07-28

versioning: next_development_version should take a string version

The notion of Version objects can be fully encapsulated in the
versioning module.

d000d4f... by Nish Aravamudan on 2017-07-28

versioning: define exposed API with __all__

d924d59... by Nish Aravamudan on 2017-07-26

versioning: add more unit tests for SRU policies

54adbf0... by Nish Aravamudan on 2017-07-28

versioning: move GitUbuntuRepository.version_compare

version_compare was a classmethod of GitUbuntuRepository because there
wasn't a better place for it. Now that we have a 'versioning' module, it
makes sense for version comparison to also live there. Indicate it is an
exposed API, as well.

Add some simple unit tests, as well.

0cede92... by Nish Aravamudan on 2017-07-26

versioning: fix stray whitespace

diff --git a/gitubuntu/build.py b/gitubuntu/build.py
index 825cb67..16d7c99 100644
--- a/gitubuntu/build.py
+++ b/gitubuntu/build.py
@@ -27,6 +27,7 @@ from gitubuntu.run import run, runq
 from gitubuntu.source_information import GitUbuntuSourceInformation, NoPublicationHistoryException
 from gitubuntu.cache import CACHE_PATH
 from gitubuntu.dsc import GitUbuntuDsc, orig_re
+from gitubuntu.versioning import version_compare
 try:
     pkg = 'python3-debian'
     from debian.changelog import Changelog
@@ -166,7 +167,10 @@ class GitUbuntuBuild:
                                       'publish %s matches %s' %
                                       (spi.version, last_upstream_version)
                                      )
-                        if spi.upstream_version < last_upstream_version:
+                        if version_compare(
+                            spi.upstream_version,
+                            last_upstream_version
+                        ) < 0:
                             logging.info('New upstream version detected '
                                 '(%s) which is after the last published '
                                 'upstream version (%s). Falling through '
@@ -174,7 +178,10 @@ class GitUbuntuBuild:
                                 last_upstream_version, spi.upstream_version)
                             upstream_version_found = True
                             break
-                        if spi.upstream_version == last_upstream_version:
+                        if version_compare(
+                            spi.upstream_version,
+                            last_upstream_version
+                        ) == 0:
                             logging.debug('Upstream version of publish %s '
                                           'matches' % spi.version
                                          )
diff --git a/gitubuntu/git_repository.py b/gitubuntu/git_repository.py
index ba0480b..b505da3 100644
--- a/gitubuntu/git_repository.py
+++ b/gitubuntu/git_repository.py
@@ -17,8 +17,6 @@ import tempfile
 import time
 from gitubuntu.run import run, runq, decode_binary
 try:
-    pkg = 'python3-debian'
-    import debian
     pkg = 'python3-pygit2'
     import pygit2
 except ImportError:
@@ -869,16 +867,6 @@ class GitUbuntuRepository:
         runq(['git', 'reset', '--hard'], env=self._env)
         runq(['git', 'clean', '-f', '-d'], env=self._env)
 
-    @staticmethod
-    def version_compare(a, b):
-        if a is None:
-            if b is None:
-                return 0
-            return -1
-        if b is None:
-            return 1
-        return debian.debian_support.version_compare(a, b)
-
     def get_all_changelog_versions_from_treeish(self, treeish):
         try:
             lines = self.parse_changelog_field_in_treeish(
diff --git a/gitubuntu/importer.py b/gitubuntu/importer.py
index 83f3675..9f466c9 100644
--- a/gitubuntu/importer.py
+++ b/gitubuntu/importer.py
@@ -41,6 +41,7 @@ from gitubuntu.git_repository import GitUbuntuRepository, orphan_tag, applied_ta
 from gitubuntu.run import decode_binary, run, runq
 from gitubuntu.source_information import GitUbuntuSourceInformation, NoPublicationHistoryException, SourceExtractionException, launchpad_login_auth
 from gitubuntu.version import VERSION
+from gitubuntu.versioning import version_compare
 try:
     pkg = 'python3-pygit2'
     import pygit2
@@ -688,7 +689,7 @@ class GitUbuntuImport:
                     devel_head_version, _ = self.local_repo.get_changelog_versions_from_treeish(devel_head_hash)
                 except AttributeError:
                     devel_head_version = None
-                if self.local_repo.version_compare(spi.version, devel_head_version) <= 0:
+                if version_compare(spi.version, devel_head_version) <= 0:
                     return
                 logging.debug("Updating %s to %s" % (devel_head,
                                                      spi.head_name(namespace)))
@@ -709,14 +710,13 @@ class GitUbuntuImport:
                 # Find highest version publish in these pockets
                 for suff in ("-proposed", "-updates", "-security", ""):
                     name = "%s/ubuntu/%s%s" % (namespace, rel, suff)
-                    if name in ubuntu_head_versions and \
-                        self.local_repo.version_compare(
-                            ubuntu_head_versions[name]['version'],
-                            series_devel_version
-                        ) > 0:
-                            series_devel_name = name
-                            series_devel_version = ubuntu_head_versions[name]['version']
-                            series_devel_hash = str(ubuntu_head_versions[name]['head'].peel().id)
+                    if name in ubuntu_head_versions and version_compare(
+                        ubuntu_head_versions[name]['version'],
+                        series_devel_version
+                    ) > 0:
+                        series_devel_name = name
+                        series_devel_version = ubuntu_head_versions[name]['version']
+                        series_devel_hash = str(ubuntu_head_versions[name]['head'].peel().id)
                 if series_devel_hash:
                     if not devel_hash:
                         devel_hash = series_devel_hash
@@ -843,7 +843,7 @@ class GitUbuntuImport:
                 except AttributeError:
                     pass
 
-            if self.local_repo.version_compare(str(spi.version), unapplied_tip_version) <= 0:
+            if version_compare(str(spi.version), unapplied_tip_version) <= 0:
                 logging.warn('Version to import (%s) is not after %s tip (%s)',
                              spi.version, pretty_head_name, unapplied_tip_version
                             )
@@ -1003,7 +1003,7 @@ class GitUbuntuImport:
                 except AttributeError:
                     pass
 
-            if self.local_repo.version_compare(str(spi.version), applied_tip_version) <= 0:
+            if version_compare(str(spi.version), applied_tip_version) <= 0:
                 logging.warn('Version to import (%s) is not after %s tip (%s)',
                              spi.version, pretty_head_name, applied_tip_version
                             )
diff --git a/gitubuntu/importlocal.py b/gitubuntu/importlocal.py
index c8c4fe4..bf1700e 100644
--- a/gitubuntu/importlocal.py
+++ b/gitubuntu/importlocal.py
@@ -11,6 +11,7 @@ from gitubuntu.git_repository import GitUbuntuRepository, git_dep14_tag
 from gitubuntu.run import decode_binary, run, runq
 from gitubuntu.version import VERSION
 from gitubuntu.importer import GitUbuntuImport
+from gitubuntu.versioning import version_compare
 try:
     pkg = 'python3-pygit2'
     import pygit2
@@ -143,7 +144,7 @@ class GitUbuntuImportLocal(GitUbuntuImport):
         unapplied_changelog_parent_commit = None
         applied_changelog_parent_commit = None
 
-        if self.local_repo.version_compare(changelog_version, head_version) <= 0:
+        if version_compare(changelog_version, head_version) <= 0:
             logging.warn('Version to import (%s) is not after HEAD '
                          'version (%s), history may not make sense.',
                          changelog_version, head_version
diff --git a/gitubuntu/lint.py b/gitubuntu/lint.py
index ef3652f..f176a44 100644
--- a/gitubuntu/lint.py
+++ b/gitubuntu/lint.py
@@ -348,9 +348,7 @@ class GitUbuntuLint:
         version, _ = self.local_repo.get_changelog_versions_from_treeish(
             commitish
         )
-        return gitubuntu.versioning.next_development_version(
-            gitubuntu.versioning.Version(version)
-        )
+        return gitubuntu.versioning.next_development_version(version)
 
     def do_merge_lint(self, old, new_base):
         """
diff --git a/gitubuntu/merge.py b/gitubuntu/merge.py
index 339c1b0..55df89a 100644
--- a/gitubuntu/merge.py
+++ b/gitubuntu/merge.py
@@ -10,6 +10,7 @@ import textwrap
 from gitubuntu.git_repository import GitUbuntuRepository, git_dep14_tag
 from gitubuntu.run import decode_binary, run
 from gitubuntu.source_information import GitUbuntuSourceInformation
+from gitubuntu.versioning import version_compare
 
 class TagException(Exception):
     pass
@@ -330,7 +331,7 @@ class GitUbuntuMerge:
 
         try:
             onto_version, _ = self.local_repo.get_changelog_versions_from_treeish(self.onto)
-            if self.local_repo.version_compare(commitish_version, onto_version) >= 0:
+            if version_compare(commitish_version, onto_version) >= 0:
                 if self.force:
                     logging.info('%s version (%s) is after %s version (%s), '
                                  'but --force passed.', self.commitish,
diff --git a/gitubuntu/versioning.py b/gitubuntu/versioning.py
index 10afb56..d2d76aa 100644
--- a/gitubuntu/versioning.py
+++ b/gitubuntu/versioning.py
@@ -1,4 +1,6 @@
+from collections import namedtuple
 import copy
+import functools
 import logging
 import re
 import sys
@@ -16,11 +18,22 @@ except ImportError:
     logging.error('Is %s installed?', pkg)
     sys.exit(1)
 
+__all__ = [
+   "next_development_version",
+   "next_sru_version",
+   "version_compare",
+]
+
+# see _decompose_version_string for explanation of members
+_VersionComps = namedtuple(
+    "_VersionComps",
+    ["prefix_parts", "ubuntu_maj", "ubuntu_series", "ubuntu_min"]
+)
+
 def _decompose_version_string(version_string):
-    """Return the "Ubuntu"-relevant parts of a version string
+    """Return the "Ubuntu"-relevant components of a version string
 
-    Returns a 3-tuple of (prefix_parts, ubuntu_maj, ubuntu_min), throwing away
-    some information.
+    Returns a _VersionComps namedtuple, throwing away some information.
 
     prefix_parts is a list of separated string parts forming the first
     "non-Ubuntu" part of the string, to which Ubuntu-specific version parts
@@ -34,10 +47,15 @@ def _decompose_version_string(version_string):
     "1.0-2ubuntu3.4", 3 is the major Ubuntu version number in both cases. In
     "1.0-2", the major Ubuntu version number is not present.
 
+    ubuntu_series is the "series" in the Ubuntu version number as a string, or
+    None if not present. For example, in the version string
+    "1.0.2ubuntu3.17.04.4", 17.04 is the Ubuntu series string. In both
+    "1.0-2ubuntu3.4" and "1.0-2", the Ubuntu series is not present.
+
     ubuntu_min is the "minor" Ubuntu version number as an integer, or None if
-    not present. For example, in the version strings "1.0-2ubuntu3.4", 4 is the
-    Ubuntu minor version number. In both "1.0-2" and "1.0-2ubuntu3", the minor
-    Ubuntu version number is not present.
+    not present. For example, in the version strings "1.0-2ubuntu3.4" and
+    "1.0-2ubuntu3.17.04.4", 4 is the Ubuntu minor version number. In both
+    "1.0-2" and "1.0-2ubuntu3", the minor Ubuntu version number is not present.
 
     For version strings not following these standard forms, the result is
     undefined except where specific test cases exist for them.
@@ -50,9 +68,13 @@ def _decompose_version_string(version_string):
     ]
 
     if 'build' in parts and 'ubuntu' in parts:
-        raise ValueError("Not sure how to decompose %s" % version_string)
+        raise ValueError("Not sure how to decompose %s: both build and "
+            "ubuntu found" % version_string
+        )
     elif 'build' in parts:
-        return parts[:parts.index('build')], None, None
+        return _VersionComps._make(
+            [parts[:parts.index('build')], None, None, None]
+        )
     elif 'ubuntu' in parts:
         ubuntu_idx = parts.index('ubuntu')
         static_parts = parts[:ubuntu_idx]
@@ -62,6 +84,7 @@ def _decompose_version_string(version_string):
         except IndexError:
             # nothing after "Xubuntu", treated as 1
             ubuntu_maj = 1
+        ubuntu_series = None
         if len(suffix_parts) < 2:
             ubuntu_min = None
         else:
@@ -69,9 +92,18 @@ def _decompose_version_string(version_string):
                 ubuntu_min = int(suffix_parts[-1])
             except ValueError:
                 ubuntu_min = None
-        return static_parts, ubuntu_maj, ubuntu_min
+            if len(suffix_parts[1:-1]) > 2:
+                ubuntu_series = ''.join(suffix_parts[2:-2])
+                if not re.match(r'\d\d\.\d\d', ubuntu_series):
+                    raise ValueError("Not sure how to decompose %s: "
+                        "series %s not in expected format" %
+                        (version_string, ubuntu_series)
+                    )
+        return _VersionComps._make(
+            [static_parts, ubuntu_maj, ubuntu_series, ubuntu_min]
+        )
     else:
-        return parts, None, None
+        return _VersionComps._make([parts, None, None, None])
 
 
 def _bump_version_object(old_version_object, bump_function):
@@ -81,8 +113,8 @@ def _bump_version_object(old_version_object, bump_function):
     non-native packages need to have their upstream_version bumped with their
     debian_version staying the same. The bumping mechanism is the same either
     way. This function handles this by working out which is needed, calling
-    bump_function with the old version string to return a bumped attribute
-    string, and creating a new Version object with the required attributed
+    bump_function with the old version suffix to return a bumped attribute
+    suffix, and creating a new Version object with the required attributed
     bumped accordingly.
     """
 
@@ -91,74 +123,133 @@ def _bump_version_object(old_version_object, bump_function):
     else:
         bump_attr = 'debian_version'
 
-    old_version_string = getattr(old_version_object, bump_attr)
-    new_version_string = bump_function(old_version_string)
+    old_version_suffix = getattr(old_version_object, bump_attr)
+    # While we are only bumping a specific suffix, we need to know the
+    # entire version for SRU version testing
+    new_version_suffix = bump_function(old_version_object, old_version_suffix)
     new_version_object = copy.deepcopy(old_version_object)
-    setattr(new_version_object, bump_attr, new_version_string)
+    setattr(new_version_object, bump_attr, new_version_suffix)
     return new_version_object
 
 
-def _bump_development_version_string(version):
-    static_parts, old_ubuntu_maj, _ = _decompose_version_string(version)
+def _bump_development_version_suffix(version, version_suffix):
+    """Return the next development version suffix
+
+    Keeping the static components the same, bump the Ubuntu major
+    version (see _decompose_version_string for definitions of these terms)
+    and drop any minors.
+    """
+
+    old_suffix_comps = _decompose_version_string(version_suffix)
+
+    new_ubuntu_maj = 1 if old_suffix_comps.ubuntu_maj is None else old_suffix_comps.ubuntu_maj + 1
+    new_suffix_comps = old_suffix_comps.prefix_parts + ['ubuntu', str(new_ubuntu_maj)]
+
+    return ''.join(new_suffix_comps)
 
-    new_ubuntu_maj = 1 if old_ubuntu_maj is None else old_ubuntu_maj + 1
-    new_parts = static_parts + ['ubuntu', str(new_ubuntu_maj)]
 
-    return ''.join(new_parts)
+def _bump_sru_version_suffix(befores, series, afters, version, version_suffix):
+    """Return the next SRU version suffix
 
+    Keeping the static components the same, maintain the same major (or
+    set it to 0 if the first major) and bump the minor. Keep the series
+    string (e.g., 16.04) in the version, if it was present before.
+    """
 
-def _bump_sru_version_string(version, series=None):
-    static_parts, old_maj, old_min = _decompose_version_string(version)
+    befores_comps = [_decompose_version_string(str(v)) for v in befores]
+    afters_comps = [_decompose_version_string(str(v)) for v in afters]
+    old_suffix_comps = _decompose_version_string(version_suffix)
+    old_version_comps = _decompose_version_string(str(version))
 
-    new_maj = 0 if old_maj is None else old_maj
-    new_min = 1 if old_min is None else old_min + 1
+    new_maj = 0 if old_suffix_comps.ubuntu_maj is None else old_suffix_comps.ubuntu_maj
+    new_min = 1 if old_suffix_comps.ubuntu_min is None else old_suffix_comps.ubuntu_min + 1
 
     bumped_parts = ['ubuntu', str(new_maj), '.']
-    if series:
+    if old_suffix_comps.ubuntu_series:
+        bumped_parts.extend([old_suffix_comps.ubuntu_series, '.'])
+    elif str(version) in [str(v) for v in befores + afters]:
+        bumped_parts.extend([series, '.'])
+    elif any(
+        v.prefix_parts + ['ubuntu', str(v.ubuntu_maj), '.'] == old_version_comps.prefix_parts + bumped_parts
+        for v in befores_comps + afters_comps
+    ):
         bumped_parts.extend([series, '.'])
     bumped_parts.append(str(new_min))
 
-    return ''.join(static_parts + bumped_parts)
+    return ''.join(old_suffix_comps.prefix_parts + bumped_parts)
 
 
-def next_development_version(version):
-    return _bump_version_object(version, _bump_development_version_string)
+def next_development_version(version_string):
+    """Return the next development version relative to @version_string
+    """
+    return _bump_version_object(
+        Version(version_string),
+        _bump_development_version_suffix
+    )
 
 
-def _next_sru_version(before, series, current, after):
-    return _bump_version_object(current, _bump_sru_version_string)
+def _next_sru_version(befores, series, current, afters):
+    """Return the next SRU version respecting other series information
+
+    Currently incorrect, as it does not actually use other series
+    information.
+    """
+    return _bump_version_object(current,
+        functools.partial(_bump_sru_version_suffix, befores, series,
+            afters
+        )
+    )
 
 
-def max_version(lp_series, pkgname):
+def max_version(lp_series_object, pkgname):
+    """Return the latest published version for a given source package
+    and series
+    """
     ubuntu_source_information = GitUbuntuSourceInformation('ubuntu', pkgname)
     for spi in ubuntu_source_information.launchpad_versions_published(
-        sorted_by_version=True, series=lp_series
+        sorted_by_version=True, series=lp_series_object
     ):
         return Version(spi.version)
 
 
-def next_sru_version(series, pkgname):
+def next_sru_version(lp_series_object, pkgname):
+    """Return the next SRU version for a given source package and series
+
+    Queries Launchpad for publishing information about other active
+    series for the same source package.
+    """
     # for a series extract the required parameters
     ubuntu_source_information = GitUbuntuSourceInformation('ubuntu')
-    active_series = ubuntu_source_information.active_series
-    before = [max_version(before_series, pkgname)
-        for before_series in active_series 
-        if float(before_series.version) < float(series.version)
+    active_series_objects = ubuntu_source_information.active_series
+    befores = [max_version(before_series_object, pkgname)
+        for before_series_object in active_series_objects
+        if float(before_series_object.version) < float(lp_series_object.version)
     ]
-    after = [max_version(after_series, pkgname)
-        for after_series in active_series 
-        if float(after_series.version) > float(series.version)
+    afters = [max_version(after_series_object, pkgname)
+        for after_series_object in active_series_objects
+        if float(after_series_object.version) > float(lp_series_object.version)
     ]
-    current = max_version(series, pkgname)
-    return _next_sru_version(before, series, current, after)
+    current = max_version(lp_series_obj, pkgname)
+    return _next_sru_version(befores, lp_series_obj, current, afters)
+
+
+def version_compare(a, b):
+    if a is None:
+        if b is None:
+            return 0
+        return -1
+    if b is None:
+        return 1
+    return debian.debian_support.version_compare(a, b)
+
 
 @pytest.mark.parametrize('test_input, expected', [
-    ('2', (['2'], None, None)),
-    ('2ubuntu1', (['2'], 1, None)),
-    ('2ubuntu1.3', (['2'], 1, 3)),
-    ('2ubuntu0.16.04.3', (['2'], 0, 3)),
-    ('2build1', (['2'], None, None)),
-    ('2build1.3', (['2'], None, None)),
+    ('2', _VersionComps._make([['2'], None, None, None])),
+    ('2ubuntu1', _VersionComps._make([['2'], 1, None, None])),
+    ('2ubuntu1.3', _VersionComps._make([['2'], 1, None, 3])),
+    ('2ubuntu0.16.04.3', _VersionComps._make([['2'], 0, '16.04', 3])),
+    ('2build1', _VersionComps._make([['2'], None, None, None])),
+    ('2build1.3', _VersionComps._make([['2'], None, None, None])),
 ])
 def test_decompose_version_string(test_input, expected):
     assert _decompose_version_string(test_input) == expected
@@ -178,14 +269,38 @@ def test_next_development_version(test_input, expected):
     assert next_development_version(Version(test_input)) == expected
 
 
[e-mail]('before, series, current, after, expected', [
[e-mail]('befores, series, current, afters, expected', [
     ([], '16.04', '1.0-1', [], '1.0-1ubuntu0.1'),
     (['1.0-1'], '16.04', '1.0-1', [], '1.0-1ubuntu0.16.04.1'),
+    ([], '16.04', '1.0-1', ['1.0-1'], '1.0-1ubuntu0.16.04.1'),
+    (['1.0-1ubuntu1'], '16.04', '1.0-1ubuntu1', [], '1.0-1ubuntu1.16.04.1'),
+    ([], '16.04', '1.0-1ubuntu1', ['1.0-1ubuntu1'], '1.0-1ubuntu1.16.04.1'),
+    (['1.0-1ubuntu1'], '16.04', '1.0-1ubuntu1', ['1.0.1-ubuntu1'], '1.0-1ubuntu1.16.04.1'),
+    (['1.0-1ubuntu1'], '16.04', '1.0-1ubuntu1', ['1.0.1-ubuntu2'], '1.0-1ubuntu1.16.04.1'),
+    (['1.0-1ubuntu1.14.04.1'], '16.04', '1.0-1ubuntu1.16.04.1', ['1.0-1ubuntu1.17.10.1'], '1.0-1ubuntu1.16.04.2'),
+    (['1.0-1ubuntu1.14.04.1'], '16.04', '1.0-1ubuntu1', ['1.0-1ubuntu2'], '1.0-1ubuntu1.16.04.1'),
+    (['1.0-1ubuntu1.14.04.1'], '16.04', '1.0-1ubuntu1', ['1.0-1ubuntu1.17.10.1'], '1.0-1ubuntu1.16.04.1'),
+    (['1.0-1'], '16.04', '1.0-1ubuntu1', ['1.0-1ubuntu11'], '1.0-1ubuntu1.1'),
+    (['1.0-1'], '16.04', '1.0-2ubuntu1', ['1.0-2ubuntu11'], '1.0-2ubuntu1.1'),
+    ([], '16.04', '1.0-2ubuntu1', ['2.0-2ubuntu1'], '1.0-2ubuntu1.1'),
 ])
-def test_next_sru_version(before, series, current, after, expected):
+def test_next_sru_version(befores, series, current, afters, expected):
     assert _next_sru_version(
-        before=[Version(vstr) for vstr in before],
+        befores=[Version(vstr) for vstr in befores],
         series=series,
         current=Version(current),
-        after=[Version(vstr) for vstr in after],
+        afters=[Version(vstr) for vstr in afters],
     ) == expected
+
+
[e-mail]('a, b, expected', [
+    (None, '1.0-1', -1),
+    (None, None, 0),
+    ('1.0-1', None, 1),
+    ('1.0-1', '1.0-1ubuntu1', -1),
+    ('1.0-1ubuntu1', '1.0-1ubuntu1', 0),
+    ('1.0-1ubuntu1', '2.0-1', -1),
+    ('1.0-1ubuntu1', '1.0-2', -1),
+])
+def test_version_compare(a, b, expected):
+    assert version_compare(a, b) == expected