def _check_argspec(self):
aav = AnsibleArgSpecValidator(data=self._task.args,
schema=DOCUMENTATION,
name=self._task.action)
valid, errors, self._task.args = aav.validate()
if not valid:
raise AnsibleActionFail(errors)
def _ipv4(*args, **kwargs):
"""This filter is designed to return the input value if a query is True, and False if a query is False"""
keys = ["value", "query"]
data = dict(zip(keys, args[1:]))
data.update(kwargs)
aav = AnsibleArgSpecValidator(data=data, schema=DOCUMENTATION, name="ipv4")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
return ipv4(**updated_data)
def _check_argspec(self):
aav = AnsibleArgSpecValidator(
data=self._task.args,
schema=DOCUMENTATION,
schema_format="doc",
name=self._task.action,
)
valid, errors, self._task.args = aav.validate()
if not valid:
self._result["failed"] = True
self._result["msg"] = errors
def test_simple_fail_no_name(self):
data = {}
aav = AnsibleArgSpecValidator(
data=data,
schema=DOCUMENTATION,
schema_format="doc",
schema_conditionals={},
)
valid, errors, _updated_data = aav.validate()
self.assertFalse(valid)
self.assertIn("missing required arguments: param_str", errors)
def _check_argspec(self):
aav = AnsibleArgSpecValidator(
data=self._task.args,
schema=dict(argument_spec=argument_spec),
schema_format="argspec",
schema_conditionals=dict(required_if=required_if),
name=self._task.action,
)
valid, errors, self._task.args = aav.validate()
if not valid:
raise AnsibleActionFail(errors)
def _next_nth_usable(*args, **kwargs):
"""This filter returns the next nth usable ip within a network described by value."""
keys = ["value", "offset"]
data = dict(zip(keys, args[1:]))
data.update(kwargs)
aav = AnsibleArgSpecValidator(data=data,
schema=DOCUMENTATION,
name="next_nth_usable")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
return next_nth_usable(**updated_data)
def _cidr_merge(*args, **kwargs):
"""Convert the given data from json to xml."""
keys = ["value", "action"]
data = dict(zip(keys, args[1:]))
data.update(kwargs)
aav = AnsibleArgSpecValidator(
data=data, schema=DOCUMENTATION, name="cidr_merge"
)
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
return cidr_merge(**updated_data)
def _hwaddr(*args, **kwargs):
"""This filter check if string is a HW/MAC address and filter it """
keys = ["value", "query", "alias"]
data = dict(zip(keys, args[1:]))
data.update(kwargs)
aav = AnsibleArgSpecValidator(data=data,
schema=DOCUMENTATION,
name="hwaddr")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
return hwaddr(**updated_data)
def _ipsubnet(*args, **kwargs):
"""Manipulate IPv4/IPv6 subnets"""
keys = ["value", "query", "index"]
data = dict(zip(keys, args[1:]))
data.update(kwargs)
aav = AnsibleArgSpecValidator(data=data,
schema=DOCUMENTATION,
name="ipsubnet")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
return ipsubnet(**updated_data)
def test_other_args(self):
data = {}
aav = AnsibleArgSpecValidator(
data=data,
schema=DOCUMENTATION,
schema_format="doc",
name="test_action",
other_args={"bypass_checks": True},
)
valid, errors, _updated_data = aav.validate()
self.assertTrue(valid)
self.assertIsNone(errors)
def test_invalid_spec(self):
data = {}
aav = AnsibleArgSpecValidator(
data=data,
schema={"not_valid": True},
schema_format="argspec",
name="test_action",
other_args={"bypass_checks": True},
)
valid, errors, _updated_data = aav.validate()
self.assertFalse(valid)
self.assertIn("Invalid keys found: not_valid", errors)
def _ipwrap(*args, **kwargs):
"""This filter is designed to Wrap IPv6 addresses in [ ] brackets."""
keys = ["value"]
data = dict(zip(keys, args[1:]))
data.update(kwargs)
aav = AnsibleArgSpecValidator(data=data,
schema=DOCUMENTATION,
name="ipwrap")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
return ipwrap(**updated_data)
def _nthhost(*args, **kwargs):
"""This filter returns whether an address or a network passed as argument is in a network."""
keys = ["value", "query"]
data = dict(zip(keys, args[1:]))
data.update(kwargs)
aav = AnsibleArgSpecValidator(data=data,
schema=DOCUMENTATION,
name="nthhost")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
return nthhost(**updated_data)
def _to_paths(*args, **kwargs):
"""Flatten a complex object into a dictionary of paths and values."""
keys = ["var", "prepend", "wantlist"]
data = dict(zip(keys, args))
data.update(kwargs)
aav = AnsibleArgSpecValidator(
data=data, schema=DOCUMENTATION, name="to_paths"
)
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
return to_paths(**updated_data)
def _ip4_hex(*args, **kwargs):
"""This filter is designed to Convert an IPv4 address to Hexadecimal notation"""
keys = ["arg", "delimiter"]
data = dict(zip(keys, args[1:]))
data.update(kwargs)
aav = AnsibleArgSpecValidator(data=data,
schema=DOCUMENTATION,
name="ip4_hex")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
return ip4_hex(**updated_data)
def _to_xml(*args, **kwargs):
"""Convert the given data from json to xml."""
keys = ["data", "engine"]
data = dict(zip(keys, args[1:]))
data.update(kwargs)
aav = AnsibleArgSpecValidator(data=data,
schema=DOCUMENTATION,
name="to_xml")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
return to_xml(**updated_data)
def test_simple_pass(self):
data = {"param_str": "string"}
aav = AnsibleArgSpecValidator(
data=data,
schema=DOCUMENTATION,
schema_format="doc",
schema_conditionals={},
name="test_action",
)
valid, errors, _updated_data = aav.validate()
self.assertTrue(valid)
self.assertEqual(errors, None)
def _keep_keys(*args, **kwargs):
"""keep specific keys from a data recursively"""
keys = ["data", "target", "matching_parameter"]
data = dict(zip(keys, args[1:]))
data.update(kwargs)
aav = AnsibleArgSpecValidator(data=data,
schema=DOCUMENTATION,
name="keep_keys")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
return keep_keys(**updated_data)
def run(self, terms, variables, **kwargs):
if isinstance(terms, list):
keys = ["var", "prepend"]
terms = dict(zip(keys, terms))
terms.update(kwargs)
aav = AnsibleArgSpecValidator(data=terms,
schema=DOCUMENTATION,
name="to_paths")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleLookupError(errors)
updated_data["wantlist"] = True
res = to_paths(**updated_data)
return res
def _get_path(*args, **kwargs):
"""Retrieve the value in a variable using a path."""
keys = ["environment", "var", "path"]
data = dict(zip(keys, args))
data.update(kwargs)
environment = data.pop("environment")
aav = AnsibleArgSpecValidator(data=data,
schema=DOCUMENTATION,
name="get_path")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
updated_data["environment"] = environment
return get_path(**updated_data)
def run(self, terms, variables, **kwargs):
if isinstance(terms, list):
keys = ["var", "path"]
terms = dict(zip(keys, terms))
terms.update(kwargs)
aav = AnsibleArgSpecValidator(data=terms,
schema=DOCUMENTATION,
name="get_path")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleLookupError(errors)
updated_data["wantlist"] = True
updated_data["environment"] = self._templar.environment
res = get_path(**updated_data)
return res
def test_schema_conditional(self):
data = {"param_str": "string"}
aav = AnsibleArgSpecValidator(
data=data,
schema=DOCUMENTATION,
schema_format="doc",
schema_conditionals={
"required_together": [["param_str", "param_bool"]]
},
name="test_action",
)
valid, errors, _updated_data = aav.validate()
self.assertFalse(valid)
self.assertIn(
"parameters are required together: param_str, param_bool", errors)
def test_not_doc(self):
data = {"param_str": "string"}
aav = AnsibleArgSpecValidator(
data=data,
schema={"argument_spec": {
"param_str": {
"type": "str"
}
}},
schema_format="argspec",
name="test_action",
)
valid, errors, _updated_data = aav.validate()
self.assertTrue(valid)
self.assertEqual(errors, None)
def test_unsupported_param(self):
data = {"param_str": "string", "not_valid": "string"}
aav = AnsibleArgSpecValidator(
data=data,
schema=DOCUMENTATION,
schema_format="doc",
name="test_action",
# other_args={'bypass_checks': True},
)
valid, errors, _updated_data = aav.validate()
self.assertFalse(valid)
self.assertIn(
"Unsupported parameters for 'test_action' module: not_valid",
errors,
)
def _check_argspec(self):
aav = AnsibleArgSpecValidator(
data=self._task.args,
schema=dict(argument_spec=argument_spec),
schema_format="argspec",
schema_conditionals=dict(
required_if=required_if,
required_one_of=required_one_of,
mutually_exclusive=mutually_exclusive,
required_together=required_together,
),
name=self._task.action,
)
valid, errors, self._task.args = aav.validate()
if not valid:
raise AnsibleActionFail(errors)
def test_simple_defaults(self):
data = {"param_str": "string"}
aav = AnsibleArgSpecValidator(
data=data,
schema=DOCUMENTATION,
schema_format="doc",
schema_conditionals={},
name="test_action",
)
expected = {
"param_str": "string",
"param_default": True,
"params_bool": None,
"params_dict": None,
}
valid, errors, updated_data = aav.validate()
self.assertTrue(valid)
self.assertEqual(errors, None)
self.assertEqual(expected, updated_data)
def run(self, terms, variables, **kwargs):
if isinstance(terms, list):
keys = [
"data",
"test",
"value",
"key",
"fail_on_missing",
"wantlist",
]
terms = dict(zip(keys, terms))
terms.update(kwargs)
aav = AnsibleArgSpecValidator(
data=terms, schema=DOCUMENTATION, name="index_of"
)
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleLookupError(errors)
updated_data["wantlist"] = True
updated_data["tests"] = self._templar.environment.tests
res = index_of(**updated_data)
return res
def _index_of(*args, **kwargs):
"""Find the indicies of items in a list matching some criteria."""
keys = [
"environment",
"data",
"test",
"value",
"key",
"fail_on_missing",
"wantlist",
]
data = dict(zip(keys, args))
data.update(kwargs)
environment = data.pop("environment")
aav = AnsibleArgSpecValidator(data=data,
schema=DOCUMENTATION,
name="index_of")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
updated_data["tests"] = environment.tests
return index_of(**updated_data)
