class TestSavedTypes(unittest.TestCase):
def setUp(self):
class MyTestEntity(Entity):
declared_params = { "some_param": "string" }
self.MyTestEntity = MyTestEntity
self.connection = Connection.test()
self.connection.create_tables()
self.m = Mapper(self.connection)
self.m.register(self.MyTestEntity)
def tearDown(self):
self.connection.drop_tables()
# need to dispose manually to avoid too many connections error
self.connection.engine.dispose()
def test_entity_type_is_correct(self):
ent = self.MyTestEntity(some_param = "a short string")
self.assertEqual(ent.type, "MyTestEntity")
self.assertEqual(ent._type, "MyTestEntity_0b97eed8bcd1ab0ceb7370dd2f9d8cb9")
self.m.save(ent)
self.assertEqual(ent.type, "MyTestEntity")
self.assertEqual(ent._type, "MyTestEntity_0b97eed8bcd1ab0ceb7370dd2f9d8cb9")
found = self.m.find(Entity).one()
self.assertEqual(found.type, "MyTestEntity")
self.assertEqual(found._type, "MyTestEntity_0b97eed8bcd1ab0ceb7370dd2f9d8cb9")
def test_entity_type_is_class_name(self):
ent = self.MyTestEntity(some_param = "a short string")
self.assertEqual(ent._type, ent.__class__.__name__)
def test_polymorphic_id_is_type(self):
ent = self.MyTestEntity(some_param = "a short string")
self.assertEqual(ent._type, ent.__mapper_args__["polymorphic_identity"])
class TestTypeMagic(unittest.TestCase):
def setUp(self):
self.connection = Connection.test()
self.connection.create_tables()
self.m = Mapper(self.connection)
def tearDown(self):
self.connection.drop_tables()
# need to dispose manually to avoid too many connections error
self.connection.engine.dispose()
def test_rebrand(self):
class E0(Entity):
declared_params = {
"q": "integer"
}
class E1(Entity):
declared_params = {
"q": "integer",
"q1": "integer"
}
e0 = E0(q=100)
self.m.save(e0)
self.m.rebrand(E0, E1)
# trying to load something from e0 now raises
self.assertRaises(DetachedInstanceError, lambda: e0.type)
self.assertRaises(DetachedInstanceError, lambda: dict(e0.params)) # lazy, so we call dict
e1 = self.m.find_roots()[0]
#self.m.session.expunge(e1)
import pdb
#pdb.set_trace()
self.assertEqual(e1._type, E1.__name__)
self.assertEqual(e1.params["q"], 100)
e1.params["q"] = 0
e1.params["q1"] = 0
def test_multi_step_rebrand(self):
class MyEntity1(Entity):
declared_params = {
"name": "string",
"version": "integer"
}
class MyEntity2a(Entity):
declared_params = {
"name": "string",
"version": "integer",
"version_string": "string",
"release_date": "date"
}
class MyEntity2b(Entity):
declared_params = {
"name": "string",
"version_string": "string",
"release_date": "date"
}
class MyEntity3(Entity):
declared_params = {
"name": "string",
"version": "string",
"release_date": "date"
}
orig_entities = [
MyEntity1(name="abc", version=1),
MyEntity1(name="def", version=2),
MyEntity1(name="ghi", version=3),
MyEntity1(name="jkl", version=4),
MyEntity1(name="mno", version=5),
MyEntity1(name="pqr", version=6),
MyEntity1(name="stu", version=7)
]
self.m.save(*orig_entities)
def change_version_string_add_date(e, params):
params["version_string"] = str(params["version"])
del params["version"]
params["release_date"] = datetime.date.today()
return params
def change_version_string(e, params):
params["version"] = params["version_string"]
del params["version_string"]
return params
self.assertEqual(len(self.m.find(MyEntity1).all()), 7)
self.assertEqual(len(self.m.find(MyEntity3).all()), 0)
version_1 = [e.params["version"] for e in self.m.find(MyEntity1)]
self.assertEqual(len(version_1), 7)
self.assertTrue(all(type(v)==int for v in version_1))
# we cannot rebrand directly:
self.assertRaises(ValueError, self.m.rebrand, MyEntity1, MyEntity3)
# do the rebranding
self.m.rebrand(MyEntity1, MyEntity2a, after=change_version_string_add_date)
# still won’t work to do this directly
self.assertRaises(ValueError, self.m.rebrand, MyEntity2a, MyEntity3)
self.m.rebrand(MyEntity2a, MyEntity2b)
self.m.rebrand(MyEntity2b, MyEntity3, after=change_version_string)
self.assertEqual(len(self.m.find(MyEntity1).all()), 0)
self.assertEqual(len(self.m.find(MyEntity3).all()), 7)
version_3 = [e.params["version"] for e in self.m.find(MyEntity3)]
self.assertEqual(len(version_3), 7)
self.assertTrue(all(isinstance(v, basestring) for v in version_3))
from xdapy import Mapper, Connection, Entity
connection = Connection.default()
m = Mapper(connection)
from objects import Experiment, Observer, Trial, Session
m.register(Experiment, Observer, Trial, Session)
print set(str(o.parent) for o in m.find_all("Session"))
obs = m.find("Observer", {"name": "%Frank%"}).all()
print obs[0].data
import pdb
pdb.set_trace()
#print m.find_with("Session").parent(m.find("Observer", {"name": ["%Alex%", "%Frank%"]})).all()
from xdapy.operators import gt, lt
#trials = m.find_with("Trial", {"_id": lambda id: id*id < 300}).parent(m.find_with("Session", {"_id": lt(300)}).parent(m.find("Observer", {"name": "%Alex%"}))).all()
trials = m.find_with("Trial", {"_id": lambda id: id*id < 300,
"_parent": ("Session", {"_id": lt(300), "_parent": ("Observer", {"name": "%Alex%"})}),
"_with": lambda entity: entity.id != 10})
# find_complex is more powerful but does not use SQLAlchemy
class TestAll(unittest.TestCase):
def setUp(self):
self.connection = Connection.test()
self.connection.create_tables()
self.mapper = Mapper(self.connection)
#register params
self.mapper.register(Observer, Experiment, Session, Trial)
#_register_parameter('Observer', 'name', 'string')
#self.p._register_parameter('Observer', 'age', 'integer')
#self.p._register_parameter('Observer', 'handedness', 'string')
#self.p._register_parameter('Experiment', 'project', 'string')
#self.p._register_parameter('Experiment', 'experimenter', 'string')
#self.p._register_parameter('Session', 'date', 'string')
#self.p._register_parameter('Trial', 'time', 'string')
#self.p._register_parameter('Trial', 'rt', 'integer')
#self.p._register_parameter('Trial', 'valid', 'integer')
#self.p._register_parameter('Trial', 'response', 'string')
#create hierarchy
self.e1 = Experiment(project='MyProject', experimenter="John Doe")
self.e2 = Experiment(project='YourProject', experimenter="Jeanne Done")
self.o3 = Observer(name="Max Mustermann", handedness="right", age=26)
self.o4 = Observer(name="Susanne Sorgenfrei", handedness='left', age=38)
self.o5 = Observer(name="Susi Sorgen", handedness='left', age=40)
self.s6 = Session(date='2009-08-20')
self.s7 = Session(date='2009-09-21')
self.s8 = Session(date='2009-09-22')
self.s9 = Session(date='2009-09-23')
self.s10 = Session(date='2009-09-24')
self.t11 = Trial(rt=int(randint(100, 3000)), valid=True, response='left')
self.t12 = Trial(rt=randint(100, 3000), valid=True, response='right')
self.t13 = Trial(rt=randint(100, 3000), valid=True, response='left')
self.t14 = Trial(rt=randint(100, 3000), valid=True, response='right')
self.t15 = Trial(rt=randint(100, 3000), valid=True, response='left')
self.t16 = Trial(rt=randint(100, 3000), valid=True, response='right')
self.t17 = Trial(rt=randint(100, 3000), valid=True, response='left')
self.t18 = Trial(rt=randint(100, 3000), valid=False, response='right')
self.t19 = Trial(rt=randint(100, 3000), valid=False, response='left')
self.t20 = Trial(rt=randint(100, 3000), valid=False, response='right')
self.t21 = Trial(rt=randint(100, 3000), valid=False, response='left')
self.t22 = Trial(rt=randint(100, 3000), valid=False, response='right')
self.t23 = Trial(rt=randint(100, 3000), valid=False, response='left')
self.t24 = Trial(rt=randint(100, 3000), valid=False, response='right')
self.mapper.save(self.e1, self.e2, self.o3, self.o4, self.o5, self.s6,
self.s7, self.s8, self.s9, self.s10, self.t11, self.t12,
self.t13, self.t14, self.t15, self.t16, self.t17, self.t18,
self.t19, self.t20, self.t21, self.t22, self.t23, self.t24)
self.e1.children.append(self.o3)
self.e1.children.append(self.o4)
self.e2.children.append(self.o4)
self.o3.children.append(self.s6)
self.o3.children.append(self.s7)
self.o4.children.append(self.s8)#, self.e1) # TODO: Children can be saved twice
#self.o4.children.append(self.s8)#, self.e2)
self.o4.children.append(self.s9)#, self.e2)
self.o4.children.append(self.s10)#, self.e2)
self.s6.children.append(self.t11)
self.s6.children.append(self.t12)
self.s7.children.append(self.t13)
self.s7.children.append(self.t14)
#self.s8.children.append(self.t15, self.e1)
#self.s8.children.append(self.t16, self.e1)
#self.s8.children.append(self.t17, self.e2)
self.s9.children.append(self.t18)
self.s9.children.append(self.t19)
self.s9.children.append(self.t20)
self.s10.children.append(self.t21)
self.s10.children.append(self.t22)
self.s10.children.append(self.t23)
self.s10.children.append(self.t24)
self.mapper.save(self.e1, self.e2, self.o3, self.o4, self.o5, self.s6,
self.s7, self.s8, self.s9, self.s10, self.t11, self.t12,
self.t13, self.t14, self.t15, self.t16, self.t17, self.t18,
self.t19, self.t20, self.t21, self.t22, self.t23, self.t24)
def tearDown(self):
self.connection.drop_tables()
# need to dispose manually to avoid too many connections error
self.connection.engine.dispose()
def testReturn(self):
self.assertEqual(self.mapper.find_first(Observer(name="Susanne Sorgenfrei")).children, [self.s8, self.s9, self.s10])
self.assertEqual(self.mapper.find_first(Observer(name="Susi Sorgen")).children, [])
self.assertEqual(self.mapper.find_first(Observer(name="Max Mustermann")).children, [self.s6, self.s7])
self.assertEqual(self.mapper.find_first("Observer", {"name": "Max Mustermann"}).children, [self.s6, self.s7])
self.assertEqual(self.mapper.find("Trial").count(), 14)
self.assertEqual(self.mapper.find_first("Observer", {"name": "Max"}, {"strict": False}).children, [self.s6, self.s7])
self.assertEqual(self.mapper.find_first(Observer(name="Max"), options={"strict": False}).children, [self.s6, self.s7])
self.assertEqual(self.mapper.find_first(Session(date='2009-09-24')), self.s10)
self.assertEqual(self.mapper.find_all(Session, {"date": "2009"}, options={"strict": False, "convert_string": True}), [self.s6, self.s7, self.s8, self.s9, self.s10])
# self.assertEqual(self.mapper.find_all(Session, {"date": "2009-09"}, options={"strict": False, "convert_string": True}), [self.s7, self.s8, self.s9, self.s10])
self.assertEqual(self.mapper.find_all(Session, {"date": "2009-08"}, options={"strict": False, "convert_string": True}), [self.s6])
experiment1 = Experiment(project="Fake Experiment", experimenter="Aaron Duindam")
experiment2 = Experiment(project="Complex Experiment", experimenter="Yasmin J. Winter")
observer1 = Observer(name=u"Irena Albertsdóttir", age=44)
observer2 = Observer(name="Semrawit Welde", age=28)
observer3 = Observer(name="Giraldo Ortega Rico", age=18)
observer4 = Observer(name="Isabel Blomqvist", age=47)
m.save(experiment1, experiment2, observer1, observer2, observer3, observer4)
#print m.toXML()
# find an object…
from xdapy.operators import *
print m.find_all(Experiment, {'experimenter': "John Do"})
print m.find(Experiment, {'experimenter': "John Do"}).all()
print m.find(Experiment, {'experimenter': "John Do"}).first()
print m.find_all(Experiment(experimenter="John Do"))
print m.find_all(Experiment, {'experimenter': "%J%"})
print m.find_all(Observer, filter={"name": "%Blom%"})
print m.find_all(Observer, filter={"name": ["%"]})
print m.find_all(Observer, filter={"age": range(30, 50), "name": ["%Alb%"]})
print m.find_all(Observer, filter={"age": between(30, 50)})
print m.find_all(Observer, filter={"age": 18})
print m.find_all(Observer, filter={"age": gt(20)})
#print m.find_all(Session, filter={"date": ge(datetime.date.today())})
# Example for sqlalchemy query syntax
