[LNT] Python 3 support: get rid of calls to cmp builtin

[thopre]

Summary

Get rid of calls to cmp builtins since it was removed in Python 3:

• for the tests, the assignment to sortTestMethodsUsing is removed altogether since the default is the built-in ordering for strings;
• for the call in the TestsuiteDB.Order class, we define the rich comparison methods that have replaced cmp;
• for the stats module, we use equality expressions since only the equality value is needed.

Note that one of the uses of cmp in the stats module is dead but removal
of the dead code is kept for future work to keep a separation of concern
between commits.

[hubert.reinterpretcast]

lnt/server/db/testsuitedb.py

289

Not sure what you think of this drive-by:

next(
    itertools.dropwhile(
        lambda x: x[0] == x[1],
        map(
            lambda item:
            (convert_revision(self.get_field(item), cache=Order.order_name_cache),
             convert_revision(b.get_field(item), cache=Order.order_name_cache)),
            self.fields)), (0, 0))

[hubert.reinterpretcast]

tests/server/ui/test_api_modify.py

229

This does get called, but the default behavior is fine.

[thopre]

• Use Hubert's improve _compare_prepare implementation and rename it accordingly

[thopre]

lnt/server/db/testsuitedb.py

289

Went for intermediate steps as I find it more readable, YMMV.

tests/server/ui/test_api_modify.py

229

What calls this lambda?

[hubert.reinterpretcast]

LGTM with suggestion for a minor drive-by typo correction.

lnt/server/db/testsuitedb.py

284

Minor drive-by: s/verse/versus/;

tests/server/ui/test_api_modify.py

229

Something called through the call to unittest.main below.

[thopre]

Fix misses uses of cmp builtin

[hubert.reinterpretcast]

LGTM.

lnt/server/db/testsuitedb.py

 """
 Database models for the TestSuite databases themselves.
 
 These are a bit magical because the models themselves are driven by the test
 suite metadata, so we only create the classes at runtime.
 """
 
 from __future__ import absolute_import
 import datetime
 import json
 import os
+import itertools
 
 import aniso8601
 import sqlalchemy
 import flask
 from sqlalchemy import Float, String, Integer, Column, ForeignKey, Binary, DateTime
 from sqlalchemy.orm import relation
 from sqlalchemy.orm.exc import ObjectDeletedError
 from typing import List
def __init__(self, v4db, name, test_suite):
                 _dict_update_abort_on_duplicates(result, self.get_fields())
                 _dict_update_abort_on_duplicates(result, self.parameters)
                 return result
 
         class Order(self.base, ParameterizedMixin):
             __tablename__ = db_key_name + '_Order'
 
             # We guarantee that our fields are stored in the order they are
-            # supposed to be lexicographically compared, the __cmp__ method
-            # relies on this.
+            # supposed to be lexicographically compared, the rich comparison
+            # methods rely on this.
             fields = sorted(self.order_fields,
                             key=lambda of: of.ordinal)
 
             id = Column("ID", Integer, primary_key=True)
 
             # Define two common columns which are used to store the previous
             # and next links for the total ordering amongst run orders.
             next_order_id = Column("NextOrder", Integer, ForeignKey(id))
def __init__(self, v4db, name, test_suite):
                 return '(%s)' % (
                     ', '.join(self.get_field(field)
                               for field in self.fields),)
 
             @property
             def name(self):
                 return self.as_ordered_string()
 
-            def __cmp__(self, b):
+            def _get_comparison_discriminant(self, b):
+                """Return a representative pair of converted revision from self
+                and b. Order of the element on this pair is the same as the
+                order of self relative to b.
+                """
                 # SA occasionally uses comparison to check model instances
                 # verse some sentinels, so we ensure we support comparison
                 # against non-instances.
                 if self.__class__ is not b.__class__:
-                    return -1
-                # Compare every field in lexicographic order.
-                return cmp([convert_revision(self.get_field(item), cache=Order.order_name_cache)
-                            for item in self.fields],
-                           [convert_revision(b.get_field(item),  cache=Order.order_name_cache)
-                            for item in self.fields])
+                    return (0, 1)
+
+                # Pair converted revision from self and b.
+                converted_revisions = map(
+                    lambda item: (
+                        convert_revision(
+                            self.get_field(item), cache=Order.order_name_cache
+                        ),
+                        convert_revision(
+                            b.get_field(item), cache=Order.order_name_cache
+                        ),
+                    ),
+                    self.fields,
+                )
+                # Return the first unequal pair, or (0, 0) otherwise.
+                return next(
+                    itertools.dropwhile(lambda x: x[0] == x[1], converted_revisions),
+                    (0, 0),
+                )
+
+            def __eq__(self, b):
+                discriminant = self._get_comparison_discriminant(b)
+                return discriminant[0] == discriminant[1]
+
+            def __ne__(self, b):
+                discriminant = self._get_comparison_discriminant(b)
+                return discriminant[0] != discriminant[1]
+
+            def __lt__(self, b):
+                discriminant = self._get_comparison_discriminant(b)
+                return discriminant[0] < discriminant[1]
+
+            def __le__(self, b):
+                discriminant = self._get_comparison_discriminant(b)
+                return discriminant[0] <= discriminant[1]
+
+            def __gt__(self, b):
+                discriminant = self._get_comparison_discriminant(b)
+                return discriminant[0] > discriminant[1]
+
+            def __ge__(self, b):
+                discriminant = self._get_comparison_discriminant(b)
+                return discriminant[0] >= discriminant[1]
 
             def __json__(self, include_id=True):
                 result = {}
                 if include_id:
                     result['id'] = self.id
                 _dict_update_abort_on_duplicates(result, self.get_fields())
                 return result
 

tests/server/ui/test_api_modify.py

def test_04_merge_into(self):
         machine_3['runs'] = [_hashabledict(run) for run in machine_3['runs']]
         allruns = set(machine_1['runs']).union(machine_3['runs'])
         resp_3 = check_json(client, 'api/db_default/v4/nts/machines/3')
         resp_3['runs'] = [_hashabledict(run) for run in resp_3['runs']]
         self.assertEqual(set(resp_3['runs']), allruns)
 
 
 if __name__ == '__main__':
-    unittest.TestLoader.sortTestMethodsUsing = lambda _, x, y: cmp(x, y)
     unittest.main(argv=[sys.argv[0], ])

tests/server/ui/test_api_roundtrip.py

def test_roundtrip(self):
         reimported = check_json(client, new_location)
 
         # The 'id' field may be the different, the rest must be the same.
         reimported['run']['id'] = original['run']['id']
         self.assertEqual(original, reimported)
 
 
 if __name__ == '__main__':
-    unittest.TestLoader.sortTestMethodsUsing = lambda _, x, y: cmp(x, y)
     unittest.main(argv=[sys.argv[0], ])