def get_test_reviews_window():
appdetails_mock = Mock()
appdetails_mock.version = "2.0"
parent = Mock()
parent.app_details = appdetails_mock
review_data = Mock()
review_data.app_name = "app"
review_data.usefulness_favorable = 10
review_data.usefulness_total = 12
review_data.usefulness_submit_error = False
review_data.reviewer_username = "******"
review_data.reviewer_displayname = "displayname"
review_data.date_created = "2011-01-01 18:00:00"
review_data.summary = "summary"
review_data.review_text = 10 * "loonng text"
review_data.rating = "3.0"
review_data.version = "1.0"
# create reviewslist
vb = reviews.UIReviewsList(parent)
vb.add_review(review_data)
vb.configure_reviews_ui()
win = get_test_window(child=vb)
return win
def get_test_reviews_window():
from mock import Mock
appdetails_mock = Mock()
appdetails_mock.version = "2.0"
parent = Mock()
parent.app_details = appdetails_mock
review_data = Mock()
review_data.app_name = "app"
review_data.usefulness_favorable = 10
review_data.usefulness_total = 12
review_data.usefulness_submit_error = False
review_data.reviewer_username = "******"
review_data.reviewer_displayname = "displayname"
review_data.date_created = "2011-01-01 18:00:00"
review_data.summary = "summary"
review_data.review_text = 10 * "loonng text"
review_data.rating = "3.0"
review_data.version = "1.0"
# create reviewslist
vb = UIReviewsList(parent)
vb.add_review(review_data)
vb.configure_reviews_ui()
win = Gtk.Window()
win.set_size_request(200, 200)
win.add(vb)
win.connect('destroy', Gtk.main_quit)
win.show_all()
return win
def get_test_reviews_window():
from mock import Mock
appdetails_mock = Mock()
appdetails_mock.version = "2.0"
parent = Mock()
parent.app_details = appdetails_mock
review_data = Mock()
review_data.app_name = "app"
review_data.usefulness_favorable = 10
review_data.usefulness_total = 12
review_data.usefulness_submit_error = False
review_data.reviewer_username = "******"
review_data.reviewer_displayname = "displayname"
review_data.date_created = "2011-01-01 18:00:00"
review_data.summary = "summary"
review_data.review_text = 10 * "loonng text"
review_data.rating = "3.0"
review_data.version = "1.0"
# create reviewslist
vb = UIReviewsList(parent)
vb.add_review(review_data)
vb.configure_reviews_ui()
win = Gtk.Window()
win.set_size_request(200, 200)
win.add(vb)
win.connect('destroy', Gtk.main_quit)
win.show_all()
return win
def test_get_current_version(self):
mock_client = Mock(spec=["version"])
mock_client.version = '2.0-beta4-trusty-amd64'
ver = get_current_version(mock_client)
self.assertEqual(ver, '2.0-beta4')
mock_client.version = '1.25.4-trusty-amd64'
ver = get_current_version(mock_client)
self.assertEqual(ver, '1.25.4')
def test_get_current_version(self):
mock_client = Mock(spec=["version"])
mock_client.version = '2.0-beta4-trusty-amd64'
ver = get_current_version(mock_client)
self.assertEqual(ver, '2.0-beta4')
mock_client.version = '1.25.4-trusty-amd64'
ver = get_current_version(mock_client)
self.assertEqual(ver, '1.25.4')
def check_get_version(self):
"""Check default and override behavior of get_version"""
node = None
assert get_version(node) == DEV_BRANCH
node = Mock()
node.version = None
assert get_version(node) == DEV_BRANCH
node = Mock()
node.version = V_0_8_2_2
assert get_version(node) == V_0_8_2_2
def build_mac_mocks(self):
mac1 = Mock()
mac1.vendor = "Wirecloud"
mac1.short_name = "mac1"
mac1.version = "1.0"
mac1.template_uri = "Wirecloud_mac1_1.0.wgt"
mac2 = Mock()
mac2.vendor = "Wirecloud"
mac2.short_name = "mac2"
mac2.version = "1.0"
mac2.template_uri = "Wirecloud_mac2_1.0.wgt"
return mac1, mac2
def build_mac_mocks(self):
mac1 = Mock()
mac1.vendor = "Wirecloud"
mac1.short_name = "mac1"
mac1.version = "1.0"
mac1.template_uri = "Wirecloud_mac1_1.0.wgt"
mac2 = Mock()
mac2.vendor = "Wirecloud"
mac2.short_name = "mac2"
mac2.version = "1.0"
mac2.template_uri = "Wirecloud_mac2_1.0.wgt"
return mac1, mac2
def test_requirement_pinned(self):
req = Mock()
req.key = "django"
req.is_pinned = True
req.latest_version_within_specs = "1.10"
req.version = "1.0"
self.assertEqual(SequentialUpdate.get_branch(req), "pyup-update-django-1.0-to-1.10")
def test_all_duplicate_reviews_keeps_going(self, mock_get_reviews):
"""AppDetailsView._reviews_ready_callback will fetch another page if
all data returned was already displayed in the reviews list.
"""
# Fixme: Do we have a test factory?
review = Mock()
review.rating = 3
review.date_created = "2011-01-01 18:00:00"
review.version = "1.0"
review.summary = 'some summary'
review.review_text = 'Some text'
review.reviewer_username = "******"
review.reviewer_displayname = "displayname"
reviews = [review]
self.view.reviews.reviews = reviews
self.view._do_load_reviews()
self.assertEqual(1, mock_get_reviews.call_count)
kwargs = mock_get_reviews.call_args[1]
self.assertEqual(False, kwargs['relaxed'])
self.assertEqual(1, kwargs['page'])
# Now we come back with no NEW data
application, callback = mock_get_reviews.call_args[0]
callback(application, reviews)
self.assertEqual(2, mock_get_reviews.call_count)
kwargs = mock_get_reviews.call_args[1]
self.assertEqual(False, kwargs['relaxed'])
self.assertEqual(2, kwargs['page'])
def test_all_duplicate_reviews_keeps_going(self, mock_get_reviews):
"""AppDetailsView._reviews_ready_callback will fetch another page if
all data returned was already displayed in the reviews list.
"""
# Fixme: Do we have a test factory?
review = Mock()
review.rating = 3
review.date_created = "2011-01-01 18:00:00"
review.version = "1.0"
review.summary = 'some summary'
review.review_text = 'Some text'
review.reviewer_username = "******"
review.reviewer_displayname = "displayname"
reviews = [review]
self.view.reviews.reviews = reviews
self.view._do_load_reviews()
self.assertEqual(1, mock_get_reviews.call_count)
kwargs = mock_get_reviews.call_args[1]
self.assertEqual(False, kwargs['relaxed'])
self.assertEqual(1, kwargs['page'])
# Now we come back with no NEW data
application = mock_get_reviews.call_args[0][0]
self.view.review_loader.emit("get-reviews-finished", application,
reviews)
self.assertEqual(2, mock_get_reviews.call_count)
kwargs = mock_get_reviews.call_args[1]
self.assertEqual(False, kwargs['relaxed'])
self.assertEqual(2, kwargs['page'])
def test_get_version(self, mock_get_distribution):
mock_distribution = Mock()
mock_distribution.version = "1.2.3"
mock_get_distribution.return_value = mock_distribution
self.assertEquals(status_manager.get_version(),
{'platform_version': '1.2.3'})
def default_args():
args = Mock()
args.conf_file = '.lamvery.yml'
args.alias = 'foo'
args.version = '1'
args.json = '{"foo": "bar"}'
return args
def test_Adds_niprov_version(self):
with patch('niprov.adding.pkg_resources') as pkgres:
dist = Mock()
dist.version = '5.4.1'
pkgres.get_distribution.return_value = dist
image = self.add('p/afile.f')
self.assertEqual(self.lastProvenance['version-added'], 5.41)
def test_get_boot_names(self, mock_warning, mock_Path_which, mock_Kernel):
boot_names_type = namedtuple('boot_names_type',
['kernel_name', 'initrd_name'])
mock_Path_which.return_value = 'dracut'
kernel = Mock()
kernel_info = Mock()
kernel_info.name = 'kernel_name'
kernel_info.version = 'kernel_version'
kernel.get_kernel.return_value = kernel_info
mock_Kernel.return_value = kernel
with patch('builtins.open', create=True) as mock_open:
mock_open.return_value = MagicMock(spec=io.IOBase)
file_handle = mock_open.return_value.__enter__.return_value
file_handle.read.return_value = 'outfile="/boot/initrd-$kernel"'
assert self.boot_image.get_boot_names() == boot_names_type(
kernel_name='kernel_name', initrd_name='initrd-kernel_version')
with patch('builtins.open', create=True) as mock_open:
mock_open.return_value = MagicMock(spec=io.IOBase)
file_handle = mock_open.return_value.__enter__.return_value
file_handle.read.return_value = 'outfile="foo"'
assert self.boot_image.get_boot_names() == boot_names_type(
kernel_name='kernel_name',
initrd_name='initramfs-kernel_version.img')
self.xml_state.get_initrd_system.return_value = 'kiwi'
mock_Path_which.return_value = None
assert self.boot_image.get_boot_names() == boot_names_type(
kernel_name='kernel_name', initrd_name='initrd-kernel_version')
def test_error(self, mock_bc, mock_cl):
class FakeError(Exception):
"""Custom exception to validate error handling."""
error = FakeError('An error during test')
client = Mock(spec=['is_jes_enabled', 'version'])
client.version = '2.0.0'
with patch('deploy_stack.client_from_config',
return_value=client) as mock_c:
with patch('assess_recovery.parse_new_state_server_from_error',
autospec=True,
return_value='a-host') as mock_pe:
with patch('assess_recovery.assess_recovery',
autospec=True,
side_effect=error) as mock_assess:
with self.assertRaises(FakeError) as ctx:
main([
'an-env', '/juju', 'log_dir', 'tmp-env', '--ha',
'--verbose', '--charm-series', 'a-series'
])
self.assertIs(ctx.exception, error)
mock_cl.assert_called_once_with(logging.DEBUG)
mock_c.assert_called_once_with('an-env',
'/juju',
debug=False,
soft_deadline=None)
mock_pe.assert_called_once_with(error)
self.assertEqual(mock_bc.call_count, 1)
self.assertEqual(mock_assess.call_count, 1)
bs_manager, strategy, series = mock_assess.call_args[0]
self.assertEqual((bs_manager.client, strategy, series),
(client, 'ha', 'a-series'))
self.assertEqual(bs_manager.known_hosts['0'], 'a-host')
def test_assess_multi_series_charms_juju1x(self):
mock_client = Mock(
spec=[
"deploy", "get_juju_output", "wait_for_started", "is_juju1x"])
mock_client.version = '1.25.5'
mock_client.is_juju1x.return_value = True
mock_client.get_juju_output.return_value = "Codename: trusty"
mock_client.deploy.return_value = None
with temp_dir() as charm_dir:
with patch('assess_multi_series_charms.temp_dir',
autospec=True) as td_mock:
td_mock.return_value.__enter__.return_value = charm_dir
with patch('assess_multi_series_charms.check_series',
autospec=True) as cs_mock:
assess_multi_series_charms(mock_client, 'angsty')
self.assertEqual(mock_client.wait_for_started.call_count, 2)
charm = os.path.join('local:trusty', 'dummy')
calls = [
call(charm=charm, force=False, repository=charm_dir,
series=None, service='test1'),
call(charm=charm, force=False, repository=charm_dir,
series='trusty', service='test2')
]
self.assertEqual(mock_client.deploy.mock_calls, calls)
td_mock.assert_called_once_with()
cs_calls = [
call(mock_client, machine='0', series=None),
call(mock_client, machine='1', series='trusty')]
self.assertEqual(cs_mock.mock_calls, cs_calls)
def test_pinned_requirement(self):
req = Mock()
req.key = "django"
req.is_pinned = True
req.latest_version_within_specs = "1.10"
req.version = "1.0"
self.assertEqual(Update.get_commit_message(req), "Update django from 1.0 to 1.10")
def test_execution_script_init_method_attempts_to_load_correct_azure_ml_model(
sklearn_model, model_path):
mlflow.sklearn.save_model(sk_model=sklearn_model, path=model_path)
model_name = "test_model_name"
model_version = 1
model_mock = Mock()
model_mock.name = model_name
model_mock.version = model_version
with TempDir() as tmp:
execution_script_path = tmp.path("dest")
mlflow.azureml._create_execution_script(
output_path=execution_script_path, azure_model=model_mock)
with open(execution_script_path, "r") as f:
execution_script = f.read()
# Define the `init` and `score` methods contained in the execution script
# pylint: disable=exec-used
exec(execution_script, globals())
with AzureMLMocks() as aml_mocks:
aml_mocks["get_model_path"].side_effect = lambda *args, **kwargs: model_path
# Execute the `init` method of the execution script.
# pylint: disable=undefined-variable
init()
assert aml_mocks["get_model_path"].call_count == 1
get_model_path_call_args = aml_mocks["get_model_path"].call_args_list
assert len(get_model_path_call_args) == 1
_, get_model_path_call_kwargs = get_model_path_call_args[0]
assert get_model_path_call_kwargs["model_name"] == model_name
assert get_model_path_call_kwargs["version"] == model_version
def test_execution_script_run_method_scores_pandas_dataframes_successfully(
sklearn_model, model_path):
mlflow.sklearn.save_model(sk_model=sklearn_model, path=model_path)
model_mock = Mock()
model_mock.name = "model_name"
model_mock.version = 1
with TempDir() as tmp:
execution_script_path = tmp.path("dest")
mlflow.azureml._create_execution_script(
output_path=execution_script_path, azure_model=model_mock)
with open(execution_script_path, "r") as f:
execution_script = f.read()
# Define the `init` and `score` methods contained in the execution script
# pylint: disable=exec-used
exec(execution_script, globals())
with AzureMLMocks() as aml_mocks:
aml_mocks["get_model_path"].side_effect = lambda *args, **kwargs: model_path
# Execute the `init` method of the execution script and load the sklearn model from the
# mocked path
# pylint: disable=undefined-variable
init()
# Invoke the `run` method of the execution script with sample input data and verify that
# reasonable output data is produced
input_data = datasets.load_iris().data[:, :2]
# pylint: disable=undefined-variable
output_data = run(pd.DataFrame(data=input_data).to_json(orient="split"))
assert len(output_data) == len(input_data)
def test_storage_2x_with_aws(self):
mock_client = Mock(spec=["juju", "wait_for_started",
"create_storage_pool", "remove_service",
"list_storage_pool", "deploy",
"get_juju_output", "add_storage",
"list_storage", "is_juju1x"])
mock_client.series = 'trusty'
mock_client.version = '2.0'
mock_client.is_juju1x.return_value = False
mock_client.env = JujuData('foo', {'type': 'ec2'}, 'data')
expected_pool = dict(AWS_DEFAULT_STORAGE_POOL_DETAILS)
expected_pool.update(storage_pool_details)
mock_client.list_storage_pool.side_effect = [
json.dumps(expected_pool)
]
mock_client.list_storage.side_effect = self.make_expected_list_storage(
mock_client)
assess_storage(mock_client, mock_client.series)
self.assertEqual(
[
call('ebsy', 'ebs', '1G'),
call('loopy', 'loop', '1G'),
call('rooty', 'rootfs', '1G'),
call('tempy', 'tmpfs', '1G')
],
mock_client.create_storage_pool.mock_calls)
self.assertEqual(
[
call('dummy-storage-lp/0', 'disks', '1')
],
mock_client.add_storage.mock_calls
)
def test_storage_2x(self):
mock_client = Mock(spec=["juju", "wait_for_started",
"create_storage_pool", "remove_service",
"list_storage_pool", "deploy",
"get_juju_output", "add_storage",
"list_storage", "is_juju1x"])
mock_client.series = 'trusty'
mock_client.version = '2.0'
mock_client.is_juju1x.return_value = False
mock_client.env = Mock(config={'type': 'local'})
mock_client.list_storage_pool.side_effect = [
json.dumps(storage_pool_details)
]
mock_client.list_storage.side_effect = self.make_expected_list_storage(
mock_client)
assess_storage(mock_client, mock_client.series)
self.assertEqual(
[
call('ebsy', 'ebs', '1G'),
call('loopy', 'loop', '1G'),
call('rooty', 'rootfs', '1G'),
call('tempy', 'tmpfs', '1G')
],
mock_client.create_storage_pool.mock_calls)
self.assertEqual(
[
call('dummy-storage-lp/0', 'disks', '1')
],
mock_client.add_storage.mock_calls
)
def default_args():
args = Mock()
args.conf_file = '.lamvery.yml'
args.alias = 'foo'
args.version = '1'
args.json = '{"foo": "bar"}'
return args
def test_get_output(self):
pack = Mock()
pack.package_format = 2
pack.name = 'foopack'
pack.version = '0.1.2'
pack.maintainers = ['m1', 'm2']
pack.build_depends = ['bd1', 'bd2']
pack.buildtool_depends = ['catkin']
pack.build_export_depends = ['bed1', 'bed2']
pack.buildtool_export_depends = ['bted1', 'bted2']
pack.exec_depends = ['ed1', 'ed2']
pack.run_depends = ['rd1', 'rd2']
pack.test_depends = ['td1', 'td2']
pack.doc_depends = ['dd1', 'dd2']
pack.exports = []
result = _get_output(pack)
self.assertEqual(
set([
'set(_CATKIN_CURRENT_PACKAGE "foopack")',
'set(foopack_MAINTAINER "m1, m2")',
'set(foopack_PACKAGE_FORMAT "2")',
'set(foopack_DEPRECATED "")',
'set(foopack_VERSION "0.1.2")',
'set(foopack_BUILD_DEPENDS "bd1" "bd2")',
'set(foopack_BUILDTOOL_DEPENDS "catkin")',
'set(foopack_BUILD_EXPORT_DEPENDS "bed1" "bed2")',
'set(foopack_BUILDTOOL_EXPORT_DEPENDS "bted1" "bted2")',
'set(foopack_EXEC_DEPENDS "ed1" "ed2")',
'set(foopack_RUN_DEPENDS "rd1" "rd2")',
'set(foopack_TEST_DEPENDS "td1" "td2")',
'set(foopack_DOC_DEPENDS "dd1" "dd2")',
]),
set(result))
def test_version(self, test_dist):
obj = Mock()
obj.version = "shellfoundry_version"
test_dist.get_distribution = Mock(return_value=obj)
result = self.runner.invoke(version)
assert result.exit_code == 0
assert result.output == "shellfoundry version shellfoundry_version\n"
def test_get_upgrade_version(self, m_get_package_version,
m_gitbuilder_project):
gb = Mock()
gb.version = "11.0.0"
gb.project = "ceph"
m_gitbuilder_project.return_value = gb
m_get_package_version.return_value = "11.0.0"
install.get_upgrade_version(Mock(), Mock(), Mock())
def default_args():
args = Mock()
args.conf_file = '.lamvery.yml'
args.dry_run = True
args.publish = True
args.alias = None
args.version = None
return args
def test_get_upgrade_version(self, m_get_package_version,
m_gitbuilder_project):
gb = Mock()
gb.version = "11.0.0"
gb.project = "ceph"
m_gitbuilder_project.return_value = gb
m_get_package_version.return_value = "11.0.0"
install.get_upgrade_version(Mock(), Mock(), Mock())
def test_pinned_requirement(self):
req = Mock()
req.key = "django"
req.is_pinned = True
req.latest_version_within_specs = "1.10"
req.version = "1.0"
self.assertEqual(self.update.get_commit_message(req),
"1.0 is old, update django to 1.10.")
def test_verify_ceph_version_success(self, m_get_package_version,
m_gitbuilder_project):
gb = Mock()
gb.version = "0.89.0"
gb.project = "ceph"
m_gitbuilder_project.return_value = gb
m_get_package_version.return_value = "0.89.0"
install.verify_package_version(Mock(), Mock(), Mock())
def test_requirement_pinned(self):
req = Mock()
req.key = "django"
req.is_pinned = True
req.latest_version_within_specs = "1.10"
req.version = "1.0"
self.assertEqual(SequentialUpdate.get_branch(req),
"update-django-1.0-to-1.10")
def test_addon_not_found(self):
class MockVersion:
@property
def addon(self):
raise ObjectDoesNotExist
file = Mock()
file.version = MockVersion()
self.assertRaises(http.Http404, allowed, self.request, file)
def _gen_rest_client(self):
instance_a = Mock()
instance_a.id = 'a_id'
instance_a.node_id = 'a_type'
instance_a.runtime_properties = {
'name': 'value',
'_transaction': '1'
}
instance_b = Mock()
instance_b.id = 'b_id'
instance_b.node_id = 'b_type'
instance_b.runtime_properties = {
'name': 'other',
'_transaction': '1'
}
instance_c = Mock()
instance_c.id = 'c_id'
instance_c.node_id = 'c_type'
instance_c.runtime_properties = {
'name': 'other',
'_transaction': '-'
}
instance_d = Mock()
instance_d.id = 'b_id'
instance_d.node_id = 'c_type'
instance_d.runtime_properties = {
'name': 'other',
}
client = Mock()
client.node_instances.list = Mock(return_value=[
instance_a, instance_b, instance_c, instance_d])
client.deployments.get = Mock(return_value={
'groups': {
'one_scale': {
'members': ['one', 'two']
},
'any': {
'members': ['one', 'two', "three"]
},
'alfa_types': {
'members': ['a_type', 'b_type']
}
}
})
# update instances
target_node = Mock()
target_node.id = 'target'
target_node.version = 1
target_node.state = 'deleted'
target_node.runtime_properties = {'a': 'b', 'd': 'e'}
client.node_instances.update = Mock()
client.node_instances.get = Mock(return_value=target_node)
return client
def test_no_update(self):
cluster = Mock()
cluster.version = None
endpoint = 'test.lwgyhw.cfg.usw2.cache.amazonaws.com:11211'
mc = MemcacheClient(endpoint)
mc.cluster = cluster
mc._update()
assert not mc.need_update
def test_addon_not_found(self):
class MockVersion:
@property
def addon(self):
raise ObjectDoesNotExist
file = Mock()
file.version = MockVersion()
self.assertRaises(http.Http404, allowed, self.request, file)
def test_no_update(self):
cluster = Mock()
cluster.version = None
endpoint = 'test.lwgyhw.cfg.usw2.cache.amazonaws.com:11211'
mc = MemcacheClient(endpoint)
mc.cluster = cluster
mc._update()
assert not mc.need_update
def test_create_initrd(
self, mock_MountManager, mock_Profile, mock_prepared,
mock_command, mock_kernel
):
profile = Mock()
profile.dot_profile = dict()
mock_Profile.return_value = profile
kernel = Mock()
kernel_details = Mock()
kernel_details.version = '1.2.3'
kernel.get_kernel = Mock(return_value=kernel_details)
mock_kernel.return_value = kernel
self.boot_image.include_file('system-directory/etc/foo')
self.boot_image.include_module('foo')
self.boot_image.omit_module('bar')
self.boot_image.create_initrd()
profile.create.assert_called_once_with(
'system-directory/.profile'
)
assert mock_MountManager.call_args_list == [
call(device='/dev', mountpoint='system-directory/dev'),
call(device='/proc', mountpoint='system-directory/proc')
]
assert mock_command.call_args_list == [
call([
'chroot', 'system-directory',
'dracut', '--verbose', '--no-hostonly',
'--no-hostonly-cmdline', '--xz',
'--add', ' foo ', '--omit', ' bar ',
'--install', 'system-directory/etc/foo',
'LimeJeOS.x86_64-1.13.2.initrd.xz', '1.2.3'
], stderr_to_stdout=True),
call([
'mv',
'system-directory/'
'LimeJeOS.x86_64-1.13.2.initrd.xz',
'some-target-dir'
])
]
mock_command.reset_mock()
self.boot_image.create_initrd(basename='foo')
assert mock_command.call_args_list == [
call([
'chroot', 'system-directory',
'dracut', '--verbose', '--no-hostonly',
'--no-hostonly-cmdline', '--xz',
'--add', ' foo ', '--omit', ' bar ',
'--install', 'system-directory/etc/foo',
'foo.xz', '1.2.3'
], stderr_to_stdout=True),
call([
'mv',
'system-directory/foo.xz',
'some-target-dir'
])
]
def test_push_resource_attach(self):
mock_client = Mock(
spec=["attach", "wait_for_started", "list_resources",
"wait_for_resource", "show_status"])
mock_client.version = '2.0.0'
mock_client.list_resources.return_value = make_resource_list()
push_resource(mock_client, 'foo', '1234', 27, 1800, 1800, deploy=False)
mock_client.attach.assert_called_once_with(
'dummy-resource', resource='foo=dummy-resource/foo.txt')
mock_client.wait_for_started.assert_called_once_with(timeout=1800)
def test_verify_ceph_version_failed(self, m_get_package_version,
m_gitbuilder_project):
gb = Mock()
gb.version = "0.89.0"
gb.project = "ceph"
m_gitbuilder_project.return_value = gb
m_get_package_version.return_value = "0.89.1"
config = dict()
with pytest.raises(RuntimeError):
install.verify_package_version(Mock(), config, Mock())
def make_file(pk, file_path, **kwargs):
obj = Mock()
obj.id = pk
for k, v in kwargs.items():
setattr(obj, k, v)
obj.file_path = file_path
obj.__str__ = lambda x: x.pk
obj.version = Mock()
obj.version.version = 1
return obj
def make_file(pk, file_path, **kwargs):
obj = Mock()
obj.id = pk
for k, v in kwargs.items():
setattr(obj, k, v)
obj.file_path = file_path
obj.__str__ = lambda x: x.pk
obj.version = Mock()
obj.version.version = 1
return obj
def test_verify_ceph_version_failed(self, m_get_package_version,
m_gitbuilder_project):
gb = Mock()
gb.version = "0.89.0"
gb.project = "ceph"
m_gitbuilder_project.return_value = gb
m_get_package_version.return_value = "0.89.1"
config = dict()
with pytest.raises(RuntimeError):
install.verify_package_version(Mock(), config, Mock())
def test_dir_from_spec(self):
mock = Mock(spec=unittest.TestCase)
testcase_attrs = set(dir(unittest.TestCase))
attrs = set(dir(mock))
# all attributes from the spec are included
self.assertEqual(set(), testcase_attrs - attrs)
# shadow a sys attribute
mock.version = 3
self.assertEqual(dir(mock).count('version'), 1)
def test_fetch_layer_uri_is_successful(self):
lambda_client_mock = Mock()
lambda_client_mock.get_layer_version.return_value = {"Content": {"Location": "some/uri"}}
download_layers = LayerDownloader("/", ".", lambda_client_mock)
layer = Mock()
layer.layer_arn = "arn"
layer.version = 1
actual_uri = download_layers._fetch_layer_uri(layer=layer)
self.assertEquals(actual_uri, "some/uri")
def test_fetch_layer_uri_fails_with_no_creds(self):
lambda_client_mock = Mock()
lambda_client_mock.get_layer_version.side_effect = NoCredentialsError()
download_layers = LayerDownloader("/", ".", lambda_client_mock)
layer = Mock()
layer.layer_arn = "arn"
layer.version = 1
with self.assertRaises(CredentialsRequired):
download_layers._fetch_layer_uri(layer=layer)
def test_skip_when_using_ceph_deploy(self, m_get_package_version,
m_gitbuilder_project):
gb = Mock()
gb.version = "0.89.0"
gb.project = "ceph"
m_gitbuilder_project.return_value = gb
# ceph isn't installed because ceph-deploy would install it
m_get_package_version.return_value = None
config = Mock()
config.extras = True
install.verify_package_version(Mock(), config, Mock())
def test_verify_ceph_version_failed(self, m_get_package_version,
m_gitbuilder_project):
gb = Mock()
gb.version = "0.89.0"
gb.project = "ceph"
m_gitbuilder_project.return_value = gb
m_get_package_version.return_value = "0.89.1"
config = Mock()
# when it looks for config.get('extras') it won't find it
config.get.return_value = False
with pytest.raises(RuntimeError):
install.verify_package_version(Mock(), config, Mock())
def test_fetch_layer_uri_fails_with_ResourceNotFoundException(self):
lambda_client_mock = Mock()
lambda_client_mock.get_layer_version.side_effect = ClientError(
error_response={'Error': {'Code': 'ResourceNotFoundException'}}, operation_name="lambda")
download_layers = LayerDownloader("/", ".", lambda_client_mock)
layer = Mock()
layer.layer_arn = "arn"
layer.version = 1
with self.assertRaises(ResourceNotFound):
download_layers._fetch_layer_uri(layer=layer)
def test_fetch_layer_uri_re_raises_client_error(self):
lambda_client_mock = Mock()
lambda_client_mock.get_layer_version.side_effect = ClientError(
error_response={'Error': {'Code': 'Unknown'}}, operation_name="lambda")
download_layers = LayerDownloader("/", ".", lambda_client_mock)
layer = Mock()
layer.layer_arn = "arn"
layer.version = 1
with self.assertRaises(ClientError):
download_layers._fetch_layer_uri(layer=layer)
def test_nightly_feed(self, get_list_or_404):
"""Nightly Notes feed should be served with public changes"""
release_1 = Mock()
release_1.version = '55.0a1'
release_1.is_public = True
release_1.release_date = date_parse('2017-03-06T00:00:00')
release_1.notes.return_value = ([
Note(id=1, tag='New', note='New 1', is_public=True,
modified=date_parse('2017-04-20T13:27:28')),
Note(id=2, tag='New', note='New 2', is_public=True,
modified=date_parse('2017-04-20T13:28:32')),
Note(id=11, tag='Changed', note='Change 1', is_public=True,
modified=date_parse('2017-04-20T13:27:50')),
Note(id=12, tag='Changed', note='Change 2', is_public=True,
modified=date_parse('2017-04-20T13:28:03')),
Note(id=13, tag='Changed', note='Change 3', is_public=False,
modified=date_parse('2017-04-20T13:28:16')),
], [
Note(id=21, tag='', note='Known issue 1', is_public=True,
modified=date_parse('2017-04-20T13:30:12')),
])
release_2 = Mock()
release_2.version = '56.0a1'
release_2.is_public = True
release_2.release_date = date_parse('2017-05-08T00:00:00')
release_2.notes.return_value = ([
Note(id=31, tag='New', note='New 1', is_public=True,
modified=date_parse('2017-05-08T13:27:28')),
], [])
get_list_or_404.return_value = [release_1, release_2]
views.nightly_feed(self.request)
eq_(len(self.last_ctx['notes']), 5)
eq_(self.last_ctx['notes'][0].id, 31)
eq_(self.last_ctx['notes'][1].id, 2)
eq_(self.last_ctx['notes'][2].id, 12)
eq_(self.last_ctx['notes'][3].id, 11)
eq_(self.last_ctx['notes'][4].id, 1)
def test_should_use_usage_information(self, mock_option_parser_class):
mock_option_parser = Mock()
mock_values = Mock()
mock_values.version = False
mock_values.debug = False
mock_arguments = ["foo", "bar"]
mock_option_parser.parse_args.return_value = (mock_values, mock_arguments)
mock_option_parser_class.return_value = mock_option_parser
parse_arguments([], version="")
mock_option_parser_class.assert_called_with(usage=USAGE_INFORMATION)
