100% coverage for timestamp.py

Deleted _makeOctets since we have native literals everywhere.

persistent/tests/test_persistence.py

@@ -99,8 +99,7 @@ class _Persistent_Base(object):
         return jar
 
     def _makeOneWithJar(self, klass=None, broken_jar=False):
-        from persistent.timestamp import _makeOctets
-        OID = _makeOctets('\x01' * 8)
+        OID = b'\x01' * 8
         if klass is not None:
             inst = klass()
         else:
@@ -201,34 +200,30 @@ class _Persistent_Base(object):
             inst._p_oid = object()
 
     def test_assign_p_oid_w_valid_oid(self):
-        from persistent.timestamp import _makeOctets
-        OID = _makeOctets('\x01' * 8)
+        OID = b'\x01' * 8
         inst = self._makeOne()
         inst._p_oid = OID
         self.assertEqual(inst._p_oid, OID)
         inst._p_oid = OID  # reassign only same OID
 
     def test_assign_p_oid_w_new_oid_wo_jar(self):
-        from persistent.timestamp import _makeOctets
-        OID1 = _makeOctets('\x01' * 8)
-        OID2 = _makeOctets('\x02' * 8)
+        OID1 = b'\x01' * 8
+        OID2 = b'\x02' * 8
         inst = self._makeOne()
         inst._p_oid = OID1
         inst._p_oid = OID2
         self.assertEqual(inst._p_oid, OID2)
 
     def test_assign_p_oid_w_None_wo_jar(self):
-        from persistent.timestamp import _makeOctets
-        OID1 = _makeOctets('\x01' * 8)
+        OID1 = b'\x01' * 8
         inst = self._makeOne()
         inst._p_oid = OID1
         inst._p_oid = None
         self.assertEqual(inst._p_oid, None)
 
     def test_assign_p_oid_w_new_oid_w_jar(self):
-        from persistent.timestamp import _makeOctets
         inst, jar, OID = self._makeOneWithJar()
-        new_OID = _makeOctets('\x02' * 8)
+        new_OID = b'\x02' * 8
         def _test():
             inst._p_oid = new_OID
         self.assertRaises(ValueError, _test)
@@ -242,8 +237,7 @@ class _Persistent_Base(object):
         self.assertEqual(inst._p_oid, 42)
 
     def test_delete_p_oid_wo_jar(self):
-        from persistent.timestamp import _makeOctets
-        OID = _makeOctets('\x01' * 8)
+        OID = b'\x01' * 8
         inst = self._makeOne()
         inst._p_oid = OID
         del inst._p_oid
@@ -289,16 +283,14 @@ class _Persistent_Base(object):
         self.assertRaises(ValueError, _test)
 
     def test_assign_p_serial_w_valid_serial(self):
-        from persistent.timestamp import _makeOctets
-        SERIAL = _makeOctets('\x01' * 8)
+        SERIAL = b'\x01' * 8
         inst = self._makeOne()
         inst._p_serial = SERIAL
         self.assertEqual(inst._p_serial, SERIAL)
 
     def test_delete_p_serial(self):
-        from persistent.timestamp import _makeOctets
         from persistent.persistence import _INITIAL_SERIAL
-        SERIAL = _makeOctets('\x01' * 8)
+        SERIAL = b'\x01' * 8
         inst = self._makeOne()
         inst._p_serial = SERIAL
         self.assertEqual(inst._p_serial, SERIAL)
@@ -738,8 +730,7 @@ class _Persistent_Base(object):
         self.assertRaises(AttributeError, getattr, Derived(), 'magic')
 
     def test___setattr___p__names(self):
-        from persistent.timestamp import _makeOctets
-        SERIAL = _makeOctets('\x01' * 8)
+        SERIAL = b'\x01' * 8
         inst, jar, OID = self._makeOneWithJar()
         inst._p_activate()
         NAMES = [('_p_jar', jar),
@@ -1488,8 +1479,7 @@ class _Persistent_Base(object):
         self._checkMRU(jar, [OID])
 
     def test__p_setattr_w__p__name(self):
-        from persistent.timestamp import _makeOctets
-        SERIAL = _makeOctets('\x01' * 8)
+        SERIAL = b'\x01' * 8
         inst, jar, OID = self._makeOneWithJar()
         inst._p_deactivate()
         self.assertTrue(inst._p_setattr('_p_serial', SERIAL))

persistent/tests/test_timestamp.py

@@ -63,9 +63,11 @@ class pyTimeStampTests(unittest.TestCase):
                     (1, 2, 3, 4, 5),
                     ('1', '2', '3', '4', '5', '6'),
                     (1, 2, 3, 4, 5, 6, 7),
+                    (b'123',),
                    ]
         for args in BAD_ARGS:
-            self.assertRaises((TypeError, ValueError), self._makeOne, *args)
+            with self.assertRaises((TypeError, ValueError)):
+                self._makeOne(*args)
 
     def test_ctor_from_invalid_strings(self):
         BAD_ARGS = [''
@@ -80,13 +82,12 @@ class pyTimeStampTests(unittest.TestCase):
             self.assertRaises((TypeError, ValueError), self._makeOne, *args)
 
     def test_ctor_from_string(self):
-        from persistent.timestamp import _makeOctets
         from persistent.timestamp import _makeUTC
         ZERO = _makeUTC(1900, 1, 1, 0, 0, 0)
         EPOCH = _makeUTC(1970, 1, 1, 0, 0, 0)
         DELTA = ZERO - EPOCH
         DELTA_SECS = DELTA.days * 86400 + DELTA.seconds
-        SERIAL = _makeOctets('\x00' * 8)
+        SERIAL = b'\x00' * 8
         ts = self._makeOne(SERIAL)
         self.assertEqual(ts.raw(), SERIAL)
         self.assertEqual(ts.year(), 1900)
@@ -104,13 +105,12 @@ class pyTimeStampTests(unittest.TestCase):
         self.assertEqual(before.timeTime(), 1297867042.80544)
 
     def test_ctor_from_elements(self):
-        from persistent.timestamp import _makeOctets
         from persistent.timestamp import _makeUTC
         ZERO = _makeUTC(1900, 1, 1, 0, 0, 0)
         EPOCH = _makeUTC(1970, 1, 1, 0, 0, 0)
         DELTA = ZERO - EPOCH
         DELTA_SECS = DELTA.days * 86400 + DELTA.seconds
-        SERIAL = _makeOctets('\x00' * 8)
+        SERIAL = b'\x00' * 8
         ts = self._makeOne(1900, 1, 1, 0, 0, 0.0)
         self.assertEqual(ts.raw(), SERIAL)
         self.assertEqual(ts.year(), 1900)
@@ -122,9 +122,8 @@ class pyTimeStampTests(unittest.TestCase):
         self.assertEqual(ts.timeTime(), DELTA_SECS)
 
     def test_laterThan_invalid(self):
-        from persistent.timestamp import _makeOctets
         ERRORS = (ValueError, TypeError)
-        SERIAL = _makeOctets('\x01' * 8)
+        SERIAL = b'\x01' * 8
         ts = self._makeOne(SERIAL)
         self.assertRaises(ERRORS, ts.laterThan, None)
         self.assertRaises(ERRORS, ts.laterThan, '')
@@ -134,26 +133,23 @@ class pyTimeStampTests(unittest.TestCase):
         self.assertRaises(ERRORS, ts.laterThan, object())
 
     def test_laterThan_self_is_earlier(self):
-        from persistent.timestamp import _makeOctets
-        SERIAL1 = _makeOctets('\x01' * 8)
-        SERIAL2 = _makeOctets('\x02' * 8)
+        SERIAL1 = b'\x01' * 8
+        SERIAL2 = b'\x02' * 8
         ts1 = self._makeOne(SERIAL1)
         ts2 = self._makeOne(SERIAL2)
         later = ts1.laterThan(ts2)
-        self.assertEqual(later.raw(), _makeOctets('\x02' * 7 + '\x03'))
+        self.assertEqual(later.raw(), b'\x02' * 7 + b'\x03')
 
     def test_laterThan_self_is_later(self):
-        from persistent.timestamp import _makeOctets
-        SERIAL1 = _makeOctets('\x01' * 8)
-        SERIAL2 = _makeOctets('\x02' * 8)
+        SERIAL1 = b'\x01' * 8
+        SERIAL2 = b'\x02' * 8
         ts1 = self._makeOne(SERIAL1)
         ts2 = self._makeOne(SERIAL2)
         later = ts2.laterThan(ts1)
         self.assertTrue(later is ts2)
 
     def test_repr(self):
-        from persistent.timestamp import _makeOctets
-        SERIAL = _makeOctets('\x01' * 8)
+        SERIAL = b'\x01' * 8
         ts = self._makeOne(SERIAL)
         self.assertEqual(repr(ts), repr(SERIAL))
 

persistent/timestamp.py

@@ -21,13 +21,7 @@ import sys
 _RAWTYPE = bytes
 _MAXINT = sys.maxsize
 
-def _makeOctets(s):
-    if sys.version_info < (3,):
-        return bytes(s)
-    return bytes(s, 'ascii') # pragma: no cover
-
-
-_ZERO = _makeOctets('\x00' * 8)
+_ZERO = b'\x00' * 8
 
 try:
     # Make sure to overflow and wraparound just