sqlobject.versioning.test.test_version — SQLObject 3.9.1 documentation

# Source code for sqlobject.versioning.test.test_version

    from sqlobject import ForeignKey, IntCol, SQLObject, StringCol
    from sqlobject.inheritance import InheritableSQLObject
    from sqlobject.versioning import Versioning
    from sqlobject.tests.dbtest import setupClass

    class MyClass(SQLObject):
        name = StringCol()
        versions = Versioning()

    class Base(InheritableSQLObject):
        name = StringCol()
        so_value = IntCol(default=0)
        versions = Versioning()

    class Child(Base):
        toy = StringCol()

    class Government(InheritableSQLObject):
        name = StringCol()

    class Monarchy(Government):
        monarch = StringCol()
        versions = Versioning()

    class VChild(Base):
        weapon = StringCol()
        versions = Versioning()

    class HasForeign(SQLObject):
        foreign = ForeignKey("Base")
        versions = Versioning()

    def _set_extra():
        return "read all about it"

    class Extra(SQLObject):
        name = StringCol()
        versions = Versioning(
            extraCols={'extra': StringCol(default=_set_extra())})

    class HasAltId(SQLObject):
        name = StringCol()
        altid = IntCol(alternateID=True)
        versions = Versioning()

    def setup():
        classes = [MyClass, Base, Child, Government,
                   Monarchy, VChild, Extra, HasAltId]
        if hasattr(HasForeign, "_connection"):
            classes.insert(0, HasForeign)
        else:
            classes.append(HasForeign)
        for cls in classes:
            if hasattr(cls, 'versions') and getattr(cls, "_connection", None) and \
                    cls._connection.tableExists(cls.sqlmeta.table):
                setupClass(cls.versions.versionClass)
            setupClass(cls)
            if hasattr(cls, 'versions'):
                setupClass(cls.versions.versionClass)
                for version in cls.versions.versionClass.select():
                    version.destroySelf()

    def test_versioning():
        # the simple case
        setup()
        mc = MyClass(name='fleem')
        mc.set(name='morx')
        assert len(list(mc.versions)) == 1
        assert mc.versions[0].name == "fleem"

        assert len(list(MyClass.select())) == 1

    def test_inheritable_versioning():
        setup()

        # base versioned, child unversioned
        base = Base(name='fleem')
        base.set(name='morx')
        assert len(list(base.versions)) == 1
        assert base.versions[0].name == "fleem"
        assert len(list(Base.select())) == 1

        child = Child(name='child', toy='nintendo')
        child.set(name='teenager', toy='guitar')
        assert len(list(child.versions)) == 0

        # child versioned, base unversioned
        government = Government(name='canada')
        assert not hasattr(government, 'versions')

        monarchy = Monarchy(name='UK', monarch='king george iv')
        assert len(list(monarchy.versions)) == 0
        monarchy.set(name='queen elisabeth ii')
        assert len(list(monarchy.versions)) == 1
        assert monarchy.versions[0].name == "UK"
        assert len(list(Monarchy.select())) == 1

        # both parent and child versioned
        num_base_versions = len(list(base.versions))
        vchild = VChild(name='kid', weapon='slingshot')
        vchild.set(name='toon', weapon='dynamite')
        assert len(list(base.versions)) == num_base_versions
        assert len(list(vchild.versions)) == 1
        # test setting using setattr directly rather than .set
        vchild.name = "newname"
        assert len(list(vchild.versions)) == 2

    def test_restore():
        setup()
        base = Base(name='fleem')
        base.set(name='morx')
        assert base.name == "morx"
        base.versions[0].restore()
        assert base.name == "fleem"

        monarchy = Monarchy(name='USA', monarch='Emperor Norton I')
        monarchy.set(name='morx')
        assert monarchy.name == "morx"
        monarchy.versions[0].restore()
        assert monarchy.name == "USA"
        assert monarchy.monarch == "Emperor Norton I"

        extra = Extra(name='fleem')
        extra.set(name='morx')
        assert extra.name == "morx"
        extra.versions[0].restore()
        assert extra.name == "fleem"

    def test_next():
        setup()
        base = Base(name='first', so_value=1)
        base.set(name='second')
        base.set(name='third', so_value=2)
        version = base.versions[0]
        assert version.nextVersion() == base.versions[1]
        assert version.nextVersion().nextVersion() == base

    def test_get_changed():
        setup()
        base = Base(name='first', so_value=1)
        base.set(name='second')
        base.set(name='third', so_value=2)
        assert base.versions[0].getChangedFields() == ['Name']
        assert sorted(base.versions[1].getChangedFields()) == ['Name', 'So_Value']

    def test_foreign_keys():
        setup()
        base1 = Base(name='first', so_value=1)
        base2 = Base(name='first', so_value=1)
        has_foreign = HasForeign(foreign=base1)
        has_foreign.foreign = base2
        assert has_foreign.versions[0].foreign == base1

    def test_extra():
        setup()
        extra = Extra(name='title')
        extra.name = 'new'
        assert extra.versions[0].extra == 'read all about it'
        assert sorted(extra.versions[0].getChangedFields()) == ['Name']

    def test_altid():
        setup()
        extra = HasAltId(name="fleem", altid=5)
        extra.name = "morx"