Implemented basic functionality for DatabaseManager; Updated docker and docker-compose file; Added tests and system tests; Updated README; Updated requirements.txt

Author: prawn-cake

.gitignore

@@ -1,3 +1,4 @@
 .idea
 .env
 *.pyc
+.coverage

.travis.yml

@@ -0,0 +1,10 @@
+language: python
+python:
+  - 2.7
+install:
+  - pip install -r requirements.txt
+  - pip install coveralls
+script:
+  - make test_ci
+after_success:
+  coveralls

Makefile

@@ -24,7 +24,7 @@ pypi_upload:
 
 .PHONY: test
 test: env
-	@$(NOSE) $(CODE_DIR)/tests.py
+	@$(NOSE) $(CODE_DIR)/tests
 
 .PHONY: system_test
 system_test: env
@@ -35,7 +35,7 @@ system_test: env
 .PHONY: test_ci
 test_ci: env
 # target: test_ci - Run tests command adapt for CI systems
-	@$(NOSE) $(CODE_DIR)/tests.py
+	@$(NOSE) $(CODE_DIR)/tests
 
 .PHONY: test_coverage
 # target: test_coverage - Run tests with coverage

README.md

@@ -3,12 +3,75 @@ pgclient
 
 pgclient - yet another pool-based psycopg2 wrapper. 
 
+The client is fully based on thread-safe connections pool and safe transactions executing
+
 
 Quick start
 ===========
-
-
-
+Main class to operate with database is a `PostgresClient`
+
+
+Initialization
+--------------
+    
+    from pgclient.client import PostgresClient
+    
+    
+    pg_client = PostgresClient(dsn='{dsn_string}')
+    # OR
+    pg_client = PostgresClient(username='test', password='test', ...)
+
+Database raw request
+--------------------
+    
+Assume that test data schema is the following:
+
+* TABLE:    users
+* SCHEMA:   name: VARCHAR, id: INTEGER
+    
+**Basic cursor**
+
+Result set index based access
+
+    with self.pg_client.cursor as cursor:
+        cursor.execute('SELECT * FROM users')
+
+    users = cursor.fetchall()
+    username = users[0][0]  # (OR users[0][1])     
+    
+    
+**Dict cursor**
+    
+    with self.pg_client.dict_cursor as cursor:
+        cursor.execute('SELECT * FROM users')
+
+    users = cursor.fetchall()
+    user = users[0]
+    print(user['name'])
+        
+        
+**Named-tuple cursor**
+
+    with self.pg_client.nt_cursor as cursor:
+        cursor.execute('SELECT * FROM users')
+    result = cursor.fetchall()
+    
+    user = users[0]
+    print(user.name)
+
+    
+Safe transactions
+-----------------
+
+All requests inside `with` context will be executed and automatically committed within one transaction
+    
+    with self.pg_client.cursor as transaction:
+        transaction.execute('INSERT INTO users VALUES name="Mark"')
+        transaction.execute('INSERT INTO users VALUES name="Paolo"')
+        transaction.execute('SELECT * FROM users')
+
+    users = transaction.fetchall()
+    
 
 Installation
 ============
@@ -26,6 +89,21 @@ Install package
     pip install pgclient
 
 
+System test
+===========
+To run integration test you need to install the following:
+ 
+* [Docker](https://www.docker.com/) 
+* [Docker compose](https://docs.docker.com/compose/)
+
+
+**Run system tests:**
+
+* Run postgresql container: `docker-compose up  -d postgresql`
+* Run system tests: `make system_test`
+* Stop postgresql container: `docker-compose stop postgresql`
+
+
 Bug tracker
 ===========
 

docker-compose.yml

@@ -1,6 +1,7 @@
-system_test:
-  build: system_test
+postgresql:
+  build: pgclient/system_test
   ports:
-    - "5432:5432"
+    - "0.0.0.0:5432:5432"
   environment:
     POSTGRES_PASSWORD: test
+    PSQL_ENTRYPOINT: /docker-entrypoint-initdb.d

pgclient/client.py

@@ -1,17 +1,12 @@
 # -*- coding: utf-8 -*-
+from contextlib import contextmanager
+
 import psycopg2
 import psycopg2.pool as pgpool
 import psycopg2.extras as pg_extras
-import abc
-import six
-from contextlib import contextmanager
-
 
-# TODO: use connection pool by default
-# TODO: add transactional contextmanager
 
-
-class DatabaseManager(object):
+class PostgresClient(object):
     def __init__(self, dsn=None, database=None, user=None, password=None,
                  host=None, port=None, pool_size=1):
         self.dsn = dsn
@@ -23,7 +18,7 @@ def __init__(self, dsn=None, database=None, user=None, password=None,
             raise ValueError('Wrong pool_size value. Must be >= 1. '
                              'Current: {}'.format(pool_size))
         # Init thread-safe connection pool
-        self.pool = pgpool.ThreadedConnectionPool(
+        self._pool = pgpool.ThreadedConnectionPool(
             minconn=1, maxconn=pool_size, **conn_params)
 
     @property
@@ -32,7 +27,7 @@ def connection(self):
 
         :return: postgresql connection instance
         """
-        return self.pool.getconn()
+        return self._pool.getconn()
 
     @contextmanager
     def _get_cursor(self, cursor_factory=None):
@@ -42,48 +37,34 @@ def _get_cursor(self, cursor_factory=None):
             conn.commit()
         except psycopg2.DatabaseError as err:
             conn.rollback()
-            raise psycopg2.DatabaseError(err)
+            raise psycopg2.DatabaseError(err.message)
         finally:
-            self.pool.putconn(conn)
+            self._pool.putconn(conn)
 
-    # TODO: rename it
     @property
     def cursor(self):
+        """Default index based cursor"""
+
         return self._get_cursor()
 
     @property
     def dict_cursor(self):
-        """Return dict cursor. It enables accessing via column names instead
-        of indexes
+        """Return dict cursor. It enables to get fields access via column names
+        instead of indexes.
         """
         return self._get_cursor(cursor_factory=pg_extras.DictCursor)
 
+    @property
+    def nt_cursor(self):
+        """Named tuple based cursor. It enables to get attributes access via
+        attributes.
+        """
+        return self._get_cursor(cursor_factory=pg_extras.NamedTupleCursor)
 
-@six.add_metaclass(abc.ABCMeta)
-class QuerySet(object):
-    def __init__(self):
-        self.request_tokens = []
-
-    def execute(self, cursor):
-        return cursor.execute(' '.join(self.request_tokens))
-
-
-class SelectRequest(QuerySet):
-    """The idea is use builder to select to database:
-    select('*').from('my_table').where('a>b').order_by('desc').
-    """
-    def __init__(self):
-        super(SelectRequest, self).__init__()
-
-    def select(self, fields=None):
-        self.request_tokens.append(fields or '*')
-        return self
-
-    def _from(self, table_name):
-        self.request_tokens.append(table_name)
-        return self
+    @property
+    def available_connections(self):
+        """Connection pool available connections
 
-    def where(self, raw_condition=None):
-        if raw_condition is not None:
-            self.request_tokens.append(raw_condition)
-        return self
+        :return: int: number of available connections
+        """
+        return len(self._pool._pool)

pgclient/system_test/Dockerfile

@@ -1,12 +1,10 @@
-FROM postgresql
+FROM postgres
+MAINTAINER Maksim Ekimovskii <[email protected]>
 
 # Default user is postgres
-ENV POSTGRES_PASSWORD: test
+# ENV POSTGRES_PASSWORD: test
 
 # This dir is supported by official postgresql image
-ENV PSQL_ENTRYPOINT /docker-entrypoint-initdb.d
+# ENV PSQL_ENTRYPOINT /docker-entrypoint-initdb.d
 
-MKDIR $PSQL_ENTRYPOINT
-RUN echo "CREATE DATABASE test WITH OWNER postgres;" >> $PSQL_ENTRYPOINT/create_db.sql
-
-#CMD python app.py
+RUN echo "CREATE DATABASE test WITH OWNER postgres;" >> $PSQL_ENTRYPOINT/create_db.sql

pgclient/system_test/system_test.py

@@ -10,14 +10,14 @@
 )
 
 import unittest
-from pgclient.client import DatabaseManager
 import random
+from pgclient.client import PostgresClient
 
 
 NAMES = ['Alex', 'Andrea', 'Ashley', 'Casey', 'Chris', 'Dorian', 'Jerry']
 
 
-class DatabaseManagerSystemTest(unittest.TestCase):
+class PostgresClientSystemTest(unittest.TestCase):
     DB_USER = 'postgres'
     DB_PASSWORD = 'test'
     DB_NAME = 'test'
@@ -26,7 +26,12 @@ class DatabaseManagerSystemTest(unittest.TestCase):
     def setUp(self):
         dsn = 'user={} password={} dbname={} host=localhost'.format(
             self.DB_USER, self.DB_PASSWORD, self.DB_NAME)
-        self.db_manager = DatabaseManager(dsn=dsn, pool_size=10)
+        try:
+            self.pg_client = PostgresClient(dsn=dsn, pool_size=10)
+        except psycopg2.OperationalError as err:
+            print('Check that postgres docker container is started. '
+                  'Check README for more information')
+            raise psycopg2.OperationalError(err.message)
 
         try:
             self._create_table()
@@ -35,69 +40,66 @@ def setUp(self):
             self._create_table()
 
         # Insert 100 entries
-        with self.db_manager.cursor as cursor:
+        with self.pg_client.cursor as cursor:
             for _ in range(100):
                 insert_str = "INSERT INTO {} (username) VALUES (%s)".format(
                     self.TABLE_NAME)
                 cursor.execute(insert_str, (random.choice(NAMES),))
 
     def _create_table(self):
         # Init database with test data
-        with self.db_manager.cursor as cursor:
+        with self.pg_client.cursor as cursor:
             cursor.execute(
                 "CREATE TABLE {} "
-                "(id serial PRIMARY KEY, username VARCHAR NOT NULL );".format(
+                "(id SERIAL, username VARCHAR NOT NULL );".format(
                     self.TABLE_NAME))
         print('Table {} has been created'.format(self.TABLE_NAME))
 
     def _drop_table(self):
-        with self.db_manager.cursor as cursor:
+        with self.pg_client.cursor as cursor:
             cursor.execute('DROP TABLE {}'.format(self.TABLE_NAME))
         print('Table {} has been dropped'.format(self.TABLE_NAME))
 
     def tearDown(self):
         self._drop_table()
 
     def test_cursor(self):
-        with self.db_manager.cursor as cursor:
+        with self.pg_client.cursor as cursor:
             cursor.execute('SELECT * FROM users')
             result_set = cursor.fetchall()
         self.assertEqual(len(result_set), 100)
 
     def test_dict_cursor(self):
-        with self.db_manager.dict_cursor as cursor:
+        with self.pg_client.dict_cursor as cursor:
             cursor.execute('SELECT * FROM users')
-            result_set = cursor.fetchall()
+        result_set = cursor.fetchall()
         item = result_set[0]
         self.assertIn('id', item)
         self.assertIn('username', item)
         self.assertIn(item['username'], NAMES)
 
     def test_named_tuple_cursor(self):
-        with self.db_manager.nt_cursor as cursor:
+        with self.pg_client.nt_cursor as cursor:
             cursor.execute('SELECT * FROM users')
-            result_set = cursor.fetchall()
+        result_set = cursor.fetchall()
         item = result_set[0]
         self.assertIsInstance(item.id, int)
         self.assertIsInstance(item.username, str)
 
     def test_success_transaction(self):
-        with self.db_manager.cursor as transaction:
+        with self.pg_client.cursor as transaction:
             insert_str = "INSERT INTO {} (username) VALUES (%s)".format(
                 self.TABLE_NAME)
             transaction.execute(insert_str, (random.choice(NAMES), ))
             transaction.execute('SELECT * FROM users')
-            result_set = transaction.fetchall()
+        result_set = transaction.fetchall()
         self.assertEqual(len(result_set), 101)
 
     def test_rollback_transaction(self):
-        with self.db_manager.cursor as transaction:
+        # Insert null username must cause an error
+        with self.pg_client.cursor as transaction:
             with self.assertRaises(psycopg2.DatabaseError) as err:
                 transaction.execute(
                     "INSERT INTO {} (username) VALUES (%s)".format(self.TABLE_NAME),
                     (None, ))
-            self.assertIn('null value in column', err.exception.message)
-
-
-if __name__ == '__main__':
-    unittest.main()
+            self.assertIn('null value in column', err.exception.message)