sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/inheritance/tests/test_asdict.py

@@ -0,0 +1,48 @@
+from sqlobject import StringCol
+from sqlobject.inheritance import InheritableSQLObject
+from sqlobject.tests.dbtest import setupClass
+
+########################################
+# sqlmeta.asDict
+########################################
+
+
+class InheritablePersonAD(InheritableSQLObject):
+    firstName = StringCol()
+    lastName = StringCol(alternateID=True, length=100)
+
+
+class ManagerAD(InheritablePersonAD):
+    department = StringCol()
+
+
+class EmployeeAD(InheritablePersonAD):
+    _inheritable = False
+    so_position = StringCol()
+
+
+def test_getColumns():
+    setupClass([InheritablePersonAD, ManagerAD, EmployeeAD])
+
+    for klass, columns in (
+            (InheritablePersonAD, ['firstName', 'lastName']),
+            (ManagerAD, ['department', 'firstName', 'lastName']),
+            (EmployeeAD, ['firstName', 'lastName', 'so_position'])):
+        _columns = sorted(klass.sqlmeta.getColumns().keys())
+        assert _columns == columns
+
+
+def test_asDict():
+    setupClass([InheritablePersonAD, ManagerAD, EmployeeAD], force=True)
+    InheritablePersonAD(firstName='Oneof', lastName='Authors')
+    ManagerAD(firstName='ManagerAD', lastName='The', department='Dep')
+    EmployeeAD(firstName='Project', lastName='Leader',
+               so_position='Project leader')
+
+    assert InheritablePersonAD.get(1).sqlmeta.asDict() == \
+        dict(firstName='Oneof', lastName='Authors', id=1)
+    assert InheritablePersonAD.get(2).sqlmeta.asDict() == \
+        dict(firstName='ManagerAD', lastName='The', department='Dep', id=2)
+    assert InheritablePersonAD.get(3).sqlmeta.asDict() == \
+        dict(firstName='Project', lastName='Leader',
+             so_position='Project leader', id=3)

sqlobject/inheritance/tests/test_deep_inheritance.py

@@ -0,0 +1,114 @@
+from pytest import raises, skip
+from sqlobject import ForeignKey, MultipleJoin, StringCol
+from sqlobject.inheritance import InheritableSQLObject
+from sqlobject.tests.dbtest import getConnection, setupClass, supports
+
+########################################
+# Deep Inheritance
+########################################
+
+
+class DIPerson(InheritableSQLObject):
+    firstName = StringCol(length=100)
+    lastName = StringCol(alternateID=True, length=100)
+    manager = ForeignKey("DIManager", default=None)
+
+
+class DIEmployee(DIPerson):
+    so_position = StringCol(unique=True, length=100)
+
+
+class DIManager(DIEmployee):
+    subdudes = MultipleJoin("DIPerson", joinColumn="manager_id")
+
+
+def test_creation_fail():
+    """
+    Try to create a Manager without specifying a position.
+    This should fail without leaving any partial records in
+    the database.
+
+    """
+    setupClass([DIManager, DIEmployee, DIPerson])
+
+    kwargs = {'firstName': 'John', 'lastname': 'Doe'}
+    raises(TypeError, DIManager, **kwargs)
+    persons = DIEmployee.select(DIPerson.q.firstName == 'John')
+    assert persons.count() == 0
+
+
+def test_creation_fail2():
+    """
+    Try to create two Managers with the same position.
+    This should fail without leaving any partial records in
+    the database.
+
+    """
+    setupClass([DIManager, DIEmployee, DIPerson])
+
+    kwargs = {'firstName': 'John', 'lastName': 'Doe',
+              'so_position': 'Project Manager'}
+    DIManager(**kwargs)
+    persons = DIEmployee.select(DIPerson.q.firstName == 'John')
+    assert persons.count() == 1
+
+    kwargs = {'firstName': 'John', 'lastName': 'Doe II',
+              'so_position': 'Project Manager'}
+    raises(Exception, DIManager, **kwargs)
+    persons = DIPerson.select(DIPerson.q.firstName == 'John')
+    assert persons.count() == 1
+
+    if not supports('transactions'):
+        skip("Transactions aren't supported")
+    transaction = DIPerson._connection.transaction()
+    kwargs = {'firstName': 'John', 'lastName': 'Doe III',
+              'so_position': 'Project Manager'}
+    raises(Exception, DIManager, connection=transaction, **kwargs)
+    transaction.rollback()
+    transaction.begin()
+    persons = DIPerson.select(DIPerson.q.firstName == 'John',
+                              connection=transaction)
+    assert persons.count() == 1
+
+
+def test_deep_inheritance():
+    conn = getConnection()
+    if conn.module.__name__ == 'mysql.connector' \
+            and conn.connector_type == 'mysql.connector-python':
+        skip("connector-python falls into an infinite loop here")
+
+    setupClass([DIManager, DIEmployee, DIPerson])
+
+    manager = DIManager(firstName='Project', lastName='Manager',
+                        so_position='Project Manager')
+    manager_id = manager.id
+    employee_id = DIEmployee(firstName='Project', lastName='Leader',
+                             so_position='Project leader', manager=manager).id
+    DIPerson(firstName='Oneof', lastName='Authors', manager=manager)
+
+    cache = conn.cache
+    cache.clear()
+
+    managers = list(DIManager.select())
+    assert len(managers) == 1
+    cache.clear()
+
+    employees = list(DIEmployee.select())
+    assert len(employees) == 2
+    cache.clear()
+
+    persons = list(DIPerson.select())
+    assert len(persons) == 3
+    cache.clear()
+
+    person = DIPerson.get(employee_id)
+    assert isinstance(person, DIEmployee)
+
+    person = DIPerson.get(manager_id)
+    assert isinstance(person, DIEmployee)
+    assert isinstance(person, DIManager)
+    cache.clear()
+
+    person = DIEmployee.get(manager_id)
+    assert isinstance(person, DIManager)
+    conn.close()

sqlobject/inheritance/tests/test_destroy_cascade.py

@@ -0,0 +1,23 @@
+from sqlobject import ForeignKey, IntCol, SQLObject
+from sqlobject.inheritance import InheritableSQLObject
+from sqlobject.tests.dbtest import setupClass
+
+
+class SOTestCascade1(InheritableSQLObject):
+    dummy = IntCol()
+
+
+class SOTestCascade2(SOTestCascade1):
+    c = ForeignKey('SOTestCascade3', cascade='null')
+
+
+class SOTestCascade3(SQLObject):
+    dummy = IntCol()
+
+
+def test_destroySelf():
+    setupClass([SOTestCascade1, SOTestCascade3, SOTestCascade2])
+
+    c = SOTestCascade3(dummy=1)
+    SOTestCascade2(cID=c.id, dummy=1)
+    c.destroySelf()

sqlobject/inheritance/tests/test_foreignKey.py

@@ -0,0 +1,94 @@
+from sqlobject import ForeignKey, SQLObject, StringCol
+from sqlobject.tests.dbtest import setupClass
+from sqlobject.inheritance import InheritableSQLObject
+
+
+class Note(SQLObject):
+    text = StringCol()
+
+
+class PersonWithNotes(InheritableSQLObject):
+    firstName = StringCol()
+    lastName = StringCol()
+    note = ForeignKey("Note", default=None)
+
+
+class Paper(SQLObject):
+    content = StringCol()
+
+
+class EmployeeWithNotes(PersonWithNotes):
+    _inheritable = False
+    paper = ForeignKey("Paper", default=None)
+
+
+def test_foreignKey():
+    setupClass([Note, PersonWithNotes, Paper, EmployeeWithNotes], force=True)
+
+    note = Note(text="person")
+    PersonWithNotes(firstName='Oneof', lastName='Authors', note=note)
+    note = Note(text="employee")
+    EmployeeWithNotes(firstName='Project', lastName='Leader', note=note)
+
+    paper = Paper(content="secret")
+    EmployeeWithNotes(firstName='Senior', lastName='Clerk', paper=paper)
+    PersonWithNotes(firstName='Some', lastName='Person')
+
+    person = PersonWithNotes.get(1)
+    assert isinstance(person, PersonWithNotes) and \
+        not isinstance(person, EmployeeWithNotes)
+    assert person.note.text == "person"
+
+    employee = EmployeeWithNotes.get(2)
+    assert isinstance(employee, EmployeeWithNotes)
+    assert employee.note.text == "employee"
+    save_employee = employee
+
+    # comparison to None needed to build the right SQL expression
+    persons = PersonWithNotes.select(PersonWithNotes.q.noteID != None)  # noqa
+    assert persons.count() == 2
+
+    persons = PersonWithNotes.selectBy(noteID=person.note.id)
+    assert persons.count() == 1
+
+    # comparison to None needed to build the right SQL expression
+    employee = EmployeeWithNotes.select(
+        PersonWithNotes.q.noteID != None)  # noqa
+    assert employee.count() == 1
+
+    persons = PersonWithNotes.selectBy(noteID=person.note.id)
+    assert persons.count() == 1
+
+    persons = PersonWithNotes.selectBy(note=person.note)
+    assert persons.count() == 1
+
+    persons = PersonWithNotes.selectBy(note=None)
+    assert persons.count() == 2
+
+    employee = EmployeeWithNotes.selectBy(paperID=None)
+    assert employee.count() == 1
+
+    employee = EmployeeWithNotes.selectBy(paper=None)
+    assert employee.count() == 1
+
+    employee = EmployeeWithNotes.selectBy(note=save_employee.note,
+                                          paper=save_employee.paper)
+    assert employee.count() == 1
+
+    employee = EmployeeWithNotes.selectBy()
+    assert employee.count() == 2
+
+
+class SOTestInhBase(InheritableSQLObject):
+    pass
+
+
+class SOTestInhFKey(SOTestInhBase):
+    base = ForeignKey("SOTestInhBase")
+
+
+def test_foreignKey2():
+    setupClass([SOTestInhBase, SOTestInhFKey])
+
+    test = SOTestInhBase()
+    SOTestInhFKey(base=test)

sqlobject/inheritance/tests/test_indexes.py

@@ -0,0 +1,42 @@
+from sqlobject import DatabaseIndex, IntCol, StringCol
+from sqlobject.tests.dbtest import setupClass
+from sqlobject.inheritance import InheritableSQLObject
+
+
+class InhPersonIdxGet(InheritableSQLObject):
+    first_name = StringCol(notNone=True, length=100)
+    last_name = StringCol(notNone=True, length=100)
+    age = IntCol()
+    pk = DatabaseIndex(first_name, last_name, unique=True)
+
+
+class InhEmployeeIdxGet(InhPersonIdxGet):
+    security_number = IntCol()
+    experience = IntCol()
+    sec_index = DatabaseIndex(security_number, unique=True)
+
+
+class InhSalesManIdxGet(InhEmployeeIdxGet):
+    _inheritable = False
+    skill = IntCol()
+
+
+def test_index_get_1():
+    setupClass([InhPersonIdxGet, InhEmployeeIdxGet, InhSalesManIdxGet])
+
+    InhSalesManIdxGet(first_name='Michael', last_name='Pallin', age=65,
+                      security_number=2304, experience=2, skill=10)
+    InhEmployeeIdxGet(first_name='Eric', last_name='Idle', age=63,
+                      security_number=3402, experience=9)
+    InhPersonIdxGet(first_name='Terry', last_name='Guilliam', age=64)
+
+    InhPersonIdxGet.pk.get('Michael', 'Pallin')
+    InhEmployeeIdxGet.pk.get('Michael', 'Pallin')
+    InhSalesManIdxGet.pk.get('Michael', 'Pallin')
+    InhPersonIdxGet.pk.get('Eric', 'Idle')
+    InhEmployeeIdxGet.pk.get('Eric', 'Idle')
+    InhPersonIdxGet.pk.get(first_name='Terry', last_name='Guilliam')
+    InhEmployeeIdxGet.sec_index.get(2304)
+    InhEmployeeIdxGet.sec_index.get(3402)
+    InhSalesManIdxGet.sec_index.get(2304)
+    InhSalesManIdxGet.sec_index.get(3402)

sqlobject/inheritance/tests/test_inheritance.py

@@ -0,0 +1,164 @@
+import pytest
+from pytest import raises
+from sqlobject import IntCol, StringCol
+from sqlobject.inheritance import InheritableSQLObject
+from sqlobject.tests.dbtest import getConnection, setupClass
+
+
+try:
+    connection = getConnection()
+except (AttributeError, NameError):
+    # The module was imported during documentation building
+    pass
+else:
+    if connection.module.__name__ == 'mysql.connector' \
+            and connection.connector_type == 'mysql.connector-python':
+        pytestmark = pytest.mark.skip(
+            "connector-python falls into an infinite loop here")
+
+
+########################################
+# Inheritance
+########################################
+
+
+class InheritablePerson(InheritableSQLObject):
+    firstName = StringCol(length=100)
+    lastName = StringCol(alternateID=True, length=100)
+
+
+class Employee(InheritablePerson):
+    _inheritable = False
+    so_position = StringCol(length=100)
+
+
+def setup():
+    setupClass(InheritablePerson)
+    setupClass(Employee)
+
+    Employee(firstName='Project', lastName='Leader',
+             so_position='Project leader')
+    InheritablePerson(firstName='Oneof', lastName='Authors')
+
+
+def test_creation_fail():
+    setup()
+    kwargs = {'firstName': 'John', 'lastname': 'Doe'}
+    raises(TypeError, Employee, **kwargs)
+    persons = InheritablePerson.select(InheritablePerson.q.firstName == 'John')
+    assert persons.count() == 0
+
+
+def test_inheritance():
+    setup()
+
+    persons = InheritablePerson.select()  # all
+    for person in persons:
+        assert isinstance(person, InheritablePerson)
+        if isinstance(person, Employee):
+            assert not hasattr(person, "childName")
+        else:
+            assert hasattr(person, "childName")
+            assert not person.childName
+
+
+def test_inheritance_select():
+    setup()
+
+    # comparison to None needed to build the right SQL expression
+    persons = InheritablePerson.select(
+        InheritablePerson.q.firstName != None)  # noqa
+    assert persons.count() == 2
+
+    persons = InheritablePerson.select(InheritablePerson.q.firstName == "phd")
+    assert persons.count() == 0
+
+    # comparison to None needed to build the right SQL expression
+    employees = Employee.select(Employee.q.firstName != None)  # noqa
+    assert employees.count() == 1
+
+    employees = Employee.select(Employee.q.firstName == "phd")
+    assert employees.count() == 0
+
+    # comparison to None needed to build the right SQL expression
+    employees = Employee.select(Employee.q.so_position != None)  # noqa
+    assert employees.count() == 1
+
+    persons = InheritablePerson.selectBy(firstName="Project")
+    assert persons.count() == 1
+    assert isinstance(persons[0], Employee)
+
+    persons = Employee.selectBy(firstName="Project")
+    assert persons.count() == 1
+
+    try:
+        person = InheritablePerson.byLastName("Oneof")
+    except Exception:
+        pass
+    else:
+        raise RuntimeError("unknown person %s" % person)
+
+    person = InheritablePerson.byLastName("Leader")
+    assert person.firstName == "Project"
+
+    person = Employee.byLastName("Leader")
+    assert person.firstName == "Project"
+
+    persons = list(InheritablePerson.select(
+        orderBy=InheritablePerson.q.lastName))
+    assert len(persons) == 2
+
+    persons = list(InheritablePerson.select(orderBy=(
+        InheritablePerson.q.lastName, InheritablePerson.q.firstName)))
+    assert len(persons) == 2
+
+    persons = list(Employee.select(orderBy=Employee.q.lastName))
+    assert len(persons) == 1
+
+    persons = list(Employee.select(orderBy=(Employee.q.lastName,
+                                            Employee.q.firstName)))
+    assert len(persons) == 1
+
+    persons = list(Employee.select(orderBy=Employee.q.so_position))
+    assert len(persons) == 1
+
+    persons = list(Employee.select(orderBy=(Employee.q.so_position,
+                                            Employee.q.lastName)))
+    assert len(persons) == 1
+
+
+def test_addDelColumn():
+    setup()
+
+    assert hasattr(InheritablePerson, "firstName")
+    assert hasattr(Employee, "firstName")
+    assert hasattr(InheritablePerson.q, "firstName")
+    assert hasattr(Employee.q, "firstName")
+
+    Employee.sqlmeta.addColumn(IntCol('runtime', default=None))
+
+    assert not hasattr(InheritablePerson, 'runtime')
+    assert hasattr(Employee, 'runtime')
+    assert not hasattr(InheritablePerson.q, 'runtime')
+    assert hasattr(Employee.q, 'runtime')
+
+    InheritablePerson.sqlmeta.addColumn(IntCol('runtime2', default=None))
+
+    assert hasattr(InheritablePerson, 'runtime2')
+    assert hasattr(Employee, 'runtime2')
+    assert hasattr(InheritablePerson.q, 'runtime2')
+    assert hasattr(Employee.q, 'runtime2')
+
+    Employee.sqlmeta.delColumn('runtime')
+
+    assert not hasattr(InheritablePerson, 'runtime')
+    assert not hasattr(Employee, 'runtime')
+    assert not hasattr(InheritablePerson.q, 'runtime')
+    assert not hasattr(Employee.q, 'runtime')
+
+    InheritablePerson.sqlmeta.delColumn('runtime2')
+
+    assert not hasattr(InheritablePerson, 'runtime2')
+    assert not hasattr(Employee, 'runtime2')
+    assert not hasattr(InheritablePerson.q, 'runtime2')
+    assert not hasattr(Employee.q, 'runtime2')

sqlobject/inheritance/tests/test_inheritance_tree.py

@@ -0,0 +1,50 @@
+from pytest import skip
+from sqlobject import StringCol
+from sqlobject.inheritance import InheritableSQLObject
+from sqlobject.tests.dbtest import getConnection, setupClass
+
+########################################
+# Inheritance Tree
+########################################
+
+
+class Tree1(InheritableSQLObject):
+    aprop = StringCol(length=10)
+
+
+class Tree2(Tree1):
+    bprop = StringCol(length=10)
+
+
+class Tree3(Tree1):
+    cprop = StringCol(length=10)
+
+
+class Tree4(Tree2):
+    dprop = StringCol(length=10)
+
+
+class Tree5(Tree2):
+    eprop = StringCol(length=10)
+
+
+def test_tree():
+    conn = getConnection()
+    if conn.module.__name__ == 'mysql.connector' \
+            and conn.connector_type == 'mysql.connector-python':
+        skip("connector-python falls into an infinite loop here")
+
+    setupClass([Tree1, Tree2, Tree3, Tree4, Tree5])
+
+    Tree1(aprop='t1')  # t1
+    t2 = Tree2(aprop='t2', bprop='t2')
+    Tree3(aprop='t3', cprop='t3')  # t3
+    t4 = Tree4(aprop='t4', bprop='t4', dprop='t4')
+    t5 = Tree5(aprop='t5', bprop='t5', eprop='t5')
+
+    # find just the t5 out of childs from Tree2
+    assert t5 == Tree1.select(Tree2.q.childName == 'Tree5')[0]
+
+    # t2,t4,t5 are all subclasses of Tree1 with t1 childName of 'Tree2'
+    assert list(Tree1.select(
+        Tree1.q.childName == 'Tree2', orderBy="aprop")) == [t2, t4, t5]