diff options
Diffstat (limited to 'test/integration/targets/filter_mathstuff/tasks/main.yml')
-rw-r--r-- | test/integration/targets/filter_mathstuff/tasks/main.yml | 320 |
1 files changed, 320 insertions, 0 deletions
diff --git a/test/integration/targets/filter_mathstuff/tasks/main.yml b/test/integration/targets/filter_mathstuff/tasks/main.yml new file mode 100644 index 0000000..019f00e --- /dev/null +++ b/test/integration/targets/filter_mathstuff/tasks/main.yml @@ -0,0 +1,320 @@ +- name: Verify unique's fallback's exception throwing for case_sensitive=False + set_fact: + unique_fallback_exc1: '{{ [{"foo": "bar", "moo": "cow"}]|unique(case_sensitive=False) }}' + ignore_errors: true + tags: unique + register: unique_fallback_exc1_res + +- name: Verify unique's fallback's exception throwing for a Hashable thing that triggers TypeError + set_fact: + unique_fallback_exc2: '{{ True|unique }}' + ignore_errors: true + tags: unique + register: unique_fallback_exc2_res + +- name: Verify unique + tags: unique + assert: + that: + - '[1,2,3,4,4,3,2,1]|unique == [1,2,3,4]' + - '["a", "b", "a", "b"]|unique == ["a", "b"]' + - '[{"foo": "bar", "moo": "cow"}, {"foo": "bar", "moo": "cow"}, {"haha": "bar", "moo": "mar"}]|unique == [{"foo": "bar", "moo": "cow"}, {"haha": "bar", "moo": "mar"}]' + - '[{"foo": "bar", "moo": "cow"}, {"foo": "bar", "moo": "mar"}]|unique == [{"foo": "bar", "moo": "cow"}, {"foo": "bar", "moo": "mar"}]' + - '{"foo": "bar", "moo": "cow"}|unique == ["foo", "moo"]' + - '"foo"|unique|sort|join == "fo"' + - '[1,2,3,4,5]|unique == [1,2,3,4,5]' + - unique_fallback_exc1_res is failed + - unique_fallback_exc2_res is failed + - "\"'bool' object is not iterable\" in unique_fallback_exc2_res.msg" + +# `unique` will fall back to a custom implementation if the Jinja2 version is +# too old to support `jinja2.filters.do_unique`. However, the built-in fallback +# is quite different by default. Namely, it ignores the case-sensitivity +# setting. This means running: +# ['a', 'b', 'A', 'B']|unique +# ... will give a different result for someone running Jinja 2.9 vs 2.10 when +# do_unique was added. So here, we do a test to see if we have `do_unique`. If +# we do, then we do another test to make sure attribute and case_sensitive +# work on it. +- name: Test for do_unique + shell: "{{ansible_python_interpreter}} -c 'from jinja2 import filters; print(\"do_unique\" in dir(filters))'" + tags: unique + register: do_unique_res + +- name: Verify unique some more + tags: unique + assert: + that: + - '["a", "b", "A", "B"]|unique(case_sensitive=True) == ["a", "b", "A", "B"]' + - '[{"foo": "bar", "moo": "cow"}, {"foo": "bar", "moo": "mar"}]|unique(attribute="foo") == [{"foo": "bar", "moo": "cow"}]' + - '["a", "b", "A", "B"]|unique == ["a", "b"]' # defaults to case_sensitive=False + - "'cannot fall back' in unique_fallback_exc1_res.msg" + when: do_unique_res.stdout == 'True' + +- name: Verify unique some more + tags: unique + assert: + that: + - "'does not support case_sensitive' in unique_fallback_exc1_res.msg" + when: do_unique_res.stdout == 'False' + +- name: Verify intersect + tags: intersect + assert: + that: + - '[1,2,3]|intersect([4,5,6]) == []' + - '[1,2,3]|intersect([3,4,5,6]) == [3]' + - '[1,2,3]|intersect([3,2,1]) == [1,2,3]' + - '(1,2,3)|intersect((4,5,6))|list == []' + - '(1,2,3)|intersect((3,4,5,6))|list == [3]' + - '["a","A","b"]|intersect(["B","c","C"]) == []' + - '["a","A","b"]|intersect(["b","B","c","C"]) == ["b"]' + - '["a","A","b"]|intersect(["b","A","a"]) == ["a","A","b"]' + - '("a","A","b")|intersect(("B","c","C"))|list == []' + - '("a","A","b")|intersect(("b","B","c","C"))|list == ["b"]' + +- name: Verify difference + tags: difference + assert: + that: + - '[1,2,3]|difference([4,5,6]) == [1,2,3]' + - '[1,2,3]|difference([3,4,5,6]) == [1,2]' + - '[1,2,3]|difference([3,2,1]) == []' + - '(1,2,3)|difference((4,5,6))|list == [1,2,3]' + - '(1,2,3)|difference((3,4,5,6))|list == [1,2]' + - '["a","A","b"]|difference(["B","c","C"]) == ["a","A","b"]' + - '["a","A","b"]|difference(["b","B","c","C"]) == ["a","A"]' + - '["a","A","b"]|difference(["b","A","a"]) == []' + - '("a","A","b")|difference(("B","c","C"))|list|sort(case_sensitive=True) == ["A","a","b"]' + - '("a","A","b")|difference(("b","B","c","C"))|list|sort(case_sensitive=True) == ["A","a"]' + +- name: Verify symmetric_difference + tags: symmetric_difference + assert: + that: + - '[1,2,3]|symmetric_difference([4,5,6]) == [1,2,3,4,5,6]' + - '[1,2,3]|symmetric_difference([3,4,5,6]) == [1,2,4,5,6]' + - '[1,2,3]|symmetric_difference([3,2,1]) == []' + - '(1,2,3)|symmetric_difference((4,5,6))|list == [1,2,3,4,5,6]' + - '(1,2,3)|symmetric_difference((3,4,5,6))|list == [1,2,4,5,6]' + - '["a","A","b"]|symmetric_difference(["B","c","C"]) == ["a","A","b","B","c","C"]' + - '["a","A","b"]|symmetric_difference(["b","B","c","C"]) == ["a","A","B","c","C"]' + - '["a","A","b"]|symmetric_difference(["b","A","a"]) == []' + - '("a","A","b")|symmetric_difference(("B","c","C"))|list|sort(case_sensitive=True) == ["A","B","C","a","b","c"]' + - '("a","A","b")|symmetric_difference(("b","B","c","C"))|list|sort(case_sensitive=True) == ["A","B","C","a","c"]' + +- name: Verify union + tags: union + assert: + that: + - '[1,2,3]|union([4,5,6]) == [1,2,3,4,5,6]' + - '[1,2,3]|union([3,4,5,6]) == [1,2,3,4,5,6]' + - '[1,2,3]|union([3,2,1]) == [1,2,3]' + - '(1,2,3)|union((4,5,6))|list == [1,2,3,4,5,6]' + - '(1,2,3)|union((3,4,5,6))|list == [1,2,3,4,5,6]' + - '["a","A","b"]|union(["B","c","C"]) == ["a","A","b","B","c","C"]' + - '["a","A","b"]|union(["b","B","c","C"]) == ["a","A","b","B","c","C"]' + - '["a","A","b"]|union(["b","A","a"]) == ["a","A","b"]' + - '("a","A","b")|union(("B","c","C"))|list|sort(case_sensitive=True) == ["A","B","C","a","b","c"]' + - '("a","A","b")|union(("b","B","c","C"))|list|sort(case_sensitive=True) == ["A","B","C","a","b","c"]' + +- name: Verify min + tags: min + assert: + that: + - '[1000,-99]|min == -99' + - '[0,4]|min == 0' + +- name: Verify max + tags: max + assert: + that: + - '[1000,-99]|max == 1000' + - '[0,4]|max == 4' + +- name: Verify logarithm on a value of invalid type + set_fact: + logarithm_exc1: '{{ "yo"|log }}' + ignore_errors: true + tags: logarithm + register: logarithm_exc1_res + +- name: Verify logarithm (which is passed to Jinja as "log" because consistency is boring) + tags: logarithm + assert: + that: + - '1|log == 0.0' + - '100|log(10) == 2.0' + - '100|log(10) == 2.0' + - '21|log(21) == 1.0' + - '(2.3|log(42)|string).startswith("0.222841")' + - '(21|log(42)|string).startswith("0.814550")' + - logarithm_exc1_res is failed + - '"can only be used on numbers" in logarithm_exc1_res.msg' + +- name: Verify power on a value of invalid type + set_fact: + power_exc1: '{{ "yo"|pow(4) }}' + ignore_errors: true + tags: power + register: power_exc1_res + +- name: Verify power (which is passed to Jinja as "pow" because consistency is boring) + tags: power + assert: + that: + - '2|pow(4) == 16.0' + - power_exc1_res is failed + - '"can only be used on numbers" in power_exc1_res.msg' + +- name: Verify inversepower on a value of invalid type + set_fact: + inversepower_exc1: '{{ "yo"|root }}' + ignore_errors: true + tags: inversepower + register: inversepower_exc1_res + +- name: Verify inversepower (which is passed to Jinja as "root" because consistency is boring) + tags: inversepower + assert: + that: + - '4|root == 2.0' + - '4|root(2) == 2.0' + - '9|root(1) == 9.0' + - '(9|root(6)|string).startswith("1.4422495")' + - inversepower_exc1_res is failed + - '"can only be used on numbers" in inversepower_exc1_res.msg' + +- name: Verify human_readable on invalid input + set_fact: + human_readable_exc1: '{{ "monkeys"|human_readable }}' + ignore_errors: true + tags: human_readable + register: human_readable_exc1_res + +- name: Verify human_readable + tags: human_readable + assert: + that: + - '"1.00 Bytes" == 1|human_readable' + - '"1.00 bits" == 1|human_readable(isbits=True)' + - '"10.00 KB" == 10240|human_readable' + - '"97.66 MB" == 102400000|human_readable' + - '"0.10 GB" == 102400000|human_readable(unit="G")' + - '"0.10 Gb" == 102400000|human_readable(isbits=True, unit="G")' + - human_readable_exc1_res is failed + - '"failed on bad input" in human_readable_exc1_res.msg' + +- name: Verify human_to_bytes + tags: human_to_bytes + assert: + that: + - "{{'0'|human_to_bytes}} == 0" + - "{{'0.1'|human_to_bytes}} == 0" + - "{{'0.9'|human_to_bytes}} == 1" + - "{{'1'|human_to_bytes}} == 1" + - "{{'10.00 KB'|human_to_bytes}} == 10240" + - "{{ '11 MB'|human_to_bytes}} == 11534336" + - "{{ '1.1 GB'|human_to_bytes}} == 1181116006" + - "{{'10.00 Kb'|human_to_bytes(isbits=True)}} == 10240" + +- name: Verify human_to_bytes (bad string) + set_fact: + bad_string: "{{ '10.00 foo' | human_to_bytes }}" + ignore_errors: yes + tags: human_to_bytes + register: _human_bytes_test + +- name: Verify human_to_bytes (bad string) + tags: human_to_bytes + assert: + that: "{{_human_bytes_test.failed}}" + +- name: Verify that union can be chained + tags: union + vars: + unions: '{{ [1,2,3]|union([4,5])|union([6,7]) }}' + assert: + that: + - "unions|type_debug == 'list'" + - "unions|length == 7" + +- name: Test union with unhashable item + tags: union + vars: + unions: '{{ [1,2,3]|union([{}]) }}' + assert: + that: + - "unions|type_debug == 'list'" + - "unions|length == 4" + +- name: Verify rekey_on_member with invalid "duplicates" kwarg + set_fact: + rekey_on_member_exc1: '{{ []|rekey_on_member("asdf", duplicates="boo") }}' + ignore_errors: true + tags: rekey_on_member + register: rekey_on_member_exc1_res + +- name: Verify rekey_on_member with invalid data + set_fact: + rekey_on_member_exc2: '{{ "minkeys"|rekey_on_member("asdf") }}' + ignore_errors: true + tags: rekey_on_member + register: rekey_on_member_exc2_res + +- name: Verify rekey_on_member with partially invalid data (list item is not dict) + set_fact: + rekey_on_member_exc3: '{{ [True]|rekey_on_member("asdf") }}' + ignore_errors: true + tags: rekey_on_member + register: rekey_on_member_exc3_res + +- name: Verify rekey_on_member with partially invalid data (key not in all dicts) + set_fact: + rekey_on_member_exc4: '{{ [{"foo": "bar", "baz": "buzz"}, {"hello": 8, "different": "haha"}]|rekey_on_member("foo") }}' + ignore_errors: true + tags: rekey_on_member + register: rekey_on_member_exc4_res + +- name: Verify rekey_on_member with duplicates and duplicates=error + set_fact: + rekey_on_member_exc5: '{{ [{"proto": "eigrp", "state": "enabled"}, {"proto": "eigrp", "state": "enabled"}]|rekey_on_member("proto", duplicates="error") }}' + ignore_errors: true + tags: rekey_on_member + register: rekey_on_member_exc5_res + +- name: Verify rekey_on_member + tags: rekey_on_member + assert: + that: + - rekey_on_member_exc1_res is failed + - '"duplicates parameter to rekey_on_member has unknown value" in rekey_on_member_exc1_res.msg' + - '[{"proto": "eigrp", "state": "enabled"}, {"proto": "ospf", "state": "enabled"}]|rekey_on_member("proto") == {"eigrp": {"proto": "eigrp", "state": "enabled"}, "ospf": {"proto": "ospf", "state": "enabled"}}' + - '{"a": {"proto": "eigrp", "state": "enabled"}, "b": {"proto": "ospf", "state": "enabled"}}|rekey_on_member("proto") == {"eigrp": {"proto": "eigrp", "state": "enabled"}, "ospf": {"proto": "ospf", "state": "enabled"}}' + - '[{"proto": "eigrp", "state": "enabled"}, {"proto": "eigrp", "state": "enabled"}]|rekey_on_member("proto", duplicates="overwrite") == {"eigrp": {"proto": "eigrp", "state": "enabled"}}' + - rekey_on_member_exc2_res is failed + - '"Type is not a valid list, set, or dict" in rekey_on_member_exc2_res.msg' + - rekey_on_member_exc3_res is failed + - '"List item is not a valid dict" in rekey_on_member_exc3_res.msg' + - rekey_on_member_exc4_res is failed + - '"was not found" in rekey_on_member_exc4_res.msg' + - rekey_on_member_exc5_res is failed + - '"is not unique, cannot correctly turn into dict" in rekey_on_member_exc5_res.msg' + +- name: test undefined positional args for rekey_on_member are properly handled + vars: + all_vars: "{{ hostvars[inventory_hostname] }}" + test_var: "{{ all_vars.foo }}" + block: + - include_vars: + file: defined_later.yml + - assert: + that: "test_var == 'test'" + - assert: + that: "rekeyed == {'value': {'test': 'value'}}" + +# TODO: For some reason, the coverage tool isn't accounting for the last test +# so add another "last test" to fake it... +- assert: + that: + - true |