support connection options as dictionary

removed unused test.py, add unit-test for specifying configuration dict

Author: adamhadani

rdflib_sqlalchemy/store.py

@@ -84,7 +84,11 @@ def __init__(self, identifier=None, configuration=None, engine=None):
 
         Args:
             identifier (rdflib.URIRef): URIRef of the Store. Defaults to CWD.
-            engine (sqlalchemy.engine.Engine, optional): a `SQLAlchemy.engine.Engine` instance
+            configuration: the database connection URL string or a configuration dictionary
+                corresponding to the connection options accepted by sqlalchemy.create_engine,
+                with the additional "url" key pointing to the connection URL. See `open` documentation
+                for more details.
+            engine (sqlalchemy.engine.Engine, optional): a pre-existing `SQLAlchemy.engine.Engine` instance.
 
         """
         self.identifier = identifier and identifier or "hardcoded"
@@ -214,9 +218,14 @@ def node_pickler(self):
 
     def open(self, configuration, create=True):
         """
-        Open the store specified by the configuration string.
+        Open the store specified by the configuration parameter.
 
         Args:
+            configuration: if a string, use as the DBAPI URL. If a dictionary, will use as the **kwargs
+                for the sqlalchemy.create_engine() call, and will attempt to extract the connection URL
+                from a 'url' key in that dictionary.
+                A valid connection string will be of the format:
+                    dialect[+driver]://user:password@host/dbname[?key=value..]
             create (bool): If create is True a store will be created if it does not already
                 exist. If create is False and a store does not already exist
                 an exception is raised. An exception is also raised if a store
@@ -232,7 +241,14 @@ def open(self, configuration, create=True):
         # Close any existing engine connection
         self.close()
 
-        self.engine = sqlalchemy.create_engine(configuration)
+        url, kwargs = configuration, {}
+        if isinstance(configuration, dict):
+            url = configuration.pop("url", None)
+            if not url:
+                raise Exception('Configuration dict is missing the required "url" key')
+            kwargs = configuration
+
+        self.engine = sqlalchemy.create_engine(url, **kwargs)
         with self.engine.connect():
             if create:
                 self.create_all()

setup.cfg

@@ -4,6 +4,7 @@ description-file = README.md
 [nosetests]
 attr = !known_issue,!performancetest
 verbosity = 2
+where = test
 
 [flake8]
 max-line-length = 120

test/test.py

@@ -1,33 +1,50 @@
-import logging
 import unittest
+from unittest.mock import patch
 
 from rdflib import (
     ConjunctiveGraph,
     Literal,
     URIRef,
+    plugin
 )
-from rdflib import plugin
 from rdflib.store import Store
 
 from rdflib_sqlalchemy import registerplugins
 
 
-_logger = logging.getLogger(__name__)
-
 michel = URIRef(u"michel")
-tarek = URIRef(u"tarek")
-bob = URIRef(u"bob")
 likes = URIRef(u"likes")
-hates = URIRef(u"hates")
 pizza = URIRef(u"pizza")
-cheese = URIRef(u"cheese")
 
 
 class mock_cursor():
     def execute(x):
         raise Exception("Forced exception")
 
 
+class ConfigTest(unittest.TestCase):
+    '''
+    Test configuration with a dict
+    '''
+
+    def setUp(self):
+        self.store = plugin.get("SQLAlchemy", Store)()
+        self.graph = ConjunctiveGraph(self.store)
+
+    def tearDown(self):
+        self.graph.close()
+
+    def test_success(self):
+        with patch('rdflib_sqlalchemy.store.sqlalchemy') as p:
+            self.graph.open({'url': 'sqlite://', 'random_key': 'something'}, create=True)
+            p.create_engine.assert_called_with('sqlite://', random_key='something')
+
+    def test_no_url(self):
+        with patch('rdflib_sqlalchemy.store.sqlalchemy') as p:
+            with self.assertRaisesRegex(Exception, '.*url.*'):
+                self.graph.open({'random_key': 'something'}, create=True)
+
+
 class SQLATestCase(unittest.TestCase):
     identifier = URIRef("rdflib_test")
     dburi = Literal("sqlite://")
@@ -46,26 +63,26 @@ def test_registerplugins(self):
         # I doubt this is quite right for a fresh pip installation,
         # this test is mainly here to fill a coverage gap.
         registerplugins()
-        self.assert_(plugin.get("SQLAlchemy", Store) is not None)
+        self.assertIsNotNone(plugin.get("SQLAlchemy", Store))
         p = plugin._plugins
-        self.assert_(("SQLAlchemy", Store) in p, p)
+        self.assertIn(("SQLAlchemy", Store), p)
         del p[("SQLAlchemy", Store)]
         plugin._plugins = p
         registerplugins()
-        self.assert_(("SQLAlchemy", Store) in p, p)
+        self.assertIn(("SQLAlchemy", Store), p)
 
     def test_namespaces(self):
-        self.assert_(list(self.graph.namespaces()) != [])
+        self.assertNotEqual(list(self.graph.namespaces()), [])
 
     def test_contexts_without_triple(self):
-        self.assert_(list(self.graph.contexts()) == [])
+        self.assertEqual(list(self.graph.contexts()), [])
 
     def test_contexts_with_triple(self):
         statemnt = (michel, likes, pizza)
-        self.assert_(self.graph.contexts(triple=statemnt) != [])
+        self.assertEqual(list(self.graph.contexts(triple=statemnt)), [])
 
     def test__len(self):
-        self.assert_(self.store.__len__() == 0)
+        self.assertEqual(self.store.__len__(), 0)
 
     def test__remove_context(self):
         self.store._remove_context(self.identifier)