def test_migrate(self, m_get_collection): """ Test last_updated and last_override_config fields added. """ collection = Mock() found = [ # these three should trigger a save {LAST_SYNC: '2016-05-04T18:19:01Z', LAST_UPDATED: '2016-05-03T18:19:01Z'}, {LAST_SYNC: '2016-05-04T18:20:01Z'}, {}, # this one should not trigger a save {LAST_OVERRIDE_CONFIG: '2016-05-04T18:20:01Z', LAST_UPDATED: '2016-05-03T18:19:01Z'}, ] collection.find.return_value = deepcopy(found) m_get_collection.return_value = collection # test module = MigrationModule(MIGRATION)._module module.migrate() # validation m_get_collection.assert_called_once_with('repo_importers') collection.find.assert_called_once_with() self.assertTrue(LAST_UPDATED in dist for dist in collection.save.call_args_list) self.assertTrue(LAST_OVERRIDE_CONFIG in dist for dist in collection.save.call_args_list) self.assertEqual( len(collection.save.call_args_list), 3)
def test_migrate(self, m_get_collection, now_utc_datetime): """ Test last_updated and last_override_config fields added. """ collection = Mock() found = [ {LAST_PUBLISH: '2016-05-04T18:19:01Z', LAST_UPDATED: '2016-05-03T18:19:01Z'}, {LAST_PUBLISH: '2016-05-04T18:20:01Z'}, {}, ] collection.find.return_value = deepcopy(found) m_get_collection.return_value = collection # test module = MigrationModule(MIGRATION)._module module.migrate() # validation m_get_collection.assert_called_once_with('repo_distributors') collection.find.assert_called_once_with() now_utc_datetime.assert_called_once_with() self.assertTrue(LAST_UPDATED in dist for dist in collection.save.call_args_list) self.assertTrue(LAST_OVERRIDE_CONFIG in dist for dist in collection.save.call_args_list) self.assertEqual( len(collection.save.call_args_list), 2)
def test_upgrade_idempotency(self): """ Simplest way to check the migration can run twice is simply to run it twice. The primary goal is to make sure an exception isn't raised. """ # Setup coll = Bind.get_collection() for counter in range(0, 3): bind_dict = { 'consumer_id': 'consumer_%s' % counter, 'repo_id': 'repo_%s' % counter, 'distributor_id': 'distributor_%s' % counter, } coll.insert(bind_dict) # Test module = MigrationModule('pulp.server.db.migrations.0003_bind_additions')._module module.migrate() module.migrate() # Verify bindings = coll.find() for b in bindings: self.assertTrue('notify_agent' in b) self.assertEqual(b['notify_agent'], True) self.assertTrue('binding_config' in b) self.assertEqual(b['binding_config'], None)
def test_migration(self): # setup collection = Bind.get_collection() for n in range(0, MAX_BINDINGS): if n % 2 == 0: conf = {ID: n} else: conf = None binding = { ID: n, CONSUMER_ID: n, REPO_ID: n, DISTRIBUTOR_ID: n, BINDING_CONFIG: conf, NOTIFY_AGENT: True, } collection.save(binding, safe=True) # migrate module = MigrationModule(MIGRATION)._module module.migrate() # verify bindings = list(collection.find({})) self.assertEqual(len(bindings), MAX_BINDINGS) for binding in bindings: conf = binding[BINDING_CONFIG] bind_id = binding[ID] if bind_id % 2 == 0: # untouched self.assertEqual(conf, {ID: bind_id}) else: # fixed self.assertEqual(conf, {})
def test_migrate(self, distributor, parse_iso8601_datetime): collection = Mock() found = [ {LAST_PUBLISH: '2015-04-28T18:19:01Z'}, {LAST_PUBLISH: datetime.now()}, {LAST_PUBLISH: '2015-04-28T18:20:01Z'}, {LAST_PUBLISH: datetime.now()}, ] parsed = [1, 2] collection.find.return_value = deepcopy(found) distributor.get_collection.return_value = collection parse_iso8601_datetime.side_effect = parsed # test module = MigrationModule(MIGRATION)._module module.migrate() # validation distributor.get_collection.assert_called_once_with() collection.find.assert_called_once_with() self.assertEqual( parse_iso8601_datetime.call_args_list, [ call(found[0][LAST_PUBLISH]), call(found[2][LAST_PUBLISH]), ]) self.assertEqual( collection.save.call_args_list, [ call({LAST_PUBLISH: parsed[0]}, safe=True), call({LAST_PUBLISH: parsed[1]}, safe=True) ])
def test_update_called(self, mock_get_collection): module = MigrationModule('pulp.server.db.migrations.0002_rename_http_notifier')._module module.migrate() # make sure the correct mongo query is being passed down mock_get_collection.return_value.update.assert_called_once_with( {'notifier_type_id': 'rest-api'}, {'$set': {'notifier_type_id': 'http'}} )
def test_update_called(self, mock_get_collection): module = MigrationModule("pulp.server.db.migrations.0002_rename_http_notifier")._module module.migrate() # make sure the correct mongo query is being passed down mock_get_collection.return_value.update.assert_called_once_with( {"notifier_type_id": "rest-api"}, {"$set": {"notifier_type_id": "http"}} )
def test_del_agent_queues_deletes_all_existing_queues(self): self.fake_broker.getQueue.side_effect = [Mock(), Mock()] # test migration = MigrationModule(MIGRATION)._module migration._del_agent_queues(self.fake_broker) expected_calls = [call(self.fake_broker, 'dog'), call(self.fake_broker, 'cat')] self.mock_del_queue_catch_queue_in_use_exc.assert_has_calls(expected_calls)
def test_del_agent_queues_skips_existing_queues(self): self.fake_broker.getQueue.side_effect = [None, None] # test migration = MigrationModule(MIGRATION)._module migration._del_agent_queues(self.fake_broker) self.fake_broker.getQueue.assert_has_calls([call('dog'), call('cat')]) self.assertTrue(not self.mock_del_queue_catch_queue_in_use_exc.called)
def test_time_to_utc_on_collection_skips_utc(self, mock_connection): migration = MigrationModule(MIGRATION)._module collection = mock_connection.get_collection.return_value unit = {'bar': '2014-07-09T11:09:07Z'} collection.find.return_value = [unit] migration.update_time_to_utc_on_collection('foo', 'bar') mock_connection.get_collection.assert_called_once_with('foo') self.assertFalse(collection.save.called)
def test_migrate_agent_queues(self, fake_add_agent_queues, fake_del_agent_queues): fake_broker = Mock() # test migration = MigrationModule(MIGRATION)._module migration._migrate_agent_queues(fake_broker) # validation fake_add_agent_queues.assert_called_with(fake_broker) fake_del_agent_queues.assert_called_with(fake_broker)
def test_migrate(self, mock_connection): """ Test the schema change happens like it should. """ role_schema = copy.deepcopy(CURRENT) migration = MigrationModule(MIGRATION)._module collection = mock_connection.get_collection.return_value collection.find.return_value = role_schema migration.migrate() self.assertEquals(role_schema, TARGET)
def test_idempotence(self, mock_connection): """ Test the idempotence of the migration """ role_schema = copy.deepcopy(TARGET) migration = MigrationModule(MIGRATION)._module collection = mock_connection.get_collection.return_value collection.find.return_value = role_schema migration.migrate() self.assertFalse(collection.save.called) self.assertEquals(role_schema, TARGET)
def test_migrate_reply_queue_not_found_does_not_delete_or_add_reply_queue(self): fake_broker = Mock() fake_broker.getQueue.return_value = None # test migration = MigrationModule(MIGRATION)._module migration._migrate_reply_queue(fake_broker) # validation fake_broker.getQueue.assert_called_with(Services.REPLY_QUEUE) self.assertTrue(not self.mock_del_queue_catch_queue_in_use_exc.called) self.assertTrue(not fake_broker.addQueue.called)
def test_time_to_utc_on_collection(self, mock_connection): migration = MigrationModule(MIGRATION)._module collection = mock_connection.get_collection.return_value unit = {'bar': '2014-07-09T11:09:07-04:00'} utc_value = '2014-07-09T15:09:07Z' collection.find.return_value = [unit] migration.update_time_to_utc_on_collection('foo', 'bar') mock_connection.get_collection.assert_called_once_with('foo') self.assertEquals(unit['bar'], utc_value) collection.save.assert_called_once_with(unit)
def test_migrate(self, mock_connection, mock_update): """ Verify that only known & valid collections are updated """ migration = MigrationModule(MIGRATION)._module collection_list = ['repo_distributors'] mock_connection.get_database.return_value.collection_names.return_value = collection_list migration.migrate() mock_update.assert_called_once_with('repo_distributors', 'last_publish')
def test_migrate(self, mock_connection): """ Test the schema change happens like it should. """ permissions_schema = [{"resource": "/", "id": "5356d55b37382030f4a80b5e", "users": {"admin": [0, 1, 2, 3, 4]}}] new_schema = [{"resource": "/", "id": "5356d55b37382030f4a80b5e", "users": [{"username": "******", "permissions": [0, 1, 2, 3, 4]}]}] migration = MigrationModule(MIGRATION)._module collection = mock_connection.get_collection.return_value collection.find.return_value = permissions_schema migration.migrate() self.assertEquals(permissions_schema, new_schema)
def test_migrate_reply_queue_not_found(self): fake_queue = Mock() fake_broker = Mock() fake_broker.getQueue.return_value = None # test migration = MigrationModule(MIGRATION)._module migration._migrate_reply_queue(fake_broker) # validation fake_broker.getQueue.assert_called_with(Services.REPLY_QUEUE) self.assertFalse(fake_broker.called) self.assertFalse(fake_broker.called)
def test_add_agent_queues_cat_only(self, fake_get): fake_collection = Mock() fake_collection.find = Mock(return_value=[{'id': 'dog'}, {'id': 'cat'}]) fake_get.return_value = fake_collection fake_broker = Mock() fake_broker.getQueue.side_effect = [None, Mock()] # test migration = MigrationModule(MIGRATION)._module migration._add_agent_queues(fake_broker) fake_broker.getQueue.assert_any('pulp.agent.dog') fake_broker.getQueue.assert_any('pulp.agent.cat') fake_broker.addQueue.assert_called__once_with('pulp.agent.dog', durable=True)
def test_del_agent_queues_cat_only(self, fake_get): fake_collection = Mock() fake_collection.find = Mock(return_value=[{'id': 'dog'}, {'id': 'cat'}]) fake_get.return_value = fake_collection fake_broker = Mock() fake_broker.getQueue.side_effect = [None, Mock()] # test migration = MigrationModule(MIGRATION)._module migration._del_agent_queues(fake_broker) fake_broker.getQueue.assert_any('dog') fake_broker.getQueue.assert_any('cat') fake_broker.delQueue.assert_calle_with('cat')
def test(self): # migrate module = MigrationModule(MIGRATION)._module module.migrate() # validation for collection in [connection.get_collection(n) for n in TEST_COLLECTIONS]: for unit in collection.find({}): self.assertTrue(LAST_UPDATED in unit) unit_id = unit[ID] last_updated = unit[LAST_UPDATED] if unit_id % 2 == 0: self.assertEqual(last_updated, 1) else: self.assertTrue(isinstance(last_updated, float))
def test__del_queue_catch_no_queue_in_use_exception_catches_cannot_delete_queue(self): fake_broker = Mock() mock_name = Mock() exc_to_raise = Exception("Cannot delete queue celery; queue in use") fake_broker.delQueue.side_effect = exc_to_raise migration = MigrationModule(MIGRATION)._module try: migration._del_queue_catch_queue_in_use_exception(fake_broker, mock_name) self.fail('An exception should have been raised, and was not.') except Exception as error: string_a = 'Consumers are still bound to the queue' string_b = 'All consumers must be unregistered, upgraded, or off before you can continue' if string_a not in error.message or string_b not in error.message: self.fail("Migration 0009 does not handle a 'queue in use' exception")
def test_database_integration(self): # make sure the migration works on a live document in mongo collection = EventListener.get_collection() event_listener_id = str( collection.insert({"notifier_type_id": "rest-api", "event_types": ["*"], "notifier_config": {}}, safe=True) ) event_listener_factory = managers.factory.event_listener_manager() module = MigrationModule("pulp.server.db.migrations.0002_rename_http_notifier")._module module.migrate() event_listener = event_listener_factory.get(event_listener_id) self.assertEqual(event_listener["notifier_type_id"], "http") # cleanup collection.remove()
def test_migrate_reply_queue(self): fake_queue = Mock() fake_queue.values = { 'exclusive': True, 'arguments': {} } fake_broker = Mock() fake_broker.getQueue.return_value = fake_queue # test migration = MigrationModule(MIGRATION)._module migration._migrate_reply_queue(fake_broker) # validation fake_broker.getQueue.assert_called_with(Services.REPLY_QUEUE) fake_broker.delQueue.assert_called_with(Services.REPLY_QUEUE) fake_broker.addQueue.assert_called_with(Services.REPLY_QUEUE, durable=True)
def test_migrate_reply_queue_not_exclusive_does_not_delete_or_add_reply_queue(self): fake_queue = Mock() fake_queue.values = { 'exclusive': False, 'arguments': {} } fake_broker = Mock() fake_broker.getQueue.return_value = fake_queue # test migration = MigrationModule(MIGRATION)._module migration._migrate_reply_queue(fake_broker) # validation fake_broker.getQueue.assert_called_with(Services.REPLY_QUEUE) self.assertTrue(not self.mock_del_queue_catch_queue_in_use_exc.called) self.assertTrue(not fake_broker.addQueue.called)
def test_migrate_reply_queue_not_exclusive(self): fake_queue = Mock() fake_queue.values = { 'exclusive': False, 'arguments': {} } fake_broker = Mock() fake_broker.getQueue.return_value = fake_queue # test migration = MigrationModule(MIGRATION)._module migration._migrate_reply_queue(fake_broker) # validation fake_broker.getQueue.assert_called_with(Services.REPLY_QUEUE) self.assertFalse(fake_broker.called) self.assertFalse(fake_broker.called)
def test_migrate(self, m_get_collection): """ Test last_updated and last_override_config fields added. """ collection = Mock() m_get_collection.return_value = collection # test module = MigrationModule(MIGRATION)._module module.migrate() # validation m_get_collection.assert_called_once_with('repo_importers') # can't do much more than see that update was called # for each key to be removed (2 total calls) self.assertEqual( len(collection.update.call_args_list), 2)
def test_migrate_reply_queue_arguments_is_exclusive_deletes_and_add_reply_queue(self): fake_queue = Mock() fake_queue.values = { 'exclusive': False, 'arguments': {'exclusive': True} } fake_broker = Mock() fake_broker.getQueue.return_value = fake_queue # test migration = MigrationModule(MIGRATION)._module migration._migrate_reply_queue(fake_broker) # validation fake_broker.getQueue.assert_called_with(Services.REPLY_QUEUE) expected_call = call(fake_broker, Services.REPLY_QUEUE) self.mock_del_queue_catch_queue_in_use_exc.assert_has_calls(expected_call) fake_broker.addQueue.assert_called_with(Services.REPLY_QUEUE, durable=True)
def test_database_integration(self): # make sure the migration works on a live document in mongo collection = EventListener.get_collection() event_listener_id = str(collection.insert({ 'notifier_type_id': 'rest-api', 'event_types': ['*'], 'notifier_config': {}, })) event_listener_factory = managers.factory.event_listener_manager() module = MigrationModule('pulp.server.db.migrations.0002_rename_http_notifier')._module module.migrate() event_listener = event_listener_factory.get(event_listener_id) self.assertEqual(event_listener['notifier_type_id'], 'http') # cleanup collection.remove()
def test_migrate_not_qpid(self, fake_conf, fake_migrate_agent_queues, fake_migrate_reply_queue, fake_connection, fake_broker): fake_conf.get.return_value = 'not-qpid' # test migration = MigrationModule(MIGRATION)._module migration.migrate() # validation self.assertFalse(fake_connection.called) self.assertFalse(fake_broker.called) self.assertFalse(fake_migrate_reply_queue.called) self.assertFalse(fake_migrate_agent_queues.called)
def test__del_queue_catch_no_queue_in_use_exception_catches_cannot_delete_queue( self): fake_broker = Mock() mock_name = Mock() exc_to_raise = Exception("Cannot delete queue celery; queue in use") fake_broker.delQueue.side_effect = exc_to_raise migration = MigrationModule(MIGRATION)._module try: migration._del_queue_catch_queue_in_use_exception( fake_broker, mock_name) self.fail('An exception should have been raised, and was not.') except Exception as error: string_a = 'Consumers are still bound to the queue' string_b = ( 'All consumers must be unregistered, upgraded, or off before you can ' 'continue') if string_a not in error.message or string_b not in error.message: self.fail( "Migration 0009 does not handle a 'queue in use' exception" )
def test_idempotence(self, mock_connection): """ Test the idempotence of the migration """ permissions_schema = [{ "resource": "/", "id": "5356d55b37382030f4a80b5e", "users": { "admin": [0, 1, 2, 3, 4] } }] new_schema = [{ "resource": "/", "id": "5356d55b37382030f4a80b5e", "users": [{ "username": "******", "permissions": [0, 1, 2, 3, 4] }] }] migration = MigrationModule(MIGRATION)._module collection = mock_connection.get_collection.return_value collection.find.return_value = permissions_schema migration.migrate() self.assertEquals(permissions_schema, new_schema) migration.migrate() self.assertEquals(permissions_schema, new_schema)
def test_database_integration(self): # make sure the migration works on a live document in mongo collection = EventListener.get_collection() event_listener_id = str( collection.insert( { 'notifier_type_id': 'rest-api', 'event_types': ['*'], 'notifier_config': {}, }, safe=True)) event_listener_factory = managers.factory.event_listener_manager() module = MigrationModule( 'pulp.server.db.migrations.0002_rename_http_notifier')._module module.migrate() event_listener = event_listener_factory.get(event_listener_id) self.assertEqual(event_listener['notifier_type_id'], 'http') # cleanup collection.remove()
def test_migrate_reply_queue_arguments_is_exclusive_deletes_and_add_reply_queue( self): fake_queue = Mock() fake_queue.values = { 'exclusive': False, 'arguments': { 'exclusive': True } } fake_broker = Mock() fake_broker.getQueue.return_value = fake_queue # test migration = MigrationModule(MIGRATION)._module migration._migrate_reply_queue(fake_broker) # validation fake_broker.getQueue.assert_called_with(Services.REPLY_QUEUE) expected_call = call(fake_broker, Services.REPLY_QUEUE) self.mock_del_queue_catch_queue_in_use_exc.assert_has_calls( expected_call) fake_broker.addQueue.assert_called_with(Services.REPLY_QUEUE, durable=True)
class TestMigrationContentUnitCount(base.PulpServerTests): def setUp(self): super(TestMigrationContentUnitCount, self).setUp() self.module = MigrationModule('pulp.server.db.migrations.0004_content_unit_counts')._module @mock.patch('pulp.server.db.model.repository.Repo.get_collection') @mock.patch('pulp.server.managers.repo.cud.RepoManager.rebuild_content_unit_counts') def test_calls(self, mock_rebuild, mock_get_collection): self.module.migrate() mock_rebuild.assert_called_once_with() mock_update = mock_get_collection.return_value.update self.assertEqual(mock_update.call_count, 1) self.assertTrue(mock_update.call_args[1].get('safe') is True) self.assertEqual(mock_update.call_args[0][0], {}) self.assertEqual(mock_update.call_args[0][1], {'$unset': {'content_unit_count': 1}}) def test_with_db(self): REPO_ID = 'repo123' repo_collection = Repo.get_collection() repo_collection.save({'id': REPO_ID, 'content_unit_count': 0}) assoc_collection = RepoContentUnit.get_collection() assoc_collection.insert({'repo_id': REPO_ID, 'unit_type_id': 'rpm', 'unit_id': 'unit1'}) assoc_collection.insert({'repo_id': REPO_ID, 'unit_type_id': 'rpm', 'unit_id': 'unit2'}) self.module.migrate() repo = repo_collection.find({'id': REPO_ID})[0] self.assertTrue('content_unit_count' not in repo) self.assertEqual(repo['content_unit_counts'], {'rpm': 2}) # cleanup repo_collection.remove({'id': REPO_ID}) assoc_collection.remove({'repo_id': REPO_ID})
def test_upgrade(self): # Setup coll = Bind.get_collection() for counter in range(0, 3): bind_dict = { 'consumer_id' : 'consumer_%s' % counter, 'repo_id' : 'repo_%s' % counter, 'distributor_id' : 'distributor_%s' % counter, } coll.insert(bind_dict, safe=True) # Test module = MigrationModule('pulp.server.db.migrations.0003_bind_additions')._module module.migrate() # Verify bindings = coll.find() for b in bindings: self.assertTrue('notify_agent' in b) self.assertEqual(b['notify_agent'], True) self.assertTrue('binding_config' in b) self.assertEqual(b['binding_config'], None)
def test_migrate(self, m_get_collection): """ Test last_updated and last_override_config fields added. """ collection = Mock() found = [ # these three should trigger a save { LAST_SYNC: '2016-05-04T18:19:01Z', LAST_UPDATED: '2016-05-03T18:19:01Z' }, { LAST_SYNC: '2016-05-04T18:20:01Z' }, {}, # this one should not trigger a save { LAST_OVERRIDE_CONFIG: '2016-05-04T18:20:01Z', LAST_UPDATED: '2016-05-03T18:19:01Z' }, ] collection.find.return_value = deepcopy(found) m_get_collection.return_value = collection # test module = MigrationModule(MIGRATION)._module module.migrate() # validation m_get_collection.assert_called_once_with('repo_importers') collection.find.assert_called_once_with() self.assertTrue(LAST_UPDATED in dist for dist in collection.save.call_args_list) self.assertTrue(LAST_OVERRIDE_CONFIG in dist for dist in collection.save.call_args_list) self.assertEqual(len(collection.save.call_args_list), 3)
def test_migrate(self, m_get_collection, parse_iso8601_datetime): collection = Mock() found = [ { LAST_PUBLISH: '2015-04-28T18:19:01Z' }, { LAST_PUBLISH: datetime.now() }, { LAST_PUBLISH: '2015-04-28T18:20:01Z' }, { LAST_PUBLISH: datetime.now() }, ] parsed = [1, 2] collection.find.return_value = deepcopy(found) m_get_collection.return_value = collection parse_iso8601_datetime.side_effect = parsed # test module = MigrationModule(MIGRATION)._module module.migrate() # validation m_get_collection.assert_called_once_with('repo_distributors') collection.find.assert_called_once_with() self.assertEqual(parse_iso8601_datetime.call_args_list, [ call(found[0][LAST_PUBLISH]), call(found[2][LAST_PUBLISH]), ]) self.assertEqual( collection.save.call_args_list, [call({LAST_PUBLISH: parsed[0]}), call({LAST_PUBLISH: parsed[1]})])
class TestMigration(TestCase): def setUp(self): # Remove dependencies on qpidtoollibs and qpid.messaging self.migration = MigrationModule(MIGRATION)._module if self.migration.QPIDTOOLLIBS_AVAILABLE: self.broker = self.migration.BrokerAgent if self.migration.QPID_MESSAGING_AVAILABLE: self.connection = self.migration.Connection self.qpidtoollibs = self.migration.QPIDTOOLLIBS_AVAILABLE self.qpid_messaging = self.migration.QPID_MESSAGING_AVAILABLE self.migration.QPIDTOOLLIBS_AVAILABLE = True self.migration.QPID_MESSAGING_AVAILABLE = True self.migration.BrokerAgent = Mock() self.migration.Connection = Mock() def tearDown(self): self.migration.QPIDTOOLLIBS_AVAILABLE = self.qpidtoollibs self.migration.QPID_MESSAGING_AVAILABLE = self.qpid_messaging if self.migration.QPIDTOOLLIBS_AVAILABLE: self.migration.BrokerAgent = self.broker if self.migration.QPID_MESSAGING_AVAILABLE: self.migration.Connection = self.connection @patch(MIGRATION + '._migrate_reply_queue') @patch(MIGRATION + '._migrate_agent_queues') @patch(MIGRATION + '.pulp_conf', PULP_CONF) def test_migrate(self, fake_migrate_agent_queues, fake_migrate_reply_queue): # test self.migration.migrate() # validation self.migration.Connection.assert_called_with( host='myhost', port=1234, transport='tcp', reconnect=False, ssl_certfile='TEST-CERTIFICATE', ssl_skip_hostname_check=True) self.migration.Connection().attach.assert_called_with() self.migration.BrokerAgent.assert_called_with( self.migration.Connection()) fake_migrate_reply_queue.assert_called_with( self.migration.BrokerAgent()) fake_migrate_agent_queues.assert_called_with( self.migration.BrokerAgent()) self.migration.Connection().detach.assert_called_with() @patch(MIGRATION + '._migrate_reply_queue') @patch(MIGRATION + '._migrate_agent_queues') @patch(MIGRATION + '.pulp_conf') def test_migrate_not_qpid( self, fake_conf, fake_migrate_agent_queues, fake_migrate_reply_queue, ): fake_conf.get.return_value = 'not-qpid' # test self.migration.migrate() # validation self.assertFalse(self.migration.Connection.called) self.assertFalse(self.migration.BrokerAgent.called) self.assertFalse(fake_migrate_reply_queue.called) self.assertFalse(fake_migrate_agent_queues.called) @patch(MIGRATION + '._del_agent_queues') @patch(MIGRATION + '._add_agent_queues') def test_migrate_agent_queues(self, fake_add_agent_queues, fake_del_agent_queues): fake_broker = Mock() # test self.migration._migrate_agent_queues(fake_broker) # validation fake_add_agent_queues.assert_called_with(fake_broker) fake_del_agent_queues.assert_called_with(fake_broker) @patch('pulp.server.db.model.consumer.Consumer.get_collection') def test_add_agent_queues(self, fake_get): fake_collection = Mock() fake_collection.find = Mock(return_value=[{ 'id': 'dog' }, { 'id': 'cat' }]) fake_get.return_value = fake_collection fake_broker = Mock() fake_broker.getQueue.side_effect = [None, None] # test self.migration._add_agent_queues(fake_broker) fake_broker.getQueue.assert_any('pulp.agent.dog') fake_broker.getQueue.assert_any('pulp.agent.cat') fake_broker.addQueue.assert_any('pulp.agent.dog') fake_broker.addQueue.assert_any('pulp.agent.cat') @patch('pulp.server.db.model.consumer.Consumer.get_collection') def test_add_agent_queues_cat_only(self, fake_get): fake_collection = Mock() fake_collection.find = Mock(return_value=[{ 'id': 'dog' }, { 'id': 'cat' }]) fake_get.return_value = fake_collection fake_broker = Mock() fake_broker.getQueue.side_effect = [None, Mock()] # test self.migration._add_agent_queues(fake_broker) fake_broker.getQueue.assert_any('pulp.agent.dog') fake_broker.getQueue.assert_any('pulp.agent.cat') fake_broker.addQueue.assert_called__once_with('pulp.agent.dog', durable=True)
class TestMigrationAddMetadata(rpm_support_base.PulpRPMTests): def setUp(self): super(TestMigrationAddMetadata, self).setUp() self.module = MigrationModule( 'pulp_rpm.plugins.migrations.0005_rpm_changelog_files')._module self.fake_unit = {'_storage_path': '/tmp/foo'} self.mock_ts = mock.MagicMock() self.mock_collection = mock.MagicMock() self.mock_package = mock.MagicMock() self.mock_package.changelog = [ ('now', '*****@*****.**', 'description'), ] self.mock_package.filelist = ['/a', '/b', '/c'] self.mock_package.files = { 'ghost': ['/xyz'], 'dir': ['/foo', '/bar'], 'file': ['/a', '/b', '/c'], } def verify_saved_unit(self, saved_unit): self.assertTrue('files' in saved_unit) for key, value in saved_unit['files'].iteritems(): for item in value: self.assertTrue(isinstance(item, unicode)) self.assertTrue('filelist' in saved_unit) for value in saved_unit['filelist']: self.assertTrue(isinstance(value, unicode)) self.assertTrue('changelog' in saved_unit) for entry in saved_unit['changelog']: # don't inspect timestamp, which is the first item for item in entry[1:]: self.assertTrue(isinstance(item, unicode)) # this is how mongo will encode it, so make sure this is possible BSON.encode(saved_unit) @mock.patch('os.path.exists', return_value=True) @mock.patch('createrepo.yumbased.CreateRepoPackage') def test_migrate_filelist(self, mock_package_class, mock_exists): mock_package_class.return_value = self.mock_package self.module._migrate_unit(self.fake_unit, self.mock_ts, self.mock_collection) self.assertEqual(self.mock_collection.save.call_count, 1) saved_unit = self.mock_collection.save.call_args[0][0] self.verify_saved_unit(saved_unit) self.assertEqual(saved_unit['files'], self.mock_package.files) self.assertEqual(saved_unit['filelist'], self.mock_package.filelist) self.assertEqual( saved_unit['changelog'][0], self.module._decode_changelog(self.mock_package.changelog[0])) def test_with_real_packages(self): current_dir = os.path.dirname(__file__) paths = glob.glob( os.path.join( current_dir, '../../data/repos.fedorapeople.org/repos/pulp/pulp/demo_repos/zoo/*.rpm' )) ts = transaction.initReadOnlyTransaction() for path in paths: fake_unit = {'_storage_path': path} self.module._migrate_unit(fake_unit, ts, self.mock_collection) saved_unit = self.mock_collection.save.call_args[0][0] self.verify_saved_unit(saved_unit) @mock.patch('os.path.exists', return_value=True) @mock.patch('createrepo.yumbased.CreateRepoPackage') def test_latin1_metadata(self, mock_package_class, mock_exists): # the following string cannot be decoded as utf8, so this checks that the # migration handles latin1 decoding also. Mongo will barf if we hand it # this string. self.mock_package.filelist.append( '/usr/share/doc/man-pages-da-0.1.1/l\xe6smig') mock_package_class.return_value = self.mock_package self.module._migrate_unit(self.fake_unit, self.mock_ts, self.mock_collection) saved_unit = self.mock_collection.save.call_args[0][0] self.verify_saved_unit(saved_unit)
def setUp(self): super(TestMigrationContentUnitCount, self).setUp() self.module = MigrationModule( 'pulp.server.db.migrations.0004_content_unit_counts')._module
# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. import os import pickle import time import unittest import bson import celery import mock from pulp.server.db.migrate.models import MigrationModule PATH = 'pulp.server.db.migrations.0007_scheduled_task_conversion' migration = MigrationModule(PATH)._module consumer_install_path = os.path.join(os.path.dirname(__file__), '../../../../data/migration_0007/consumer_install.pickle') consumer_install = open(consumer_install_path).read() publish_path = os.path.join(os.path.dirname(__file__), '../../../../data/migration_0007/publish.pickle') publish = open(publish_path).read() @mock.patch('pulp.server.db.connection.get_collection') class TestMigrate(unittest.TestCase): def fake_get_collection(self, name): mocks = { 'scheduled_calls': self.mock_sched_collection,