349 lines
12 KiB
Python
349 lines
12 KiB
Python
# dabmodel (c) by chacha
|
|
#
|
|
# dabmodel is licensed under a
|
|
# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
|
|
#
|
|
# You should have received a copy of the license along with this
|
|
# work. If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
|
|
|
|
import unittest
|
|
|
|
import sys
|
|
import subprocess
|
|
from os import chdir, environ
|
|
from pathlib import Path
|
|
|
|
print(__name__)
|
|
print(__package__)
|
|
|
|
from src import dabmodel as dm
|
|
|
|
testdir_path = Path(__file__).parent.resolve()
|
|
chdir(testdir_path.parent.resolve())
|
|
|
|
|
|
class ElementTest(unittest.TestCase):
|
|
def setUp(self):
|
|
print("\n->", unittest.TestCase.id(self))
|
|
|
|
def test_element_simple(self):
|
|
class E(dm.Element):
|
|
ivalue: int = 43
|
|
strvalue: str = "test"
|
|
fvalue: float = 1.4322
|
|
ar_int: list[int] = [1, 54, 65]
|
|
ar_int2: list[int] = [1, 54, 65]
|
|
|
|
class A(dm.Appliance):
|
|
elem: E = E(ivalue=45, strvalue="coucou", ar_int=[5, 7])
|
|
|
|
a = A()
|
|
|
|
self.assertIsInstance(a.elem, E)
|
|
self.assertIsInstance(a.elem.ivalue, int)
|
|
self.assertEqual(a.elem.ivalue, 45)
|
|
self.assertIsInstance(a.elem.strvalue, str)
|
|
self.assertEqual(a.elem.strvalue, "coucou")
|
|
self.assertIsInstance(a.elem.fvalue, float)
|
|
self.assertEqual(a.elem.fvalue, 1.4322)
|
|
self.assertIsInstance(a.elem.ar_int, tuple)
|
|
self.assertEqual(a.elem.ar_int, (5, 7))
|
|
self.assertIsInstance(a.elem.ar_int2, tuple)
|
|
self.assertEqual(a.elem.ar_int2, (1, 54, 65))
|
|
|
|
def test_element_in_container(self):
|
|
class E(dm.Element):
|
|
ivalue: int = 43
|
|
strvalue: str = "test"
|
|
fvalue: float = 1.4322
|
|
ar_int: list[int] = [1, 54, 65]
|
|
ar_int2: list[int] = [1, 54, 65]
|
|
|
|
class A(dm.Appliance):
|
|
elems: list[E] = [
|
|
E(ivalue=45, strvalue="coucou", ar_int=[5, 7]),
|
|
E(ivalue=46, strvalue="coucou2", ar_int=[50, 7]),
|
|
]
|
|
|
|
a = A()
|
|
|
|
self.assertIsInstance(a.elems, tuple)
|
|
self.assertEqual(len(a.elems), 2)
|
|
|
|
self.assertIsInstance(a.elems[0], E)
|
|
self.assertIsInstance(a.elems[0].ivalue, int)
|
|
self.assertEqual(a.elems[0].ivalue, 45)
|
|
self.assertIsInstance(a.elems[0].strvalue, str)
|
|
self.assertEqual(a.elems[0].strvalue, "coucou")
|
|
self.assertIsInstance(a.elems[0].fvalue, float)
|
|
self.assertEqual(a.elems[0].fvalue, 1.4322)
|
|
self.assertIsInstance(a.elems[0].ar_int, tuple)
|
|
self.assertEqual(a.elems[0].ar_int, (5, 7))
|
|
self.assertIsInstance(a.elems[0].ar_int2, tuple)
|
|
self.assertEqual(a.elems[0].ar_int2, (1, 54, 65))
|
|
|
|
self.assertIsInstance(a.elems[1], E)
|
|
self.assertIsInstance(a.elems[1].ivalue, int)
|
|
self.assertEqual(a.elems[1].ivalue, 46)
|
|
self.assertIsInstance(a.elems[1].strvalue, str)
|
|
self.assertEqual(a.elems[1].strvalue, "coucou2")
|
|
self.assertIsInstance(a.elems[1].fvalue, float)
|
|
self.assertEqual(a.elems[1].fvalue, 1.4322)
|
|
self.assertIsInstance(a.elems[1].ar_int, tuple)
|
|
self.assertEqual(a.elems[1].ar_int, (50, 7))
|
|
self.assertIsInstance(a.elems[1].ar_int2, tuple)
|
|
self.assertEqual(a.elems[1].ar_int2, (1, 54, 65))
|
|
|
|
def test_element_frozen(self):
|
|
class E(dm.Element):
|
|
ivalue: int = 43
|
|
strvalue: str = "test"
|
|
fvalue: float = 1.4322
|
|
ar_int: list[int] = [1, 54, 65]
|
|
ar_int2: list[int] = [1, 54, 65]
|
|
|
|
class A(dm.Appliance):
|
|
elems: list[E] = [
|
|
E(ivalue=45, strvalue="coucou", ar_int=[5, 7]),
|
|
E(ivalue=46, strvalue="coucou2", ar_int=[50, 7]),
|
|
]
|
|
elem: E = E()
|
|
|
|
a = A()
|
|
|
|
with self.assertRaises(AttributeError):
|
|
a.elems.add(E())
|
|
|
|
with self.assertRaises(dm.ReadOnlyField):
|
|
a.elem.ivalue = 1
|
|
|
|
with self.assertRaises(dm.ReadOnlyField):
|
|
a.elems[0].ivalue = 1
|
|
|
|
def test_element_inheritance(self):
|
|
class E(dm.Element):
|
|
ivalue: int = 43
|
|
strvalue: str = "test"
|
|
fvalue: float = 1.4322
|
|
ar_int: list[int] = [1, 54, 65]
|
|
ar_int2: list[int] = [1, 54, 65]
|
|
|
|
class E2(E):
|
|
ivalue2: int = 43
|
|
|
|
class A(dm.Appliance):
|
|
elems: list[E] = [
|
|
E(ivalue=45, strvalue="coucou", ar_int=[5, 7]),
|
|
E2(ivalue=46, strvalue="coucou2", ar_int=[50, 7], ivalue2=32),
|
|
]
|
|
elem: E = E()
|
|
elem2: E2 = E2(ivalue=7, ivalue2=33)
|
|
|
|
a = A()
|
|
|
|
self.assertIsInstance(a.elems, tuple)
|
|
self.assertEqual(len(a.elems), 2)
|
|
|
|
self.assertIsInstance(a.elems[0], E)
|
|
self.assertIsInstance(a.elems[0].ivalue, int)
|
|
self.assertEqual(a.elems[0].ivalue, 45)
|
|
self.assertIsInstance(a.elems[0].strvalue, str)
|
|
self.assertEqual(a.elems[0].strvalue, "coucou")
|
|
self.assertIsInstance(a.elems[0].fvalue, float)
|
|
self.assertEqual(a.elems[0].fvalue, 1.4322)
|
|
self.assertIsInstance(a.elems[0].ar_int, tuple)
|
|
self.assertEqual(a.elems[0].ar_int, (5, 7))
|
|
self.assertIsInstance(a.elems[0].ar_int2, tuple)
|
|
self.assertEqual(a.elems[0].ar_int2, (1, 54, 65))
|
|
|
|
self.assertIsInstance(a.elems[1], E2)
|
|
self.assertIsInstance(a.elems[1].ivalue, int)
|
|
self.assertEqual(a.elems[1].ivalue, 46)
|
|
self.assertIsInstance(a.elems[1].ivalue2, int)
|
|
self.assertEqual(a.elems[1].ivalue2, 32)
|
|
self.assertIsInstance(a.elems[1].strvalue, str)
|
|
self.assertEqual(a.elems[1].strvalue, "coucou2")
|
|
self.assertIsInstance(a.elems[1].fvalue, float)
|
|
self.assertEqual(a.elems[1].fvalue, 1.4322)
|
|
self.assertIsInstance(a.elems[1].ar_int, tuple)
|
|
self.assertEqual(a.elems[1].ar_int, (50, 7))
|
|
self.assertIsInstance(a.elems[1].ar_int2, tuple)
|
|
self.assertEqual(a.elems[1].ar_int2, (1, 54, 65))
|
|
|
|
self.assertIsInstance(a.elem, E)
|
|
self.assertIsInstance(a.elem.ivalue, int)
|
|
self.assertEqual(a.elem.ivalue, 43)
|
|
self.assertIsInstance(a.elem.strvalue, str)
|
|
self.assertEqual(a.elem.strvalue, "test")
|
|
self.assertIsInstance(a.elem.fvalue, float)
|
|
self.assertEqual(a.elem.fvalue, 1.4322)
|
|
self.assertIsInstance(a.elem.ar_int, tuple)
|
|
self.assertEqual(a.elem.ar_int, (1, 54, 65))
|
|
self.assertIsInstance(a.elem.ar_int2, tuple)
|
|
self.assertEqual(a.elem.ar_int2, (1, 54, 65))
|
|
|
|
self.assertIsInstance(a.elem2, E2)
|
|
self.assertIsInstance(a.elem2.ivalue, int)
|
|
self.assertEqual(a.elem2.ivalue, 7)
|
|
self.assertIsInstance(a.elem2.ivalue2, int)
|
|
self.assertEqual(a.elem2.ivalue2, 33)
|
|
self.assertIsInstance(a.elem2.strvalue, str)
|
|
self.assertEqual(a.elem2.strvalue, "test")
|
|
self.assertIsInstance(a.elem2.fvalue, float)
|
|
self.assertEqual(a.elem2.fvalue, 1.4322)
|
|
self.assertIsInstance(a.elem2.ar_int, tuple)
|
|
self.assertEqual(a.elem2.ar_int, (1, 54, 65))
|
|
self.assertIsInstance(a.elem2.ar_int2, tuple)
|
|
self.assertEqual(a.elem2.ar_int2, (1, 54, 65))
|
|
|
|
def test_element_initializer(self):
|
|
class E(dm.Element):
|
|
ivalue: int = 43
|
|
strvalue: str = "test"
|
|
fvalue: float = 1.4322
|
|
ar_int: list[int] = [1, 54, 65]
|
|
ar_int2: list[int] = [1, 54, 65]
|
|
|
|
class A(dm.Appliance):
|
|
elem: E = E(ivalue=45, strvalue="coucou", ar_int=[5, 7])
|
|
|
|
@classmethod
|
|
def __initializer(self):
|
|
self.elem = E(ivalue=12, strvalue="coucou", ar_int=[5, 7])
|
|
|
|
a = A()
|
|
|
|
self.assertIsInstance(a.elem, E)
|
|
self.assertIsInstance(a.elem.ivalue, int)
|
|
self.assertEqual(a.elem.ivalue, 12)
|
|
self.assertIsInstance(a.elem.strvalue, str)
|
|
self.assertEqual(a.elem.strvalue, "coucou")
|
|
self.assertIsInstance(a.elem.fvalue, float)
|
|
self.assertEqual(a.elem.fvalue, 1.4322)
|
|
self.assertIsInstance(a.elem.ar_int, tuple)
|
|
self.assertEqual(a.elem.ar_int, (5, 7))
|
|
self.assertIsInstance(a.elem.ar_int2, tuple)
|
|
self.assertEqual(a.elem.ar_int2, (1, 54, 65))
|
|
|
|
def test_element_in_container_initializer(self):
|
|
class E(dm.Element):
|
|
ivalue: int = 43
|
|
strvalue: str = "test"
|
|
fvalue: float = 1.4322
|
|
ar_int: list[int] = [1, 54, 65]
|
|
ar_int2: list[int] = [1, 54, 65]
|
|
|
|
class A(dm.Appliance):
|
|
elems: list[E] = [E(ivalue=45, strvalue="coucou", ar_int=[5, 7])]
|
|
|
|
class B(A):
|
|
@classmethod
|
|
def __initializer(cls):
|
|
cls.elems.append(E(ivalue=46, strvalue="coucou2", ar_int=[50, 7]))
|
|
|
|
a = A()
|
|
b = B()
|
|
|
|
self.assertIsInstance(a.elems, tuple)
|
|
self.assertEqual(len(a.elems), 1)
|
|
|
|
self.assertIsInstance(a.elems[0], E)
|
|
self.assertIsInstance(a.elems[0].ivalue, int)
|
|
self.assertEqual(a.elems[0].ivalue, 45)
|
|
self.assertIsInstance(a.elems[0].strvalue, str)
|
|
self.assertEqual(a.elems[0].strvalue, "coucou")
|
|
self.assertIsInstance(a.elems[0].fvalue, float)
|
|
self.assertEqual(a.elems[0].fvalue, 1.4322)
|
|
self.assertIsInstance(a.elems[0].ar_int, tuple)
|
|
self.assertEqual(a.elems[0].ar_int, (5, 7))
|
|
self.assertIsInstance(a.elems[0].ar_int2, tuple)
|
|
self.assertEqual(a.elems[0].ar_int2, (1, 54, 65))
|
|
|
|
self.assertIsInstance(b.elems, tuple)
|
|
self.assertEqual(len(b.elems), 2)
|
|
|
|
self.assertIsInstance(b.elems[0], E)
|
|
self.assertIsInstance(b.elems[0].ivalue, int)
|
|
self.assertEqual(b.elems[0].ivalue, 45)
|
|
self.assertIsInstance(b.elems[0].strvalue, str)
|
|
self.assertEqual(b.elems[0].strvalue, "coucou")
|
|
self.assertIsInstance(b.elems[0].fvalue, float)
|
|
self.assertEqual(b.elems[0].fvalue, 1.4322)
|
|
self.assertIsInstance(b.elems[0].ar_int, tuple)
|
|
self.assertEqual(b.elems[0].ar_int, (5, 7))
|
|
self.assertIsInstance(b.elems[0].ar_int2, tuple)
|
|
self.assertEqual(b.elems[0].ar_int2, (1, 54, 65))
|
|
|
|
self.assertIsInstance(b.elems[1], E)
|
|
self.assertIsInstance(b.elems[1].ivalue, int)
|
|
self.assertEqual(b.elems[1].ivalue, 46)
|
|
self.assertIsInstance(b.elems[1].strvalue, str)
|
|
self.assertEqual(b.elems[1].strvalue, "coucou2")
|
|
self.assertIsInstance(b.elems[1].fvalue, float)
|
|
self.assertEqual(b.elems[1].fvalue, 1.4322)
|
|
self.assertIsInstance(b.elems[1].ar_int, tuple)
|
|
self.assertEqual(b.elems[1].ar_int, (50, 7))
|
|
self.assertIsInstance(b.elems[1].ar_int2, tuple)
|
|
self.assertEqual(b.elems[1].ar_int2, (1, 54, 65))
|
|
|
|
def test_method(self):
|
|
class E(dm.Element):
|
|
ivalue: int = 43
|
|
|
|
def get_increment(self) -> int:
|
|
return self.ivalue + 1
|
|
|
|
def increment(self) -> int:
|
|
return type(self)(ivalue=self.ivalue + 1)
|
|
|
|
class A(dm.Appliance):
|
|
elem: E = E(ivalue=45)
|
|
|
|
a = A()
|
|
|
|
self.assertIsInstance(a.elem, E)
|
|
self.assertEqual(a.elem.ivalue, 45)
|
|
self.assertEqual(a.elem.get_increment(), 46)
|
|
|
|
class B(A):
|
|
|
|
@classmethod
|
|
def __initializer(cls):
|
|
cls.elem = cls.elem.increment()
|
|
|
|
b = B()
|
|
|
|
self.assertEqual(b.elem.ivalue, 46)
|
|
self.assertEqual(b.elem.get_increment(), 47)
|
|
|
|
def test_initializer_appliance_function_forbidden(self):
|
|
def test_fun() -> int:
|
|
return 12
|
|
|
|
class E(dm.Element):
|
|
ivalue: int = 43
|
|
|
|
with self.assertRaises(dm.FunctionForbidden):
|
|
|
|
class B(dm.Element):
|
|
elem: E = E()
|
|
|
|
@classmethod
|
|
def __initializer(cls):
|
|
cls.elem.ivalue = test_fun()
|
|
|
|
with self.assertRaises(dm.FunctionForbidden):
|
|
|
|
class B(dm.Element):
|
|
elem: E = E()
|
|
|
|
@classmethod
|
|
def __initializer(cls):
|
|
cls.elem = E(ivalue=test_fun())
|
|
|
|
|
|
# ---------- main ----------
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|