Merge lp:~ricardokirkner/django-pgtools/support-django-1.6-to-1.10 into lp:django-pgtools

[Ricardo Kirkner]

support django 1.6 to 1.10

- dropped support for python 2.5 and 2.6
- dropped support for django < 1.6
- improved bootstrapping and testing of project

[lp:~ricardokirkner/django-pgtools/support-django-1.6-to-1.10]

18. By Ricardo Kirkner on 2017-01-17

swapped distutils for setuptools

19. By Ricardo Kirkner on 2017-01-17

support building universal wheels

20. By Ricardo Kirkner on 2017-01-17

better version of get_models that supports django 1.6 to 1.10

[Fabián Ezequiel Gallina (fgallina)]

LGTM

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2011-05-30 14:30:10 +0000
+++ .bzrignore	2017-01-17 15:08:22 +0000
@@ -1,1 +1,4 @@
-.tox
\ No newline at end of file
+.tox
+*.pyc
+
+env

=== added file 'Makefile'
--- Makefile	1970-01-01 00:00:00 +0000
+++ Makefile	2017-01-17 15:08:22 +0000
@@ -0,0 +1,51 @@
+.PHONY: help
+.DEFAULT_GOAL := help
+
+DJANGO_SETTINGS_MODULE ?= test_project.settings
+ENV = $(CURDIR)/env
+ENV_CREATED = $(shell test -e $(PYTHON) && echo "yes" || echo "no")
+PIP = $(ENV)/bin/pip
+PYTHON ?= $(ENV)/bin/python
+export DJANGO_SETTINGS_MODULE
+export PYTHONPATH
+
+help:
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) \
+		| cut -d ':' -f 2,3 \
+		| sort \
+		| awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+
+# pre-process arguments
+# if the first argument is "special" (manage, test)...
+ifneq (,$(filter $(firstword $(MAKECMDGOALS)),manage test))
+# use the rest as sub-arguments
+ARGS := $(wordlist 2,$(words $(MAKECMDGOALS)),$(MAKECMDGOALS))
+# ...and turn them into do-nothing targets
+$(eval $(ARGS):;@:)
+endif
+
+bootstrap: ARGS=-r requirements.txt
+bootstrap: $(ENV)  ## Bootstrap the project
+	@$(PIP) install $(ARGS)
+
+$(ENV):
+	@virtualenv --clear $(ENV)
+
+clean:  ## Remove build artifacts
+	@rm -rf $(WHEELS_DIR)
+	@find -name '*.pyc' -delete
+	@find -name '*.~*' -delete
+
+clean-env:  ## Remove virtualenv
+	@rm -rf $(ENV)
+
+manage:  ## Run django management commands
+	@$(PYTHON) manage.py $(ARGS)
+
+test:  ## Run unit tests
+	@$(PYTHON) manage.py test $(ARGS)
+
+# database related targets
+ifeq (yes,$(ENV_CREATED))
+include Makefile.db
+endif

=== added file 'Makefile.db'
--- Makefile.db	1970-01-01 00:00:00 +0000
+++ Makefile.db	2017-01-17 15:08:22 +0000
@@ -0,0 +1,44 @@
+PGNAME = $(shell DJANGO_SETTINGS_MODULE=$(DJANGO_SETTINGS_MODULE) PYTHONPATH=$(PYTHONPATH) $(PYTHON) -c "from django.conf import settings; print settings.DATABASES['default']['NAME']")
+PGHOST = $(shell DJANGO_SETTINGS_MODULE=$(DJANGO_SETTINGS_MODULE) PYTHONPATH=$(PYTHONPATH) $(PYTHON) -c "from django.conf import settings; print settings.DATABASES['default']['HOST']")
+PGUSER = $(shell DJANGO_SETTINGS_MODULE=$(DJANGO_SETTINGS_MODULE) PYTHONPATH=$(PYTHONPATH) $(PYTHON) -c "from django.conf import settings; print settings.DATABASES['default']['USER']")
+DATA_DIR = $(PGHOST)/data
+LOG_FILE = $(PGHOST)/postgresql.log
+CONF_FILE = $(PGHOST)/postgresql.conf
+PGBIN = /usr/lib/postgresql/9.3/bin
+PGCTL = $(PGBIN)/pg_ctl
+PGINIT = $(PGBIN)/initdb
+PGSOCKET = $(PGHOST)/.s.PGSQL.5432
+
+# The weird setup-db/pgsocket dependency is so that other rules can depend
+# on setup-db which is nice, but the behavior is that if the socket exists,
+# the database won't be started again.
+setup-db: $(PGSOCKET)
+
+$(PGSOCKET):
+	# If the socket didn't exist, means the db server was stopped.
+	# In this case it should be safe to blast the directory as developers
+	# don't usually stop the db server if they care about the (transient,
+	# anyway) data.
+	rm -rf $(DATA_DIR)
+	mkdir -p $(DATA_DIR)
+	$(PGINIT) -A trust -D $(DATA_DIR)
+	echo "fsync = off" > $(CONF_FILE)
+	echo "standard_conforming_strings = off" >> $(CONF_FILE)
+	echo "escape_string_warning = off" >> $(CONF_FILE)
+	$(PGCTL) start -w -D $(DATA_DIR) -l $(LOG_FILE) -o "-F -k $(PGHOST) -h ''"
+	PGHOST=$(PGHOST) createdb $(PGNAME)
+	PGHOST=$(PGHOST) createuser --superuser --createdb $(PGUSER)
+
+start-db:  ## Start database server
+	$(MAKE) setup-db
+	$(MAKE) manage migrate
+
+stop-db:  ## Stop database server
+	PGHOST=$(PGHOST) dropdb $(PGNAME)
+	$(PGCTL) stop -w -D $(DATA_DIR) -m smart
+	rm -rf $(PGHOST)
+
+reset-db:  ## Reset database state
+	PGHOST=$(PGHOST) dropdb $(PGNAME)
+	PGHOST=$(PGHOST) createdb $(PGNAME)
+	$(MAKE) manage migrate

=== added file 'manage.py'
--- manage.py	1970-01-01 00:00:00 +0000
+++ manage.py	2017-01-17 15:08:22 +0000
@@ -0,0 +1,10 @@
+#!/usr/bin/env python
+import os
+import sys
+
+if __name__ == "__main__":
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "test_project.settings")
+
+    from django.core.management import execute_from_command_line
+
+    execute_from_command_line(sys.argv)

=== modified file 'pgtools/dbrole.py'
--- pgtools/dbrole.py	2011-05-30 14:30:10 +0000
+++ pgtools/dbrole.py	2017-01-17 15:08:22 +0000
@@ -24,20 +24,16 @@
 
             cursor = self.connection.cursor()
             cursor.execute("CREATE ROLE %s" % rolename)
-            if commit:
-                self.transaction.commit_unless_managed()
-                if not self.exists(rolename):
-                    raise CommandError("Role couldn't be created: %s" % rolename)
+            if commit and not self.exists(rolename):
+                raise CommandError("Role couldn't be created: %s" % rolename)
         elif not exists:
             raise CommandError("Role doesn't exist: %s" % rolename)
 
     def delete(self, commit=True):
         cursor = self.connection.cursor()
         cursor.execute("DROP ROLE %s" % self.rolename)
-        if commit:
-            self.transaction.commit_unless_managed()
-            if self.exists(self.rolename):
-                raise CommandError("Role cannot be deleted: %s" % self.rolename)
+        if commit and self.exists(self.rolename):
+            raise CommandError("Role cannot be deleted: %s" % self.rolename)
 
     @classmethod
     def exists(cls, rolename, db_connection=None):
@@ -65,13 +61,9 @@
     def grant(self, user, commit=True):
         cursor = self.connection.cursor()
         cursor.execute("GRANT %s TO %s" % (self.rolename, user.username))
-        if commit:
-            self.transaction.commit_unless_managed()
 
     def revoke(self, user, commit=True):
         cursor = self.connection.cursor()
         cursor.execute("REVOKE %s FROM %s" % (self.rolename, user.username))
-        if commit:
-            self.transaction.commit_unless_managed()
-            if user.has_role(self):
-                raise CommandError("Role cannot be revoked: %s" % self.rolename)
+        if commit and user.has_role(self):
+            raise CommandError("Role cannot be revoked: %s" % self.rolename)

=== modified file 'pgtools/dbuser.py'
--- pgtools/dbuser.py	2011-05-30 14:30:10 +0000
+++ pgtools/dbuser.py	2017-01-17 15:08:22 +0000
@@ -27,21 +27,17 @@
             else:
                 cursor.execute("CREATE USER %s PASSWORD %%s" % username,
                     (password,))
-            if commit:
-                self.transaction.commit_unless_managed()
-                if not self.exists(username):
-                    raise CommandError(
-                        "User couldn't be created: %s" % username)
+            if commit and not self.exists(username):
+                raise CommandError(
+                    "User couldn't be created: %s" % username)
         elif not exists:
             raise CommandError("User doesn't exist: %s" % username)
 
     def delete(self, commit=True):
         cursor = self.connection.cursor()
         cursor.execute("DROP USER %s" % self.username)
-        if commit:
-            self.transaction.commit_unless_managed()
-            if self.exists(self.username):
-                raise CommandError("User cannot be deleted: %s" % self.username)
+        if commit and self.exists(self.username):
+            raise CommandError("User cannot be deleted: %s" % self.username)
 
     @classmethod
     def exists(cls, username, db_connection=None):

=== modified file 'pgtools/management/commands/createuser.py'
--- pgtools/management/commands/createuser.py	2011-05-30 14:30:10 +0000
+++ pgtools/management/commands/createuser.py	2017-01-17 15:08:22 +0000
@@ -11,19 +11,44 @@
 from pgtools.dbrole import DatabaseRole
 from pgtools.dbuser import DatabaseUser
 from pgtools.decorators import graceful_db_errors
-from pgtools.utils import check_database_engine, parse_username_and_rolename
+from pgtools.utils import (
+    DJANGO_VERSION,
+    check_database_engine,
+    parse_username_and_rolename,
+)
 
 
 class Command(BaseCommand):
-    option_list = BaseCommand.option_list + (
-        make_option('-p', '--password', default=None, dest='password',
-            help='Password of the user to be created.'),
-        make_option('-P', '--no-password', default=False, dest='no_password',
-            action='store_true',
-            help='If given, then no password is set up for the user.'),
-    )
     help = 'Create a new database user based on an existing role.'
-    args = 'username [rolename]'
+    OPTIONS = [
+        (('-p', '--password'),
+         dict(default=None, dest='password',
+              help='Password of the user to be created.')),
+        (('-P', '--no-password'),
+         dict(default=False, dest='no_password',
+              help='If given, then no password is set up for the user.')),
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super(Command, self).__init__(*args, **kwargs)
+        if DJANGO_VERSION < (1, 8):
+            self.args = "username [rolename]"
+            self.option_list = BaseCommand.option_list + tuple(
+                make_option(*a, **kw) for (a, kw) in self.OPTIONS
+            )
+
+    def add_arguments(self, parser):
+        # positional arguments
+        parser.add_argument(
+            'username', metavar='username', nargs=1,
+            help='Username for the new user.')
+        parser.add_argument(
+            'rolename', metavar='rolename', nargs='?',
+            help='Role to use for creating the new user.')
+
+        # named arguments
+        for (args, kwargs) in self.OPTIONS:
+            parser.add_argument(*args, **kwargs)
 
     def _ask_password(self):
         password = None
@@ -50,7 +75,7 @@
     @graceful_db_errors
     def handle(self, *args, **options):
         check_database_engine()
-        username, rolename = parse_username_and_rolename(args)
+        username, rolename = parse_username_and_rolename(*args, **options)
 
         password = options.get('password')
         no_password = options.get('no_password')

=== modified file 'pgtools/management/commands/deleteuser.py'
--- pgtools/management/commands/deleteuser.py	2011-05-30 14:30:10 +0000
+++ pgtools/management/commands/deleteuser.py	2017-01-17 15:08:22 +0000
@@ -7,17 +7,34 @@
 from pgtools.dbrole import DatabaseRole
 from pgtools.dbuser import DatabaseUser
 from pgtools.decorators import graceful_db_errors
-from pgtools.utils import check_database_engine, parse_username_and_rolename
+from pgtools.utils import (
+    DJANGO_VERSION,
+    check_database_engine,
+    parse_username_and_rolename,
+)
 
 
 class Command(BaseCommand):
     help = 'Delete an existing database user based on given role.'
-    args = 'username [rolename]'
+
+    def __init__(self, *args, **kwargs):
+        super(Command, self).__init__(*args, **kwargs)
+        if DJANGO_VERSION < (1, 8):
+            self.args = "username [rolename]"
+
+    def add_arguments(self, parser):
+        # positional arguments
+        parser.add_argument(
+            'username', metavar='username', nargs=1,
+            help='Username for the new user.')
+        parser.add_argument(
+            'rolename', metavar='rolename', nargs='?',
+            help='Role to use for creating the new user.')
 
     @graceful_db_errors
     def handle(self, *args, **options):
         check_database_engine()
-        username, rolename = parse_username_and_rolename(args)
+        username, rolename = parse_username_and_rolename(*args, **options)
 
         role = DatabaseRole(rolename)
         user = DatabaseUser(username, create=False)

=== modified file 'pgtools/management/commands/grantuser.py'
--- pgtools/management/commands/grantuser.py	2013-02-21 21:16:14 +0000
+++ pgtools/management/commands/grantuser.py	2017-01-17 15:08:22 +0000
@@ -2,12 +2,16 @@
 # Copyright 2011 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-from django.core.management.base import BaseCommand,CommandError
+from django.core.management.base import BaseCommand
 from django.db import connection
-from django.db.models.loading import get_models
 
 from pgtools.decorators import graceful_db_errors
-from pgtools.utils import check_database_engine
+from pgtools.utils import (
+    DJANGO_VERSION,
+    check_database_engine,
+    get_models,
+    parse_username,
+)
 
 
 GRANT_SQL = "GRANT ALL ON %s TO %s;"
@@ -16,20 +20,23 @@
 
 class Command(BaseCommand):
     help = 'Grant access to user to all models.'
-    args = 'username'
+
+    def __init__(self, *args, **kwargs):
+        super(Command, self).__init__(*args, **kwargs)
+        if DJANGO_VERSION < (1, 8):
+            self.args = "username"
+
+    def add_arguments(self, parser):
+        # positional arguments
+        parser.add_argument(
+            'username', metavar='username', nargs=1,
+            help='Username for the new user.')
 
     @graceful_db_errors
     def handle(self, *args, **options):
         check_database_engine()
 
-        arg_count = len(args)
-        if arg_count > 1:
-            raise CommandError('Too many arguments provided.')
-        elif arg_count < 1:
-            raise CommandError(
-                'Please provide a username.')
-
-        self.username = args[0]
+        self.username = parse_username(*args, **options)
         self.cursor = connection.cursor()
 
         for model in get_models():

=== modified file 'pgtools/management/commands/listusers.py'
--- pgtools/management/commands/listusers.py	2011-05-30 14:30:10 +0000
+++ pgtools/management/commands/listusers.py	2017-01-17 15:08:22 +0000
@@ -2,26 +2,35 @@
 # Copyright 2011 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import BaseCommand
 
 from pgtools.dbrole import DatabaseRole
 from pgtools.decorators import graceful_db_errors
-from pgtools.utils import check_database_engine, get_rolename_from_settings
+from pgtools.utils import (
+    DJANGO_VERSION,
+    check_database_engine,
+    parse_rolename,
+)
 
 
 class Command(BaseCommand):
     help = 'List database users with access to given role.'
-    args = 'rolename'
+
+    def __init__(self, *args, **kwargs):
+        super(Command, self).__init__(*args, **kwargs)
+        if DJANGO_VERSION < (1, 8):
+            self.args = "[rolename]"
+
+    def add_arguments(self, parser):
+        # positional arguments
+        parser.add_argument(
+            'rolename', metavar='rolename', nargs='?',
+            help='Role to use for creating the new user.')
 
     @graceful_db_errors
     def handle(self, *args, **options):
         check_database_engine()
-        if len(args) < 1:
-            rolename = get_rolename_from_settings()
-        elif len(args) == 1:
-            rolename = args[0]
-        else:
-            raise CommandError('Too many arguments.')
+        rolename = parse_rolename(*args, **options)
 
         role = DatabaseRole(rolename)
         roles = role.get_users()

=== modified file 'pgtools/tests.py'
--- pgtools/tests.py	2013-07-11 20:09:14 +0000
+++ pgtools/tests.py	2017-01-17 15:08:22 +0000
@@ -7,30 +7,32 @@
 import sys
 
 from cStringIO import StringIO
-from contextlib import contextmanager
-
-from psycopg2 import ProgrammingError
-
-from mock import Mock, patch
-
-import django
+from unittest import skipIf
+
 from django.conf import settings
 from django.core.management import call_command
 from django.core.management.base import CommandError
 from django.db import connection, models
-from django.db.backends import postgresql_psycopg2
-from django.db.models.loading import get_models
+from django.db.backends.postgresql_psycopg2.base import (
+    DatabaseWrapper as PGDatabaseWrapper,
+)
 from django.db.utils import load_backend
-from django.test import TestCase
-
+from django.test import TransactionTestCase
+from django.test.utils import override_settings
+from mock import Mock, patch
+from psycopg2 import ProgrammingError
 
 from pgtools.dbrole import DatabaseRole
 from pgtools.dbuser import DatabaseUser
 from pgtools.decorators import graceful_db_errors
 from pgtools.management.commands import grantuser
 from pgtools.utils import (
-    check_database_engine, get_rolename_from_settings,
-    parse_username_and_rolename
+    DJANGO_VERSION,
+    check_database_engine,
+    get_rolename_from_settings,
+    parse_rolename,
+    parse_username,
+    parse_username_and_rolename,
 )
 
 EMPTY_ROLE_NAME = 'test_empty_role'
@@ -39,35 +41,7 @@
 TEST_USER_NAME2 = 'test_user2'
 
 
-# Original snippet from http://djangosnippets.org/snippets/2156/
-class SettingDoesNotExist:
-    pass
-
-
-def switch_settings(**kwargs):
-    """Helper method that updates settings and returns old settings."""
-    old_settings = {}
-    for key, new_value in kwargs.items():
-        old_value = getattr(settings, key, SettingDoesNotExist)
-        old_settings[key] = old_value
-
-        if new_value is SettingDoesNotExist:
-            delattr(settings, key)
-        else:
-            setattr(settings, key, new_value)
-
-    return old_settings
-
-
-@contextmanager
-def patch_settings(**kwargs):
-    old_settings = switch_settings(**kwargs)
-    yield
-    switch_settings(**old_settings)
-# end snippet
-
-
-class CommandTestCase(TestCase):
+class CommandBaseTestCase(TransactionTestCase):
 
     def setUp(self):
         test_settings = {
@@ -80,7 +54,9 @@
                 'USER': 'postgres',
                 'PASSWORD': '',
             })
-        self.old_settings = switch_settings(**test_settings)
+        overrides = self.settings(**test_settings)
+        overrides.enable()
+        self.addCleanup(overrides.disable)
 
         self._refresh_connection()
         self._capture_stdout_stderr()
@@ -141,7 +117,6 @@
     def tearDown(self):
         self._delete_roles_and_users()
         self._release_stdout_stderr()
-        switch_settings(**self.old_settings)
 
     def _delete_roles_and_users(self):
         # clean up everything
@@ -170,7 +145,7 @@
         sys.stderr = sys.__stderr__
 
 
-class CommandTest(CommandTestCase):
+class CommandTestCase(CommandBaseTestCase):
 
     def test_command_createuser_no_args(self):
         # No argument
@@ -307,19 +282,17 @@
         except (CommandError, SystemExit):
             pass
         # No argument, but existing role predefined
-        old_PG_BASE_ROLE = getattr(settings, 'PG_BASE_ROLE', None)
-        settings.PG_BASE_ROLE = MASTER_ROLE_NAME
-        call_command('listusers')
+        with self.settings(PG_BASE_ROLE=MASTER_ROLE_NAME):
+            call_command('listusers')
         # No argument, non-existing role predefined
-        settings.PG_BASE_ROLE = 'somefunkynonexistingrole'
-        try:
-            call_command('listusers')
-            self.fail(
-                'Calling listusers without arguments and non-existing role '
-                'predefined should fail.')
-        except (CommandError, SystemExit):
-            pass
-        settings.PG_BASE_ROLE = old_PG_BASE_ROLE
+        with self.settings(PG_BASE_ROLE='somefunkynonexistingrole'):
+            try:
+                call_command('listusers')
+                self.fail(
+                    'Calling listusers without arguments and non-existing role '
+                    'predefined should fail.')
+            except (CommandError, SystemExit):
+                pass
         # Too many arguments
         try:
             call_command('listusers', 'foo', 'bar')
@@ -447,9 +420,8 @@
                 "User cannot be deleted: %s" % TEST_USER_NAME1)
 
     def get_backends(self):
-        django_version = django.VERSION[:2]
         backends = ['django.db.backends.postgresql_psycopg2']
-        if django_version < (1,4):
+        if DJANGO_VERSION < (1,4):
             backends.insert(0, 'postgresql_psycopg2')
         return backends
 
@@ -484,7 +456,7 @@
     @patch('pgtools.utils.settings')
     def test_utils_check_database_engine_subclass_13_style(self,
                                                            mock_settings):
-        class CustomDatabaseWrapper(postgresql_psycopg2.base.DatabaseWrapper):
+        class CustomDatabaseWrapper(PGDatabaseWrapper):
             pass
 
         dbconfig = {'default': {'NAME': 'mydatabase',
@@ -505,11 +477,13 @@
         # Test with default (nothing set)
         self.assertRaises(CommandError, get_rolename_from_settings)
         # Test with the master role
-        old_PG_BASE_ROLE = getattr(settings, 'PG_BASE_ROLE', None)
-        settings.PG_BASE_ROLE = MASTER_ROLE_NAME
-        master_role_name = get_rolename_from_settings()
-        self.assertEqual(master_role_name, MASTER_ROLE_NAME)
-        settings.PG_BASE_ROLE = old_PG_BASE_ROLE
+        with self.settings(PG_BASE_ROLE=MASTER_ROLE_NAME):
+            master_role_name = get_rolename_from_settings()
+            self.assertEqual(master_role_name, MASTER_ROLE_NAME)
+
+
+@skipIf(DJANGO_VERSION >= (1, 8), 'Django 1.8 and later uses argparse')
+class Django17ParserTestCase(CommandBaseTestCase):
 
     def test_parse_username_and_rolename_no_args(self):
         # Test with no args
@@ -519,31 +493,93 @@
     def test_parse_username_and_rolename_two_args(self):
         # Test with two arguments
         args = ['username', 'rolename']
-        username, rolename = parse_username_and_rolename(args)
+        username, rolename = parse_username_and_rolename(*args)
         self.assertEqual(username, 'username')
         self.assertEqual(rolename, 'rolename')
 
     def test_parse_username_and_rolename_username_no_role(self):
         # One argument, no predefined base role
         args = ['username']
-        self.assertRaises(CommandError, parse_username_and_rolename, args)
+        self.assertRaises(CommandError, parse_username_and_rolename, *args)
 
+    @override_settings(PG_BASE_ROLE=MASTER_ROLE_NAME)
     def test_parse_username_and_rolename_username_with_role(self):
         # One argument, predefined base role
-        old_PG_BASE_ROLE = getattr(settings, 'PG_BASE_ROLE', None)
-        settings.PG_BASE_ROLE = MASTER_ROLE_NAME
         args = ['username', 'rolename']
-        username, rolename = parse_username_and_rolename(args)
+        username, rolename = parse_username_and_rolename(*args)
         self.assertEqual(username, 'username')
         self.assertEqual(rolename, 'rolename')
-        settings.PG_BASE_ROLE = old_PG_BASE_ROLE
 
     def test_parse_username_and_rolename_too_many_args(self):
         args = ['username', 'rolename', 'foo']
-        self.assertRaises(CommandError, parse_username_and_rolename, args)
-
-
-class GrantUserCommandTestCase(CommandTestCase):
+        self.assertRaises(CommandError, parse_username_and_rolename, *args)
+
+    def test_parse_username_no_args(self):
+        self.assertRaises(CommandError, parse_username)
+
+    def test_parse_username_too_many_args(self):
+        args = ['username', 'rolename']
+        self.assertRaises(CommandError, parse_username, *args)
+
+    def test_parse_username_from_args(self):
+        args = ['username']
+        username = parse_username(*args)
+        self.assertEqual(username, 'username')
+
+    @override_settings(PG_BASE_ROLE=MASTER_ROLE_NAME)
+    def test_parse_rolename_no_args(self):
+        rolename = parse_rolename()
+        self.assertEqual(rolename, MASTER_ROLE_NAME)
+
+    def test_parse_rolename_too_many_args(self):
+        args = ['username', 'rolename']
+        self.assertRaises(CommandError, parse_rolename, *args)
+
+    def test_parse_rolename_from_args(self):
+        args = ['rolename']
+        rolename = parse_rolename(*args)
+        self.assertEqual(rolename, 'rolename')
+
+
+
+@skipIf(DJANGO_VERSION < (1, 8), 'Django 1.7 and earlier uses optparse')
+class Django18ParserTestCase(CommandBaseTestCase):
+
+    def test_parse_username_and_rolename_from_options(self):
+        args = ['foo', 'bar']
+        options = {'username': 'username', 'rolename': 'rolename'}
+        username, rolename = parse_username_and_rolename(*args, **options)
+        self.assertEqual(username, 'username')
+        self.assertEqual(rolename, 'rolename')
+
+    @override_settings(PG_BASE_ROLE=MASTER_ROLE_NAME)
+    def test_parse_username_and_rolename_from_options_with_default_role(self):
+        args = ['foo', 'bar']
+        options = {'username': 'username'}
+        username, rolename = parse_username_and_rolename(*args, **options)
+        self.assertEqual(username, 'username')
+        self.assertEqual(rolename, MASTER_ROLE_NAME)
+
+    def test_parse_username_from_options(self):
+        args = ['foo']
+        options = {'username': 'username'}
+        username = parse_username(*args, **options)
+        self.assertEqual(username, 'username')
+
+    def test_parse_rolename_from_options(self):
+        args = ['foo']
+        options = {'rolename': 'rolename'}
+        rolename = parse_rolename(*args, **options)
+        self.assertEqual(rolename, 'rolename')
+
+
+@skipIf(DJANGO_VERSION < (1, 7), "django.apps not available in Django 1.6")
+class GrantUserCommandTestCase(CommandBaseTestCase):
+
+    def get_models(self, app_label):
+        from django.apps import apps
+        return apps.get_app_config(app_label).get_models()
+
     def test_command_grantuser_no_args(self):
         try:
             call_command('grantuser')
@@ -553,8 +589,7 @@
 
     @patch('pgtools.management.commands.grantuser.get_models')
     def test_command_grantuser(self, mock_get_models):
-        from django.contrib.admin import models as admin_models
-        mock_get_models.return_value = get_models(admin_models)
+        mock_get_models.return_value = self.get_models('admin')
         command = grantuser.Command
         with patch.object(command, '_grant_one') as mock_grant_one:
             # force the cache to reload the apps
@@ -600,8 +635,7 @@
     @patch('pgtools.management.commands.grantuser.connection')
     def test__grant_many_to_many(self, mock_connection, mock_get_models):
         mock_connection.cursor.return_value.fetchone.return_value = ['foo']
-        from django.contrib.auth import models as auth_models
-        mock_get_models.return_value = get_models(auth_models)
+        mock_get_models.return_value = self.get_models('auth')
 
         call_command('grantuser', 'payments')
 
@@ -612,3 +646,18 @@
                 'GRANT ALL ON foo TO payments;'
             ]:
             self.assertTrue(expected in calls)
+
+
+@skipIf(DJANGO_VERSION > (1, 6), "Django 1.7 and later use django.apps for getting models")
+class Django16GrantUserCommandTestCase(GrantUserCommandTestCase):
+
+    def get_models(self, app_label):
+        import django.contrib.admin.models
+        import django.contrib.auth.models
+        from django.db.models.loading import get_models
+
+        if app_label == 'admin':
+            models = django.contrib.admin.models
+        elif app_label == 'auth':
+            models = django.contrib.auth.models
+        return get_models(models)

=== modified file 'pgtools/utils.py'
--- pgtools/utils.py	2013-07-11 19:14:08 +0000
+++ pgtools/utils.py	2017-01-17 15:08:22 +0000
@@ -2,12 +2,16 @@
 # Copyright 2011 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
+import django
 from django.conf import settings
 from django.core.management.base import CommandError
 from django.db import DEFAULT_DB_ALIAS
 from django.db.utils import load_backend
 
 
+DJANGO_VERSION = django.VERSION[:2]
+
+
 def check_database_engine(alias=None):
     if alias is None:
         alias = DEFAULT_DB_ALIAS
@@ -29,20 +33,70 @@
     return rolename
 
 
-def parse_username_and_rolename(args):
+def parse_username_and_rolename(*args, **options):
     username = None
     rolename = None
-    arg_count = len(args)
+    if DJANGO_VERSION < (1, 8):
+        arg_count = len(args)
 
-    if arg_count == 2:
-        username, rolename = args
+        if arg_count == 2:
+            username, rolename = args
+        else:
+            if arg_count > 2:
+                raise CommandError('Too many arguments provided.')
+            elif arg_count < 1:
+                raise CommandError(
+                    'Please provide both a username and a role name.')
+            username = args[0]
+            rolename = get_rolename_from_settings()
     else:
-        if arg_count > 2:
+        username = options.get('username', None)
+        rolename = options.get('rolename', None)
+
+        if isinstance(username, list) and len(username) > 0:
+            username = username[0]
+
+        if rolename is None:
+            rolename = get_rolename_from_settings()
+
+    return (username, rolename)
+
+
+def parse_username(*args, **options):
+    if DJANGO_VERSION < (1, 8):
+        arg_count = len(args)
+        if arg_count > 1:
             raise CommandError('Too many arguments provided.')
         elif arg_count < 1:
-            raise CommandError(
-                'Please provide both a username and a role name.')
+            raise CommandError('Please provide a username.')
         username = args[0]
-        rolename = get_rolename_from_settings()
-
-    return (username, rolename)
+    else:
+        username = options['username']
+        if isinstance(username, list) and len(username) > 0:
+            username = username[0]
+    return username
+
+
+def parse_rolename(*args, **options):
+    if DJANGO_VERSION < (1, 8):
+        if len(args) < 1:
+            rolename = get_rolename_from_settings()
+        elif len(args) == 1:
+            rolename = args[0]
+        else:
+            raise CommandError('Too many arguments.')
+    else:
+        rolename = options.get('rolename', None)
+        if rolename is None:
+            rolename = get_rolename_from_settings()
+    return rolename
+
+
+def get_models():
+    try:
+        from django.apps import apps
+        models = apps.get_models()
+    except ImportError:
+        from django.db.models import loading
+        models = loading.get_models()
+    return models

=== modified file 'requirements.txt'
--- requirements.txt	2011-05-30 14:30:10 +0000
+++ requirements.txt	2017-01-17 15:08:22 +0000
@@ -1,3 +1,3 @@
 mock
-psycopg2
+psycopg2==2.4.5
 django

=== added file 'setup.cfg'
--- setup.cfg	1970-01-01 00:00:00 +0000
+++ setup.cfg	2017-01-17 15:08:22 +0000
@@ -0,0 +1,2 @@
+[wheel]
+universal = 1

=== modified file 'setup.py'
--- setup.py	2013-07-11 19:14:08 +0000
+++ setup.py	2017-01-17 15:08:22 +0000
@@ -1,68 +1,19 @@
 #!/usr/bin/env python
 # -*- encoding: utf-8 -*-
-# Copyright 2011 Canonical Ltd.  This software is licensed under the
+# Copyright 2011-2017 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-from distutils.core import setup, Command
-
-
-class TestCommand(Command):
-    user_options = []
-
-    def initialize_options(self):
-        pass
-
-    def finalize_options(self):
-        pass
-
-    def run(self):
-        """Run the project tests."""
-
-        import django
-        from django.conf import settings
-        from django.core.management import call_command
-
-        config = {
-            'SITE_ID': 1,
-            'ROOT_URLCONF': '',
-            'INSTALLED_APPS': [
-                'django.contrib.admin',
-                'django.contrib.auth',
-                'django.contrib.contenttypes',
-                'django.contrib.sessions',
-                'pgtools',
-            ],
-            'DATABASES': {
-                'default': {
-                    'NAME': 'pgtools',
-                    'ENGINE': 'django.db.backends.postgresql_psycopg2',
-                    'USER': 'postgres',
-                }
-            }
-        }
-
-        django_version = django.VERSION[:2]
-        if django_version < (1,4):
-            config.update({
-                'DATABASE_ENGINE': 'django.db.backends.postgresql_psycopg2',
-                'DATABASE_NAME': 'pgtools',
-                'DATABASE_USER': 'postgres',
-            })
-
-        settings.configure(**config)
-
-        call_command('test', interactive=False)
+from setuptools import setup
 
 
 setup(
     name='django-pgtools',
-    version='0.2',
+    version='0.3',
     description="Set of Django management commands for handling various aspects of managing PostgreSQL database.",
     url='https://launchpad.net/django-pgtools',
     author='Canonical ISD',
     author_email='[e-mail]',
     packages=['pgtools', 'pgtools/management', 'pgtools/management/commands'],
     license='AGPLv3',
-    cmdclass = {'test': TestCommand},
-    requires=['django (>=1.2)']
+    requires=['django (>=1.6)']
 )

=== added directory 'test_project'
=== added file 'test_project/__init__.py'
=== added file 'test_project/settings.py'
--- test_project/settings.py	1970-01-01 00:00:00 +0000
+++ test_project/settings.py	2017-01-17 15:08:22 +0000
@@ -0,0 +1,29 @@
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.postgresql_psycopg2',
+        'NAME': 'pgtools',
+        'USER': 'postgres',
+        'HOST': '/dev/shm/pg_pgtools',
+    }
+}
+INSTALLED_APPS = (
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'pgtools',
+)
+MIDDLEWARE_CLASSES = (
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
+    'django.middleware.locale.LocaleMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+    'django.middleware.security.SecurityMiddleware',
+)
+ROOT_URLCONF = ''
+SECRET_KEY = 'secret'
+SITE_ID = 1

=== modified file 'tox.ini'
--- tox.ini	2013-07-11 19:14:08 +0000
+++ tox.ini	2017-01-17 15:08:22 +0000
@@ -1,84 +1,36 @@
 [tox]
-envlist = 
-        py2.5-django1.2, py2.5-django1.3, py2.5-django1.4, py2.5-django1.5,
-        py2.6-django1.2, py2.6-django1.3, py2.6-django1.4, py2.6-django1.5,
-        py2.7-django1.2, py2.7-django1.3, py2.7-django1.4, py2.7-django1.5,
-
+envlist = py27-django1.6,py27-django1.7,py27-django1.8,py27-django1.9,py27-django1.10
 
 [testenv]
-commands = python setup.py test
-
-# Python 2.5
-[testenv:py2.5-django1.2]
-basepython = python2.5
-deps = django >= 1.2, < 1.3
-       psycopg2==2.4.1
-       mock
-
-[testenv:py2.5-django1.3]
-basepython = python2.5
-deps = django >= 1.3, < 1.4
-       psycopg2==2.4.1
-       mock
-
-[testenv:py2.5-django1.4]
-basepython = python2.5
-deps = django >= 1.4, < 1.5
-       psycopg2==2.4.1
-       mock
-
-[testenv:py2.5-django1.5]
-basepython = python2.5
-deps = django >= 1.5, < 1.6
-       psycopg2==2.4.1
-       mock
-
-# Python 2.6
-[testenv:py2.6-django1.2]
-basepython = python2.6
-deps = django >= 1.2, < 1.3
-       psycopg2==2.4.1
-       mock
-
-[testenv:py2.6-django1.3]
-basepython = python2.6
-deps = django >= 1.3, < 1.4
-       psycopg2==2.4.1
-       mock
-
-[testenv:py2.6-django1.4]
-basepython = python2.6
-deps = django >= 1.4, < 1.5
-       psycopg2==2.4.1
-       mock
-
-[testenv:py2.6-django1.5]
-basepython = python2.6
-deps = django >= 1.5, < 1.6
-       psycopg2==2.4.1
-       mock
+commands = python manage.py test pgtools
+basepython =
+    python2.7
+deps =
+    psycopg2 == 2.4.5
+    mock
 
 # Python 2.7
-[testenv:py2.7-django1.2]
-basepython = python2.7
-deps = django >= 1.2, < 1.3
-       psycopg2==2.4.1
-       mock
-
-[testenv:py2.7-django1.3]
-basepython = python2.7
-deps = django >= 1.3, < 1.4
-       psycopg2==2.4.1
-       mock
-
-[testenv:py2.7-django1.4]
-basepython = python2.7
-deps = django >= 1.4, < 1.5
-       psycopg2==2.4.1
-       mock
-
-[testenv:py2.7-django1.5]
-basepython = python2.7
-deps = django >= 1.5, < 1.6
-       psycopg2==2.4.1
-       mock
+[testenv:py27-django1.6]
+deps =
+    django == 1.6.11
+    {[testenv]deps}
+
+[testenv:py27-django1.7]
+deps =
+    django == 1.7.11
+    {[testenv]deps}
+
+[testenv:py27-django1.8]
+deps =
+    django == 1.8.17
+    {[testenv]deps}
+
+[testenv:py27-django1.9]
+deps =
+    django == 1.9.12
+    {[testenv]deps}
+
+[testenv:py27-django1.10]
+deps =
+    django == 1.10.5
+    {[testenv]deps}