Return to 100% coverage.

Also, fix bugs uncovered thereby in processing float / tuple arguments.

zodburi/datatypes.py

@@ -36,3 +36,6 @@ def convert_int(value):
     if value in TRUETYPES:
         return 1
     return int(value)
+
+def convert_tuple(value):
+    return tuple(value.split(','))

zodburi/resolvers.py

@@ -13,6 +13,7 @@ import ZConfig
 
 from zodburi.datatypes import convert_bytesize
 from zodburi.datatypes import convert_int
+from zodburi.datatypes import convert_tuple
 
 
 class Resolver(object):
@@ -26,15 +27,14 @@ class Resolver(object):
         unused = kw.copy()
         new = {}
         convert_string = lambda s: s
-        converters = (
-            convert_int,
-            convert_string,
-            convert_bytesize)
-        args = (
-            self._int_args,
-            self._string_args,
-            self._bytesize_args)
-        for convert, arg_names in zip(converters, args):
+        converters = [
+            (convert_int, self._int_args),
+            (convert_string, self._string_args),
+            (convert_bytesize, self._bytesize_args),
+            (float, self._float_args),
+            (convert_tuple, self._tuple_args),
+        ]
+        for convert, arg_names in converters:
             for arg_name in arg_names:
                 value = unused.pop(arg_name, None)
                 if value is not None:

zodburi/resolvers_relstorage.py

 import cgi
 import urlparse
 from ZODB.DemoStorage import DemoStorage
-from relstorage.adapters.postgresql import PostgreSQLAdapter
-from relstorage.options import Options
-from relstorage.storage import RelStorage
 
 from .resolvers import Resolver
 
+try:
+    from relstorage.adapters.postgresql import PostgreSQLAdapter
+    from relstorage.options import Options
+    from relstorage.storage import RelStorage
+except ImportError: #pragma NO COVER
+    pass
+else:
+    # Not a real resolver, but we use interpret_kwargs
+    class PostgreSQLAdapterHelper(Resolver):
+        _int_args = ('connect_timeout', )
+        _string_args = ('ssl_mode', )
 
-# Not a real resolver, but we use interpret_kwargs
-class PostgreSQLAdapterHelper(Resolver):
-    _int_args = ('connect_timeout', )
-    _string_args = ('ssl_mode', )
+        def __call__(self, parsed_uri, kw):
+            dsn_args = [
+                ('dbname', parsed_uri.path[1:]),
+                ('user', parsed_uri.username),
+                ('password', parsed_uri.password),
+                ('host', parsed_uri.hostname),
+                ('port', parsed_uri.port)
+            ]
 
-    def __call__(self, parsed_uri, kw):
-        dsn_args = [
-            ('dbname', parsed_uri.path[1:]),
-            ('user', parsed_uri.username),
-            ('password', parsed_uri.password),
-            ('host', parsed_uri.hostname),
-            ('port', parsed_uri.port)
-        ]
+            kw, unused = self.interpret_kwargs(kw)
+            dsn_args.extend(kw.items())
 
-        kw, unused = self.interpret_kwargs(kw)
-        dsn_args.extend(kw.items())
+            dsn = ' '.join("%s='%s'"%arg for arg in dsn_args)
 
-        dsn = ' '.join("%s='%s'"%arg for arg in dsn_args)
+            def factory(options):
+                return PostgreSQLAdapter(dsn=dsn, options=options)
+            return factory, unused
 
-        def factory(options):
-            return PostgreSQLAdapter(dsn=dsn, options=options)
-        return factory, unused
 
+    # The relstorage support is inspired by django-zodb.
+    # Oracle and mysql should be easily implementable from here
+    class RelStorageURIResolver(Resolver):
+        _int_args = ('poll_interval', 'cache_local_mb', 'commit_lock_timeout',
+                    'commit_lock_id', 'read_only', 'shared_blob_dir',
+                    'keep_history', 'pack_gc', 'pack_dry_run', 'strict_tpc',
+                    'create', 'demostorage',)
+        _string_args = ('name', 'blob_dir', 'replica_conf',
+                        'cache_module_name', 'cache_prefix',
+                        'cache_delta_size_limit')
+        _bytesize_args = ('blob_cache_size', 'blob_cache_size_check',
+                        'blob_cache_chunk_size')
+        _float_args = ('replica_timeout', 'pack_batch_timeout',
+                       'pack_duty_cycle', 'pack_max_delay')
+        _tuple_args = ('cache_servers',)
 
-# The relstorage support is inspired by django-zodb.
-# Oracle and mysql should be easily implementable from here
-class RelStorageURIResolver(Resolver):
-    _int_args = ('poll_interval', 'cache_local_mb', 'commit_lock_timeout',
-                 'commit_lock_id', 'read_only', 'shared_blob_dir',
-                 'keep_history', 'pack_gc', 'pack_dry_run', 'strict_tpc',
-                 'create', 'demostorage',)
-    _string_args = ('name', 'blob_dir', 'replica_conf', 'cache_module_name',
-                    'cache_prefix', 'cache_delta_size_limit')
-    _bytesize_args = ('blob_cache_size', 'blob_cache_size_check',
-                      'blob_cache_chunk_size')
-    _float_args = ('replica_timeout', 'pack_batch_timeout', 'pack_duty_cycle',
-                   'pack_max_delay')
-    _tuple_args = ('cache_servers',)
+        def __init__(self, adapter_helper):
+            self.adapter_helper = adapter_helper
 
-    def __init__(self, adapter_helper):
-        self.adapter_helper = adapter_helper
+        def __call__(self, uri):
+            uri = uri.replace('postgres://', 'http://', 1)
+            parsed_uri = urlparse.urlsplit(uri)
+            kw = dict(cgi.parse_qsl(parsed_uri.query))
 
-    def __call__(self, uri):
-        uri = uri.replace('postgres://', 'http://', 1)
-        parsed_uri = urlparse.urlsplit(uri)
-        kw = dict(cgi.parse_qsl(parsed_uri.query))
+            adapter_factory, kw = self.adapter_helper(parsed_uri, kw)
+            kw, unused = self.interpret_kwargs(kw)
 
-        adapter_factory, kw = self.adapter_helper(parsed_uri, kw)
-        kw, unused = self.interpret_kwargs(kw)
+            demostorage = kw.pop('demostorage', False)
+            options = Options(**kw)
 
-        demostorage = kw.pop('demostorage', False)
-        options = Options(**kw)
+            def factory():
+                adapter = adapter_factory(options)
+                storage = RelStorage(adapter=adapter, options=options)
+                if demostorage:
+                    storage = DemoStorage(base=storage)
+                return storage
+            return factory, unused
 
-        def factory():
-            adapter = adapter_factory(options)
-            storage = RelStorage(adapter=adapter, options=options)
-            if demostorage:
-                storage = DemoStorage(base=storage)
-            return storage
-        return factory, unused
-
-postgresql_resolver = RelStorageURIResolver(PostgreSQLAdapterHelper())
\ No newline at end of file
+    postgresql_resolver = RelStorageURIResolver(PostgreSQLAdapterHelper())