def environment_created(self):
for table in db_default.schema:
create_table(self.env, table)
cache_manager = HttpRequestCacheManager(self.env)
po_manager = PersistentObjectManager(self.env)
for manager in cache_manager.managers:
model_class = manager.for_model()
if issubclass(model_class, PersistentObject):
module_name = model_class.__module__
# We don't want to create tables for dummy classes automatically
# but the test finder may load some of these managers so we
# need to exclude them here.
if ('tests.' not in module_name):
po_manager.create_table(model_class)
# Need to create Agilo types in the database before writing to the
# configuration - otherwise we get a warning during config setup (you'll
# see it in every test case during setUp)
db_default.create_default_types(self.env)
initialize_config(self.env, __CONFIG_PROPERTIES__)
db_default.create_default_backlogs(self.env)
super(AgiloInit, self).environment_created()
for listener in self.setup_listeners:
listener.agilo_was_installed()
# Reload the AgiloConfig to make sure all the changes have been updated
AgiloConfig(self.env).reload()
info(self, 'Agilo environment initialized')
def test_return_items_in_lists_as_dict(self):
PersistentObjectManager(self.env).create_table(MyCommandPO)
input = [MyCommandPO(self.env, name='foo')]
self.assert_equals([{
'name': 'foo',
'exists': False
}],
MyCommand(self.env).return_as_value_object(input))
def setUp(self):
self.super()
self.pom = PersistentObjectManager(self.env)
#FIXME: I don't know why, but putting the test to check if the table
# is created, after a while gives error. I didn't have the chance to
# check it through, but I guess it is related to the :memory: db that
# SQLite reallocate in the same position, so the new Env (which has
# a different Python id) is till pointing to the old InMemoryDatabase
self.pom.create_table(MyPO)
self.assert_true(self.pom.create_table(MyPOwithoutPK))
self.pomm = MyPOModelManager(self.env)
def testRaiseExceptionIfWrongTypeForPrimaryKeyIsUsed(self):
class FakeSprint(PersistentObject):
class Meta(object):
sprint = Field(primary_key=True)
class FakeContingent(PersistentObject):
class Meta(object):
name = Field(primary_key=True)
sprint = Relation(FakeSprint,
db_name='sprint',
primary_key=True)
PersistentObjectManager(self.env).create_table(FakeSprint)
PersistentObjectManager(self.env).create_table(FakeContingent)
FakeSprint(self.env, sprint='Alpha').save()
self.assert_raises(Exception,
FakeContingent,
self.env,
name='bugs',
sprint='Alpha')
def test_can_delete_items_with_id_field(self):
class AutoIncrementPrimaryKeyClass(PersistentObject):
class Meta(object):
id = Field(primary_key=True, auto_increment=True)
name = Field()
PersistentObjectManager(
self.env).create_table(AutoIncrementPrimaryKeyClass)
first = AutoIncrementPrimaryKeyClass(self.env)
first.save()
first.delete()
def testCanSelectWithCriteriaNone(self):
"""This is a bugfix test to check that the _old values for persistent
objects are set per instance and not on a class level."""
class MyPOWithNone(PersistentObject):
class Meta(object):
name = Field(primary_key=True)
value = Field()
PersistentObjectManager(self.env).create_table(MyPOWithNone)
obj1 = MyPOWithNone(self.env, name='foo')
obj1.save()
results = obj1.select(self.env, criteria={'value': None})
self.assert_equals(1, len(results))
def test_model_cache_can_handle_multiple_primary_keys(self):
"""Check that the model cache checks all primary keys for a match and
not only one of them."""
class MultiplePrimaryKeyModel(PersistentObject):
class Meta(object):
name = Field(primary_key=True)
sprint = Field(primary_key=True)
value = Field(type="real")
class MultiplePrimaryKeyModelManager(PersistentObjectModelManager):
model = MultiplePrimaryKeyModel
PersistentObjectManager(self.env).create_table(MultiplePrimaryKeyModel)
manager = MultiplePrimaryKeyModelManager(self.env)
manager.create(name='a', sprint='b', value=12)
self.assert_none(manager.get(name='a', sprint='c'))
def test_insert_omits_autoincrement_column(self):
class AutoIncrementPrimaryKeyClass(PersistentObject):
class Meta(object):
id = Field(primary_key=True, auto_increment=True)
name = Field()
PersistentObjectManager(
self.env).create_table(AutoIncrementPrimaryKeyClass)
first = AutoIncrementPrimaryKeyClass(self.env)
sql, parameters = first._sql_and_parameters_for_insert()
expected_sql = 'INSERT INTO agilo_auto_increment_primary_key_class (name) VALUES (%(name)s)'
self.assert_equals(expected_sql, sql)
# parameters contains id as well but that does not cause any problems
# safe_execute filters it out (very likely)
self.assert_contains('name', parameters)
def test_can_support_autoincrement(self):
class AutoIncrementPrimaryKeyClass(PersistentObject):
class Meta(object):
id = Field(primary_key=True, auto_increment=True)
name = Field()
PersistentObjectManager(
self.env).create_table(AutoIncrementPrimaryKeyClass)
first = AutoIncrementPrimaryKeyClass(self.env)
self.assert_none(first.id)
first.save()
self.assert_not_none(first.id)
second = AutoIncrementPrimaryKeyClass(self.env)
second.save()
self.assert_equals(first.id + 1, second.id)
def test__old_is_initialized_correctly_on_load_if_init_sets_a_default_value(
self):
class InitializerSetsDefault(PersistentObject):
class Meta(object):
scope = Field(primary_key=True)
def __init__(self, env, scope='global', **kwargs):
# simple_super can not cope with keyword arguments as Python
# provides no means to find out the difference between
# (**[]) and () so we have an explicit call here.
self.super(env, scope=scope, **kwargs)
PersistentObjectManager(self.env).create_table(InitializerSetsDefault)
first = InitializerSetsDefault(self.env, scope="Foo")
first.save()
found_objects = InitializerSetsDefault.select(self.env)
self.assert_length(1, found_objects)
self.assert_equals(dict(scope='Foo'), found_objects[0]._old)
def testOldValuesAreSetPerInstance(self):
"""This is a bugfix test to check that the _old values for persistent
objects are set per instance and not on a class level."""
class MyPOWithOld(PersistentObject):
class Meta(object):
name = Field(primary_key=True)
env = self.teh.get_env()
PersistentObjectManager(env).create_table(MyPOWithOld)
obj1 = MyPOWithOld(env, name='foo')
obj1.save()
obj2 = MyPOWithOld(env, name='bar')
obj2.save()
obj2.name = 'baz'
self.assert_equals({'name': 'bar'}, obj2._old)
self.assert_false(obj1._changed)
def setUp(self):
self.super()
# Register object with PersistentManager
PersistentObjectManager(self.env).create_table(MyModel)
def setUp(self):
self.super()
PersistentObjectManager(self.env).create_table(BurndownDataChange)
self.change = BurndownDataChange(self.env)
self.sprint = self.teh.create_sprint(self.sprint_name())
