def validate(self):
self.property = self.entity if not self.property else self.property
try:
self._find_robot_instance()
self._check_test_data()
call_validator(self.instance.sut.target_type, validators.Context, self.allowed_contexts)
call_validator(self.matcher, validators.InList, Address.properties.get('entity', {}).get('matchers', []))
call_validator(self.value, validators.InList, Address.properties.get('entity', {}).get('values', []))
# split address in case a port is given
split_entity = self.entity.split(':')
if len(split_entity) > 2:
raise ValidationError('Value "{}" is invalid.'.format(self.entity))
self.address = split_entity[0]
self.port = split_entity[1] if len(split_entity) == 2 else '80'
# valid in addition to domain names are: all container names, service names with and without stack name
override = [c.attrs['Config']['Hostname'] for c in self.instance.containers]
override.extend([s.name for s in self.instance.services])
override.extend([s.name.split('{}_'.format(self.instance.deployment_name))[1:][0]
for s in self.instance.services])
call_validator(entity=self.address, validator=validators.Domain, override=override)
call_validator(self.port, validators.Port)
except (SetupError, ValidationError) as exc:
raise exc
def validate(self):
self._find_robot_instance()
self._check_test_data()
call_validator(self.instance.sut.target_type, validators.Service, File.allowed_contexts)
self.property = validate_property(File.properties, self.property)
validate_matcher([self.matcher], limit_to=File.properties.get('entity', {}).get('matchers', []))
self.value = validate_value(File.properties, self.property, self.value)
def validate(self):
self.property = self.entity if not self.property else self.property
self._find_robot_instance()
self._check_test_data()
call_validator(self.instance.sut.target_type, validators.Context,
Variable.allowed_contexts)
call_validator(self.entity, validators.Regex, Variable.entity_matcher)
call_validator(self.matcher, validators.InList,
Variable.properties.get('entity', {}).get('matchers'))
call_validator(self.value, validators.Regex,
Variable.properties.get('entity', {}).get('values'))
def validate(self):
self._find_robot_instance()
# self._check_test_data()
call_validator(self.instance.sut.target_type, validators.Context, LogsTarget.allowed_contexts)
call_validator(self.matcher, validators.InList, LogsTarget.properties.get('entity', {}).get('matchers', []))
call_validator(self.value, validators.NonEmptyString)
def validate(self):
self._find_robot_instance()
self._check_test_data()
try:
call_validator(self.instance.sut.target_type, validators.Context,
Placement.allowed_contexts)
call_validator(self.property, validators.Property,
Placement.properties)
call_validator(
self.matcher, validators.InList,
Placement.properties.get(self.property,
{}).get('matchers', []))
call_validator(
self.value,
Placement.properties.get(self.property, {}).get('values', ''))
except ValidationError:
raise
def test__validate_entity__regex__no_regex__fail():
inp = 'a'
validator = validators.Regex
with pytest.raises(ValidationError, match='regex'):
call_validator(inp, validator, '[')
def test__validate_entity__regex__no_basestring__fail():
inp = 'a'
validator = validators.Regex
with pytest.raises(ValidationError, match='basestring'):
call_validator(inp, validator, [''])
def test__validate_entity__regex__pass():
inp = 'isnot'
validator = validators.Regex
call_validator(inp, validator, '\S+')
def test__validate_entity__domain__pass():
inp = 'www.google.de'
url_validator = validators.Domain
assert call_validator(inp, url_validator)
def test__validate_entity__url__pass():
inp = 'http://www.google.de'
url_validator = validators.Url
assert call_validator(inp, url_validator)
def test__validate_entity__chmod__fail(perm):
validator = validators.Permission
with pytest.raises(ValidationError, match=not_valid_match):
call_validator(perm, validator)
def test__validate_entity__port__fail(port):
validator = validators.Port
with pytest.raises(ValidationError, match=not_valid_match):
call_validator(port, validator)
def test__validate_entity__property__no_dict__fail():
inp = 'a'
validator = validators.Property
with pytest.raises(ValidationError, match='dict'):
call_validator(inp, validator, ['application'])
def test__validate_entity__property__pass():
inp = 'a'
validator = validators.Property
call_validator(inp, validator, {'a': {}})
def test__validate_entity__context__fail():
inp = 'service'
validator = validators.Context
with pytest.raises(ValidationError, match=not_valid_match):
call_validator(inp, validator, ['application'])
def test__validate_entity__context__pass():
inp = 'service'
validator = validators.Context
call_validator(inp, validator, ['service', 'network'])
def test__validate_entity__service__no_context__fail():
inp = 'sutnotexist'
validator = validators.Service
with pytest.raises(ValidationError):
call_validator(inp, validator, '')
def test__validate_entity__service__pass(sut):
inp = 'sut'
validator = validators.Service
assert call_validator(inp, validator, sut)
def test__validate_entity__domain__override__pass():
inp = 'www.google.de'
override = ['awesome']
url_validator = validators.Domain
assert call_validator(inp, url_validator, override=override)
def test__validate_entity__regex__fail():
inp = 'bla a '
validator = validators.InList
with pytest.raises(ValidationError, match=not_valid_match):
call_validator(inp, validator, ['\S+'])
def test__validate_entity__port__pass(port):
validator = validators.Port
call_validator(port, validator)
def test__validate_entity__property__fail():
inp = 'a'
validator = validators.Property
with pytest.raises(ValidationError, match=not_valid_match):
call_validator(inp, validator, {'b': {}})
def test__validate_entity__chmod__pass(perm):
validator = validators.Permission
assert call_validator(perm, validator)
def test__validate_entity__matcher__no_list__fail():
inp = 'a'
validator = validators.InList
with pytest.raises(ValidationError, match='list'):
call_validator(inp, validator, 'application')
def test__validate_entity__url__fail():
inp = 'http://www.google.d'
url_validator = validators.Url
with pytest.raises(ValidationError):
call_validator(inp, url_validator)
def test__validate_entity__matcher__fail():
inp = 'is'
validator = validators.InList
with pytest.raises(ValidationError, match=not_valid_match):
call_validator(inp, validator, ['contains'])
def test__validate_entity__matcher__pass():
inp = 'is not'
validator = validators.InList
call_validator(inp, validator, ['is not'])
def test__validate_entity__domain__fail():
inp = 'www.google.d'
url_validator = validators.Domain
with pytest.raises(ValidationError):
call_validator(inp, url_validator)
