def test_multiple_same_objects(self): """ Tests initial data when registering the same object for deletion twice. """ class AccountInitialData1(BaseInitialData): """ Initial data code that registers the same object many times for deletion """ def update_initial_data(self): # Return the object from update_initial_data, thus registering it for deletion account = Account.objects.get_or_create()[0] return [account, account, account] # Verify no account objects exist self.assertEquals(Account.objects.count(), 0) with patch.object(InitialDataUpdater, 'load_app', return_value=AccountInitialData1): InitialDataUpdater().update_all_apps() InitialDataUpdater().update_all_apps() # Verify an account object was created and is managed by a deletion receipt self.assertEquals(Account.objects.count(), 1) self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 1)
def test_update_all_apps(self, update_app_patch): """ Verifies that update_app is called with all installed apps """ initial_data_manager = InitialDataUpdater() initial_data_manager.update_all_apps() self.assertEqual(2, update_app_patch.call_count)
def test_update_all_apps(self, update_app_patch): """ Verifies that update_app is called with all installed apps """ initial_data_manager = InitialDataUpdater() initial_data_manager.update_all_apps() self.assertEqual(2, update_app_patch.call_count)
def test_update_all_apps(self): """ Verifies that update_app is called with all installed apps """ num_apps = len(settings.INSTALLED_APPS) with patch('dynamic_initial_data.base.InitialDataUpdater.update_app', spec_set=True) as update_app_patch: initial_data_manager = InitialDataUpdater() initial_data_manager.update_all_apps() self.assertEqual(num_apps, update_app_patch.call_count)
def test_verbose_option(self): """ Verifies that the verbose option gets set from the manage options """ options = {'verbose': True} initial_data_manager = InitialDataUpdater(options) self.assertTrue(initial_data_manager.verbose) # cover the branch that prints if verbose is true initial_data_manager.log('test')
def test_load_app_cached(self, import_patch): """ Tests that the cache is hit since import is only called once. """ initial_data_updater = InitialDataUpdater() initial_data_updater.load_app('fake') initial_data_updater.load_app('fake') initial_data_updater.load_app('fake') self.assertEquals(import_patch.call_count, 1)
def test_verbose_option(self): """ Verifies that the verbose option gets set from the manage options """ options = {'verbose': True} initial_data_manager = InitialDataUpdater(options) self.assertTrue(initial_data_manager.verbose) # cover the branch that prints if verbose is true initial_data_manager.log('test')
def test_update_all_apps(self): """ Verifies that update_app is called with all installed apps """ num_apps = len(settings.INSTALLED_APPS) with patch('dynamic_initial_data.base.InitialDataUpdater.update_app', spec_set=True) as update_app_patch: initial_data_manager = InitialDataUpdater() initial_data_manager.update_all_apps() self.assertEqual(num_apps, update_app_patch.call_count)
def test_load_app(self): """ Tests the load_app method """ with patch('dynamic_initial_data.base.import_string') as import_patch: import_patch.return_value = MockInitialData initial_data_manager = InitialDataUpdater() self.assertEqual(MockInitialData, initial_data_manager.load_app('fake')) # try to load an app that doesn't exist initial_data_manager = InitialDataUpdater() import_patch.return_value = MockClass self.assertIsNone(initial_data_manager.load_app('fake'))
def test_update_app_cached_updated_apps(self, update_initial_data_patch, mock_load_app): """ Tests that the app gets added to updated apps and it is cached """ initial_data_manager = InitialDataUpdater() initial_data_manager.update_app('dynamic_initial_data') self.assertEqual(1, update_initial_data_patch.call_count) # make sure it doesn't call update static again initial_data_manager.update_app('dynamic_initial_data') self.assertEqual(1, update_initial_data_patch.call_count) # make sure the app is in the updated_apps list self.assertIn('dynamic_initial_data', initial_data_manager.updated_apps)
def test_get_dependency_call_list_circular_dependency( self, load_app_patch): """ Tests when a circular dependency is found """ with self.assertRaises(InitialDataCircularDependency): InitialDataUpdater().update_app('MockThree')
def test_handle_deletions_updates_registered_from_update_initial_data( self): """ Tests handling of deletions and updates when they are registered from the update_initial_data function. """ class AccountInitialData1(BaseInitialData): """ The initial data code the first time it is called. It registers two accounts for deletion by returning it from the update_initial_data function. """ def update_initial_data(self): # Register two account objects for deletion self.register_for_deletion( Account.objects.get_or_create(name='hi')[0], Account.objects.get_or_create(name='hi2')[0]) class AccountInitialData2(BaseInitialData): """ The initial data code the second time it is called. It only manages one of the previous accounts """ def update_initial_data(self): self.register_for_deletion( Account.objects.get_or_create(name='hi')[0]) # Verify no account objects exist self.assertEquals(Account.objects.count(), 0) with patch.object(InitialDataUpdater, 'load_app', return_value=AccountInitialData1): InitialDataUpdater().update_all_apps() # Verify two account objects were created and are managed by deletion receipts self.assertEquals(Account.objects.count(), 2) self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 2) # Run the initial data process again, this time deleting the account named 'hi2' with patch.object(InitialDataUpdater, 'load_app', return_value=AccountInitialData2): InitialDataUpdater().update_all_apps() # Verify only the 'hi' account exists self.assertEquals(Account.objects.count(), 1) self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 1) self.assertEquals( RegisteredForDeletionReceipt.objects.get().model_obj.name, 'hi')
def test_cant_delete_obj_in_receipt(self): """ Tests when the object in the receipt cant be deleted such as a deleted content type or another model that cant be cascaded. """ initial_data_updater = InitialDataUpdater() rel_model = G(RelModel) G(CantCascadeModel, rel_model=rel_model) RegisteredForDeletionReceipt.objects.create(model_obj=rel_model, register_time=datetime(2013, 4, 5)) account = G(Account) RegisteredForDeletionReceipt.objects.create(model_obj=account, register_time=datetime(2013, 4, 5)) initial_data_updater.model_objs_registered_for_deletion = [] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 2) with transaction.atomic(): initial_data_updater.handle_deletions() self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0)
def test_handle_deletions_returned_from_update_initial_data(self): """ Tests handling of deletions when they are returned from the update_initial_data function. """ class AccountInitialData1(BaseInitialData): """ The initial data code the first time it is called. It registers an account for deletion by returning it from the update_initial_data function. """ def update_initial_data(self): # Return the object from update_initial_data, thus registering it for deletion return [Account.objects.get_or_create()[0]] class AccountInitialData2(BaseInitialData): """ The initial data code the second time it is called. It no longer creates the account object, so the previously created account object should be deleted. """ def update_initial_data(self): pass # Verify no account objects exist self.assertEquals(Account.objects.count(), 0) with patch.object(InitialDataUpdater, 'load_app', return_value=AccountInitialData1): InitialDataUpdater().update_all_apps() # Verify an account object was created and is managed by a deletion receipt self.assertEquals(Account.objects.count(), 1) self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 1) # Run the initial data process again, this time not registering the account for # deletion. It should be deleted. with patch.object(InitialDataUpdater, 'load_app', return_value=AccountInitialData2): InitialDataUpdater().update_all_apps() # Verify there are no accounts or receipts self.assertEquals(Account.objects.count(), 0) self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0)
def test_cant_delete_obj_in_receipt(self): """ Tests when the object in the receipt cant be deleted such as a deleted content type or another model that cant be cascaded. """ initial_data_updater = InitialDataUpdater() rel_model = G(RelModel) G(CantCascadeModel, rel_model=rel_model) RegisteredForDeletionReceipt.objects.create(model_obj=rel_model, register_time=datetime( 2013, 4, 5)) account = G(Account) RegisteredForDeletionReceipt.objects.create(model_obj=account, register_time=datetime( 2013, 4, 5)) initial_data_updater.model_objs_registered_for_deletion = [] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 2) with transaction.atomic(): initial_data_updater.handle_deletions() self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0)
def test_get_dependency_call_list(self): """ Makes sure that dependency cycles are found and raises an exception """ initial_data_manager = InitialDataUpdater() with patch('dynamic_initial_data.base.InitialDataUpdater.load_app', spec_set=True) as load_app_patch: load_app_patch.return_value = MockThree with self.assertRaises(InitialDataCircularDependency): initial_data_manager.update_app('MockThree') initial_data_manager = InitialDataUpdater() with self.assertRaises(InitialDataMissingApp): initial_data_manager.get_dependency_call_list('fake')
def test_load_app_cached(self, import_patch): """ Tests that the cache is hit since import is only called once. """ initial_data_updater = InitialDataUpdater() initial_data_updater.load_app('fake') initial_data_updater.load_app('fake') initial_data_updater.load_app('fake') self.assertEquals(import_patch.call_count, 1)
def test_create_account(self): """ Tests creating a test account in the initial data process. """ class AccountInitialData(BaseInitialData): def update_initial_data(self): Account.objects.get_or_create() # Verify no account objects exist self.assertEquals(Account.objects.count(), 0) with patch.object(InitialDataUpdater, 'load_app', return_value=AccountInitialData) as load_app_mock: InitialDataUpdater().update_app('test_app') # It should be called twice - once for initial loading, and twice for dependency testing self.assertEquals(load_app_mock.call_count, 2) # Verify an account object was created self.assertEquals(Account.objects.count(), 1)
def test_load_app(self): """ Tests the load_app method """ with patch('dynamic_initial_data.base.import_string') as import_patch: import_patch.return_value = MockInitialData initial_data_manager = InitialDataUpdater() self.assertEqual(MockInitialData, initial_data_manager.load_app('fake')) # try to load an app that doesn't exist initial_data_manager = InitialDataUpdater() import_patch.return_value = MockClass self.assertIsNone(initial_data_manager.load_app('fake'))
def test_get_dependency_call_list(self): """ Makes sure that dependency cycles are found and raises an exception """ initial_data_manager = InitialDataUpdater() with patch('dynamic_initial_data.base.InitialDataUpdater.load_app', spec_set=True) as load_app_patch: load_app_patch.return_value = MockThree with self.assertRaises(InitialDataCircularDependency): initial_data_manager.update_app('MockThree') initial_data_manager = InitialDataUpdater() with self.assertRaises(InitialDataMissingApp): initial_data_manager.get_dependency_call_list('fake')
def test_update_app_dependencies(self, update_initial_data_patch2, update_initial_data_patch1): """ Tests the update_app method when there are dependencies. """ # test dependencies def app_loader(app): if app == 'MockOne': return MockOne else: return MockTwo with patch.object(InitialDataUpdater, 'load_app', side_effect=app_loader, spec_set=True): InitialDataUpdater().update_app('MockTwo') self.assertEqual(1, update_initial_data_patch1.call_count) self.assertEqual(1, update_initial_data_patch2.call_count)
def test_update_app_cached_updated_apps(self, update_initial_data_patch, mock_load_app): """ Tests that the app gets added to updated apps and it is cached """ initial_data_manager = InitialDataUpdater() initial_data_manager.update_app('dynamic_initial_data') self.assertEqual(1, update_initial_data_patch.call_count) # make sure it doesn't call update static again initial_data_manager.update_app('dynamic_initial_data') self.assertEqual(1, update_initial_data_patch.call_count) # make sure the app is in the updated_apps list self.assertIn('dynamic_initial_data', initial_data_manager.updated_apps)
class TestHandleDeletions(TestCase): """ Tests the handle_deletions functionality in the InitialDataUpater class. """ def setUp(self): super(TestHandleDeletions, self).setUp() self.initial_data_updater = InitialDataUpdater() def test_handle_deletions_no_objs(self): """ Tests when there are no objs to handle. The function should not raise any exceptions. """ self.initial_data_updater.handle_deletions() def test_create_one_obj(self): """ Tests creating one object to handle for deletion. """ account = G(Account) self.initial_data_updater.model_objs_registered_for_deletion = [ account ] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) with freeze_time('2013-04-12'): self.initial_data_updater.handle_deletions() receipt = RegisteredForDeletionReceipt.objects.get() self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account)) self.assertEquals(receipt.model_obj_id, account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) def test_create_dup_objs(self): """ Tests creating duplicate objects for deletion. """ account = G(Account) self.initial_data_updater.model_objs_registered_for_deletion = [ account, account ] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) with freeze_time('2013-04-12'): self.initial_data_updater.handle_deletions() receipt = RegisteredForDeletionReceipt.objects.get() self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account)) self.assertEquals(receipt.model_obj_id, account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) def test_create_dup_proxy_objs(self): """ Tests creating duplicate objects for deletion when one is a proxy of another. """ account = G(Account) proxy_account = ProxyAccount.objects.get(id=account.id) self.initial_data_updater.model_objs_registered_for_deletion = [ account, account, proxy_account ] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) with freeze_time('2013-04-12'): self.initial_data_updater.handle_deletions() self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 2) receipt = RegisteredForDeletionReceipt.objects.get( model_obj_type=ContentType.objects.get_for_model(account)) self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account)) self.assertEquals(receipt.model_obj_id, account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) receipt = RegisteredForDeletionReceipt.objects.get( model_obj_type=ContentType.objects.get_for_model( proxy_account, for_concrete_model=False)) self.assertEquals( receipt.model_obj_type, ContentType.objects.get_for_model(ProxyAccount, for_concrete_model=False)) self.assertEquals(receipt.model_obj_id, proxy_account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) def test_create_delete_one_obj(self): """ Tests creating one object to handle for deletion and then deleting it. """ account = G(Account) self.initial_data_updater.model_objs_registered_for_deletion = [ account ] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) with freeze_time('2013-04-12'): self.initial_data_updater.handle_deletions() receipt = RegisteredForDeletionReceipt.objects.get() self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account)) self.assertEquals(receipt.model_obj_id, account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) # Now, don't register the object for deletion and run it again at a different time self.initial_data_updater.model_objs_registered_for_deletion = [] with freeze_time('2013-04-12 05:00:00'): self.initial_data_updater.handle_deletions() # The object should be deleted, along with its receipt self.assertEquals(Account.objects.count(), 0) self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) def test_create_update_one_obj(self): """ Tests creating one object to handle for deletion and then updating it. """ account = G(Account) self.initial_data_updater.model_objs_registered_for_deletion = [ account ] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) with freeze_time('2013-04-12'): self.initial_data_updater.handle_deletions() receipt = RegisteredForDeletionReceipt.objects.get() self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account)) self.assertEquals(receipt.model_obj_id, account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) # Run the deletion handler again at a different time. It should not delete the object with freeze_time('2013-04-12 05:00:00'): self.initial_data_updater.handle_deletions() # The object should not be deleted, along with its receipt self.assertEquals(Account.objects.count(), 1) self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 1) self.assertEquals( RegisteredForDeletionReceipt.objects.get().register_time, datetime(2013, 4, 12, 5)) def test_delete_already_deleted_obj(self): """ Tests the case when an object that was registered for deletion has already been deleted. """ account = G(Account) self.initial_data_updater.model_objs_registered_for_deletion = [ account ] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) with freeze_time('2013-04-12'): self.initial_data_updater.handle_deletions() receipt = RegisteredForDeletionReceipt.objects.get() self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account)) self.assertEquals(receipt.model_obj_id, account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) # Delete the model object. The receipt should still exist account.delete() self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 1) # Now, don't register the object for deletion and run it again at a different time self.initial_data_updater.model_objs_registered_for_deletion = [] with freeze_time('2013-04-12 05:00:00'): self.initial_data_updater.handle_deletions() # The object should be deleted, along with its receipt self.assertEquals(Account.objects.count(), 0) self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0)
def setUp(self): super(TestHandleDeletions, self).setUp() self.initial_data_updater = InitialDataUpdater()
class TestHandleDeletions(TestCase): """ Tests the handle_deletions functionality in the InitialDataUpater class. """ def setUp(self): super(TestHandleDeletions, self).setUp() self.initial_data_updater = InitialDataUpdater() def test_handle_deletions_no_objs(self): """ Tests when there are no objs to handle. The function should not raise any exceptions. """ self.initial_data_updater.handle_deletions() def test_create_one_obj(self): """ Tests creating one object to handle for deletion. """ account = G(Account) self.initial_data_updater.model_objs_registered_for_deletion = [account] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) with freeze_time('2013-04-12'): self.initial_data_updater.handle_deletions() receipt = RegisteredForDeletionReceipt.objects.get() self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account)) self.assertEquals(receipt.model_obj_id, account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) def test_create_dup_objs(self): """ Tests creating duplicate objects for deletion. """ account = G(Account) self.initial_data_updater.model_objs_registered_for_deletion = [account, account] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) with freeze_time('2013-04-12'): self.initial_data_updater.handle_deletions() receipt = RegisteredForDeletionReceipt.objects.get() self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account)) self.assertEquals(receipt.model_obj_id, account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) def test_create_dup_proxy_objs(self): """ Tests creating duplicate objects for deletion when one is a proxy of another. """ account = G(Account) proxy_account = ProxyAccount.objects.get(id=account.id) self.initial_data_updater.model_objs_registered_for_deletion = [account, account, proxy_account] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) with freeze_time('2013-04-12'): self.initial_data_updater.handle_deletions() self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 2) receipt = RegisteredForDeletionReceipt.objects.get(model_obj_type=ContentType.objects.get_for_model(account)) self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account)) self.assertEquals(receipt.model_obj_id, account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) receipt = RegisteredForDeletionReceipt.objects.get( model_obj_type=ContentType.objects.get_for_model(proxy_account, for_concrete_model=False)) self.assertEquals( receipt.model_obj_type, ContentType.objects.get_for_model(ProxyAccount, for_concrete_model=False)) self.assertEquals(receipt.model_obj_id, proxy_account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) def test_create_delete_one_obj(self): """ Tests creating one object to handle for deletion and then deleting it. """ account = G(Account) self.initial_data_updater.model_objs_registered_for_deletion = [account] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) with freeze_time('2013-04-12'): self.initial_data_updater.handle_deletions() receipt = RegisteredForDeletionReceipt.objects.get() self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account)) self.assertEquals(receipt.model_obj_id, account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) # Now, don't register the object for deletion and run it again at a different time self.initial_data_updater.model_objs_registered_for_deletion = [] with freeze_time('2013-04-12 05:00:00'): self.initial_data_updater.handle_deletions() # The object should be deleted, along with its receipt self.assertEquals(Account.objects.count(), 0) self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) def test_create_update_one_obj(self): """ Tests creating one object to handle for deletion and then updating it. """ account = G(Account) self.initial_data_updater.model_objs_registered_for_deletion = [account] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) with freeze_time('2013-04-12'): self.initial_data_updater.handle_deletions() receipt = RegisteredForDeletionReceipt.objects.get() self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account)) self.assertEquals(receipt.model_obj_id, account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) # Run the deletion handler again at a different time. It should not delete the object with freeze_time('2013-04-12 05:00:00'): self.initial_data_updater.handle_deletions() # The object should not be deleted, along with its receipt self.assertEquals(Account.objects.count(), 1) self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 1) self.assertEquals(RegisteredForDeletionReceipt.objects.get().register_time, datetime(2013, 4, 12, 5)) def test_delete_already_deleted_obj(self): """ Tests the case when an object that was registered for deletion has already been deleted. """ account = G(Account) self.initial_data_updater.model_objs_registered_for_deletion = [account] self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0) with freeze_time('2013-04-12'): self.initial_data_updater.handle_deletions() receipt = RegisteredForDeletionReceipt.objects.get() self.assertEquals(receipt.model_obj_type, ContentType.objects.get_for_model(Account)) self.assertEquals(receipt.model_obj_id, account.id) self.assertEquals(receipt.register_time, datetime(2013, 4, 12)) # Delete the model object. The receipt should still exist account.delete() self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 1) # Now, don't register the object for deletion and run it again at a different time self.initial_data_updater.model_objs_registered_for_deletion = [] with freeze_time('2013-04-12 05:00:00'): self.initial_data_updater.handle_deletions() # The object should be deleted, along with its receipt self.assertEquals(Account.objects.count(), 0) self.assertEquals(RegisteredForDeletionReceipt.objects.count(), 0)
def test_update_app(self): """ Tests the update_app method """ # an error should only be raised for missing dependencies and not for directly # calling update on an app that doesn't have an initial data file initial_data_manager = InitialDataUpdater() initial_data_manager.update_app('fake') # make sure app gets added to updated apps initial_data_manager = InitialDataUpdater() with patch( 'dynamic_initial_data.base.InitialDataUpdater.get_class_path', spec_set=True) as get_path_patch: get_path_patch.return_value = 'dynamic_initial_data.tests.mocks.MockInitialData' # patch the update_initial_data method so we make sure it is called update_initial_data_patcher = patch( 'dynamic_initial_data.tests.mocks.MockInitialData.update_initial_data' ) update_initial_data_patch = update_initial_data_patcher.start() initial_data_manager.update_app('dynamic_initial_data') self.assertEqual(1, update_initial_data_patch.call_count) # make sure it doesn't call update static again initial_data_manager.update_app('dynamic_initial_data') self.assertEqual(1, update_initial_data_patch.call_count) # stop the patcher update_initial_data_patcher.stop() # make sure the app is in the updated_apps list self.assertIn('dynamic_initial_data', initial_data_manager.updated_apps) # test dependencies def app_loader(app): if app == 'MockOne': return MockOne elif app == 'MockTwo': return MockTwo return None # coverage app_loader(None) initial_data_manager = InitialDataUpdater() with patch('dynamic_initial_data.base.InitialDataUpdater.load_app', spec_set=True) as load_app_patch: load_app_patch.side_effect = app_loader # patch update_initial_data methods update_initial_data_patcher1 = patch( 'dynamic_initial_data.tests.mocks.MockOne.update_initial_data') update_initial_data_patcher2 = patch( 'dynamic_initial_data.tests.mocks.MockTwo.update_initial_data') update_initial_data_patch1 = update_initial_data_patcher1.start() update_initial_data_patch2 = update_initial_data_patcher2.start() initial_data_manager.update_app('MockTwo') self.assertEqual(1, update_initial_data_patch1.call_count) self.assertEqual(1, update_initial_data_patch2.call_count) update_initial_data_patcher1.stop() update_initial_data_patcher2.stop()
def test_update_app_cant_load_initial_data(self): """ Tests when the initial data class can't be loaded. It should execute without error """ InitialDataUpdater().update_app('bad_app_path')
def test_update_app_no_errors_raised(self, mock_load_app): """ Tests the update_app method. No errors should be raised since it has all of the required components """ InitialDataUpdater().update_app('fake')
def test_load_app_exists(self, import_patch): """ Tests the load_app method on an app that exists """ self.assertEqual(MockInitialData, InitialDataUpdater().load_app('fake'))
def handle(self, *args, **options): updater = InitialDataUpdater(options) if options['app']: updater.update_app(options['app']) else: updater.update_all_apps()
def test_get_dependency_call_list_initial_data_missing(self): """ Tests when the initial data is missing. """ with self.assertRaises(InitialDataMissingApp): InitialDataUpdater().get_dependency_call_list('fake')
def handle(self, *args, **options): updater = InitialDataUpdater(options) if options['app']: updater.update_app(options['app']) else: updater.update_all_apps()
def test_update_app(self): """ Tests the update_app method """ # an error should only be raised for missing dependencies and not for directly # calling update on an app that doesn't have an initial data file initial_data_manager = InitialDataUpdater() initial_data_manager.update_app('fake') # make sure app gets added to updated apps initial_data_manager = InitialDataUpdater() with patch('dynamic_initial_data.base.InitialDataUpdater.get_class_path', spec_set=True) as get_path_patch: get_path_patch.return_value = 'dynamic_initial_data.tests.mocks.MockInitialData' # patch the update_initial_data method so we make sure it is called update_initial_data_patcher = patch('dynamic_initial_data.tests.mocks.MockInitialData.update_initial_data') update_initial_data_patch = update_initial_data_patcher.start() initial_data_manager.update_app('dynamic_initial_data') self.assertEqual(1, update_initial_data_patch.call_count) # make sure it doesn't call update static again initial_data_manager.update_app('dynamic_initial_data') self.assertEqual(1, update_initial_data_patch.call_count) # stop the patcher update_initial_data_patcher.stop() # make sure the app is in the updated_apps list self.assertIn('dynamic_initial_data', initial_data_manager.updated_apps) # test dependencies def app_loader(app): if app == 'MockOne': return MockOne elif app == 'MockTwo': return MockTwo return None # coverage app_loader(None) initial_data_manager = InitialDataUpdater() with patch('dynamic_initial_data.base.InitialDataUpdater.load_app', spec_set=True) as load_app_patch: load_app_patch.side_effect = app_loader # patch update_initial_data methods update_initial_data_patcher1 = patch('dynamic_initial_data.tests.mocks.MockOne.update_initial_data') update_initial_data_patcher2 = patch('dynamic_initial_data.tests.mocks.MockTwo.update_initial_data') update_initial_data_patch1 = update_initial_data_patcher1.start() update_initial_data_patch2 = update_initial_data_patcher2.start() initial_data_manager.update_app('MockTwo') self.assertEqual(1, update_initial_data_patch1.call_count) self.assertEqual(1, update_initial_data_patch2.call_count) update_initial_data_patcher1.stop() update_initial_data_patcher2.stop()
def test_load_app_doesnt_exist(self, import_patch): """ Tests the load_app method on an app that doesnt exist """ self.assertIsNone(InitialDataUpdater().load_app('fake'))
def setUp(self): super(TestHandleDeletions, self).setUp() self.initial_data_updater = InitialDataUpdater()
def handle(self, *args, **options): manager = InitialDataUpdater(options) manager.update_all_apps()