def setup_method(self, method):
        self.Model = declarative_base()
        make_versioned(options=self.options)

        driver = os.environ.get('DB', 'sqlite')
        driver = get_driver_name(driver)
        versioning_manager.plugins = self.plugins
        versioning_manager.transaction_cls = self.transaction_cls
        versioning_manager.user_cls = self.user_cls

        self.engine = create_engine(get_dns_from_driver(driver))
        # self.engine.echo = True
        self.connection = self.engine.connect()

        self.create_models()

        sa.orm.configure_mappers()

        if hasattr(self, 'Article'):
            self.ArticleVersion = version_class(self.Article)
        if hasattr(self, 'Tag'):
            try:
                self.TagVersion = version_class(self.Tag)
            except ClassNotVersioned:
                pass
        self.create_tables()

        Session = sessionmaker(bind=self.connection)
        self.session = Session(autoflush=False)

 def test_sa_inheritance_with_no_distinct_table_has_right_translation_class(self):
     class_ = version_class(self.BaseModel)
     assert class_.__name__ == 'BaseModelVersion'
     assert class_.__table__.name == 'base_model_version'
     class_ = version_class(self.FirstLevel)
     assert class_.__name__ == 'FirstLevelVersion'
     assert class_.__table__.name == 'first_level_version'
     class_ = version_class(self.SecondLevel)
     assert class_.__name__ == 'SecondLevelVersion'
     assert class_.__table__.name == 'first_level_version'

 def test_versioned_table_structure(self):
     table = version_class(self.Article).__table__
     assert 'id' in table.c
     assert 'name' in table.c
     assert 'content' in table.c
     assert 'description'in table.c
     assert 'transaction_id' in table.c
     assert 'operation_type' in table.c

    def test_something(self):
        table = version_class(self.Article).__table__
        self._insert(
            {
                'id': 1,
                'transaction_id': 1,
                'name': u'Article 1',
                'operation_type': 1,
            }
        )
        self._insert(
            {
                'id': 1,
                'transaction_id': 2,
                'name': u'Article 1 updated',
                'operation_type': 2,
            }
        )
        self._insert(
            {
                'id': 2,
                'transaction_id': 3,
                'name': u'Article 2',
                'operation_type': 1,
            }
        )
        self._insert(
            {
                'id': 1,
                'transaction_id': 4,
                'name': u'Article 1 updated (again)',
                'operation_type': 2,
            }
        )
        self._insert(
            {
                'id': 2,
                'transaction_id': 5,
                'name': u'Article 2 updated',
                'operation_type': 2,
            }
        )

        update_end_tx_column(table, conn=self.session)
        rows = self.session.execute(
            'SELECT * FROM article_version ORDER BY transaction_id'
        ).fetchall()
        assert rows[0].transaction_id == 1
        assert rows[0].end_transaction_id == 2
        assert rows[1].transaction_id == 2
        assert rows[1].end_transaction_id == 4
        assert rows[2].transaction_id == 3
        assert rows[2].end_transaction_id == 5
        assert rows[3].transaction_id == 4
        assert rows[3].end_transaction_id is None
        assert rows[4].transaction_id == 5
        assert rows[4].end_transaction_id is None

    def test_change_single_entity(self):
        self.article = self.Article()
        self.article.name = u'Some article'
        self.article.content = u'Some content'
        self.session.add(self.article)
        self.session.commit()
        tx = self.article.versions[0].transaction

        assert tx.changed_entities == {
            version_class(self.article.__class__):
            [self.article.versions[0]]
        }

def get_revision(endpoint, pid_value, transaction_id, rec_uuid):
    """Get the revision of given record (uuid)"""
    RecordMetadataVersion = version_class(RecordMetadata)

    revision = RecordMetadataVersion.query.with_entities(
        RecordMetadataVersion.json
    ).filter(
        RecordMetadataVersion.transaction_id == transaction_id,
        RecordMetadataVersion.id == rec_uuid
    ).one()

    return jsonify(revision.json)

 def test_assigns_foreign_keys_for_versions(self):
     article = self.Article()
     article.name = u'Some article'
     article.content = u'Some content'
     article.tags.append(self.Tag(name=u'some tag'))
     self.session.add(article)
     self.session.commit()
     cls = version_class(self.Tag)
     version = self.session.query(cls).first()
     assert version.name == u'some tag'
     assert version.id == 1
     assert version.article_id == 1

 def test_mod_properties_with_delete(self):
     user = self.User(name=u'John')
     self.session.add(user)
     self.session.commit()
     self.session.delete(user)
     self.session.commit()
     UserVersion = version_class(self.User)
     version = (
         self.session
         .query(UserVersion)
         .order_by(sa.desc(UserVersion.transaction_id))
     ).first()
     assert version.age_mod
     assert version.name_mod

def test_create_file_version(monkeypatch, first_version_node, middle_version_node, current_version_node):
    from sqlalchemy_continuum import version_class
    from core import File
    NodeToFileVersion = version_class(NodeToFile)
    FileVersion = version_class(File)
    
    def _version_class(clz):
        if clz == NodeToFile:
            return NodeToFileVersion
        elif clz == File:
            return FileVersion
    
    monkeypatch.setattr(version_migration, "version_class", _version_class)
    
    Transaction = versioning_manager.transaction_cls
    remove_versioning()
    
    first = first_version_node
    middle = middle_version_node
    current = current_version_node


    first_files = [FileFactory()]
    first.files.extend(first_files)

    middle_files = [FileFactory()]
    middle.files.extend(middle_files)

    current_files = [FileFactory()]
    current.files.extend(current_files)

    transaction = Transaction()
    version_migration.create_file_versions(first, middle, transaction)

    transaction2 = Transaction()
    version_migration.create_file_versions(middle, current, transaction2)
    

    def find_by_holding(cls, **kwargs):
        """Find item versions based on their holdings information.

        Every given kwarg will be queried as a key-value pair in the items
        holding.

        :returns: List[(UUID, version_id)] with `version_id` as used by
                  `RecordMetadata.version_id`.
        """
        def _get_filter_clause(obj, key, value):
            val = obj[key].astext
            CASTS = {
                bool: lambda x: cast(x, BOOLEAN),
                int: lambda x: cast(x, INTEGER),
                datetime.date: lambda x: cast(x, DATE),
            }
            if (not isinstance(value, six.string_types) and
                    isinstance(value, collections.Sequence)):
                if len(value) == 2:
                    return CASTS[type(value[0])](val).between(*value)
                raise ValueError('Too few/many values for a range query. '
                                 'Range query requires two values.')
            return CASTS.get(type(value), lambda x: x)(val) == value

        RecordMetadataVersion = version_class(RecordMetadata)

        data = type_coerce(RecordMetadataVersion.json, JSONB)
        path = ('_circulation', 'holdings')

        subquery = db.session.query(
            RecordMetadataVersion.id.label('id'),
            RecordMetadataVersion.version_id.label('version_id'),
            func.json_array_elements(data[path]).label('obj')
        ).subquery()

        obj = type_coerce(subquery.c.obj, JSONB)

        query = db.session.query(
            RecordMetadataVersion.id,
            RecordMetadataVersion.version_id
        ).filter(
            RecordMetadataVersion.id == subquery.c.id,
            RecordMetadataVersion.version_id == subquery.c.version_id,
            *(_get_filter_clause(obj, k, v) for k, v in kwargs.items())
        )

        for result in query:
            yield result

def upgrade():
    op.add_column('volunteer', sa.Column('over_18', sa.Boolean(), nullable=False, server_default=expression.false()))
    op.add_column('volunteer_version', sa.Column('over_18', sa.Boolean(), autoincrement=False, nullable=True))

    bind = op.get_bind()
    session = sa.orm.Session(bind=bind)

    for volunteer in session.query(Volunteer):
        volunteer.over_18 = (volunteer.age >= 18)

    # include deleted records
    for version in session.query(version_class(Volunteer)):
        version.over_18 = (version.age >= 18)

    session.commit()

    op.drop_column('volunteer', 'age')
    op.drop_column('volunteer_version', 'age')

def downgrade():
    op.add_column('volunteer_version', sa.Column('age', sa.INTEGER(), autoincrement=False, nullable=True))
    op.add_column('volunteer', sa.Column('age', sa.INTEGER(), autoincrement=False, nullable=False, server_default=text('0')))

    # No clean downgrade, as we want to get rid of the data
    bind = op.get_bind()
    session = sa.orm.Session(bind=bind)

    for volunteer in session.query(Volunteer):
        volunteer.age = 18 if volunteer.over_18 else 17

    # include deleted records
    for version in session.query(version_class(Volunteer)):
        version.age = 18 if version.over_18 else 17

    session.commit()

    op.drop_column('volunteer_version', 'over_18')
    op.drop_column('volunteer', 'over_18')

    def test_previous_for_deleted_parent(self):
        item = self.TextItem()
        item.name = u'Some item'
        item.content = u'Some content'
        self.session.add(item)
        self.session.commit()
        self.session.delete(item)
        self.session.commit()
        TextItemVersion = version_class(self.TextItem)

        versions = (
            self.session.query(TextItemVersion)
            .order_by(
                getattr(
                    TextItemVersion,
                    self.options['transaction_column_name']
                )
            )
        ).all()
        assert versions[1].previous.name == u'Some item'

 def _insert(self, values):
     table = version_class(self.Article).__table__
     stmt = table.insert().values(values)
     self.session.execute(stmt)

 def test_primary_keys_not_included(self):
     UserVersion = version_class(self.User)
     assert 'id_mod' not in UserVersion.__table__.c

 def test_each_column_generates_additional_mod_column(self):
     UserVersion = version_class(self.User)
     assert 'name_mod' in UserVersion.__table__.c
     column = UserVersion.__table__.c['name_mod']
     assert not column.nullable
     assert isinstance(column.type, sa.Boolean)

 def test_created_tables_retain_schema(self):
     table = version_class(self.Article).__table__
     assert table.schema is not None
     assert table.schema == self.Article.__table__.schema

    def test_does_not_make_composite_primary_keys_not_nullable(self):
        TeamMemberVersion = version_class(self.TeamMember)

        assert not TeamMemberVersion.__table__.c.user_id.nullable

 def test_takes_out_onupdate_triggers(self):
     table = version_class(self.Article).__table__
     assert table.c.last_update.onupdate is None

 def test_transaction_id_column_not_nullable(self):
     assert self.Article.__table__.c.name.nullable is False
     table = version_class(self.Article).__table__
     assert table.c.transaction_id.nullable is False