Improve readability by extracting repeated type instantiations

- test_marshalling.py: Extract DecimalType(proto_ver) to avoid duplicate calls
- test_orderedmap.py: Extract key_type_class(protocol_version) to reuse instance
- test_geometry.py: Extract cql_type(proto_ver) and PointType(0) to avoid duplicates

This makes the code more readable and efficient by avoiding repeated
instantiation of the same type objects.

Author: mykaul

tests/unit/advanced/test_geometry.py

@@ -35,8 +35,9 @@ class GeoTypes(unittest.TestCase):
     def test_marshal_platform(self):
         for proto_ver in protocol_versions:
             for geo in self.samples:
-                cql_type = lookup_casstype(geo.__class__.__name__ + 'Type')
-                assert cql_type(proto_ver).from_binary(cql_type(proto_ver).to_binary(geo)) == geo
+                cql_type_class = lookup_casstype(geo.__class__.__name__ + 'Type')
+                cql_type = cql_type_class(proto_ver)
+                assert cql_type.from_binary(cql_type.to_binary(geo)) == geo
 
     def _verify_both_endian(self, typ, body_fmt, params, expected):
         for proto_ver in protocol_versions:
@@ -51,9 +52,11 @@ def test_both_endian(self):
     def test_empty_wkb(self):
         for cls in (LineString, Polygon):
             class_name = cls.__name__
-            cql_type = lookup_casstype(class_name + 'Type')
-            assert str(cql_type(0).from_binary(cql_type(0).to_binary(cls()))) == class_name.upper() + " EMPTY"
-        assert str(PointType(0).from_binary(PointType(0).to_binary(Point()))) == "POINT (nan nan)"
+            cql_type_class = lookup_casstype(class_name + 'Type')
+            cql_type = cql_type_class(0)
+            assert str(cql_type.from_binary(cql_type.to_binary(cls()))) == class_name.upper() + " EMPTY"
+        point_type = PointType(0)
+        assert str(point_type.from_binary(point_type.to_binary(Point()))) == "POINT (nan nan)"
 
     def test_str_wkt(self):
         assert str(Point(1., 2.)) == 'POINT (1.0 2.0)'

tests/unit/test_marshalling.py

@@ -132,6 +132,7 @@ def test_decimal(self):
         converted_types = (10001, (0, (1, 0, 0, 0, 0, 1), -3), 100.1, -87.629798)
 
         for proto_ver in range(3, ProtocolVersion.MAX_SUPPORTED + 1):
+            decimal_type = DecimalType(proto_ver)
             for n in converted_types:
                 expected = Decimal(n)
-                assert DecimalType(proto_ver).from_binary(DecimalType(proto_ver).to_binary(n)) == expected
+                assert decimal_type.from_binary(decimal_type.to_binary(n)) == expected

tests/unit/test_orderedmap.py

@@ -171,13 +171,14 @@ def test_init(self):
         assert om == {}
 
     def test_normalized_lookup(self):
-        key_type = lookup_casstype('MapType(UTF8Type, Int32Type)')
+        key_type_class = lookup_casstype('MapType(UTF8Type, Int32Type)')
         protocol_version = 3
-        om = OrderedMapSerializedKey(key_type(protocol_version))
+        key_type = key_type_class(protocol_version)
+        om = OrderedMapSerializedKey(key_type)
         key_ascii = {'one': 1}
         key_unicode = {u'two': 2}
-        om._insert_unchecked(key_ascii, key_type(protocol_version).serialize(key_ascii), object())
-        om._insert_unchecked(key_unicode, key_type(protocol_version).serialize(key_unicode), object())
+        om._insert_unchecked(key_ascii, key_type.serialize(key_ascii), object())
+        om._insert_unchecked(key_unicode, key_type.serialize(key_unicode), object())
 
         # type lookup is normalized by key_type
         # PYTHON-231