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])
class TestJson(unittest.TestCase):
def setUp(self):
"""Create test database in memory"""
self.connection = Connection.test()
self.connection.create_tables()
self.mapper = 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_null_import(self):
json = """
{ "types": [],
"objects": [],
"relations": []
}"""
jio = JsonIO(self.mapper)
objs = jio.read_string(json)
self.assertEqual(len(objs), 0)
def test_unknown_types(self):
json = """
{ "types": [{"type": "A"}, {"type": "B"}],
"objects": [{"type": "A"}, {"type": "A"}, {"type": "A"}, {"type": "B"}],
"relations": []
}"""
jio = JsonIO(self.mapper)
self.assertRaises(InvalidInputError, jio.read_string, json)
def test_simple_import(self):
json = """
{ "types": [{"type": "A"}, {"type": "B"}],
"objects": [{"type": "A"}, {"type": "A"}, {"type": "A"}, {"type": "B"}],
"relations": []
}"""
jio = JsonIO(self.mapper, add_new_types=True)
objs = jio.read_string(json)
self.assertEqual(len(objs), 4)
def test_parameters(self):
json = """
{ "types": [
{ "type": "A",
"parameters": {
"s": "string",
"d": "datetime",
"i": "integer"
}
}
],
"objects": [
{ "type": "A",
"parameters": {
"s": "string",
"d": "2012-02-10T20:00:00",
"i": 12
} },
{ "type": "A" },
{ "type": "A" }
],
"relations": []
}"""
jio = JsonIO(self.mapper, add_new_types=True)
objs = jio.read_string(json)
self.assertEqual(len(objs), 3)
self.assertEqual(objs[0].params["s"], "string")
self.assertEqual(objs[0].params["d"], datetime.datetime(2012, 2, 10, 20, 0, 0))
self.assertEqual(objs[0].params["i"], 12)
def test_parameters_as_dict(self):
json = { "types": [
{ "type": "A",
"parameters": {
"s": "string",
"d": "datetime"
}
}
],
"objects": [
{ "type": "A",
"parameters": {
"s": "string",
"d": "2012-02-10T20:00:00"
} },
{ "type": "A",
"parameters": {
"d": datetime.datetime(2012, 2, 10, 20, 0, 0)
}},
{ "type": "A" }
],
"relations": []
}
jio = JsonIO(self.mapper, add_new_types=True)
objs = jio.read_json(json)
self.assertEqual(len(objs), 3)
self.assertEqual(objs[0].params["s"], "string")
self.assertEqual(objs[0].params["d"], datetime.datetime(2012, 2, 10, 20, 0, 0))
def test_children(self):
json = {
"types": [{ "type": "A", "parameters": { "s": "string" } }],
"objects": [
{ "type": "A",
"id": 1,
"parameters": { "s": "parent1" }
},
{ "type": "A",
"parameters": { "s": "parent2" },
"children": [
{ "type": "A",
"parameters": { "s": "child21" }
},
{ "type": "A",
"parameters": { "s": "child22" }
},
]
},
{ "type": "A",
"id": 2,
"parameters": { "s": "child11" }
}
],
"relations": [
{
"relation": "child",
"from": "id:2",
"to": "id:1"
}
]
}
jio = JsonIO(self.mapper, add_new_types=True)
objs = jio.read_json(json)
self.assertEqual(len(objs), 5)
roots = self.mapper.find_roots()
self.assertEqual(set([roots[0].params["s"], roots[1].params["s"]]), set(["parent1", "parent2"]))
def test_data_export(self):
class SomeEntity(Entity):
declared_params = {"some_value": "string"}
obj = SomeEntity()
self.mapper.register(SomeEntity)
self.mapper.save(obj)
data_to_save = [("some key", "ABCDE", None),
("some other key", "ABCDEFGHIJ", "text")]
for (key, value, mimetype) in data_to_save:
obj.data[key].put(value)
if mimetype:
obj.data[key].mimetype = mimetype
# we create a named temporary file and just hope
# there is no conflict with the autodetected folder name
tmp_name = tempfile.mktemp()
jio = JsonIO(self.mapper, add_new_types=True)
jio.write_file(self.mapper.find_roots(), tmp_name)
# check that file has been written:
for (data_key, data_value, data_mimetype) in data_to_save:
data_file = os.path.join(tmp_name + ".data", obj.unique_id, data_key)
with open(data_file) as df:
self.assertEqual(df.read(), data_value)
with open(tmp_name) as tmp_file:
json_obj = json.load(tmp_file)
#print json_obj
jio_2 = JsonIO(self.mapper)
self.assertRaises(IntegrityError, jio_2.read_file, tmp_name)
self.mapper.delete(*self.mapper.find_roots())
jio_2 = JsonIO(self.mapper)
jio_2.read_file(tmp_name)
obj_in_db = self.mapper.find_first(SomeEntity)
for (data_key, data_value, data_mimetype) in data_to_save:
self.assertEqual(obj_in_db.data[data_key].get_string(), data_value)
self.assertEqual(obj_in_db.data[data_key].mimetype, data_mimetype)
print ""
obs_1.print_tree()
print ""
trial1_1.print_tree()
#exp_neptune.attach("C", obs_1)
from xdapy.structures import Context
print m.find_all(Context)
#m.delete(obs_1)
#print m.find_all(Context)
m.delete(*m.find_all(Context))
print m.find_all(Context)
print m.find_all(Experiment)
contx = m.find_first(Context)
#m.registerConnection(Experiment, Observer, "Observer")
exp_monorail.attach("Observer", obs_1)
from xdapy.io import XmlIO
xmlio = XmlIO(m, Entity.__subclasses__())
print xmlio.write()
db.drop_tables()
