def test_process_inserts(self):
        models.delete_tables()
        models.create_tables()

        new_playgrounds, revision_group = data.process_changes('tests/data/test_inserts.json')

        self.assertEqual(len(new_playgrounds), 1)

        playground = Playground.select().where(Playground.id == new_playgrounds[0].id)[0]
        self.assertEqual(playground.name, 'NEW NAME')

        revisions = Revision.select().where(Revision.revision_group == revision_group)

        self.assertEqual(revisions.count(), 1)

        revision = revisions[0]
        self.assertEqual(revision.playground.id, playground.id)

        log = revision.get_log()
        self.assertEqual(len(log), 1)
        self.assertEqual(log[0]['field'], 'name')
        self.assertEqual(log[0]['from'], '')
        self.assertEqual(log[0]['to'], 'NEW NAME')

        headers = revision.get_headers()
        self.assertEqual(headers['content_length'], '18')
        self.assertEqual(headers['host'], 'localhost')

        cookies = revision.get_cookies()

 def resetDB(self):
     self.db.session.remove()
     self.db.drop_all()
     
     models.create_tables(self.app)
     fixtures.install(self.app, *fixtures.all_data)
     self.db = models.init_app(self.app)

 def __init__(self):
     """
     Initialize database connection and create tables.
     """
     engine = db_connect()
     create_tables(engine)
     self.Session = sessionmaker(bind=engine)

def bootstrap():
    with settings(warn_only=True):
        local("dropdb breaking")
        local("createdb breaking")

    models.create_tables()
    data.load_test_event()
    data.load_test_facts()

 def __init__(self):
     """
     Initializes database connection and sessionmaker.
     Creates tables.
     """
     self.engine = db_connect()
     create_tables(self.engine)
     self.Session = sessionmaker(bind=self.engine)

def create(options, *args, **kwargs):
    ''' Creates/bootstraps the database '''
    from libs.ConfigManager import ConfigManager  # Sets up logging
    from models import create_tables, boot_strap
    print(INFO+'%s : Creating the database ...' % current_time())
    create_tables()
    print(INFO+'%s : Bootstrapping the database ...' % current_time())
    boot_strap()

 def __dbinit__(self):
     ''' Initializes the SQLite database '''
     logging.info("Initializing SQLite db ...")
     if not os.path.exists(DBFILE_NAME):
         logging.info("Creating SQLite tables")
         dbConn = sqlite3.connect(DBFILE_NAME)
         dbConn.close()
         create_tables()

 def __init__(self):
     """
     Initializes database connection and sessionmaker.
     Creates nfl_rosters_2015 table.
     """
     engine = db_connect()
     create_tables(engine)
     self.Session = sessionmaker(bind=engine)

 def setUp(self):
     self.app = mvp.create_app('./settings/test.cfg')
     
     models.create_tables(self.app.engine)
     
     Session = sessionmaker(bind=self.app.engine)
     
     self.db = Session()

 def __init__(self):
     '''
     initializes the database connections and sessionmaker
     creates all tables
     '''
     engine = db_connect()
     create_tables(engine)
     self.Session = sessionmaker(bind=engine)

	def on_novo_menu_item_activate(self, widget):
                self.file_chooser.set_action(Gtk.FileChooserAction.SAVE)
                response = self.file_chooser.run()
                if response == Gtk.ResponseType.OK:
                        self.filename = self.file_chooser.get_filename()
                        models.init(self.filename)
                        models.open()
                        models.create_tables()
                        self.file_chooser.hide()

def create():
    """ Creates/bootstraps the database """
    from libs.ConfigManager import ConfigManager  # Sets up logging
    from models import create_tables, boot_strap

    print(INFO + "%s : Creating the database ... " % current_time())
    create_tables()
    if len(argv) == 3 and (argv[2] == "bootstrap" or argv[2] == "-b"):
        print("\n\n\n" + INFO + "%s : Bootstrapping the database ... \n" % current_time())
        boot_strap()

def create():
    ''' Creates/bootstraps the database '''
    from libs.ConfigManager import ConfigManager  # Sets up logging
    from models import create_tables, boot_strap
    print(INFO+'%s : Creating the database ...' % current_time())
    create_tables()
    print(INFO+'%s : Bootstrapping the database ...' % current_time())
    try:
        boot_strap()
    except:
        print(WARN+"%s : Database has already been bootstrapped" % current_time())

 def __init__(self):
     """Initializes database connection and sessionmaker
     Create:
     users table
     reviews table
     violations table
     restaurants table
     """
     engine = db_connect()
    # engine.echo = True #prints out SQL we are loading
     create_tables(engine)
     self.Session = sessionmaker(bind=engine)

    def __init__(self, url):
        self.url = url
        engine = db_connect()
        try:
            create_tables(engine)
        except:
            e = sys.exc_info()[0]
            log.error("Unable to create tables. %s" % e)
        self.Session = sessionmaker(bind=engine)

        if not self.model:
            log.warning("BaseStore instantiated without model class variable")
            raise NotImplementedError("Subclasses must set model class!")

def get_players():
    """Gets player listings from db"""
    engine = models.db_connect()
    models.create_tables(engine)
    Session = sessionmaker(bind=engine)
    session = Session()
    players = {}

    for player in session.query(models.NFL_Player_2015):
        players[str(player.name)] = 0

    session.close()

    return players

    def __init__(self, db_url, **settings):
        if db_url is not None:
            engine = create_engine(db_url,
                                   connect_args={'sslmode': 'require'})
            create_tables(engine)

            self.db = scoped_session(sessionmaker(bind=engine))

        handlers = [
            (r"/", MainHandler),
        ] + repo_crud.handlers + github_handlers.handlers

        settings['template_path'] = os.path.join(os.path.dirname(__file__),
                                                 "templates")
        settings['static_path'] = os.path.join(os.path.dirname(__file__),
                                               "static")
        super().__init__(handlers, **settings)

    def test_add_playground(self):
        models.delete_tables()
        models.create_tables()

        response = self.client.post(url_for('insert_playground'), data={
            'name': 'NEW PLAYGROUND'
        })

        self.assertEqual(response.status_code, 302)

        redirect_url = app_config.S3_BASE_URL
        self.assertEqual(response.headers['Location'].split('?')[0], redirect_url + '/search.html')

        with open('data/changes.json') as f:
            inserts = json.load(f)

        self.assertEqual(len(inserts), 1)
        self.assertEqual(inserts[0]['action'], 'insert')
        self.assertEqual(inserts[0]['playground']['name'], 'NEW PLAYGROUND')

    def __init__(self):
        engine = db_connect()
        create_tables(engine)
        self.Session = sessionmaker(bind=engine)

        session = self.Session()

        # make sure the root of the product type tree exists
        ptt = session.query(ProductTypeTree).filter_by(lft=0).first()
        if ptt is None:
            ptt = ProductTypeTree(name='Root', lft=0, rgt=1)
            try:
                session.add(ptt)
                session.commit()
            except:
                session.rollback()
                raise
            finally:
                session.close()

    def __init__(self, db_url, **settings):
        if db_url is not None:
            engine = create_engine(db_url,
                                   echo=True,
                                   connect_args={'sslmode': 'require'})
            create_tables(engine)

            self.db = scoped_session(sessionmaker(bind=engine))

        handlers = [
            (r"/", MainHandler),
            URLSpec(r"/repos", RepoList, name='repo_list'),
            URLSpec(r"/repos/add", RepoAdd, name='repo_add'),
            URLSpec(r"/repos/(\d+)", RepoEdit, name='repo_edit'),
        ]

        settings['template_path'] = os.path.join(os.path.dirname(__file__),
                                                 "templates")
        settings['static_path'] = os.path.join(os.path.dirname(__file__),
                                               "static")
        super().__init__(handlers, **settings)