def test__validate_helper__no_valid(self):
validators = [
mock.MagicMock(return_value=validation.ValidationResult(True)),
mock.MagicMock(return_value=validation.ValidationResult(
is_valid=False))
]
clients = mock.MagicMock()
args = {"a": 1, "b": 2}
self.assertRaises(exceptions.InvalidScenarioArgument,
base.Scenario._validate_helper, validators, clients,
args, "fake_uuid")
def test__validate_helper(self):
validators = [
mock.MagicMock(return_value=validation.ValidationResult()),
mock.MagicMock(return_value=validation.ValidationResult())
]
clients = mock.MagicMock()
config = {"a": 1, "b": 2}
task = mock.MagicMock()
base.Scenario._validate_helper(validators, clients, config, task)
for validator in validators:
validator.assert_called_with(config, clients=clients, task=task)
def test_validator(self):
failure = validation.ValidationResult(False)
func = lambda *args, **kv: kv
scenario = lambda: None
# Check arguments passed to validator
wrap = validation.validator(func)
wrap_args = ["foo", "bar"]
wrap_kwargs = {"foo": "spam"}
wrap_scenario = wrap(*wrap_args, **wrap_kwargs)
wrap_validator = wrap_scenario(scenario)
validators = wrap_validator.validators
self.assertEqual(1, len(validators))
validator, = validators
self.assertEqual(wrap_kwargs, validator(None, None, None))
self.assertEqual(wrap_validator, scenario)
# Default result
func_success = lambda *a, **kv: None
validator, = self._get_scenario_validators(func_success, scenario)
self.assertTrue(validator(None, None, None).is_valid)
# Failure result
func_failure = lambda *a, **kv: failure
validator, = self._get_scenario_validators(func_failure, scenario)
self.assertFalse(validator(None, None, None).is_valid)
def test_image_valid_on_flavor(self, mock_get_flavor, mock_get_image):
image = mock.MagicMock()
flavor = mock.MagicMock()
success = validation.ValidationResult()
mock_get_flavor.return_value = (success, flavor)
mock_get_image.return_value = (success, image)
validator = self._unwrap_validator(validation.image_valid_on_flavor,
"flavor", "image")
# test ram
flavor.disk = None
flavor.ram = 2
image.min_ram = None
result = validator(None, None, None)
self.assertTrue(result.is_valid, result.msg)
image.min_ram = 4
result = validator(None, None, None)
self.assertFalse(result.is_valid, result.msg)
image.min_ram = 1
result = validator(None, None, None)
self.assertTrue(result.is_valid, result.msg)
# test disk (flavor.disk not None)
image.size = 2
image.min_disk = 0
flavor.disk = 5.0 / (1024**3)
result = validator(None, None, None)
self.assertTrue(result.is_valid, result.msg)
image.min_disk = flavor.disk * 2
result = validator(None, None, None)
self.assertFalse(result.is_valid, result.msg)
image.min_disk = flavor.disk / 4
image.size = 1000
result = validator(None, None, None)
self.assertFalse(result.is_valid, result.msg)
def test_image_valid_on_flavor_context(self, mock_get_image,
mock_transform):
clients = mock.MagicMock()
clients.nova().flavors.get.side_effect = nova_exc.NotFound("")
image = mock.MagicMock()
success = validation.ValidationResult(True)
mock_get_image.return_value = (success, image)
validator = self._unwrap_validator(validation.image_valid_on_flavor,
"flavor", "image")
config = {
"args": {"flavor": {"name": "test"}},
"context": {
"flavors": [{
"name": "test",
"ram": 32,
}]
}
}
# test ram
image.min_ram = None
result = validator(config, clients, None)
self.assertTrue(result.is_valid, result.msg)
image.min_ram = 64
result = validator(config, clients, None)
self.assertFalse(result.is_valid, result.msg)
def test_image_valid_on_flavor(self, mock_get_flavor, mock_get_image):
image = {"id": "fake_id", "min_ram": None, "size": 2, "min_disk": 0}
flavor = mock.MagicMock()
success = validation.ValidationResult(True)
mock_get_flavor.return_value = (success, flavor)
mock_get_image.return_value = (success, image)
validator = self._unwrap_validator(validation.image_valid_on_flavor,
"flavor", "image")
# test ram
flavor.disk = None
flavor.ram = 2
image["min_ram"] = None
result = validator(None, None, None)
self.assertTrue(result.is_valid, result.msg)
image["min_ram"] = 4
result = validator(None, None, None)
self.assertFalse(result.is_valid, result.msg)
image["min_ram"] = 1
result = validator(None, None, None)
self.assertTrue(result.is_valid, result.msg)
# test disk (flavor.disk not None)
image["size"] = 2
image["min_disk"] = 0
flavor.disk = 5.0 / (1024**3)
result = validator(None, None, None)
self.assertTrue(result.is_valid, result.msg)
image["min_disk"] = flavor.disk * 2
result = validator(None, None, None)
self.assertFalse(result.is_valid, result.msg)
image["min_disk"] = flavor.disk / 4
image["size"] = 1000
result = validator(None, None, None)
self.assertFalse(result.is_valid, result.msg)
def test_valid_command_unreadable_script_file(self, mock__file_access_ok):
mock__file_access_ok.return_value = validation.ValidationResult(False)
validator = self._unwrap_validator(validation.valid_command,
param_name="p")
command = {"script_file": "foobar", "interpreter": "foo"}
result = validator({"args": {"p": command}}, None, None)
self.assertFalse(result.is_valid, result.msg)
def test_valid_command(self, mock__file_access_ok):
validator = self._unwrap_validator(validation.valid_command,
param_name="p")
mock__file_access_ok.return_value = validation.ValidationResult(True)
command = {"script_file": "foobar", "interpreter": "foo"}
result = validator({"args": {"p": command}}, None, None)
self.assertTrue(result.is_valid, result.msg)
mock__file_access_ok.assert_called_once_with("foobar", os.R_OK,
"p.script_file", True)
def test_validator(self):
failure = validation.ValidationResult(False)
func = lambda *args, **kv: kv
scenario = lambda: None
# Check arguments passed to validator
wrap = validation.validator(func)
wrap_args = ["foo", "bar"]
wrap_kwargs = {"foo": "spam"}
wrap_scenario = wrap(*wrap_args, **wrap_kwargs)
wrap_validator = wrap_scenario(scenario)
validators = wrap_validator.validators
self.assertEqual(1, len(validators))
validator, = validators
self.assertEqual(wrap_kwargs, validator(None, None, None))
self.assertEqual(wrap_validator, scenario)
# Default permission
validator, = self._get_scenario_validators(func, scenario)
self.assertEqual(validator.permission,
validation.consts.EndpointPermission.USER)
# Custom permission
func.permission = "another_permission"
del scenario.validators
validator, = self._get_scenario_validators(func, scenario, reset=False)
self.assertEqual(validator.permission, "another_permission")
# Default result
func_success = lambda *a, **kv: None
validator, = self._get_scenario_validators(func_success, scenario)
self.assertTrue(validator(None, None, None).is_valid)
# Failure result
func_failure = lambda *a, **kv: failure
validator, = self._get_scenario_validators(func_failure, scenario)
self.assertFalse(validator(None, None, None).is_valid)
