sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/tests/test_ForeignKey_cascade.py

@@ -0,0 +1,150 @@
+from sqlobject import ForeignKey, SQLObject, StringCol, \
+    SQLObjectIntegrityError, SQLObjectNotFound
+from sqlobject.tests.dbtest import raises, setupClass
+
+
+class SOTestPerson1(SQLObject):
+    name = StringCol()
+
+
+class SOTestMessageCascadeTrue(SQLObject):
+    sender = ForeignKey('SOTestPerson1', cascade=True)
+    recipient = ForeignKey('SOTestPerson1', cascade=True)
+    body = StringCol()
+
+
+def test1():
+    setupClass([SOTestPerson1, SOTestMessageCascadeTrue])
+
+    john = SOTestPerson1(name='john')
+    emily = SOTestPerson1(name='emily')
+    message = SOTestMessageCascadeTrue(
+        sender=emily, recipient=john, body='test1'
+    )
+
+    SOTestPerson1.delete(emily.id)
+    john.expire()
+    message.expire()
+
+    john.sync()
+    raises(SQLObjectNotFound, emily.sync)
+    raises(SQLObjectNotFound, message.sync)
+
+
+class SOTestPerson2(SQLObject):
+    name = StringCol()
+
+
+class SOTestMessageCascadeFalse(SQLObject):
+    sender = ForeignKey('SOTestPerson2', cascade=False)
+    recipient = ForeignKey('SOTestPerson2', cascade=False)
+    body = StringCol()
+
+
+def test2():
+    setupClass([SOTestPerson2, SOTestMessageCascadeFalse])
+
+    john = SOTestPerson2(name='john')
+    emily = SOTestPerson2(name='emily')
+    message = SOTestMessageCascadeFalse(
+        sender=emily, recipient=john, body='test2'
+    )
+
+    raises(SQLObjectIntegrityError, SOTestPerson2.delete, emily.id)
+    john.expire()
+    emily.expire()
+    message.expire()
+
+    john.sync()
+    emily.sync()
+    message.sync()
+
+    assert message.sender == emily
+    assert message.recipient == john
+
+
+class SOTestPerson3(SQLObject):
+    name = StringCol()
+
+
+class SOTestMessageCascadeNull(SQLObject):
+    sender = ForeignKey('SOTestPerson3', cascade='null')
+    recipient = ForeignKey('SOTestPerson3', cascade='null')
+    body = StringCol()
+
+
+def test3():
+    setupClass([SOTestPerson3, SOTestMessageCascadeNull])
+
+    john = SOTestPerson3(name='john')
+    emily = SOTestPerson3(name='emily')
+    message = SOTestMessageCascadeNull(
+        sender=emily, recipient=john, body='test3'
+    )
+
+    SOTestPerson3.delete(emily.id)
+    john.expire()
+    message.expire()
+
+    john.sync()
+    message.sync()
+    raises(SQLObjectNotFound, emily.sync)
+
+    assert message.sender is None
+    assert message.recipient == john
+
+    SOTestPerson3.delete(john.id)
+    john.expire()
+    message.expire()
+
+    message.sync()
+    raises(SQLObjectNotFound, john.sync)
+
+    assert message.recipient is None
+
+
+class SOTestPerson4(SQLObject):
+    name = StringCol()
+
+
+class SOTestMessageCascadeMixed(SQLObject):
+    sender = ForeignKey('SOTestPerson4', cascade=True)
+    recipient = ForeignKey('SOTestPerson4', cascade='null')
+    body = StringCol()
+
+
+def test4():
+    setupClass([SOTestPerson4, SOTestMessageCascadeMixed])
+
+    john = SOTestPerson4(name='john')
+    emily = SOTestPerson4(name='emily')
+    message = SOTestMessageCascadeMixed(
+        sender=emily, recipient=john, body='test4'
+    )
+
+    SOTestPerson4.delete(emily.id)
+    john.expire()
+    message.expire()
+
+    john.sync()
+    raises(SQLObjectNotFound, message.sync)
+
+
+def test5():
+    setupClass([SOTestPerson4, SOTestMessageCascadeMixed])
+
+    john = SOTestPerson4(name='john')
+    emily = SOTestPerson4(name='emily')
+    message = SOTestMessageCascadeMixed(
+        sender=emily, recipient=john, body='test5'
+    )
+
+    john.destroySelf()
+    emily.expire()
+    message.expire()
+
+    emily.sync()
+    message.sync()
+
+    assert message.recipient is None
+    assert message.sender == emily

sqlobject/tests/test_NoneValuedResultItem.py

@@ -0,0 +1,33 @@
+# Test that selectResults handle NULL values from, for example, outer joins.
+
+from sqlobject import ForeignKey, SQLObject, StringCol, sqlbuilder
+from sqlobject.tests.dbtest import setupClass
+
+
+class SOTestComposer(SQLObject):
+    name = StringCol()
+
+
+class SOTestWork(SQLObject):
+    class sqlmeta:
+        idName = "work_id"
+
+    composer = ForeignKey('SOTestComposer')
+    title = StringCol()
+
+
+def test1():
+    setupClass([SOTestComposer,
+                SOTestWork])
+
+    c = SOTestComposer(name='Mahler, Gustav')
+    w = SOTestWork(composer=c, title='Symphony No. 9')
+    SOTestComposer(name='Bruckner, Anton')
+    # but don't add any works for Bruckner
+
+    # do a left join, a common use case that often involves NULL results
+    s = SOTestWork.select(
+        join=sqlbuilder.LEFTJOINOn(
+            SOTestComposer, SOTestWork,
+            SOTestComposer.q.id == SOTestWork.q.composerID))
+    assert tuple(s) == (w, None)

sqlobject/tests/test_SQLMultipleJoin.py

@@ -0,0 +1,65 @@
+import pytest
+from sqlobject import ForeignKey, IntCol, MultipleJoin, SQLMultipleJoin, \
+    SQLObject, StringCol
+from sqlobject.tests.dbtest import setupClass, supports
+
+
+class Race(SQLObject):
+    name = StringCol()
+    fightersAsList = MultipleJoin('RFighter', joinColumn="rf_id")
+    fightersAsSResult = SQLMultipleJoin('RFighter', joinColumn="rf_id")
+
+
+class RFighter(SQLObject):
+    name = StringCol()
+    race = ForeignKey('Race', dbName="rf_id")
+    power = IntCol()
+
+
+def createAllTables():
+    setupClass([Race, RFighter])
+
+
+def test_1():
+    createAllTables()
+    # create some races
+    human = Race(name='human')
+    saiyajin = Race(name='saiyajin')
+    hibrid = Race(name='hibrid (human with sayajin)')
+    namek = Race(name='namekuseijin')
+    # create some fighters
+    RFighter(name='Gokou (Kakaruto)', race=saiyajin, power=10)
+    RFighter(name='Vegeta', race=saiyajin, power=9)
+    RFighter(name='Krilim', race=human, power=3)
+    RFighter(name='Yancha', race=human, power=2)
+    RFighter(name='Jackie Chan', race=human, power=2)
+    RFighter(name='Gohan', race=hibrid, power=8)
+    RFighter(name='Goten', race=hibrid, power=7)
+    trunks = RFighter(name='Trunks', race=hibrid, power=8)
+    picollo = RFighter(name='Picollo', race=namek, power=6)
+    RFighter(name='Neil', race=namek, power=5)
+
+    # testing the SQLMultipleJoin stuff
+    for i, j in zip(human.fightersAsList, human.fightersAsSResult):
+        assert i is j  # the 2 ways should give the same result
+    assert namek.fightersAsSResult.count() == len(namek.fightersAsList)
+    assert saiyajin.fightersAsSResult.max('power') == 10
+    assert trunks in hibrid.fightersAsSResult
+    assert picollo not in hibrid.fightersAsSResult
+    assert str(hibrid.fightersAsSResult.sum('power')) == '23'
+
+
+def test_multiple_join_transaction():
+    if not supports('transactions'):
+        pytest.skip("Transactions aren't supported")
+    createAllTables()
+    trans = Race._connection.transaction()
+    try:
+        namek = Race(name='namekuseijin', connection=trans)
+        RFighter(name='Gokou (Kakaruto)', race=namek, power=10,
+                 connection=trans)
+        assert namek.fightersAsSResult.count() == 1
+        assert namek.fightersAsSResult[0]._connection == trans
+    finally:
+        trans.commit(True)
+        Race._connection.autoCommit = True

sqlobject/tests/test_SQLRelatedJoin.py

@@ -0,0 +1,114 @@
+import pytest
+from sqlobject import RelatedJoin, SQLObject, SQLRelatedJoin, StringCol, \
+    ForeignKey
+from sqlobject.sqlbuilder import Alias
+from sqlobject.tests.dbtest import setupClass, supports
+
+
+class Fighter(SQLObject):
+    class sqlmeta:
+        idName = 'fighter_id'  # test on a non-standard way
+    name = StringCol()
+    tourtments = RelatedJoin('Tourtment')
+
+
+class Tourtment(SQLObject):
+    class sqlmeta:
+        table = 'competition'  # test on a non-standard way
+    name = StringCol()
+    fightersAsList = RelatedJoin('Fighter')
+    fightersAsSResult = SQLRelatedJoin('Fighter')
+
+
+def createAllTables():
+    setupClass(Fighter)
+    setupClass(Tourtment)
+
+
+def createData():
+    createAllTables()
+    # create some tourtments
+    t1 = Tourtment(name='Tourtment #1')
+    t2 = Tourtment(name='Tourtment #2')
+    t3 = Tourtment(name='Tourtment #3')
+    # create some fighters
+    gokou = Fighter(name='gokou')
+    vegeta = Fighter(name='vegeta')
+    gohan = Fighter(name='gohan')
+    trunks = Fighter(name='trunks')
+    # relating them
+    t1.addFighter(gokou)
+    t1.addFighter(vegeta)
+    t1.addFighter(gohan)
+    t2.addFighter(gokou)
+    t2.addFighter(vegeta)
+    t2.addFighter(trunks)
+    t3.addFighter(gohan)
+    t3.addFighter(trunks)
+    return t1, t2, t3, gokou, vegeta, gohan, trunks
+
+
+def test_1():
+    t1, t2, t3, gokou, vegeta, gohan, trunks = createData()
+    for i, j in zip(t1.fightersAsList, t1.fightersAsSResult):
+        assert i is j
+    assert len(t2.fightersAsList) == t2.fightersAsSResult.count()
+
+
+def test_related_join_transaction():
+    if not supports('transactions'):
+        pytest.skip("Transactions aren't supported")
+    createAllTables()
+    trans = Tourtment._connection.transaction()
+    try:
+        t1 = Tourtment(name='Tourtment #1', connection=trans)
+        t1.addFighter(Fighter(name='Jim', connection=trans))
+        assert t1.fightersAsSResult.count() == 1
+        assert t1.fightersAsSResult[0]._connection == trans
+    finally:
+        trans.commit(True)
+        Tourtment._connection.autoCommit = True
+
+
+def test_related_join_filter():
+    t1, t2, t3, gokou, vegeta, gohan, trunks = createData()
+    filteredFighters = t1.fightersAsSResult.filter(
+        Fighter.q.name.startswith('go')
+    ).orderBy('id')
+    for i, j in zip(filteredFighters, [gokou, gohan]):
+        assert i is j
+
+
+class RecursiveGroup(SQLObject):
+    name = StringCol(length=255, unique=True)
+    subgroups = SQLRelatedJoin(
+        'RecursiveGroup',
+        otherColumn='group_id',
+        intermediateTable='rec_group_map',
+        createRelatedTable=False,
+    )
+
+
+class RecGroupMap(SQLObject):
+    recursive_group = ForeignKey('RecursiveGroup')
+    group = ForeignKey('RecursiveGroup')
+
+
+def test_rec_group():
+    setupClass([RecursiveGroup, RecGroupMap])
+    a = RecursiveGroup(name='a')
+    a1 = RecursiveGroup(name='a1')
+    a.addRecursiveGroup(a1)
+    a2 = RecursiveGroup(name='a2')
+    a.addRecursiveGroup(a2)
+
+    assert sorted(a.subgroups, key=lambda x: x.name) == [a1, a2]
+
+    pytest.raises(
+        ValueError,
+        a.subgroups.filter,
+        RecursiveGroup.q.name == 'a1',
+    )
+
+    rgroupAlias = Alias(RecursiveGroup, '_SO_SQLRelatedJoin_OtherTable')
+    assert list(a.subgroups.filter(rgroupAlias.q.name == 'a1')) == [a1]

sqlobject/tests/test_SingleJoin.py

@@ -0,0 +1,30 @@
+from sqlobject import ForeignKey, SQLObject, SingleJoin, StringCol
+from sqlobject.tests.dbtest import setupClass
+
+
+class PersonWithAlbum(SQLObject):
+    name = StringCol()
+    # albumNone returns the album or none
+    albumNone = SingleJoin('PhotoAlbum', joinColumn='test_person_id')
+    # albumInstance returns the album or an default album instance
+    albumInstance = SingleJoin('PhotoAlbum', makeDefault=True,
+                               joinColumn='test_person_id')
+
+
+class PhotoAlbum(SQLObject):
+    color = StringCol(default='red')
+    person = ForeignKey('PersonWithAlbum', dbName='test_person_id')
+
+
+def test_1():
+    setupClass([PersonWithAlbum, PhotoAlbum])
+
+    person = PersonWithAlbum(name='Gokou (Kakarouto)')
+    # We didn't create an album, this way it returns None
+    assert not person.albumNone
+    assert isinstance(person.albumInstance, PhotoAlbum)
+
+    PhotoAlbum(person=person)
+    assert person.albumNone
+    assert isinstance(person.albumNone, PhotoAlbum)
+    assert isinstance(person.albumInstance, PhotoAlbum)

sqlobject/tests/test_aggregates.py

@@ -0,0 +1,75 @@
+from sqlobject import FloatCol, IntCol, SQLObject
+from sqlobject.tests.dbtest import setupClass
+
+
+# Test MIN, AVG, MAX, COUNT, SUM
+
+
+class IntAccumulator(SQLObject):
+    so_value = IntCol()
+
+
+class FloatAccumulator(SQLObject):
+    so_value = FloatCol()
+
+
+def test_integer():
+    setupClass(IntAccumulator)
+    IntAccumulator(so_value=1)
+    IntAccumulator(so_value=2)
+    IntAccumulator(so_value=3)
+
+    assert IntAccumulator.select().min(IntAccumulator.q.so_value) == 1
+    assert IntAccumulator.select().avg(IntAccumulator.q.so_value) == 2
+    assert IntAccumulator.select().max(IntAccumulator.q.so_value) == 3
+    assert IntAccumulator.select().sum(IntAccumulator.q.so_value) == 6
+
+    assert IntAccumulator.select(IntAccumulator.q.so_value > 1).\
+        max(IntAccumulator.q.so_value) == 3
+    assert IntAccumulator.select(IntAccumulator.q.so_value > 1).\
+        sum(IntAccumulator.q.so_value) == 5
+
+
+def floatcmp(f1, f2):
+    if abs(f1 - f2) < 0.1:
+        return 0
+    if f1 < f2:
+        return 1
+    return -1
+
+
+def test_float():
+    setupClass(FloatAccumulator)
+    FloatAccumulator(so_value=1.2)
+    FloatAccumulator(so_value=2.4)
+    FloatAccumulator(so_value=3.8)
+
+    assert floatcmp(
+        FloatAccumulator.select().min(FloatAccumulator.q.so_value), 1.2) == 0
+    assert floatcmp(
+        FloatAccumulator.select().avg(FloatAccumulator.q.so_value), 2.5) == 0
+    assert floatcmp(
+        FloatAccumulator.select().max(FloatAccumulator.q.so_value), 3.8) == 0
+    assert floatcmp(
+        FloatAccumulator.select().sum(FloatAccumulator.q.so_value), 7.4) == 0
+
+
+def test_many():
+    setupClass(IntAccumulator)
+    IntAccumulator(so_value=1)
+    IntAccumulator(so_value=1)
+    IntAccumulator(so_value=2)
+    IntAccumulator(so_value=2)
+    IntAccumulator(so_value=3)
+    IntAccumulator(so_value=3)
+
+    attribute = IntAccumulator.q.so_value
+    assert list(IntAccumulator.select().accumulateMany(
+        ("MIN", attribute), ("AVG", attribute), ("MAX", attribute),
+        ("COUNT", attribute), ("SUM", attribute)
+    )) == [1, 2, 3, 6, 12]
+
+    assert list(IntAccumulator.select(distinct=True).accumulateMany(
+        ("MIN", attribute), ("AVG", attribute), ("MAX", attribute),
+        ("COUNT", attribute), ("SUM", attribute)
+    )) == [1, 2, 3, 3, 6]

sqlobject/tests/test_aliases.py

@@ -0,0 +1,49 @@
+from sqlobject import SQLObject, StringCol
+from sqlobject.sqlbuilder import Alias, LEFTJOINOn
+from sqlobject.tests.dbtest import setupClass
+
+
+########################################
+# Table aliases and self-joins
+########################################
+
+
+class JoinAlias(SQLObject):
+    name = StringCol()
+    parent = StringCol()
+
+
+def test_1syntax():
+    setupClass(JoinAlias)
+    alias = Alias(JoinAlias)
+    select = JoinAlias.select(JoinAlias.q.parent == alias.q.name)
+    assert str(select) == \
+        "SELECT join_alias.id, join_alias.name, join_alias.parent " \
+        "FROM join_alias, join_alias  join_alias_alias1 " \
+        "WHERE ((join_alias.parent) = (join_alias_alias1.name))"
+
+
+def test_2perform_join():
+    setupClass(JoinAlias)
+    JoinAlias(name="grandparent", parent=None)
+    JoinAlias(name="parent", parent="grandparent")
+    JoinAlias(name="child", parent="parent")
+    alias = Alias(JoinAlias)
+    select = JoinAlias.select(JoinAlias.q.parent == alias.q.name)
+    assert select.count() == 2
+
+
+def test_3joins():
+    setupClass(JoinAlias)
+    alias = Alias(JoinAlias)
+    select = JoinAlias.select(
+        (JoinAlias.q.name == 'a') & (alias.q.name == 'b'),
+        join=LEFTJOINOn(None, alias, alias.q.name == 'c')
+    )
+    assert str(select) == \
+        "SELECT join_alias.id, join_alias.name, join_alias.parent " \
+        "FROM join_alias " \
+        "LEFT JOIN join_alias  join_alias_alias3 " \
+        "ON ((join_alias_alias3.name) = ('c')) " \
+        "WHERE (((join_alias.name) = ('a')) AND " \
+        "((join_alias_alias3.name) = ('b')))"

sqlobject/tests/test_asdict.py

@@ -0,0 +1,18 @@
+from sqlobject import SQLObject, StringCol
+from sqlobject.tests.dbtest import setupClass
+
+
+########################################
+# sqlmeta.asDict()
+########################################
+
+
+class SOTestAsDict(SQLObject):
+    name = StringCol(length=10)
+    name2 = StringCol(length=10)
+
+
+def test_asDict():
+    setupClass(SOTestAsDict, force=True)
+    t1 = SOTestAsDict(name='one', name2='1')
+    assert t1.sqlmeta.asDict() == dict(name='one', name2='1', id=1)