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())