def test_tag_objects(self):
family2 = Family(family=u'family2')
self.session.add(family2)
self.session.commit()
family1_id = self.family.id
family2_id = family2.id
tag_plugin.tag_objects('test', [self.family, family2])
# we do not offer gettin object by string
# get object by tag
tag = self.session.query(Tag).filter_by(tag=u'test').one()
tagged_objs = tag.objects
sorted_pairs = sorted([(type(o), o.id) for o in tagged_objs])
self.assertEquals(sorted([(Family, family1_id),
(Family, family2_id)]),
sorted_pairs)
tag_plugin.tag_objects('test', [self.family, family2])
self.assertEquals(tag.objects, [self.family, family2])
#
# now untag everything
#
tag_plugin.untag_objects('test', [self.family, family2])
# get object by tag
tag = self.session.query(Tag).filter_by(tag=u'test').one()
tagged_objs = tag.objects
self.assertEquals(tagged_objs, [])
def test_tag_objects(self):
family2 = Family(epithet=u'family2')
self.session.add(family2)
self.session.commit()
family1_id = self.family.id
family2_id = family2.id
tag_plugin.tag_objects('test', [self.family, family2])
# we do not offer gettin object by string
# get object by tag
tag = self.session.query(Tag).filter_by(tag=u'test').one()
tagged_objs = tag.objects
sorted_pairs = sorted([(type(o), o.id) for o in tagged_objs])
self.assertEquals(sorted([(Family, family1_id),
(Family, family2_id)]),
sorted_pairs)
tag_plugin.tag_objects('test', [self.family, family2])
self.assertEquals(tag.objects, [self.family, family2])
#
# now untag everything
#
tag_plugin.untag_objects('test', [self.family, family2])
# get object by tag
tag = self.session.query(Tag).filter_by(tag=u'test').one()
tagged_objs = tag.objects
self.assertEquals(tagged_objs, [])
def test_get_all_plants(self):
"""
Test getting the plants from different types
"""
get_ids = lambda objs: sorted([o.id for o in objs])
# get plants from one family
family = self.session.query(Family).get(1)
ids = get_ids(get_all_plants(family, self.session))
self.assert_(ids == range(1, 17), ids)
# get plants from multiple families
family = self.session.query(Family).get(1)
family2 = self.session.query(Family).get(2)
ids = get_ids(get_all_plants([family, family2], self.session))
self.assert_(ids == range(1, 33), ids)
genus = self.session.query(Genus).get(1)
ids = get_ids(get_all_plants(genus, self.session))
self.assert_(ids == range(1, 9), ids)
species = self.session.query(Species).get(1)
ids = get_ids(get_all_plants(species, self.session))
self.assert_(ids == range(1, 5), ids)
accession = self.session.query(Accession).get(1)
ids = get_ids(get_all_plants(accession, self.session))
self.assert_(ids == range(1, 3), ids)
plant = self.session.query(Plant).get(1)
ids = get_ids(get_all_plants(plant, self.session))
self.assert_(ids == [1], ids)
location = self.session.query(Location).get(1)
plants = get_all_plants([location], self.session)
plant_ids = sorted([p.id for p in plants])
self.assert_(plant_ids == [1], plant_ids)
vn = self.session.query(VernacularName).get(1)
ids = get_ids(get_all_plants(vn, self.session))
self.assert_(ids == range(1, 5), ids)
tag_objects('test', [family, genus])
tag = self.session.query(Tag).filter_by(tag=u'test').one()
ids = get_ids(get_all_plants(tag, self.session))
self.assert_(ids == range(1, 17), ids)
# now test all the objects
plants = get_all_plants([family, genus, species, accession, plant,
location], self.session)
ids = get_ids(plants)
self.assert_(ids == range(1, 17), ids)
def test_get_plants_pertinent_to(self):
"""
Test getting the plants from different types
"""
get_ids = lambda objs: sorted([o.id for o in objs])
# get plants from one family
family = self.session.query(Family).get(1)
ids = get_ids(get_plants_pertinent_to(family, self.session))
self.assert_(ids == range(1, 17), ids)
# get plants from multiple families
family = self.session.query(Family).get(1)
family2 = self.session.query(Family).get(2)
ids = get_ids(get_plants_pertinent_to([family, family2], self.session))
self.assert_(ids == range(1, 33), ids)
genus = self.session.query(Genus).get(1)
ids = get_ids(get_plants_pertinent_to(genus, self.session))
self.assert_(ids == range(1, 9), ids)
species = self.session.query(Species).get(1)
ids = get_ids(get_plants_pertinent_to(species, self.session))
self.assert_(ids == range(1, 5), ids)
accession = self.session.query(Accession).get(1)
ids = get_ids(get_plants_pertinent_to(accession, self.session))
self.assert_(ids == range(1, 3), ids)
plant = self.session.query(Plant).get(1)
ids = get_ids(get_plants_pertinent_to(plant, self.session))
self.assert_(ids == [1], ids)
location = self.session.query(Location).get(1)
plants = get_plants_pertinent_to([location], self.session)
plant_ids = sorted([p.id for p in plants])
self.assert_(plant_ids == [1], plant_ids)
vn = self.session.query(VernacularName).get(1)
ids = get_ids(get_plants_pertinent_to(vn, self.session))
self.assert_(ids == range(1, 5), ids)
tag_objects('test', [family, genus])
tag = self.session.query(Tag).filter_by(tag=u'test').one()
ids = get_ids(get_plants_pertinent_to(tag, self.session))
self.assert_(ids == range(1, 17), ids)
# now test all the objects
plants = get_plants_pertinent_to(
[family, genus, species, accession, plant, location], self.session)
ids = get_ids(plants)
self.assert_(ids == range(1, 17), ids)
def test_get_accessions_pertinent_to(self):
"""
Test getting the accessions from different types
"""
get_ids = lambda objs: sorted([o.id for o in objs])
family = self.session.query(Family).get(1)
ids = get_ids(get_accessions_pertinent_to([family], self.session))
self.assert_(ids == range(1, 9), ids)
family = self.session.query(Family).get(1)
family2 = self.session.query(Family).get(1)
ids = get_ids(
get_accessions_pertinent_to([family, family2], self.session))
self.assert_(ids == range(1, 9), ids)
genus = self.session.query(Genus).get(1)
ids = get_ids(get_accessions_pertinent_to(genus, self.session))
self.assert_(ids == range(1, 5), ids)
species = self.session.query(Species).get(1)
ids = get_ids(get_accessions_pertinent_to(species, self.session))
self.assert_(ids == [1, 2], ids)
accession = self.session.query(Accession).get(1)
ids = get_ids(get_accessions_pertinent_to([accession], self.session))
self.assert_(ids == [1], ids)
plant = self.session.query(Plant).get(1)
ids = get_ids(get_accessions_pertinent_to([plant], self.session))
self.assert_(ids == [1], ids)
location = self.session.query(Location).get(1)
ids = get_ids(get_accessions_pertinent_to([location], self.session))
self.assert_(ids == [1], ids)
vn = self.session.query(VernacularName).get(1)
ids = get_ids(get_accessions_pertinent_to([vn], self.session))
self.assert_(ids == [1, 2], ids)
tag_objects('test', [family, genus])
tag = self.session.query(Tag).filter_by(tag=u'test').one()
ids = get_ids(get_accessions_pertinent_to([tag], self.session))
self.assert_(ids == range(1, 9), ids)
# now test all the objects
ids = get_ids(
get_accessions_pertinent_to(
[family, genus, species, accession, plant, location],
self.session))
self.assert_(ids == range(1, 9), ids)
def test_get_accessions_pertinent_to(self):
"""
Test getting the accessions from different types
"""
get_ids = lambda objs: sorted([o.id for o in objs])
family = self.session.query(Family).get(1)
ids = get_ids(get_accessions_pertinent_to([family], self.session))
self.assert_(ids == range(1, 9), ids)
family = self.session.query(Family).get(1)
family2 = self.session.query(Family).get(1)
ids = get_ids(get_accessions_pertinent_to(
[family, family2], self.session))
self.assert_(ids == range(1, 9), ids)
genus = self.session.query(Genus).get(1)
ids = get_ids(get_accessions_pertinent_to(genus, self.session))
self.assert_(ids == range(1, 5), ids)
species = self.session.query(Species).get(1)
ids = get_ids(get_accessions_pertinent_to(species, self.session))
self.assert_(ids == [1, 2], ids)
accession = self.session.query(Accession).get(1)
ids = get_ids(get_accessions_pertinent_to([accession], self.session))
self.assert_(ids == [1], ids)
plant = self.session.query(Plant).get(1)
ids = get_ids(get_accessions_pertinent_to([plant], self.session))
self.assert_(ids == [1], ids)
location = self.session.query(Location).get(1)
ids = get_ids(get_accessions_pertinent_to([location], self.session))
self.assert_(ids == [1], ids)
vn = self.session.query(VernacularName).get(1)
ids = get_ids(get_accessions_pertinent_to([vn], self.session))
self.assert_(ids == [1, 2], ids)
tag_objects('test', [family, genus])
tag = self.session.query(Tag).filter_by(tag=u'test').one()
ids = get_ids(get_accessions_pertinent_to([tag], self.session))
self.assert_(ids == range(1, 9), ids)
# now test all the objects
ids = get_ids(get_accessions_pertinent_to(
[family, genus, species, accession, plant, location],
self.session))
self.assert_(ids == range(1, 9), ids)
def test_get_tag_ids(self):
family2 = Family(family=u'family2')
self.session.add(family2)
self.session.commit()
tag_plugin.tag_objects('test', [self.family, family2])
tag_plugin.tag_objects('test2', [self.family])
# test we only return the ids the objects have in common
#sel = select([tag_table.c.id], tag_table.c.tag==u'test')
results = self.session.query(Tag.id).filter_by(tag=u'test')
test_id = [r[0] for r in results]
# should only return id for "test"
ids = tag_plugin.get_tag_ids([self.family, family2])
self.assert_(ids == test_id, '%s==%s' % (ids, test_id))
# test that we return multiple tag ids if the objs share tags
tag_plugin.tag_objects('test2', [family2])
#sel = select([tag_table.c.id], or_(tag_table.c.tag==u'test',
# tag_table.c.tag==u'test2'))
results = self.session.query(Tag.id).filter(or_(Tag.tag == u'test',
Tag.tag == u'test2'))
test_id = sorted([r[0] for r in results])
# should return ids for both test and test2
ids = sorted(tag_plugin.get_tag_ids([self.family, family2]))
self.assert_(ids == test_id, '%s == %s' % (ids, test_id))
def test_get_tag_ids(self):
family2 = Family(family=u'family2')
self.session.add(family2)
self.session.commit()
tag_plugin.tag_objects('test', [self.family, family2])
tag_plugin.tag_objects('test2', [self.family])
# test we only return the ids the objects have in common
#sel = select([tag_table.c.id], tag_table.c.tag==u'test')
results = self.session.query(Tag.id).filter_by(tag=u'test')
test_id = [r[0] for r in results]
# should only return id for "test"
ids = tag_plugin.get_tag_ids([self.family, family2])
self.assert_(ids == test_id, '%s==%s' % (ids, test_id))
# test that we return multiple tag ids if the objs share tags
tag_plugin.tag_objects('test2', [family2])
#sel = select([tag_table.c.id], or_(tag_table.c.tag==u'test',
# tag_table.c.tag==u'test2'))
results = self.session.query(Tag.id).filter(
or_(Tag.tag == u'test', Tag.tag == u'test2'))
test_id = sorted([r[0] for r in results])
# should return ids for both test and test2
ids = sorted(tag_plugin.get_tag_ids([self.family, family2]))
self.assert_(ids == test_id, '%s == %s' % (ids, test_id))
def test_tag_objects(self):
family2 = Family(family=u'family2')
self.session.add(family2)
self.session.commit()
family1_id = self.family.id
family2_id = family2.id
tag_plugin.tag_objects('test', [self.family, family2])
# get object by string
tagged_objs = tag_plugin.get_tagged_objects('test')
sorted_pairs = sorted([(type(o), o.id) for o in tagged_objs],
cmp=lambda x, y: cmp(x[0], y[0]))
self.assert_(sorted_pairs == [(Family, family1_id),
(Family, family2_id)],
sorted_pairs)
# get object by tag
tag = self.session.query(Tag).filter_by(tag=u'test').one()
tagged_objs = tag_plugin.get_tagged_objects(tag)
sorted_pairs = sorted([(type(o), o.id) for o in tagged_objs],
cmp=lambda x, y: cmp(x[0], y[0]))
self.assert_(sorted_pairs == [(Family, family1_id),
(Family, family2_id)],
sorted_pairs)
tag_plugin.tag_objects('test', [self.family, family2])
#
# now untag everything
#
tag_plugin.untag_objects('test', [self.family, family2])
# get object by string
tagged_objs = tag_plugin.get_tagged_objects('test')
pairs = [(type(o), o.id) for o in tagged_objs]
self.assert_(pairs == [], pairs)
# get object by tag
tag = self.session.query(Tag).filter_by(tag=u'test').one()
tagged_objs = tag_plugin.get_tagged_objects(tag)
def test_tag_objects(self):
family2 = Family(family=u'family2')
self.session.add(family2)
self.session.commit()
family1_id = self.family.id
family2_id = family2.id
tag_plugin.tag_objects('test', [self.family, family2])
# get object by string
tagged_objs = tag_plugin.get_tagged_objects('test')
sorted_pairs = sorted([(type(o), o.id) for o in tagged_objs],
cmp=lambda x, y: cmp(x[0], y[0]))
self.assert_(
sorted_pairs == [(Family, family1_id), (Family, family2_id)],
sorted_pairs)
# get object by tag
tag = self.session.query(Tag).filter_by(tag=u'test').one()
tagged_objs = tag_plugin.get_tagged_objects(tag)
sorted_pairs = sorted([(type(o), o.id) for o in tagged_objs],
cmp=lambda x, y: cmp(x[0], y[0]))
self.assert_(
sorted_pairs == [(Family, family1_id), (Family, family2_id)],
sorted_pairs)
tag_plugin.tag_objects('test', [self.family, family2])
#
# now untag everything
#
tag_plugin.untag_objects('test', [self.family, family2])
# get object by string
tagged_objs = tag_plugin.get_tagged_objects('test')
pairs = [(type(o), o.id) for o in tagged_objs]
self.assert_(pairs == [], pairs)
# get object by tag
tag = self.session.query(Tag).filter_by(tag=u'test').one()
tagged_objs = tag_plugin.get_tagged_objects(tag)
def test_attached_tags_many(self):
fam = self.session.query(Family).one()
tags = self.session.query(Tag).all()
for t in tags:
tag_plugin.tag_objects(t, [fam])
self.assertEquals(Tag.attached_to(fam), tags)
def test_attached_tags_singleton(self):
fam = self.session.query(Family).one()
obj2 = self.session.query(Tag).filter(Tag.tag == u'maderable').one()
tag_plugin.tag_objects(obj2, [fam])
self.assertEquals(Tag.attached_to(fam), [obj2])
def test_attached_tags_many(self):
fam = self.session.query(Family).one()
tags = self.session.query(Tag).all()
for t in tags:
tag_plugin.tag_objects(t, [fam])
self.assertEquals(Tag.attached_to(fam), tags)
def test_attached_tags_singleton(self):
fam = self.session.query(Family).one()
obj2 = self.session.query(Tag).filter(Tag.tag == u'maderable').one()
tag_plugin.tag_objects(obj2, [fam])
self.assertEquals(Tag.attached_to(fam), [obj2])
