def test_move_directory_contents(self): test_old_publish_dir = tempfile.mkdtemp(prefix='test_0002_migration_old') old_http_publish_dir = os.path.join(test_old_publish_dir, 'http', 'repos') old_https_publish_dir = os.path.join(test_old_publish_dir, 'https', 'repos') os.makedirs(old_http_publish_dir) os.makedirs(old_https_publish_dir) test_new_publish_dir = tempfile.mkdtemp(prefix='test_0002_migration_new') test_new_publish_puppet_dir = os.path.join(test_new_publish_dir, 'puppet') # on a real system, this dir is created by the rpm os.mkdir(test_new_publish_puppet_dir) new_http_publish_dir = os.path.join(test_new_publish_puppet_dir, 'http', 'repos') new_https_publish_dir = os.path.join(test_new_publish_puppet_dir, 'https', 'repos') # put a file in the top-level dir to ensure it gets copied over too. # It is not typical to have a file there but we should move it over # just in case. open(os.path.join(test_old_publish_dir, 'some_file'), 'w').close() migration = _import_all_the_way('pulp_puppet.plugins.migrations.0002_puppet_' 'publishing_directory_change') migration.move_directory_contents(test_old_publish_dir, test_new_publish_puppet_dir) self.assertTrue(os.path.exists(new_http_publish_dir)) self.assertTrue(os.path.exists(new_https_publish_dir)) self.assertTrue(os.path.exists(os.path.join(test_new_publish_puppet_dir, 'some_file'))) # bz 1153072 - user needs to clear this dir manually self.assertTrue(os.path.exists(test_old_publish_dir)) for (root, files, dirs) in os.walk(test_old_publish_dir): self.assertTrue(files == []) self.assertTrue(dirs == [])
def setUp(self): super(Migration0004Tests, self).setUp() # Special way to import modules that start with a number self.migration = _import_all_the_way( 'pulp_rpm.plugins.migrations.0004_pkg_group_category_repoid') factory.initialize() types_db.update_database([TYPE_DEF_GROUP, TYPE_DEF_CATEGORY]) # Create the repositories necessary for the tests self.source_repo_id = 'source-repo' # where units were copied from with the bad code self.dest_repo_id = 'dest-repo' # where bad units were copied to source_repo = Repo(self.source_repo_id, '') Repo.get_collection().insert(source_repo, safe=True) dest_repo = Repo(self.dest_repo_id, '') Repo.get_collection().insert(dest_repo, safe=True) source_importer = RepoImporter(self.source_repo_id, 'yum_importer', 'yum_importer', {}) RepoImporter.get_collection().insert(source_importer, safe=True) dest_importer = RepoImporter(self.dest_repo_id, 'yum_importer', 'yum_importer', {}) RepoImporter.get_collection().insert(dest_importer, safe=True)
def test_migrate(self): # Let's set up some package groups, some with the new way, and some with the old way # We'll only put the name and conditional_package_names attributes since the # migration only touches those fields package_groups = [ {"name": "v1_style_1", "conditional_package_names" : {'a': 1, 'b': 2}}, {"name": "v1_style_2", "conditional_package_names" : {'b': 1, 'c': 3}}, {"name": "v2_style", "conditional_package_names" : [['d', 4], ['e', 5]]}] for package_group in package_groups: self.package_group_collection.insert(package_group) migration = _import_all_the_way( 'pulp_rpm.migrations.0012_conditional_package_names_v1_v2_upgrade') # Run the migration migration.migrate() # Inspect the package groups expected_package_groups = [ {"name": "v1_style_1", "conditional_package_names" : [['a', 1], ['b', 2]]}, {"name": "v1_style_2", "conditional_package_names" : [['b', 1], ['c', 3]]}, {"name": "v2_style", "conditional_package_names" : [['d', 4], ['e', 5]]}] for expected_package_group in expected_package_groups: package_group = self.package_group_collection.find_one( {'name': expected_package_group['name']}) self.assertTrue(isinstance(package_group['conditional_package_names'], list)) self.assertEqual(len(package_group['conditional_package_names']), len(expected_package_group['conditional_package_names'])) # Since dictionaries don't have ordering, we cannot assert that the expected # list is the same as the actual list. Instead, we assert that the lengths are # the same, and that all the expected items appear in the actual for pair in expected_package_group['conditional_package_names']: self.assertTrue(pair in package_group['conditional_package_names'])
def test_migrate(self): migration = _import_all_the_way('pulp_rpm.migrations.0009_iso_importer_config_keys') # Run the migration migration.migrate() # Verify the proxy repo proxy = self.repo_importers.find_one({'repo_id': 'proxy'}) self.assertEqual(proxy['importer_type_id'], 'iso_importer') self.assertEqual(proxy['last_sync'], '2013-04-09T16:57:06-04:00') self.assertEqual(proxy['scheduled_syncs'], []) self.assertEqual(proxy['scratchpad'], None) self.assertEqual(dict(proxy['config']), { u'proxy_username': u'rbarlow', u'feed': u'http://pkilambi.fedorapeople.org/test_file_repo/', u'proxy_host': u'localhost', u'proxy_password': u'password', u'proxy_port': 3128, u'id': u'proxy'}) self.assertEqual(proxy['id'], 'iso_importer') # Verify the test repo test = self.repo_importers.find_one({'repo_id': 'test'}) self.assertEqual(test['importer_type_id'], 'iso_importer') self.assertEqual(dict(test['config']), { u'max_downloads': 42, u'feed': u'http://feed.com/isos', u'proxy_host': u'proxy.com', u'proxy_username': u'jeeves', u'remove_missing': False, u'validate': True}) self.assertEqual(test['id'], 'iso_importer') # verify that the yum repo wasn't touched a_yum_repo = self.repo_importers.find_one({'repo_id': 'a_yum_repo'}) self.assertEqual(a_yum_repo['importer_type_id'], 'yum_importer') self.assertEqual(dict(a_yum_repo['config']), {u'feed_url': u'This should not change.'})
def setUp(self): super(Migration0004Tests, self).setUp() # Special way to import modules that start with a number self.migration = _import_all_the_way( 'pulp_rpm.plugins.migrations.0004_pkg_group_category_repoid') factory.initialize() api.initialize(False) types_db.update_database([TYPE_DEF_GROUP, TYPE_DEF_CATEGORY]) # Create the repositories necessary for the tests self.source_repo_id = 'source-repo' # where units were copied from with the bad code self.dest_repo_id = 'dest-repo' # where bad units were copied to source_repo = model.Repository(repo_id=self.source_repo_id) source_repo.save() dest_repo = model.Repository(repo_id=self.dest_repo_id) dest_repo.save() source_importer = model.Importer(self.source_repo_id, 'yum_importer', {}) source_importer.save() dest_importer = model.Importer(self.dest_repo_id, 'yum_importer', {}) dest_importer.save()
def test_fix_distribution_units(self): migration = _import_all_the_way('pulp_rpm.plugins.migrations.0015_fix_distributor_units') mock_collection = mock.MagicMock() mock_collection.find.return_value = FAKE_DIST_UNITS migration._fix_distribution_units(mock_collection) mock_collection.find.assert_called_once_with({'files': {'$exists': True}}) mock_collection.update.assert_called_once_with({'_id': u'6ec94809-6d4f-48cf-9077-88d003eb284e'}, {'$set': {'files': []}}, safe=True)
def setUp(self): super(BaseMigrationTests, self).setUp() self.distributors_collection = RepoDistributor.get_collection() self.root_test_dir = tempfile.mkdtemp(prefix='test_0016_migration_') self.http_publish_dir = os.path.join(self.root_test_dir, 'http', 'repos') self.https_publish_dir = os.path.join(self.root_test_dir, 'https', 'repos') self.migration_module = _import_all_the_way(MIGRATION_MODULE)
def test_migrate(self): migration = _import_all_the_way('pulp_rpm.migrations.0013_errata_from_str') # Run the migration migration.migrate() # Verify that this one's "from_str" got changed to "from" old = self.collection.find_one({'id': 'RHEA-2012:0003'}) self.assertEqual(old.get('from', None), '*****@*****.**') self.assertFalse('from_str' in old) # Verify that this one's "from" is still "from" new = self.collection.find_one({'id': 'RHEA-2012:0004'}) self.assertEqual(new.get('from', None), '*****@*****.**') self.assertFalse('from_str' in new)
def test_migration(self, mock_query_manager, mock_calc_checksum): migration = _import_all_the_way('pulp_puppet.plugins.migrations.0001_puppet_' 'module_unit_checksum') storage_path = '/foo/storage' mock_calc_checksum.return_value = "foo_checksum" unit = {'_storage_path': storage_path} mock_query_manager.return_value.get_content_unit_collection.return_value.find.return_value \ = MockCursor([unit]) migration.migrate() mock_calc_checksum.assert_called_once_with(storage_path) mock_query_manager.return_value.get_content_unit_collection.return_value.\ save.assert_called_once() target_unit = mock_query_manager.return_value.get_content_unit_collection.return_value. \ save.call_args[0][0] self.assertEquals(target_unit['checksum'], 'foo_checksum') self.assertEquals(target_unit['checksum_type'], constants.DEFAULT_HASHLIB)
def test_fix_distribution_units_multifile(self): """ verify that we don't remove files that are OK """ migration = _import_all_the_way('pulp_rpm.plugins.migrations.0015_fix_distributor_units') mock_collection = mock.MagicMock() mock_collection.find.return_value = FAKE_DIST_UNITS_MULTIFILE migration._fix_distribution_units(mock_collection) mock_collection.find.assert_called_once_with({'files': {'$exists': True}}) mock_collection.update.assert_called_once_with({'_id': u'6ec94809-6d4f-48cf-9077-88d003eb284e'}, {'$set': {'files': [{'downloadurl': 'http ://fake-url/os/another_file', 'item_type': 'distribution', 'fileName': 'another_file'}]}}, safe=True)
def test_migrate(self): migration = _import_all_the_way("pulp_rpm.plugins.migrations.0009_iso_importer_config_keys") # Run the migration migration.migrate() # Verify the proxy repo proxy = self.repo_importers.find_one({"repo_id": "proxy"}) self.assertEqual(proxy["importer_type_id"], "iso_importer") self.assertEqual(proxy["last_sync"], "2013-04-09T16:57:06-04:00") self.assertEqual(proxy["scheduled_syncs"], []) self.assertEqual(proxy["scratchpad"], None) self.assertEqual( dict(proxy["config"]), { u"proxy_username": u"rbarlow", u"feed": u"http://pkilambi.fedorapeople.org/test_file_repo/", u"proxy_host": u"localhost", u"proxy_password": u"password", u"proxy_port": 3128, u"id": u"proxy", }, ) self.assertEqual(proxy["id"], "iso_importer") # Verify the test repo test = self.repo_importers.find_one({"repo_id": "test"}) self.assertEqual(test["importer_type_id"], "iso_importer") self.assertEqual( dict(test["config"]), { u"max_downloads": 42, u"feed": u"http://feed.com/isos", u"proxy_host": u"proxy.com", u"proxy_username": u"jeeves", u"remove_missing": False, u"validate": True, }, ) self.assertEqual(test["id"], "iso_importer") # verify that the yum repo wasn't touched a_yum_repo = self.repo_importers.find_one({"repo_id": "a_yum_repo"}) self.assertEqual(a_yum_repo["importer_type_id"], "yum_importer") self.assertEqual(dict(a_yum_repo["config"]), {u"feed_url": u"This should not change."})
def test_migrate(self): # Test migration = _import_all_the_way('pulp_rpm.plugins.migrations.0010_yum_importer_config_keys') migration.migrate() # Verify proxy = self.repo_importers.find_one({'repo_id': 'proxy'}) self.assertTrue('proxy_url' not in proxy['config']) self.assertTrue('proxy_user' not in proxy['config']) self.assertTrue('proxy_pass' not in proxy['config']) self.assertEqual(proxy['config']['proxy_host'], 'localhost') self.assertEqual(proxy['config']['proxy_username'], 'user-1') self.assertEqual(proxy['config']['proxy_password'], 'pass-1') mixed = self.repo_importers.find_one({'repo_id': 'mixed'}) self.assertTrue('feed_url' not in mixed['config']) self.assertTrue('ssl_verify' not in mixed['config']) self.assertTrue('num_threads' not in mixed['config']) self.assertTrue('verify_checksum' not in mixed['config']) self.assertTrue('remove_old' not in mixed['config']) self.assertTrue('num_old_packages' not in mixed['config']) self.assertEqual(mixed['config']['feed'], 'http://localhost/repo') self.assertEqual(mixed['config']['ssl_validation'], True) self.assertEqual(mixed['config']['max_downloads'], 42) self.assertEqual(mixed['config']['validate'], True) self.assertEqual(mixed['config']['remove_missing'], False) self.assertEqual(mixed['config']['retain_old_count'], 3) self.assertEqual(mixed['config']['skip'], ['rpm']) self.assertEqual(mixed['config']['max_speed'], 1024) remove = self.repo_importers.find_one({'repo_id': 'remove'}) self.assertTrue('newest' not in remove['config']) self.assertTrue('verify_size' not in remove['config']) self.assertTrue('purge_orphaned' not in remove['config']) self.assertEqual(remove['config']['feed'], 'localhost') no_touch = self.repo_importers.find_one({'repo_id': 'no-touch'}) self.assertEqual(no_touch['config']['feed'], 'localhost') self.assertEqual(no_touch['config']['newest'], True) self.assertEqual(no_touch['config']['verify_size'], True) self.assertEqual(no_touch['config']['purge_orphaned'], True)
def test_migrate(self): # Test migration = _import_all_the_way("pulp_rpm.plugins.migrations.0010_yum_importer_config_keys") migration.migrate() # Verify proxy = self.repo_importers.find_one({"repo_id": "proxy"}) self.assertTrue("proxy_url" not in proxy["config"]) self.assertTrue("proxy_user" not in proxy["config"]) self.assertTrue("proxy_pass" not in proxy["config"]) self.assertEqual(proxy["config"]["proxy_host"], "localhost") self.assertEqual(proxy["config"]["proxy_username"], "user-1") self.assertEqual(proxy["config"]["proxy_password"], "pass-1") mixed = self.repo_importers.find_one({"repo_id": "mixed"}) self.assertTrue("feed_url" not in mixed["config"]) self.assertTrue("ssl_verify" not in mixed["config"]) self.assertTrue("num_threads" not in mixed["config"]) self.assertTrue("verify_checksum" not in mixed["config"]) self.assertTrue("remove_old" not in mixed["config"]) self.assertTrue("num_old_packages" not in mixed["config"]) self.assertEqual(mixed["config"]["feed"], "http://localhost/repo") self.assertEqual(mixed["config"]["ssl_validation"], True) self.assertEqual(mixed["config"]["max_downloads"], 42) self.assertEqual(mixed["config"]["validate"], True) self.assertEqual(mixed["config"]["remove_missing"], False) self.assertEqual(mixed["config"]["retain_old_count"], 3) self.assertEqual(mixed["config"]["skip"], ["rpm"]) self.assertEqual(mixed["config"]["max_speed"], 1024) remove = self.repo_importers.find_one({"repo_id": "remove"}) self.assertTrue("newest" not in remove["config"]) self.assertTrue("verify_size" not in remove["config"]) self.assertTrue("purge_orphaned" not in remove["config"]) self.assertEqual(remove["config"]["feed"], "localhost") no_touch = self.repo_importers.find_one({"repo_id": "no-touch"}) self.assertEqual(no_touch["config"]["feed"], "localhost") self.assertEqual(no_touch["config"]["newest"], True) self.assertEqual(no_touch["config"]["verify_size"], True) self.assertEqual(no_touch["config"]["purge_orphaned"], True)
def test_move_directory_contents_and_rename(self): test_old_publish_dir = tempfile.mkdtemp(prefix='test_0002_migration_old') old_http_publish_dir = os.path.join(test_old_publish_dir, 'http', 'repos') old_https_publish_dir = os.path.join(test_old_publish_dir, 'https', 'repos') os.makedirs(old_http_publish_dir) os.makedirs(old_https_publish_dir) test_new_publish_dir = tempfile.mkdtemp(prefix='test_0002_migration_new') new_http_publish_dir = os.path.join(test_new_publish_dir, 'puppet', 'http', 'repos') new_https_publish_dir = os.path.join(test_new_publish_dir, 'puppet', 'https', 'repos') migration = _import_all_the_way('pulp_puppet.plugins.migrations.0002_puppet_' 'publishing_directory_change') migration.move_directory_contents_and_rename(test_old_publish_dir, test_new_publish_dir, os.path.basename(test_old_publish_dir), 'puppet') self.assertTrue(os.path.exists(new_http_publish_dir)) self.assertTrue(os.path.exists(new_https_publish_dir)) self.assertFalse(os.path.exists(test_old_publish_dir))
def test_migrate(self): # Setup for type_id in (TYPE_ID_RPM, TYPE_ID_SRPM, TYPE_ID_DRPM): self.add_sample_data(type_id) # Test migration = _import_all_the_way('pulp_rpm.plugins.migrations.0008_version_sort_index') migration.migrate() # Verify # The migration should cover these three types, so make sure they were all included for type_id in (TYPE_ID_RPM, TYPE_ID_SRPM, TYPE_ID_DRPM): collection = types_db.type_units_collection(type_id) test_me = collection.find_one({'version': '1.1'}) self.assertEqual(test_me['version_sort_index'], version_utils.encode('1.1')) self.assertEqual(test_me['release_sort_index'], version_utils.encode('1.1')) # Make sure the script didn't run on units that already have the indexes test_me = collection.find_one({'version': '3.1'}) self.assertEqual(test_me['version_sort_index'], 'fake') self.assertEqual(test_me['release_sort_index'], 'fake')
from unittest import TestCase from mock import patch from pulp.server.db.migrate.models import _import_all_the_way MODULE = 'pulp_rpm.plugins.migrations.0032_ensure_variant_field' migration = _import_all_the_way(MODULE) class TestMigrate(TestCase): """ Test migration 0032. """ @patch(MODULE + '.connection.get_collection') def test_migration(self, get_collection): # test migration.migrate() # validation get_collection.assert_called_once_with('units_distribution') get_collection.return_value.update.assert_called_once_with( {'$or': [{ 'variant': None }, { 'variant': { '$exists': False } }]}, {'$set': { 'variant': ''
def test__import_all_the_way(self): """ Make sure that models._import_all_the_way() gives back the most specific module. """ module = models._import_all_the_way('unit.server.db.migration_packages.z.0001_test') self.assertEqual(module.__name__, 'unit.server.db.migration_packages.z.0001_test')
def test_migration(self, mock_listdir, mock_path_exists, mock_move_directory): migration = _import_all_the_way('pulp_puppet.plugins.migrations.0002_puppet_' 'publishing_directory_change') migration.migrate() mock_listdir.assert_called_once_with('/var/www/pulp_puppet') mock_path_exists.assert_called_once_with('/var/www/pulp_puppet')
# -*- coding: utf-8 -*- import copy import json import unittest import mock from pulp.server.db.migrate.models import _import_all_the_way from pulp_rpm.plugins.db.models import RPM, SRPM migration = _import_all_the_way("pulp_rpm.plugins.migrations.0011_new_importer") class TestMigrateNewImporter(unittest.TestCase): def setUp(self): self.rpm_unit = copy.deepcopy(RPM_UNIT) self.srpm_unit = copy.deepcopy(SRPM_UNIT) @mock.patch.object(migration, "_migrate_collection") def test_types(self, mock_add): migration.migrate() self.assertEqual(mock_add.call_count, 2) mock_add.assert_any_call(RPM.TYPE) mock_add.assert_any_call(SRPM.TYPE) @mock.patch("pulp.plugins.types.database.type_units_collection") def test_adds_size(self, mock_collection): mock_collection.return_value.find.return_value = [self.rpm_unit] self.assertFalse("size" in self.rpm_unit)
handle = MagicMock(spec=file_spec) handle.write.return_value = None fake_file = StringIO(read_data) if read_data is None: if hasattr(handle, '__enter__'): handle.__enter__.return_value = handle else: if hasattr(handle, '__enter__'): handle.__enter__.return_value = fake_file handle.read = fake_file.read mock.return_value = handle return mock migration = _import_all_the_way('pulp.server.db.migrations.0015_load_content_types') class TestMigrate(unittest.TestCase): @patch('pulp.plugins.types.database._drop_indexes') @patch('pulp.plugins.loader.api._generate_plugin_definitions', return_value=[]) @patch('__builtin__.open', mock_open(read_data=_test_type_json)) @patch('os.listdir', return_value=['test_type.json']) @patch('sys.argv', ["pulp-manage-db"]) @patch('sys.stdout', MagicMock()) @patch('pulp.server.db.manage._start_logging') def test_migrate(self, start_logging_mock, listdir_mock, mock_plugin_definitions, mock_drop_indices): """ Ensure that migrate() imports types on a clean types database. """
def test_treeinfo_fix_dot_treeinfo(self, mock_strip_treeinfo, mock_walk): mock_walk.return_value = [('/some/path/', [], ['file-A', '.treeinfo'])] migration = _import_all_the_way( 'pulp_rpm.plugins.migrations.0015_fix_distributor_units') migration._fix_treeinfo_files('/some/path') mock_strip_treeinfo.assert_called_once_with('/some/path/.treeinfo')
def test_treeinfo_fix_dot_treeinfo(self, mock_strip_treeinfo, mock_walk): mock_walk.return_value = [('/some/path/', [], ['file-A', '.treeinfo'])] migration = _import_all_the_way('pulp_rpm.plugins.migrations.0015_fix_distributor_units') migration._fix_treeinfo_files('/some/path') mock_strip_treeinfo.assert_called_once_with('/some/path/.treeinfo')
from pulp.common.compat import unittest from pulp.server.db.migrate.models import _import_all_the_way, MigrationRemovedError migration = _import_all_the_way( 'pulp_rpm.plugins.migrations.0014_migrations_removed') class TestMigrate(unittest.TestCase): def test_raises_exception(self): with self.assertRaises(MigrationRemovedError) as assertion: migration.migrate() self.assertEqual(assertion.exception.migration_version, '0014') self.assertEqual(assertion.exception.component_version, '2.8.0') self.assertEqual(assertion.exception.min_component_version, '2.4.0') self.assertEqual(assertion.exception.component, 'pulp_rpm')
import tempfile import os import shutil import unittest from pulp.devel.unit import util from pulp.server.db.migrate.models import _import_all_the_way import mock migration = _import_all_the_way( 'pulp_rpm.plugins.migrations.0020_nested_drpm_directory') DATA_DIR = os.path.join(os.path.dirname(__file__), '../../../data/') class TestMigrate(unittest.TestCase): def setUp(self): # Create the sample environment self.working_dir = tempfile.mkdtemp() # Create the nested drpm directory drpm_foo = os.path.join(self.working_dir, 'drpms', 'drpms', 'foo.drpm') util.touch(os.path.join(drpm_foo)) # create the repomd files & prestodelta files self.repodata_dir = os.path.join(self.working_dir, 'repodata') os.makedirs(self.repodata_dir) self.good_presto = os.path.join(self.working_dir, 'repodata', 'good-prestodelta.xml.gz') util.touch(self.good_presto) self.bad_presto = os.path.join(self.working_dir, 'repodata', 'bad-prestodelta.xml.gz')
""" This module contains tests for pulp.server.db.migrations.0014_pulp_user_metadata. """ import unittest import mock from pulp.server import constants from pulp.server.db.migrate.models import _import_all_the_way migration = _import_all_the_way( 'pulp.server.db.migrations.0014_pulp_user_metadata') class TestMigrate(unittest.TestCase): """ Test the migrate() function. """ @mock.patch( 'pulp.server.db.migrations.0014_pulp_user_metadata.database.type_units_collection' ) @mock.patch( 'pulp.server.db.migrations.0014_pulp_user_metadata.factory.plugin_manager' ) def test_migrate(self, plugin_manager, type_units_collection): """ Ensure that migrate() runs the correct queries on the correct collections. """ types = [{'id': 'type_a'}, {'id': 'type_2'}] class MockPluginManager(object):
""" This module contains unit tests for pulp.server.db.migrations.0012_reserved_resources_schema_change. """ import unittest from mock import call, patch from pulp.server.db.migrate.models import _import_all_the_way migration = _import_all_the_way( 'pulp.server.db.migrations.0012_reserved_resources_schema_change') class TestMigrate(unittest.TestCase): """ Test the migrate() function. """ @patch( 'pulp.server.db.migrations.0012_reserved_resources_schema_change._migrate_task_status', side_effect=migration._migrate_task_status) @patch('pulp.server.db.migrations.0012_reserved_resources_schema_change.' '_migrate_reserved_resources', side_effect=migration._migrate_reserved_resources) @patch( 'pulp.server.db.migrations.0012_reserved_resources_schema_change.connection.get_collection', autospec=True) def test_calls_correct_functions(self, get_collection, _migrate_reserved_resources, _migrate_task_status): """ Assert that migrate() calls the correct other functions that do the real work.
""" This module contains tests for pulp.server.db.migrations.0018_remove_archived_calls. """ import unittest from mock import patch from pulp.server.db.migrate.models import _import_all_the_way migration = _import_all_the_way('pulp.server.db.migrations.0018_remove_archived_calls') class TestMigrate(unittest.TestCase): """ Test the migrate() function. """ @patch.object(migration.connection, 'get_database') def test_migrate_no_collection_archived_calls(self, mock_get_database): """ Assert that drop is not called when archived_calls is not present in the db """ mock_get_database.return_value.collection_names.return_value = [] collection = mock_get_database.return_value['archived_calls'] migration.migrate() self.assertFalse(collection.drop.called) @patch.object(migration.connection, 'get_database') def test_migrate_collection_present_archived_calls(self, mock_get_database): """
""" This module contains tests for pulp.server.db.migrations.0020_drop_celery_taskmeta.py """ import unittest from mock import patch from pulp.server.db.migrate.models import _import_all_the_way migration = _import_all_the_way( 'pulp.server.db.migrations.0020_drop_celery_taskmeta') class TestMigrate(unittest.TestCase): """ Test the migrate() function. """ @patch.object(migration.connection, 'get_database') def test_celery_taskmeta_collection_dropped(self, mock_get_database): mock_get_database.return_value.collection_names.return_value = [] collection = mock_get_database.return_value['celery_taskmeta'] migration.migrate() collection.drop.assert_called_once()
""" This module contains tests for pulp.server.db.migrations.0019_repo_collection_id.py """ import unittest from mock import patch from pulp.server.db.migrate.models import _import_all_the_way migration = _import_all_the_way('pulp.server.db.migrations.0019_repo_collection_id') class TestMigrate(unittest.TestCase): """ Test the migrate() function. """ @patch.object(migration.connection, 'get_database') def test_repos_collection_id_renamed(self, mock_get_database): mock_get_database.return_value.collection_names.return_value = [] collection = mock_get_database.return_value['archived_calls'] migration.migrate() collection.update.assert_called_once_with({}, {"$rename": {"id": "repo_id"}}) collection.drop_index.assert_called_once_with("id_-1")
import os.path import unittest from pulp.server.db.migrate.models import _import_all_the_way import mock migration = _import_all_the_way( 'pulp_rpm.plugins.migrations.0019_add_timestamp_' 'to_distribution') class TestMigrate(unittest.TestCase): """ Test the migrate() function. """ @mock.patch.object(migration, 'get_collection') def test_calls_correct_functions(self, mock_get_collection): """ """ mock_get_collection.return_value.find.return_value = [ fake_distribution1, ] migration.migrate() self.assertEqual(mock_get_collection.call_count, 1) mock_get_collection.return_value.update.assert_called_once_with( {'_id': fake_distribution1['_id']}, {'$set': { 'timestamp': 1354213090.94 }},
import os import shutil import tempfile import unittest import mock from pulp.devel.unit import util from pulp.server.db.migrate.models import _import_all_the_way migration = _import_all_the_way( 'pulp_rpm.plugins.migrations.0021_clean_http_directories') class TestMigrate(unittest.TestCase): """ Test migration 0021. """ @mock.patch('pulp_rpm.plugins.migrations.0021_clean_http_directories.' 'configuration') @mock.patch('pulp_rpm.plugins.migrations.0021_clean_http_directories.' 'walk_and_clean_directories') def test_walk_correct_directories(self, mock_walk, mock_conf): """Migration should check http and https simple serve directories""" mock_conf.get_http_publish_dir.return_value = 'http' mock_conf.get_https_publish_dir.return_value = 'https' migration.migrate() mock_walk.assert_has_calls([mock.call('https'), mock.call('http')]) def setUp(self): """Setup a publish base"""
from pulp.common.compat import unittest import mock from pymongo.errors import DuplicateKeyError from pulp.server.db.migrate.models import _import_all_the_way PATH_TO_MODULE = 'pulp_rpm.plugins.migrations.0040_errata_pkglist_collection' migration = _import_all_the_way(PATH_TO_MODULE) @mock.patch('pulp.server.db.connection.get_database') @mock.patch.object(migration, 'migrate_erratum_pkglist') class TestMigrate(unittest.TestCase): def test_calls_migrate_erratum_pkglist(self, mock_migrate_pkglist, mock_get_db): mock_db = mock_get_db.return_value mock_unit = mock.MagicMock() mock_erratum_collection = mock_db['units_erratum'] mock_pkglist_collection = mock_db['erratum_pkglists'] mock_erratum_collection.find.return_value.batch_size.return_value = [ mock_unit ] migration.migrate() self.assertEqual(mock_migrate_pkglist.call_count, 1) mock_migrate_pkglist.assert_called_with(mock_erratum_collection, mock_pkglist_collection, mock_unit)
""" This module contains tests for pulp.server.db.migrations.0021_remove_extra_importer_fields.py """ import unittest import mock from pulp.server.db.migrate.models import _import_all_the_way migration = _import_all_the_way( 'pulp.server.db.migrations.0021_remove_extra_importer_fields') class TestMigrate(unittest.TestCase): """ Test the migrate() function. """ @classmethod def setUpClass(cls): """ Run the migration """ with mock.patch.object(migration.connection, 'get_database') as mock_db: cls.collection = mock_db.return_value['archived_calls'] migration.migrate() def test_index_removed(self): """ Assert that the old index is removed. """
def test_migration(self): """ Assert that the migration adds the appropriate hashes to the three consumers. """ consumer_unit_profiles = [ { "consumer_id": "consumer_1", "content_type": "rpm", "profile": [ { "name": "Package A", "epoch": 0, "version": "1.0.1", "release": "1.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, { "name": "Package B", "epoch": 0, "version": "2.0.3", "release": "3.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, { "name": "Package C", "epoch": 0, "version": "1.3.6", "release": "2.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, ], }, { "consumer_id": "consumer_2", "content_type": "rpm", "profile": [ { "name": "Package B", "epoch": 0, "version": "2.0.3", "release": "3.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, { "name": "Package A", "epoch": 0, "version": "1.0.1", "release": "1.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, { "name": "Package C", "epoch": 0, "version": "1.3.6", "release": "2.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, ], }, { "consumer_id": "consumer_3", "content_type": "rpm", "profile": [ { "name": "Package A", "epoch": 0, "version": "1.0.1", "release": "1.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, { "name": "Package B", "epoch": 0, "version": "2.0.3", "release": "3.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, { "name": "Package C", "epoch": 0, "version": "1.3.6", "release": "2.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, { "name": "Package D", "epoch": 1, "version": "12.1.6", "release": "27.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, ], }, { "consumer_id": "consumer_3", "content_type": "some_other_type_that_should_be_left_alone", "profile": [ { "name": "Package A", "epoch": 0, "version": "1.0.1", "release": "1.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, { "name": "Package B", "epoch": 0, "version": "2.0.3", "release": "3.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, { "name": "Package C", "epoch": 0, "version": "1.3.6", "release": "2.el6", "arch": "x86_64", "vendor": "Red Hat, Inc.", }, ], }, ] self.collection.insert(consumer_unit_profiles) migration_module = _import_all_the_way("pulp_rpm.migrations.0014_add_consumer_profile_hash") # Run the migration migration_module.migrate("arg_1", kwarg_1="kwarg_1") # Get the profiles consumer_1_profile = self.collection.find_one({"consumer_id": "consumer_1"}) consumer_2_profile = self.collection.find_one({"consumer_id": "consumer_2"}) consumer_3_rpm_profile = self.collection.find_one({"consumer_id": "consumer_3", "content_type": "rpm"}) consumer_3_other_profile = self.collection.find_one( {"consumer_id": "consumer_3", "content_type": "some_other_type_that_should_be_left_alone"} ) # Consumer 1 and Consumer 2 should have the same hashes, even though the RPMs were recorded # in a different order self.assertEqual(consumer_1_profile["profile_hash"], consumer_2_profile["profile_hash"]) # Consumer 3 should have a different hash, since it has an additional package self.assertNotEqual(consumer_1_profile["profile_hash"], consumer_3_rpm_profile["profile_hash"]) # Consumer 3's non-RPM profile should not have a hash self.assertTrue("profile_hash" not in consumer_3_other_profile) # Now, let's make sure the hashes are actually correct. We only have to check 1 and 3, since # we already asserted that 1 is equal to 2 profiler = yum.YumProfiler() for profile in [consumer_1_profile, consumer_3_rpm_profile]: sorted_profile = profiler.update_profile(None, profile["profile"], None, None) expected_hash = UnitProfile.calculate_hash(profile["profile"]) self.assertEqual(profile["profile_hash"], expected_hash)
""" This module contains unit tests for pulp_rpm.plugins.migrations.0017_merge_sha_sha1.py. """ import unittest from pulp.server.db.migrate.models import _import_all_the_way from pymongo import collection, errors import mock migration = _import_all_the_way('pulp_rpm.plugins.migrations.0017_merge_sha_sha1') SUM_NONE_ERRATA = [ {u'issued': u'2012-01-27 16:08:06', u'references': [], u'_content_type_id': u'erratum', u'id': u'RHEA-2012:0002', u'from': u'*****@*****.**', u'severity': u'', u'title': u'Sea_Erratum', u'_ns': u'units_erratum', u'version': u'1', u'reboot_suggested': True, u'type': u'security', u'pkglist': [ {u'packages': [ {u'src': u'http://www.fedoraproject.org', u'name': u'walrus', u'sum': None, u'filename': u'walrus-0.71-1.noarch.rpm', u'epoch': u'0', u'version': u'0.71', u'release': u'1', u'reboot_suggested': u'False', u'arch': u'noarch'}, {u'src': u'http://www.fedoraproject.org', u'name': u'penguin', u'sum': None, u'filename': u'penguin-0.9.1-1.noarch.rpm', u'epoch': u'0', u'version': u'0.9.1', u'release': u'1', u'reboot_suggested': u'False', u'arch': u'noarch'}, {u'src': u'http://www.fedoraproject.org', u'name': u'shark', u'sum': None, u'filename': u'shark-0.1-1.noarch.rpm', u'epoch': u'0', u'version': u'0.1', u'release': u'1', u'reboot_suggested': u'False', u'arch': u'noarch'}], u'name': u'1', u'short': u''}], u'status': u'stable', u'updated': u'', u'description': u'Sea_Erratum', u'_last_updated': 1416857488, u'pushcount': u'', u'_storage_path': None, u'rights': u'',
""" This module contains functional tests for the 23rd migration. """ import os import shutil import stat import tempfile import unittest import mock from pulp.server.db import connection from pulp.server.db.migrate.models import _import_all_the_way migration = _import_all_the_way('pulp.server.db.migrations.0023_importer_tls_storage') class TestMigrate(unittest.TestCase): def tearDown(self): """ Remove any database objects that were created during the test. """ connection._DATABASE.repo_importers.remove() def test_LOCAL_STORAGE(self): """ Assert that the LOCAL_STORAGE variable is correct. """ self.assertEqual(migration.LOCAL_STORAGE, '/var/lib/pulp')
""" This module contains functional tests for the 23rd migration. """ import os import shutil import stat import tempfile import unittest import mock from pulp.server.db import connection from pulp.server.db.migrate.models import _import_all_the_way migration = _import_all_the_way( 'pulp.server.db.migrations.0023_importer_tls_storage') class TestMigrate(unittest.TestCase): def tearDown(self): """ Remove any database objects that were created during the test. """ connection._DATABASE.repo_importers.remove() def test_LOCAL_STORAGE(self): """ Assert that the LOCAL_STORAGE variable is correct. """ self.assertEqual(migration.LOCAL_STORAGE, '/var/lib/pulp')
""" This module contains tests for pulp.server.db.migrations.0014_pulp_user_metadata. """ import unittest import mock from pulp.server import constants from pulp.server.db.migrate.models import _import_all_the_way migration = _import_all_the_way('pulp.server.db.migrations.0014_pulp_user_metadata') class TestMigrate(unittest.TestCase): """ Test the migrate() function. """ @mock.patch('pulp.server.db.migrations.0014_pulp_user_metadata.database.type_units_collection') @mock.patch('pulp.server.db.migrations.0014_pulp_user_metadata.factory.plugin_manager') def test_migrate(self, plugin_manager, type_units_collection): """ Ensure that migrate() runs the correct queries on the correct collections. """ types = [{'id': 'type_a'}, {'id': 'type_2'}] class MockPluginManager(object): def types(self): return types plugin_manager.return_value = MockPluginManager()
mock = MagicMock(spec=file_spec) handle = MagicMock(spec=file_spec) handle.write.return_value = None fake_file = StringIO(read_data) if read_data is None: if hasattr(handle, '__enter__'): handle.__enter__.return_value = handle else: if hasattr(handle, '__enter__'): handle.__enter__.return_value = fake_file handle.read = fake_file.read mock.return_value = handle return mock migration = _import_all_the_way('pulp.server.db.migrations.0015_load_content_types') class TestMigrate(unittest.TestCase): @patch('pulp.plugins.types.database._drop_indexes') @patch('__builtin__.open', mock_open(read_data=_test_type_json)) @patch('os.listdir', return_value=['test_type.json']) @patch('sys.argv', ["pulp-manage-db"]) @patch('sys.stdout', MagicMock()) @patch('pulp.server.db.manage._start_logging') def test_migrate(self, start_logging_mock, listdir_mock, mock_drop_indices): """ Ensure that migrate() imports types on a clean types database. """ migration.migrate() self.assertTrue(mock_drop_indices.called)
def test_migration(self, mock_listdir, mock_path_exists, mock_move_directory): migration = _import_all_the_way('pulp_puppet.plugins.migrations.0002_puppet_' 'publishing_directory_change') migration.migrate() mock_listdir.assert_called_once_with('/var/www/pulp_puppet') mock_path_exists.assert_has_call('/var/www/pulp_puppet')
""" This module contains tests for pulp.server.db.migrations.0022_distributor_collection_trim.py """ import unittest import mock from pulp.server.db.migrate.models import _import_all_the_way migration = _import_all_the_way( 'pulp.server.db.migrations.0022_distributor_collection_trim') class TestMigrate(unittest.TestCase): """ Test the migrate() function. """ @classmethod def setUpClass(cls): """ Run the migration """ with mock.patch.object(migration.connection, 'get_database') as mock_db: cls.collection = mock_db.return_value['archived_calls'] migration.migrate() def test_index_removed(self): """ Assert that the old index is removed. """
""" This module contains tests for pulp.server.db.migrations.0015_load_content_types. """ import unittest from mock import Mock, call, patch from pulp.server.db.migrate.models import _import_all_the_way migration = _import_all_the_way('pulp.server.db.migrations.' '0016_remove_repo_content_unit_owner_type_and_id') class TestMigrate(unittest.TestCase): @patch.object(migration.connection, 'get_database') def test_migrate_no_collection_in_db(self, mock_get_database): """ Test doing nothing, no actual tests since if it tries to do any work it will raise """ mock_get_database.return_value.collection_names.return_value = [] migration.migrate() @patch.object(migration.connection, 'get_database') @patch.object(migration, 'remove_duplicates') def test_migrate_removes_duplicates(self, mock_remove_duplicates, mock_get_database): """ Test that the migration calls the remove_duplicates method & drops the owner_type and owner_id fields from the repo_content_units collection """ mock_get_database.return_value.collection_names.return_value = ['repo_content_units'] collection = mock_get_database.return_value['repo_content_units']
def test_migration(self): """ Assert that the migration adds the appropriate hashes to the three consumers. """ consumer_unit_profiles = [ {'consumer_id': 'consumer_1', 'content_type': 'rpm', 'profile': [{'name': 'Package A', 'epoch': 0, 'version': '1.0.1', 'release': '1.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}, {'name': 'Package B', 'epoch': 0, 'version': '2.0.3', 'release': '3.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}, {'name': 'Package C', 'epoch': 0, 'version': '1.3.6', 'release': '2.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}]}, {'consumer_id': 'consumer_2', 'content_type': 'rpm', 'profile': [{'name': 'Package B', 'epoch': 0, 'version': '2.0.3', 'release': '3.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}, {'name': 'Package A', 'epoch': 0, 'version': '1.0.1', 'release': '1.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}, {'name': 'Package C', 'epoch': 0, 'version': '1.3.6', 'release': '2.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}]}, {'consumer_id': 'consumer_3', 'content_type': 'rpm', 'profile': [{'name': 'Package A', 'epoch': 0, 'version': '1.0.1', 'release': '1.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}, {'name': 'Package B', 'epoch': 0, 'version': '2.0.3', 'release': '3.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}, {'name': 'Package C', 'epoch': 0, 'version': '1.3.6', 'release': '2.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}, {'name': 'Package D', 'epoch': 1, 'version': '12.1.6', 'release': '27.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}]}, {'consumer_id': 'consumer_3', 'content_type': 'some_other_type_that_should_be_left_alone', 'profile': [{'name': 'Package A', 'epoch': 0, 'version': '1.0.1', 'release': '1.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}, {'name': 'Package B', 'epoch': 0, 'version': '2.0.3', 'release': '3.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}, {'name': 'Package C', 'epoch': 0, 'version': '1.3.6', 'release': '2.el6', 'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'}]}, ] self.collection.insert(consumer_unit_profiles) migration_module = _import_all_the_way( 'pulp_rpm.plugins.migrations.0014_add_consumer_profile_hash') # Run the migration migration_module.migrate('arg_1', kwarg_1='kwarg_1') # Get the profiles consumer_1_profile = self.collection.find_one({'consumer_id': 'consumer_1'}) consumer_2_profile = self.collection.find_one({'consumer_id': 'consumer_2'}) consumer_3_rpm_profile = self.collection.find_one({'consumer_id': 'consumer_3', 'content_type': 'rpm'}) consumer_3_other_profile = self.collection.find_one( {'consumer_id': 'consumer_3', 'content_type': 'some_other_type_that_should_be_left_alone'}) # Consumer 1 and Consumer 2 should have the same hashes, even though the RPMs were recorded # in a different order self.assertEqual(consumer_1_profile['profile_hash'], consumer_2_profile['profile_hash']) # Consumer 3 should have a different hash, since it has an additional package self.assertNotEqual(consumer_1_profile['profile_hash'], consumer_3_rpm_profile['profile_hash']) # Consumer 3's non-RPM profile should not have a hash self.assertTrue('profile_hash' not in consumer_3_other_profile) # Now, let's make sure the hashes are actually correct. We only have to check 1 and 3, since # we already asserted that 1 is equal to 2 profiler = yum.YumProfiler() for profile in [consumer_1_profile, consumer_3_rpm_profile]: profiler.update_profile(None, profile['profile'], None, None) expected_hash = UnitProfile.calculate_hash(profile['profile']) self.assertEqual(profile['profile_hash'], expected_hash)
""" This module contains unit tests for pulp_rpm.plugins.migrations.0018_remove_old_repo_profile_applicability. """ import unittest from pulp.server.db.migrate.models import _import_all_the_way import mock migration = _import_all_the_way('pulp_rpm.plugins.migrations.0018_remove_old_' 'repo_profile_applicability') class TestMigrate(unittest.TestCase): """ Test the migrate() function. """ @mock.patch('pulp_rpm.plugins.migrations.0018_remove_old_repo_profile_applicability.' 'connection.get_collection') def test_calls_correct_functions(self, get_collection): """ Assert that migrate() drops the collection it should """ fake_rpa = mock.Mock() get_collection.return_value = fake_rpa migration.migrate() get_collection.assert_called_once_with('repo_profile_applicability') fake_rpa.drop.assert_called_once_with()
from pulp.common.compat import unittest from pulp.server.db.migrate.models import _import_all_the_way, MigrationRemovedError migration = _import_all_the_way( 'pulp.server.db.migrations.0006_migrations_removed') class TestMigrate(unittest.TestCase): def test_raises_exception(self): with self.assertRaises(MigrationRemovedError) as assertion: migration.migrate() self.assertEqual(assertion.exception.migration_version, '0006') self.assertEqual(assertion.exception.component_version, '2.8.0') self.assertEqual(assertion.exception.min_component_version, '2.4.0') self.assertEqual(assertion.exception.component, 'pulp')
from pulp.common.compat import unittest import mock from pulp.server.db.migrate.models import _import_all_the_way PATH_TO_MODULE = 'pulp_rpm.plugins.migrations.0031_checksums_and_templates' migration = _import_all_the_way(PATH_TO_MODULE) @mock.patch('pulp.server.db.connection.get_database') @mock.patch.object(migration, 'migrate_rpm_base') @mock.patch.object(migration, 'migrate_drpms') class TestMigrate(unittest.TestCase): def test_calls_migrate_rpm_base(self, mock_migrate_drpms, mock_migrate_rpm_base, mock_get_db): mock_db = mock_get_db.return_value mock_unit = mock.MagicMock() mock_rpm_collection = mock_db['units_rpm'] mock_rpm_collection.find.return_value = [mock_unit] mock_srpm_collection = mock_db['units_srpm'] mock_srpm_collection.find.return_value = [mock_unit] migration.migrate() self.assertEqual(mock_migrate_rpm_base.call_count, 2) mock_migrate_rpm_base.assert_called_with(mock_rpm_collection, mock_unit) mock_migrate_rpm_base.assert_called_with(mock_srpm_collection, mock_unit) def test_calls_migrate_drpms(self, mock_migrate_drpms, mock_migrate_rpm_base, mock_get_db): mock_db = mock_get_db.return_value
import os.path import unittest from pulp.server.db.migrate.models import _import_all_the_way import mock migration = _import_all_the_way('pulp_rpm.plugins.migrations.0019_add_timestamp_' 'to_distribution') class TestMigrate(unittest.TestCase): """ Test the migrate() function. """ @mock.patch.object(migration, 'get_collection') def test_calls_correct_functions(self, mock_get_collection): """ """ mock_get_collection.return_value.find.return_value = [ fake_distribution1, ] migration.migrate() self.assertEqual(mock_get_collection.call_count, 1) mock_get_collection.return_value.update.assert_called_once_with( {'_id': fake_distribution1['_id']}, {'$set': {'timestamp': 1354213090.94}}, safe=True )