def test_validate_label_accepts_valid_labels(label):
# Arrange
validation_rule = ValidationRule({'classification': 'Required'})
# Act
validation_result = argument_validator.validate("label", label,
validation_rule)
assert validation_result.is_valid is True
def validate_request_keys(self, request_body):
is_valid = True
error_msg = "The following errors were found:\n"
# Get keys required/supported
required_keys = self._validation_ruleset.get_keys_of_required_inputs()
if 'language' in request_body:
language = request_body['language']
rule = self._validation_ruleset.get_validation_rule_for_key('language')
validation_result = validate('language', language, rule)
if validation_result.is_valid:
required_keys += self._validation_ruleset.get_keys_for_language(request_body['language'])
else:
is_valid = False
error_msg += f'Unsupported language "{language}" provided\n'
supported_keys = required_keys + self._validation_ruleset.get_keys_of_optional_inputs()
# Find any discrepancies
missing_keys = get_set_difference(required_keys, request_body)
unsupported_keys = get_set_difference(request_body, supported_keys)
# Group the results together
for key in missing_keys:
is_valid = False
error_msg += f'Missing required input "{key}"\n'
for key in unsupported_keys:
is_valid = False
error_msg += f'Unsupported input "{key}" provided\n'
result = ValidationResult(
is_valid,
"All input keys provided are valid\n" if is_valid else error_msg,
None
)
return result
def test_validate_main_class_rejects_empty_strings_and_non_strings(main_class):
# Arrange
validation_rule = ValidationRule({'classification': 'Required'})
# Act
validation_result = argument_validator.validate("main_class", main_class,
validation_rule)
# Assert
assert validation_result.is_valid is False
def test_validate_label_rejects_empty_strings_and_non_strings(label):
# Arrange
validation_rule = ValidationRule({'classification': 'Optional'})
# Act
validation_result = argument_validator.validate("label", label,
validation_rule)
# Assert
assert validation_result.is_valid is False
def test_validate_name_validates_well_formatted_strings(name):
# Arrange
validation_rule = ValidationRule({'classification': 'Required'})
# Act
validation_result = argument_validator.validate("name", name,
validation_rule)
# Assert
assert validation_result.is_valid is True
def test_validate_path_to_main_app_file_validates_non_empty_strings(path):
# Arrange
validation_rule = ValidationRule({'classification': 'Required'})
# Act
validation_result = argument_validator.validate("path_to_main_app_file",
path, validation_rule)
# Assert
assert validation_result.is_valid is True
def test_validate_label_rejects_invalid_non_empty_labels(label):
# Arrange
validation_rule = ValidationRule({'classification': 'Required'})
# Act
validation_result = argument_validator.validate("label", label,
validation_rule)
assert validation_result.is_valid is False
assert validation_result.message == '"label" input must obey naming convention: ' \
'see https://github.com/ukaea/piezo/wiki/WebAppUserGuide#submit-a-job'
def test_validate_label_validates_label_with_63_characters():
# Arrange
validation_rule = ValidationRule({'classification': 'Required'})
label = "abcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyabcdefghijklm"
assert len(label) == 63
# Act
validation_result = argument_validator.validate("label", label,
validation_rule)
assert validation_result.is_valid is True
def test_validate_label_rejects_empty_strings(label):
# Arrange
validation_rule = ValidationRule({'classification': 'Required'})
# Act
validation_result = argument_validator.validate("label", label,
validation_rule)
# Assert
assert validation_result.is_valid is False
assert validation_result.message == '"label" input cannot be empty'
def test_validate_name_rejects_non_string_values(name):
# Arrange
validation_rule = ValidationRule({'classification': 'Required'})
# Act
validation_result = argument_validator.validate("name", name,
validation_rule)
# Assert
assert validation_result.is_valid is False
assert validation_result.message == '"name" input must be a string'
def test_validate_name_allows_29_character_name():
# Arrange
validation_rule = ValidationRule({'classification': 'Required'})
name = 'abcdefghijklmnopqrstuvwxyzabc'
assert len(name) == 29
# Act
validation_result = argument_validator.validate("name", name,
validation_rule)
# Assert
assert validation_result.is_valid is True
def test_validate_name_rejects_poorly_formatted_strings(name):
# Arrange
validation_rule = ValidationRule({'classification': 'Required'})
# Act
validation_result = argument_validator.validate("name", name,
validation_rule)
# Assert
assert validation_result.is_valid is False
assert validation_result.message == '"name" input must obey naming convention: '\
'see https://github.com/ukaea/piezo/wiki/WebAppUserGuide#submit-a-job'
def test_validate_label_rejects_label_with_64_characters():
# Arrange
validation_rule = ValidationRule({'classification': 'Required'})
label = "abcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyabcdefghijklm" + "n"
assert len(label) == 64
# Act
validation_result = argument_validator.validate("label", label,
validation_rule)
assert validation_result.is_valid is False
assert validation_result.message == '"label" input has a maximum length of 63 characters'
def test_validate_language_rejects_non_valid_languages(language):
# Arrange
validation_rule = ValidationRule({
'classification': 'Required',
'options': ['Python', 'Scala']
})
# Act
validation_result = argument_validator.validate("language", language,
validation_rule)
# Assert
assert validation_result.is_valid is False
def test_validate_name_rejects_30_character_name():
# Arrange
validation_rule = ValidationRule({'classification': 'Required'})
name = 'abcdefghijklmnopqrstuvwxyzabc' + 'd'
assert len(name) == 30
# Act
validation_result = argument_validator.validate("name", name,
validation_rule)
# Assert
assert validation_result.is_valid is False
assert validation_result.message == '"name" input must obey naming convention: ' \
'see https://github.com/ukaea/piezo/wiki/WebAppUserGuide#submit-a-job'
def test_validate_python_version_validates_string_2_or_3(version):
# Arrange
validation_rule = ValidationRule({
'classification': 'Conditional',
'options': ['2', '3'],
'conditional_input_name': 'language',
'conditional_input_value': 'Python'
})
# Act
validation_result = argument_validator.validate("python_version", version,
validation_rule)
# Assert
assert validation_result.is_valid is True
def test_validate_driver_memory_accepts_values_for_megabytes_as_string(memory):
# Arrange
validation_rule = ValidationRule({
'classification': 'Optional',
'default': '512m',
'minimum': 512,
'maximum': 2048
})
# Act
validation_result = argument_validator.validate("driver_memory", memory,
validation_rule)
# Assert
assert validation_result.is_valid is True
def test_validate_driver_cores_accepts_values_within_valid_range(cores):
# Arrange
validation_rule = ValidationRule({
'classification': 'Optional',
'default': 0.1,
'minimum': 0.1,
'maximum': 1
})
# Act
validation_result = argument_validator.validate("driver_cores", cores,
validation_rule)
# Assert
assert validation_result.is_valid is True
def test_validate_executor_memory_rejects_values_outside_valid_range(memory):
# Arrange
validation_rule = ValidationRule({
'classification': 'Optional',
'default': '512m',
'minimum': 512,
'maximum': 4096
})
# Act
validation_result = argument_validator.validate("executor_memory", memory,
validation_rule)
# Assert
assert validation_result.is_valid is False
assert validation_result.message == '"executor_memory" input must be in range [512m, 4096m]'
def test_validate_executors_rejects_badly_formatted_inputs(executors):
# Arrange
validation_rule = ValidationRule({
'classification': 'Optional',
'default': 1,
'minimum': 1,
'maximum': 10
})
# Act
validation_result = argument_validator.validate("executors", executors,
validation_rule)
# Assert
assert validation_result.is_valid is False
assert validation_result.message == '"executors" input must be an integer'
def test_validate_executors_accepts_numerical_values_within_valid_range(
executors):
# Arrange
validation_rule = ValidationRule({
'classification': 'Optional',
'default': 1,
'minimum': 1,
'maximum': 10
})
# Act
validation_result = argument_validator.validate("executors", executors,
validation_rule)
# Assert
assert validation_result.is_valid is True
def test_validate_driver_cores_rejects_values_not_a_multiple_of_a_tenth(cores):
# Arrange
validation_rule = ValidationRule({
'classification': 'Optional',
'default': 0.1,
'minimum': 0.1,
'maximum': 1
})
# Act
validation_result = argument_validator.validate("driver_cores", cores,
validation_rule)
# Assert
assert validation_result.is_valid is False
assert validation_result.message == '"driver_cores" input must be a multiple of 0.1'
def test_validate_executors_rejects_values_outside_valid_range(executors):
# Arrange
validation_rule = ValidationRule({
'classification': 'Optional',
'default': 1,
'minimum': 1,
'maximum': 10
})
# Act
validation_result = argument_validator.validate("executors", executors,
validation_rule)
# Assert
assert validation_result.is_valid is False
assert validation_result.message == '"executors" input must be in range [1, 10]'
def test_validate_driver_cores_rejects_values_outside_valid_range(cores):
# Arrange
validation_rule = ValidationRule({
'classification': 'Optional',
'default': 0.1,
'minimum': 0.1,
'maximum': 1
})
# Act
validation_result = argument_validator.validate("driver_cores", cores,
validation_rule)
# Assert
assert validation_result.is_valid is False
assert validation_result.message == '"driver_cores" input must be in range [0.1, 1]'
def test_validate_python_version_rejects_string_not_in_list(version):
# Arrange
validation_rule = ValidationRule({
'classification': 'Conditional',
'options': ['2', '3'],
'conditional_input_name': 'language',
'conditional_input_value': 'Python'
})
# Act
validation_result = argument_validator.validate("python_version", version,
validation_rule)
# Assert
assert validation_result.is_valid is False
assert validation_result.message == '"python_version" input must be one of: "2", "3"'
def test_validate_executor_cores_rejects_values_outside_valid_range_or_with_bad_format(
executor_cores):
# Arrange
validation_rule = ValidationRule({
'classification': 'Optional',
'default': 1,
'minimum': 1,
'maximum': 4
})
# Act
validation_result = argument_validator.validate("executor_cores",
executor_cores,
validation_rule)
# Assert
assert validation_result.is_valid is False
def test_validate_executor_memory_rejects_incorrectly_formatted_values(memory):
# Arrange
validation_rule = ValidationRule({
'classification': 'Optional',
'default': '512m',
'minimum': 512,
'maximum': 4096
})
# Act
validation_result = argument_validator.validate("executor_memory", memory,
validation_rule)
# Assert
assert validation_result.is_valid is False
assert validation_result.message == '"executor_memory" input must be a string integer value ending in "m" ' \
'(e.g. "512m" for 512 megabytes)'
def validate_request_values(self, request_body):
validated_dict = {}
error_msg = "The following errors were found:\n"
is_valid = True
for key, input_value in request_body.items():
rule_for_key = self._validation_ruleset.get_validation_rule_for_key(key)
validation_result = validate(key, input_value, rule_for_key)
if validation_result.is_valid is True:
validated_dict[key] = validation_result.validated_value
else:
error_msg += validation_result.message + '\n'
is_valid = False
result = ValidationResult(
is_valid,
"All inputs provided are valid\n" if is_valid else error_msg,
validated_dict if is_valid else None
)
return result
