def test_pulp_manage_db_loads_types(self, start_logging_mock, listdir_mock):
"""
Test calling pulp-manage-db imports types on a clean types database.
"""
manage.main()
all_collection_names = types_db.all_type_collection_names()
self.assertEqual(len(all_collection_names), 1)
self.assertEqual(['units_test_type_id'], all_collection_names)
# Let's make sure we loaded the type definitions correctly
db_type_definitions = types_db.all_type_definitions()
self.assertEquals(len(db_type_definitions), 1)
test_json = json.loads(_test_type_json)
for attribute in ['id', 'display_name', 'description', 'unit_key', 'search_indexes']:
self.assertEquals(test_json['types'][0][attribute], db_type_definitions[0][attribute])
# Now let's ensure that we have the correct indexes
collection = types_db.type_units_collection('test_type_id')
indexes = collection.index_information()
self.assertEqual(indexes['_id_']['key'], [(u'_id', 1)])
# Make sure we have the unique constraint on all three attributes
self.assertEqual(indexes['attribute_1_1_attribute_2_1_attribute_3_1']['unique'], True)
self.assertEqual(indexes['attribute_1_1_attribute_2_1_attribute_3_1']['dropDups'], False)
self.assertEqual(indexes['attribute_1_1_attribute_2_1_attribute_3_1']['key'],
[(u'attribute_1', 1), (u'attribute_2', 1), (u'attribute_3', 1)])
# Make sure we indexes attributes 1 and 3
self.assertEqual(indexes['attribute_1_1']['dropDups'], False)
self.assertEqual(indexes['attribute_1_1']['key'], [(u'attribute_1', 1)])
self.assertEqual(indexes['attribute_3_1']['dropDups'], False)
self.assertEqual(indexes['attribute_3_1']['key'], [(u'attribute_3', 1)])
# Make sure we only have the indexes that we've hand inspected here
self.assertEqual(indexes.keys(), [u'_id_', u'attribute_1_1_attribute_2_1_attribute_3_1',
u'attribute_1_1', u'attribute_3_1'])
def test_dry_run_no_changes(self, mock_file_config, mock_parse_args, initialize,
mocked_apply_migration, mock_entry, getLogger, mock_ensure_indexes):
logger = MagicMock()
getLogger.return_value = logger
mock_args = Namespace(dry_run=True, test=False)
mock_parse_args.return_value = mock_args
# Test that when dry run is on, it returns 1 if migrations remain
exit_code = manage.main()
self.assertEqual(exit_code, 1)
self.assertFalse(mock_ensure_indexes.called)
initialize.assert_called_once_with(max_timeout=1)
# Actually apply the migrations
mock_args.dry_run = False
mock_ensure_indexes.reset_mock()
initialize.reset_mock()
exit_code = manage.main()
self.assertEqual(exit_code, 0)
self.assertTrue(mock_ensure_indexes.called)
initialize.assert_called_once_with(max_timeout=1)
# Perform another dry run and check the return value is now 0
mock_args.dry_run = True
mock_ensure_indexes.reset_mock()
initialize.reset_mock()
exit_code = manage.main()
self.assertEquals(exit_code, 0)
self.assertFalse(mock_ensure_indexes.called)
initialize.assert_called_once_with(max_timeout=1)
def test_user_not_prompted_if_workers_timeout(self, mock__auto_manage_db, mock__user_input,
mock_get_workers, *unused_mocks):
mock_get_workers.return_value = [{'last_heartbeat':
UTCDateTimeField().to_python(datetime(2000, 1, 1))}]
manage.main()
# make sure user is not asked for input when workers have timed out
self.assertFalse(mock__user_input.called)
def test_pulp_manage_db_loads_types(self, start_logging_mock, listdir_mock):
"""
Test calling pulp-manage-db imports types on a clean types database.
"""
manage.main()
all_collection_names = types_db.all_type_collection_names()
self.assertEqual(len(all_collection_names), 1)
self.assertEqual(['units_test_type_id'], all_collection_names)
# Let's make sure we loaded the type definitions correctly
db_type_definitions = types_db.all_type_definitions()
self.assertEquals(len(db_type_definitions), 1)
test_json = json.loads(_test_type_json)
for attribute in ['id', 'display_name', 'description', 'unit_key', 'search_indexes']:
self.assertEquals(test_json['types'][0][attribute], db_type_definitions[0][attribute])
# Now let's ensure that we have the correct indexes
collection = types_db.type_units_collection('test_type_id')
indexes = collection.index_information()
self.assertEqual(indexes['_id_']['key'], [(u'_id', 1)])
# Make sure we have the unique constraint on all three attributes
self.assertEqual(indexes['attribute_1_1_attribute_2_1_attribute_3_1']['unique'], True)
self.assertEqual(indexes['attribute_1_1_attribute_2_1_attribute_3_1']['dropDups'], False)
self.assertEqual(indexes['attribute_1_1_attribute_2_1_attribute_3_1']['key'],
[(u'attribute_1', 1), (u'attribute_2', 1), (u'attribute_3', 1)])
# Make sure we indexes attributes 1 and 3
self.assertEqual(indexes['attribute_1_1']['dropDups'], False)
self.assertEqual(indexes['attribute_1_1']['key'], [(u'attribute_1', 1)])
self.assertEqual(indexes['attribute_3_1']['dropDups'], False)
self.assertEqual(indexes['attribute_3_1']['key'], [(u'attribute_3', 1)])
# Make sure we only have the indexes that we've hand inspected here
self.assertEqual(indexes.keys(), [u'_id_', u'attribute_1_1_attribute_2_1_attribute_3_1',
u'attribute_1_1', u'attribute_3_1'])
def test_migrate(self, mock_file_config, initialize,
mocked_apply_migration, getLogger):
"""
Let's set all the packages to be at version 0, and then check that the migrations get
called in the correct order.
"""
logger = MagicMock()
getLogger.return_value = logger
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.objects().count(), 0)
# Make sure that our mock works. There are three valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
# Set all versions back to 0
for package in models.get_migration_packages():
package._migration_tracker.version = 0
package._migration_tracker.save()
manage.main()
# There should have been a critical log about the Exception
expected_messages = (
'Applying migration '
'unit.server.db.migration_packages.raise_exception.0002_oh_no failed.\n\n'
'Halting migrations due to a migration failure.',
"Bet you didn\'t see this coming.")
critical_messages = ''.join(
[mock_call[1][0] for mock_call in logger.critical.mock_calls])
for msg in expected_messages:
self.assertTrue(msg in critical_messages)
migration_modules_called = [
mock_call[1][1].name
for mock_call in mocked_apply_migration.mock_calls
]
# Note that none of the migrations that don't meet our criteria show up in this list. Also,
# Note that migration_packages.raise_exception.0003_shouldnt_run doesn't appear
# since migration_packages.raise_exception.0002_oh_no raised an Exception. Note
# also that even though the raise_exception package raised an Exception, we still run all
# the z migrations because we don't want one package to break another.
expected_migration_modules_called = [
'unit.server.db.migration_packages.platform.0001_stuff_and_junk',
'unit.server.db.migration_packages.raise_exception.0001_works_fine',
'unit.server.db.migration_packages.raise_exception.0002_oh_no'
]
self.assertEquals(migration_modules_called,
expected_migration_modules_called)
# Assert that our precious versions have been updated correctly
for package in models.get_migration_packages():
if package.name == 'unit.server.db.migration_packages.platform':
self.assertEqual(package.current_version,
package.latest_available_version)
elif package.name == 'unit.server.db.migration_packages.raise_exception':
# The raised Exception should have prevented us from getting past version 1
self.assertEquals(package.current_version, 1)
else:
# raise_exception should cause the migrations to stop
self.assertEqual(package.current_version, 0)
initialize.assert_called_once_with(max_timeout=1)
def test_migrate_with_new_packages(self, initialize, start_logging_mock,
logger_mock, mocked_stdout,
mocked_stderr):
"""
Adding new packages to a system that doesn't have any trackers should advance
each package to the latest available version, applying all migrate() functions along the
way.
"""
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.objects().count(), 0)
# Make sure that our mock works. There are four valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
manage.main()
for package in models.get_migration_packages():
if 'raise_exception' in str(package):
# The Exception raising package should get to version 1, because version 2 raises
self.assertEqual(package.current_version, 1)
elif 'z' in str(package):
self.assertEquals(package.current_version, 0)
else:
# All other packages should reach their top versions
self.assertEqual(package.current_version,
package.latest_available_version)
initialize.assert_called_once_with(max_timeout=1)
def test_migrate(self, mock_file_config, initialize, mocked_apply_migration, getLogger):
"""
Let's set all the packages to be at version 0, and then check that the migrations get
called in the correct order.
"""
logger = MagicMock()
getLogger.return_value = logger
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.objects().count(), 0)
# Make sure that our mock works. There are three valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
# Set all versions back to 0
for package in models.get_migration_packages():
package._migration_tracker.version = 0
package._migration_tracker.save()
manage.main()
# There should have been a critical log about the Exception
expected_messages = (
'Applying migration '
'unit.server.db.migration_packages.raise_exception.0002_oh_no failed.\n\n'
'Halting migrations due to a migration failure.',
"Bet you didn\'t see this coming."
)
critical_messages = ''.join([mock_call[1][0] for mock_call in logger.critical.mock_calls])
for msg in expected_messages:
self.assertTrue(msg in critical_messages)
migration_modules_called = [
mock_call[1][1].name for mock_call in mocked_apply_migration.mock_calls]
# Note that none of the migrations that don't meet our criteria show up in this list. Also,
# Note that migration_packages.raise_exception.0003_shouldnt_run doesn't appear
# since migration_packages.raise_exception.0002_oh_no raised an Exception. Note
# also that even though the raise_exception package raised an Exception, we still run all
# the z migrations because we don't want one package to break another.
expected_migration_modules_called = [
'unit.server.db.migration_packages.platform.0001_stuff_and_junk',
'unit.server.db.migration_packages.raise_exception.0001_works_fine',
'unit.server.db.migration_packages.raise_exception.0002_oh_no']
self.assertEquals(migration_modules_called, expected_migration_modules_called)
# Assert that our precious versions have been updated correctly
for package in models.get_migration_packages():
if package.name == 'unit.server.db.migration_packages.platform':
self.assertEqual(package.current_version, package.latest_available_version)
elif package.name == 'unit.server.db.migration_packages.raise_exception':
# The raised Exception should have prevented us from getting past version 1
self.assertEquals(package.current_version, 1)
else:
# raise_exception should cause the migrations to stop
self.assertEqual(package.current_version, 0)
initialize.assert_called_once_with(max_timeout=1)
def test_migrate(self, file_config_mock, logger_mock,
mocked_apply_migration, mocked_stdout, mocked_stderr):
"""
Let's set all the packages to be at version 0, and then check that the migrations get
called in the correct order.
"""
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.get_collection().find({}).count(),
0)
# Make sure that our mock works. There are three valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
# Set all versions back to 0
for package in models.get_migration_packages():
package._migration_tracker.version = 0
package._migration_tracker.save()
manage.main()
# There should have been a print to stderr about the Exception
expected_stderr_calls = [(
'Applying migration unit.server.db.migration_packages.raise_exception.0002_oh_no '
'failed.'), ' ', ' See log for details.', '\n']
stderr_calls = [
mock_call[1][0] for mock_call in mocked_stderr.mock_calls
]
self.assertEquals(stderr_calls, expected_stderr_calls)
migration_modules_called = [
mock_call[1][1].name
for mock_call in mocked_apply_migration.mock_calls
]
# Note that none of the migrations that don't meet our criteria show up in this list. Also,
# Note that migration_packages.raise_exception.0003_shouldnt_run doesn't appear
# since migration_packages.raise_exception.0002_oh_no raised an Exception. Note
# also that even though the raise_exception package raised an Exception, we still run all
# the z migrations because we don't want one package to break another.
expected_migration_modules_called = [
'unit.server.db.migration_packages.platform.0001_stuff_and_junk',
'unit.server.db.migration_packages.raise_exception.0001_works_fine',
'unit.server.db.migration_packages.raise_exception.0002_oh_no',
'unit.server.db.migration_packages.z.0001_test',
'unit.server.db.migration_packages.z.0002_test',
'unit.server.db.migration_packages.z.0003_test'
]
self.assertEquals(migration_modules_called,
expected_migration_modules_called)
# Assert that our precious versions have been updated correctly
for package in models.get_migration_packages():
if package.name != 'unit.server.db.migration_packages.raise_exception':
self.assertEqual(package.current_version,
package.latest_available_version)
else:
# The raised Exception should have prevented us from getting past version 1
self.assertEqual(package.current_version, 1)
def test_migrate_with_test_flag(self, mock_file_config,
mocked_apply_migration, getLogger):
"""
Let's set all the packages to be at version 0, and then check that the migrations get called
in the correct order. We will also set the --test flag and ensure that the migration
versions do not get updated.
"""
logger = MagicMock()
getLogger.return_value = logger
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.get_collection().find({}).count(),
0)
# Make sure that our mock works. There are three valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
# Set all versions back to 0
for package in models.get_migration_packages():
package._migration_tracker.version = 0
package._migration_tracker.save()
manage.main()
# There should have been a critical log about the Exception
expected_messages = (
'Applying migration unit.server.db.migration_packages.raise_exception.0002_oh_no '
'failed.\n\nHalting migrations due to a migration failure.',
'Bet you didn\'t see this coming.')
critical_messages = [
mock_call[1][0] for mock_call in logger.critical.mock_calls
]
for msg in expected_messages:
self.assertTrue(msg in critical_messages)
migration_modules_called = [
mock_call[1][1].name
for mock_call in mocked_apply_migration.mock_calls
]
# Note that none of the migrations that don't meet our criteria show up in this list. Also,
# Note that migration_packages.raise_exception.0003_shouldnt_run doesn't appear
# since migration_packages.raise_exception.0002_oh_no raised an Exception. Note
# also that even though the raise_exception package raised an Exception, we still run all
# the z migrations because we don't want one package to break another.
expected_migration_modules_called = [
'unit.server.db.migration_packages.platform.0001_stuff_and_junk',
'unit.server.db.migration_packages.raise_exception.0001_works_fine',
'unit.server.db.migration_packages.raise_exception.0002_oh_no'
]
self.assertEquals(migration_modules_called,
expected_migration_modules_called)
# Assert that our precious versions have not been updated, since we have the --test flag
for package in models.get_migration_packages():
self.assertEqual(package.current_version, 0)
def test_admin_is_ensured(self, apply_migration, ensure_admin, ensure_super_user_role,
getLogger, factory, initialize, fileConfig, ensure_db_indexes):
"""
pulp-manage-db is responsible for making sure the admin user and role are in place. This
test makes sure the manager methods that do that are called.
"""
logger = MagicMock()
getLogger.return_value = logger
code = manage.main()
self.assertEqual(code, os.EX_OK)
# Make sure all the right logging happens
expected_messages = ('Ensuring the admin role and user are in place.',
'Admin role and user are in place.')
info_messages = ''.join([mock_call[1][0] for mock_call in logger.info.mock_calls])
for msg in expected_messages:
self.assertTrue(msg in info_messages)
# Make sure the admin user and role creation methods were called. We'll leave it up to other
# tests to make sure they work.
ensure_admin.assert_called_once_with()
ensure_super_user_role.assert_called_once_with()
# Also, make sure the factory was initialized
factory.initialize.assert_called_once_with()
initialize.assert_called_once_with(max_timeout=1)
def test_current_version_too_high(self, mocked_file_config, initialize, getLogger):
"""
Set the current package version higher than latest available version, then sit back and eat
popcorn.
"""
logger = MagicMock()
getLogger.return_value = logger
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.objects().count(), 0)
# Make sure that our mock works. There are four valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
# Set all versions to ridiculously high values
for package in models.get_migration_packages():
package._migration_tracker.version = 9999999
package._migration_tracker.save()
error_code = manage.main()
self.assertEqual(error_code, os.EX_DATAERR)
# There should have been a critical log about the Exception
expected_messages = (
'The database for migration package unit.server.db.migration_packages.'
'platform is at version 9999999, which is larger than the latest version available, 1.')
critical_messages = ''.join([mock_call[1][0] for mock_call in logger.critical.mock_calls])
for msg in expected_messages:
self.assertTrue(msg in critical_messages)
initialize.assert_called_once_with(max_timeout=1)
def test_current_version_too_high(self, mocked_file_config, mocked_logger,
mocked_stdout, mocked_stderr):
"""
Set the current package version higher than latest available version, then sit back and eat
popcorn.
"""
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.get_collection().find({}).count(),
0)
# Make sure that our mock works. There are four valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
# Set all versions to ridiculously high values
for package in models.get_migration_packages():
package._migration_tracker.version = 9999999
package._migration_tracker.save()
error_code = manage.main()
self.assertEqual(error_code, os.EX_DATAERR)
# There should have been a print to stderr about the Exception
expected_stderr_calls = [(
'The database for migration package unit.server.db.migration_packages.platform is at '
'version 9999999, which is larger than the latest version available, 1.'
), '\n']
stderr_calls = [
mock_call[1][0] for mock_call in mocked_stderr.mock_calls
]
self.assertEquals(stderr_calls, expected_stderr_calls)
def test_migrate_with_dry_run_flag(self, mock_file_config, initialize, mocked_apply_migration,
getLogger):
"""
Test that when a dry run is performed, no migrations actually occur.
"""
logger = MagicMock()
getLogger.return_value = logger
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.objects().count(), 0)
# Make sure that our mock works. There are three valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
# Set all versions back to 0
for package in models.get_migration_packages():
package._migration_tracker.version = 0
package._migration_tracker.save()
result = manage.main()
# Test that none of the mock objects were actually called
migration_modules_called = [
mock_call[1][1].name for mock_call in mocked_apply_migration.mock_calls]
self.assertEquals(0, len(migration_modules_called))
self.assertEquals(1, result)
for package in models.get_migration_packages():
self.assertEqual(package.current_version, 0)
initialize.assert_called_once_with(max_timeout=1)
def test_migration_removed(self, mock_auto_manage_db, mock_parse_args, mock_init,
mock_getLogger):
e = models.MigrationRemovedError('0002', '1.2.0', '1.1.0', 'foo')
mock_auto_manage_db.side_effect = e
ret = manage.main()
self.assertEqual(ret, os.EX_SOFTWARE)
def test_migrate(self, file_config_mock, logger_mock, mocked_apply_migration, mocked_stdout,
mocked_stderr):
"""
Let's set all the packages to be at version 0, and then check that the migrations get
called in the correct order.
"""
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.get_collection().find({}).count(), 0)
# Make sure that our mock works. There are three valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
# Set all versions back to 0
for package in models.get_migration_packages():
package._migration_tracker.version = 0
package._migration_tracker.save()
manage.main()
# There should have been a print to stderr about the Exception
expected_stderr_calls = [
('Applying migration unit.server.db.migration_packages.raise_exception.0002_oh_no '
'failed.\n\nHalting migrations due to a migration failure.'), ' ', ' See log for details.', '\n',
'Bet you didn\'t see this coming.', '\n']
stderr_calls = [mock_call[1][0] for mock_call in mocked_stderr.mock_calls]
self.assertEquals(stderr_calls, expected_stderr_calls)
migration_modules_called = [
mock_call[1][1].name for mock_call in mocked_apply_migration.mock_calls]
# Note that none of the migrations that don't meet our criteria show up in this list. Also,
# Note that migration_packages.raise_exception.0003_shouldnt_run doesn't appear
# since migration_packages.raise_exception.0002_oh_no raised an Exception. Note
# also that even though the raise_exception package raised an Exception, we still run all
# the z migrations because we don't want one package to break another.
expected_migration_modules_called = [
'unit.server.db.migration_packages.platform.0001_stuff_and_junk',
'unit.server.db.migration_packages.raise_exception.0001_works_fine',
'unit.server.db.migration_packages.raise_exception.0002_oh_no']
self.assertEquals(migration_modules_called, expected_migration_modules_called)
# Assert that our precious versions have been updated correctly
for package in models.get_migration_packages():
if package.name == 'unit.server.db.migration_packages.platform':
self.assertEqual(package.current_version, package.latest_available_version)
elif package.name == 'unit.server.db.migration_packages.raise_exception':
# The raised Exception should have prevented us from getting past version 1
self.assertEquals(package.current_version, 1)
else:
# raise_exception should cause the migrations to stop
self.assertEqual(package.current_version, 0)
def test_migrate_with_test_flag(self, mock_file_config, mocked_apply_migration, getLogger):
"""
Let's set all the packages to be at version 0, and then check that the migrations get called
in the correct order. We will also set the --test flag and ensure that the migration
versions do not get updated.
"""
logger = MagicMock()
getLogger.return_value = logger
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.get_collection().find({}).count(), 0)
# Make sure that our mock works. There are three valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
# Set all versions back to 0
for package in models.get_migration_packages():
package._migration_tracker.version = 0
package._migration_tracker.save()
manage.main()
# There should have been a critical log about the Exception
expected_messages = (
'Applying migration unit.server.db.migration_packages.raise_exception.0002_oh_no '
'failed.\n\nHalting migrations due to a migration failure.',
'Bet you didn\'t see this coming.'
)
critical_messages = [mock_call[1][0] for mock_call in logger.critical.mock_calls]
for msg in expected_messages:
self.assertTrue(msg in critical_messages)
migration_modules_called = [
mock_call[1][1].name for mock_call in mocked_apply_migration.mock_calls]
# Note that none of the migrations that don't meet our criteria show up in this list. Also,
# Note that migration_packages.raise_exception.0003_shouldnt_run doesn't appear
# since migration_packages.raise_exception.0002_oh_no raised an Exception. Note
# also that even though the raise_exception package raised an Exception, we still run all
# the z migrations because we don't want one package to break another.
expected_migration_modules_called = [
'unit.server.db.migration_packages.platform.0001_stuff_and_junk',
'unit.server.db.migration_packages.raise_exception.0001_works_fine',
'unit.server.db.migration_packages.raise_exception.0002_oh_no']
self.assertEquals(migration_modules_called, expected_migration_modules_called)
# Assert that our precious versions have not been updated, since we have the --test flag
for package in models.get_migration_packages():
self.assertEqual(package.current_version, 0)
def test_migrate_with_test_flag(self, start_logging_mock,
mocked_apply_migration, mocked_stderr):
"""
Let's set all the packages to be at version 0, and then check that the migrations get called
in the correct order. We will also set the --test flag and ensure that the migration
versions do not get updated.
"""
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.get_collection().find({}).count(),
0)
# Make sure that our mock works. There are three valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
# Set all versions back to 0
for package in models.get_migration_packages():
package._migration_tracker.version = 0
package._migration_tracker.save()
manage.main()
# There should have been a print to stderr about the Exception
expected_stderr_calls = [
'Applying migration data.test_migration_packages.raise_exception.0002_oh_no failed.',
' ', ' See log for details.', '\n'
]
stderr_calls = [call[1][0] for call in mocked_stderr.mock_calls]
self.assertEquals(stderr_calls, expected_stderr_calls)
migration_modules_called = [
call[1][1].name for call in mocked_apply_migration.mock_calls
]
# Note that none of the migrations that don't meet our criteria show up in this list. Also,
# Note that data.test_migration_packages.raise_exception.0003_shouldnt_run doesn't appear
# since data.test_migration_packages.raise_exception.0002_oh_no raised an Exception. Note
# also that even though the raise_exception package raised an Exception, we still run all
# the z migrations because we don't want one package to break another.
expected_migration_modules_called = [
'data.test_migration_packages.platform.0001_stuff_and_junk',
'data.test_migration_packages.raise_exception.0001_works_fine',
'data.test_migration_packages.raise_exception.0002_oh_no',
'data.test_migration_packages.z.0001_test',
'data.test_migration_packages.z.0002_test',
'data.test_migration_packages.z.0003_test'
]
self.assertEquals(migration_modules_called,
expected_migration_modules_called)
# Assert that our precious versions have not been updated, since we have the --test flag
for package in models.get_migration_packages():
self.assertEqual(package.current_version, 0)
def test_wont_run_as_root(self, mock_getuid, mock_stderr):
ret = manage.main()
# make sure the exit code reflect a usage error
self.assertEqual(ret, os.EX_USAGE)
# make sure a message was written to stderr with appropriate keywords
self.assertTrue(mock_stderr.write.call_count > 0)
self.assertTrue('root' in mock_stderr.write.call_args_list[0][0][0])
self.assertTrue('apache' in mock_stderr.write.call_args_list[0][0][0])
def test_migrate_with_new_packages(self, start_logging_mock, logger_mock, mocked_stderr):
"""
Adding new packages to a system that doesn't have any trackers should advance
each package to the latest available version, applying all migrate() functions along the way.
"""
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.get_collection().find({}).count(), 0)
# Make sure that our mock works. There are four valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
manage.main()
for package in models.get_migration_packages():
if 'raise_exception' in str(package):
# The Exception raising package should get to version 1, because version 2 raises
self.assertEqual(package.current_version, 1)
else:
# All other packages should reach their top versions
self.assertEqual(package.current_version, package.latest_available_version)
def test_user_prompted_if_workers_tasks_exist(self, mock__auto_manage_db,
mock__user_input, mock_get_workers,
*unused_mocks):
mock_get_workers.return_value = [{'last_heartbeat':
UTCDateTimeField().to_python(datetime.now())}]
ret = manage.main()
# make sure system exits ok if user chooses not to proceed
self.assertEqual(ret, os.EX_OK)
# make sure user is asked for input when there are workers running
self.assertTrue(mock__user_input.called)
def test_dry_run_no_changes(self, mock_file_config, mock_parse_args, mocked_apply_migration, mock_entry, getLogger):
logger = MagicMock()
getLogger.return_value = logger
mock_args = Namespace(dry_run=True, test=False)
mock_parse_args.return_value = mock_args
# Test that when dry run is on, it returns 1 if migrations remain
exit_code = manage.main()
self.assertEqual(exit_code, 1)
# Actually apply the migrations
mock_args.dry_run = False
exit_code = manage.main()
self.assertEqual(exit_code, 0)
# Perform another dry run and check the return value is now 0
mock_args.dry_run = True
exit_code = manage.main()
self.assertEquals(exit_code, 0)
def test_dry_run_no_changes(self, mock_file_config, mock_parse_args, mocked_apply_migration,
mock_entry, getLogger):
logger = MagicMock()
getLogger.return_value = logger
mock_args = Namespace(dry_run=True, test=False)
mock_parse_args.return_value = mock_args
# Test that when dry run is on, it returns 1 if migrations remain
exit_code = manage.main()
self.assertEqual(exit_code, 1)
# Actually apply the migrations
mock_args.dry_run = False
exit_code = manage.main()
self.assertEqual(exit_code, 0)
# Perform another dry run and check the return value is now 0
mock_args.dry_run = True
exit_code = manage.main()
self.assertEquals(exit_code, 0)
def test_admin_creation_dry_run(self, mock_file_config, mocked_apply_migration, getLogger,
mock_ensure_admin, mock_ensure_super_role):
logger = MagicMock()
getLogger.return_value = logger
exit_code = manage.main()
self.assertEqual(exit_code, 1)
# Make sure the admin user and role creation methods were not called
self.assertEquals(0, mock_ensure_admin.call_count)
self.assertEquals(0, mock_ensure_super_role.call_count)
def test_migrate_with_new_packages(self, mocked_apply_migration):
"""
Adding new packages to a system that doesn't have any trackers should automatically advance
each package to the latest available version without calling any migrate() functions.
"""
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.get_collection().find({}).count(), 0)
# Make sure that our mock works. There are three valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
manage.main()
# No calls to apply_migration should have been made, and we should be at the latest package
# versions for each of the packages that have valid migrations.
self.assertFalse(mocked_apply_migration.called)
for package in models.get_migration_packages():
self.assertEqual(package.current_version, package.latest_available_version)
# Calling main() again should still not call apply_migration() or change the versions
manage.main()
self.assertFalse(mocked_apply_migration.called)
for package in models.get_migration_packages():
self.assertEqual(package.current_version, package.latest_available_version)
def test_admin_creation_dry_run(self, mock_file_config, mocked_apply_migration, getLogger,
mock_ensure_admin, mock_ensure_super_role):
logger = MagicMock()
getLogger.return_value = logger
exit_code = manage.main()
self.assertEqual(exit_code, 1)
# Make sure the admin user and role creation methods were not called
self.assertEquals(0, mock_ensure_admin.call_count)
self.assertEquals(0, mock_ensure_super_role.call_count)
def test_migrate_with_test_flag(self, start_logging_mock, mocked_apply_migration, mocked_stdout,
mocked_stderr):
"""
Let's set all the packages to be at version 0, and then check that the migrations get called
in the correct order. We will also set the --test flag and ensure that the migration
versions do not get updated.
"""
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.get_collection().find({}).count(), 0)
# Make sure that our mock works. There are three valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
# Set all versions back to 0
for package in models.get_migration_packages():
package._migration_tracker.version = 0
package._migration_tracker.save()
manage.main()
# There should have been a print to stderr about the Exception
expected_stderr_calls = [
('Applying migration unit.server.db.migration_packages.raise_exception.0002_oh_no '
'failed.'), ' ', ' See log for details.', '\n']
stderr_calls = [mock_call[1][0] for mock_call in mocked_stderr.mock_calls]
self.assertEquals(stderr_calls, expected_stderr_calls)
migration_modules_called = [
mock_call[1][1].name for mock_call in mocked_apply_migration.mock_calls]
# Note that none of the migrations that don't meet our criteria show up in this list. Also,
# Note that migration_packages.raise_exception.0003_shouldnt_run doesn't appear
# since migration_packages.raise_exception.0002_oh_no raised an Exception. Note
# also that even though the raise_exception package raised an Exception, we still run all
# the z migrations because we don't want one package to break another.
expected_migration_modules_called = [
'unit.server.db.migration_packages.platform.0001_stuff_and_junk',
'unit.server.db.migration_packages.raise_exception.0001_works_fine',
'unit.server.db.migration_packages.raise_exception.0002_oh_no',
'unit.server.db.migration_packages.z.0001_test',
'unit.server.db.migration_packages.z.0002_test',
'unit.server.db.migration_packages.z.0003_test']
self.assertEquals(migration_modules_called, expected_migration_modules_called)
# Assert that our precious versions have not been updated, since we have the --test flag
for package in models.get_migration_packages():
self.assertEqual(package.current_version, 0)
def test_migrate_with_new_packages(self, initialize, start_logging_mock, logger_mock,
mocked_stdout, mocked_stderr):
"""
Adding new packages to a system that doesn't have any trackers should advance
each package to the latest available version, applying no migrate() functions along the
way.
"""
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.objects().count(), 0)
# Make sure that our mock works. There are five valid packages.
self.assertEquals(len(models.get_migration_packages()), 5)
manage.main()
for package in models.get_migration_packages():
if 'raise_exception' in str(package):
# The Exception raising package should get to version 3, despite the fact that
# version 2 raises an exception, because new trackers get fast-forwarded.
self.assertEqual(package.current_version, 3)
else:
# All other packages should reach their top versions
self.assertEqual(package.current_version, package.latest_available_version)
initialize.assert_called_once_with(max_timeout=1)
def test_current_version_too_high(self, mocked_file_config, mocked_logger, mocked_stderr):
"""
Set the current package version higher than latest available version, then sit back and eat
popcorn.
"""
# Make sure we start out with a clean slate
self.assertEquals(MigrationTracker.get_collection().find({}).count(), 0)
# Make sure that our mock works. There are four valid packages.
self.assertEquals(len(models.get_migration_packages()), 4)
# Set all versions to ridiculously high values
for package in models.get_migration_packages():
package._migration_tracker.version = 9999999
package._migration_tracker.save()
error_code = manage.main()
self.assertEqual(error_code, os.EX_DATAERR)
# There should have been a print to stderr about the Exception
expected_stderr_calls = [
'The database for migration package data.test_migration_packages.platform is at ' +\
'version 9999999, which is larger than the latest version available, 1.', '\n']
stderr_calls = [call[1][0] for call in mocked_stderr.mock_calls]
self.assertEquals(stderr_calls, expected_stderr_calls)
def test_admin_is_ensured(self, apply_migration, stdout, ensure_admin,
ensure_super_user_role, getLogger, factory,
fileConfig):
"""
pulp-manage-db is responsible for making sure the admin user and role are in place. This
test makes sure the manager methods that do that are called.
"""
logger = MagicMock()
def get_logger(*args):
"""
This is used to side effect getLogger so that we can mock the logger.
"""
return logger
getLogger.side_effect = get_logger
code = manage.main()
self.assertEqual(code, os.EX_OK)
# Make sure all the right logging and printing happens
expected_messages = ('Ensuring the admin role and user are in place.',
'Admin role and user are in place.')
stdout_messages = ''.join(
[mock_call[1][0] for mock_call in stdout.mock_calls])
info_messages = ''.join(
[mock_call[1][0] for mock_call in logger.info.mock_calls])
for msg in expected_messages:
self.assertTrue(msg in stdout_messages)
self.assertTrue(msg in info_messages)
# Make sure the admin user and role creation methods were called. We'll leave it up to other
# tests to make sure they work.
ensure_admin.assert_called_once_with()
ensure_super_user_role.assert_called_once_with()
# Also, make sure the factory was initialized
factory.initialize.assert_called_once_with()
def test_admin_is_ensured(self, apply_migration, stdout, ensure_admin, ensure_super_user_role,
getLogger, factory, fileConfig):
"""
pulp-manage-db is responsible for making sure the admin user and role are in place. This
test makes sure the manager methods that do that are called.
"""
logger = MagicMock()
def get_logger(*args):
"""
This is used to side effect getLogger so that we can mock the logger.
"""
return logger
getLogger.side_effect = get_logger
code = manage.main()
self.assertEqual(code, os.EX_OK)
# Make sure all the right logging and printing happens
expected_messages = ('Ensuring the admin role and user are in place.',
'Admin role and user are in place.')
stdout_messages = ''.join([mock_call[1][0] for mock_call in stdout.mock_calls])
info_messages = ''.join([mock_call[1][0] for mock_call in logger.info.mock_calls])
for msg in expected_messages:
self.assertTrue(msg in stdout_messages)
self.assertTrue(msg in info_messages)
# Make sure the admin user and role creation methods were called. We'll leave it up to other
# tests to make sure they work.
ensure_admin.assert_called_once_with()
ensure_super_user_role.assert_called_once_with()
# Also, make sure the factory was initialized
factory.initialize.assert_called_once_with()
def test_user_not_prompted_if_no_workers(self, mock_auto_manage_db,
mock_user_input, *unused_mocks):
manage.main()
# make sure user is not asked for input when there are no tasks/workers
self.assertFalse(mock_user_input.called)
self.assertTrue(mock_auto_manage_db.called)
def test_set_connection_timeout(self, mock_auto_manage_db, mock_initialize):
manage.main()
mock_initialize.assert_called_once_with(max_timeout=1)
def test_set_connection_timeout(self, mock_initialize, *unused_mocks):
manage.main()
mock_initialize.assert_called_once_with(max_timeout=1)
