Add model and tests to verify model

database.py

+from sqlalchemy import create_engine
+from os import environ
+from sqlalchemy.orm import scoped_session, sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+
+db_user = environ["DATABASE_USER"]
+db_password = environ["DATABASE_PASSWORD"]
+db_host = environ["DATABASE_HOST"]
+db_name = environ["DATABASE_NAME"]
+
+Session = sessionmaker()
+Base = declarative_base()
+
+engine = create_engine('postgresql://{0}:{1}@{2}/{3}'.format(
+    db_user, db_password, db_host, db_name))
+
+Session.configure(bind=engine, autocommit=True)
+#db_session = scoped_session(sessionmaker(autocommit=False,
+#                                     autoflush=False,
+#                                     bind=engine))
+
+##Base.query = Session.query_property()
+
+def init_db():
+    # import all modules here that might define models so that
+    # they will be registered properly on the metadata.  Otherwise
+     # you will have to import them first before calling init_db()
+    import models
+    Base.metadata.create_all(bind=engine)

models.py

+from database import Base
+from flask_security import UserMixin, RoleMixin
+from sqlalchemy import create_engine
+from sqlalchemy.orm import relationship, backref
+from sqlalchemy import Boolean, DateTime, Column, Integer, \
+                       String, ForeignKey
+
+class RolesUsers(Base):
+    __tablename__ = 'roles_users'
+    id = Column(Integer(), primary_key=True)
+    user_id = Column('user_id', Integer(), ForeignKey('user.id'))
+    role_id = Column('role_id', Integer(), ForeignKey('role.id'))
+
+class Role(Base, RoleMixin):
+    __tablename__ = 'role'
+    id = Column(Integer(), primary_key=True)
+    name = Column(String(80), unique=True)
+    description = Column(String(255))
+
+class User(Base, UserMixin):
+    __tablename__ = 'user'
+    id = Column(Integer, primary_key=True)
+    email = Column(String(255), unique=True)
+    username = Column(String(255))
+    password = Column(String(255))
+    active = Column(Boolean())
+    roles = relationship('Role', secondary='roles_users',
+                         backref=backref('users', lazy='dynamic'))

requirements.txt

 sqlalchemy
 psycopg2
+flask-sqlalchemy
+flask-security

test/test_database.py

 import unittest
 from os import environ
 from sqlalchemy import create_engine
-from sqlalchemy.engine import Connection
+from sqlalchemy.orm import scoped_session, sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+from flask_security import SQLAlchemySessionUserDatastore
+from models import User, Role
 
 class DatabaseSetupTest(unittest.TestCase):
 
     def setUp(self):
         # Setup local database for testing
         self.engine = create_engine('sqlite:///:memory:')
-        self.db_connection = self.engine.connect()
+        session_factory = sessionmaker(bind=self.engine)
+        Session = scoped_session(session_factory)
+        import models
+        base = declarative_base()
+        base.query = Session.query_property()
+        base.metadata.create_all(self.engine)
+        new_session = Session()
+        self.user_datastore = SQLAlchemySessionUserDatastore(
+            new_session, User, Role)
 
-    def teatDown(self):
-        self.db_connection.close()
+    def tearDown(self):
+        pass
 
     def test_connect_to_database_with_provided_config(self):
         db_user = environ["DATABASE_USER"]
         db_password = environ["DATABASE_PASSWORD"]
         db_host = environ["DATABASE_HOST"]
         db_name = environ["DATABASE_NAME"]
-            db_user, db_password, db_host, db_name))
         engine = create_engine('postgresql://{0}:{1}@{2}/{3}'.format(
             db_user, db_password, db_host, db_name))
-        self.assertIsInstance(engine.connect(), Connection)
+        self.assertTrue(engine.connect())
+
+    def test_create_and_activate_user_with_role(self):
+        user = self.user_datastore.create_user(
+            email="admin@example.net",
+            username="admin",
+            password="password")
+        self.user_datastore.activate_user(user)
+        self.assertTrue(user.is_active)
+        admin_role = self.user_datastore.create_role(name="admin", description="Admins")
+        self.assertIsInstance(admin_role, Role)
+        self.user_datastore.add_role_to_user(user, admin_role)
+        self.assertTrue(user.has_role(admin_role))
+