mirror of https://github.com/ansible/ansible.git
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1400 lines
39 KiB
YAML
1400 lines
39 KiB
YAML
# test code for the lineinfile module
|
|
# (c) 2014, James Cammarata <jcammarata@ansible.com>
|
|
|
|
# This file is part of Ansible
|
|
#
|
|
# Ansible is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# Ansible is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
- name: deploy the test file for lineinfile
|
|
copy:
|
|
src: test.txt
|
|
dest: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: assert that the test file was deployed
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- "result.checksum == '5feac65e442c91f557fc90069ce6efc4d346ab51'"
|
|
- "result.state == 'file'"
|
|
|
|
- name: "create a file that does not yet exist with `create: yes` and produce diff"
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/a/a.txt"
|
|
state: present
|
|
line: "First line"
|
|
create: yes
|
|
diff: yes
|
|
register: result1
|
|
|
|
- name: assert that a diff was returned
|
|
assert:
|
|
that:
|
|
- result1.diff | length > 0
|
|
|
|
- name: stat the new file
|
|
stat:
|
|
path: "{{ output_dir }}/a/a.txt"
|
|
register: result
|
|
|
|
- name: assert that the file exists
|
|
assert:
|
|
that:
|
|
- result.stat.exists
|
|
|
|
- block:
|
|
- name: "EXPECTED FAILURE - test source file does not exist w/o `create: yes`"
|
|
lineinfile:
|
|
path: "/some/where/that/doesnotexist.txt"
|
|
state: present
|
|
line: "Doesn't matter"
|
|
- fail:
|
|
msg: "Should not get here"
|
|
rescue:
|
|
- name: Validate failure
|
|
assert:
|
|
that:
|
|
- "'Destination /some/where/that/doesnotexist.txt does not exist !' in ansible_failed_result.msg"
|
|
|
|
- block:
|
|
- name: EXPECTED FAILURE - test invalid `validate` value
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test.txt"
|
|
state: present
|
|
line: "Doesn't matter"
|
|
validate: '/some/path'
|
|
- fail:
|
|
msg: "Should not get here"
|
|
rescue:
|
|
- name: Validate failure
|
|
assert:
|
|
that:
|
|
- "'validate must contain %s: /some/path' in ansible_failed_result.msg"
|
|
|
|
- name: insert a line at the beginning of the file, and back it up
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test.txt"
|
|
state: present
|
|
line: "New line at the beginning"
|
|
insertbefore: "BOF"
|
|
backup: yes
|
|
register: result1
|
|
|
|
- name: insert a line at the beginning of the file again
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test.txt"
|
|
state: present
|
|
line: "New line at the beginning"
|
|
insertbefore: "BOF"
|
|
register: result2
|
|
|
|
- name: assert that the line was inserted at the head of the file
|
|
assert:
|
|
that:
|
|
- result1 is changed
|
|
- result2 is not changed
|
|
- result1.msg == 'line added'
|
|
- result1.backup != ''
|
|
|
|
- name: stat the backup file
|
|
stat:
|
|
path: "{{ result1.backup }}"
|
|
register: result
|
|
|
|
- name: assert the backup file matches the previous hash
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == '5feac65e442c91f557fc90069ce6efc4d346ab51'"
|
|
|
|
- name: stat the test after the insert at the head
|
|
stat:
|
|
path: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: assert test hash is what we expect for the file with the insert at the head
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == '7eade4042b23b800958fe807b5bfc29f8541ec09'"
|
|
|
|
- name: insert a line at the end of the file
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test.txt"
|
|
state: present
|
|
line: "New line at the end"
|
|
insertafter: "EOF"
|
|
register: result
|
|
|
|
- name: assert that the line was inserted at the end of the file
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- "result.msg == 'line added'"
|
|
|
|
- name: stat the test after the insert at the end
|
|
stat:
|
|
path: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: assert test checksum matches after the insert at the end
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == 'fb57af7dc10a1006061b000f1f04c38e4bef50a9'"
|
|
|
|
- name: insert a line after the first line
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test.txt"
|
|
state: present
|
|
line: "New line after line 1"
|
|
insertafter: "^This is line 1$"
|
|
register: result
|
|
|
|
- name: assert that the line was inserted after the first line
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- "result.msg == 'line added'"
|
|
|
|
- name: stat the test after insert after the first line
|
|
stat:
|
|
path: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: assert test checksum matches after the insert after the first line
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == '5348da605b1bc93dbadf3a16474cdf22ef975bec'"
|
|
|
|
- name: insert a line before the last line
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test.txt"
|
|
state: present
|
|
line: "New line before line 5"
|
|
insertbefore: "^This is line 5$"
|
|
register: result
|
|
|
|
- name: assert that the line was inserted before the last line
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- "result.msg == 'line added'"
|
|
|
|
- name: stat the test after the insert before the last line
|
|
stat:
|
|
path: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: assert test checksum matches after the insert before the last line
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == '2e9e460ff68929e4453eb765761fd99814f6e286'"
|
|
|
|
- name: Replace a line with backrefs
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test.txt"
|
|
state: present
|
|
line: "This is line 3"
|
|
backrefs: yes
|
|
regexp: "^(REF) .* \\1$"
|
|
register: backrefs_result1
|
|
|
|
- name: Replace a line with backrefs again
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test.txt"
|
|
state: present
|
|
line: "This is line 3"
|
|
backrefs: yes
|
|
regexp: "^(REF) .* \\1$"
|
|
register: backrefs_result2
|
|
- command: cat {{ output_dir }}/test.txt
|
|
|
|
- name: assert that the line with backrefs was changed
|
|
assert:
|
|
that:
|
|
- backrefs_result1 is changed
|
|
- backrefs_result2 is not changed
|
|
- "backrefs_result1.msg == 'line replaced'"
|
|
|
|
- name: stat the test after the backref line was replaced
|
|
stat:
|
|
path: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: assert test checksum matches after backref line was replaced
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == '72f60239a735ae06e769d823f5c2b4232c634d9c'"
|
|
|
|
- name: remove the middle line
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test.txt"
|
|
state: absent
|
|
regexp: "^This is line 3$"
|
|
register: result
|
|
|
|
- name: assert that the line was removed
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- "result.msg == '1 line(s) removed'"
|
|
|
|
- name: stat the test after the middle line was removed
|
|
stat:
|
|
path: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: assert test checksum matches after the middle line was removed
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == 'd4eeb07bdebab2d1cdb3ec4a3635afa2618ad4ea'"
|
|
|
|
- name: run a validation script that succeeds
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test.txt"
|
|
state: absent
|
|
regexp: "^This is line 5$"
|
|
validate: "true %s"
|
|
register: result
|
|
|
|
- name: assert that the file validated after removing a line
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- "result.msg == '1 line(s) removed'"
|
|
|
|
- name: stat the test after the validation succeeded
|
|
stat:
|
|
path: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: assert test checksum matches after the validation succeeded
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == 'ab56c210ea82839a54487464800fed4878cb2608'"
|
|
|
|
- name: run a validation script that fails
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test.txt"
|
|
state: absent
|
|
regexp: "^This is line 1$"
|
|
validate: "/bin/false %s"
|
|
register: result
|
|
ignore_errors: yes
|
|
|
|
- name: assert that the validate failed
|
|
assert:
|
|
that:
|
|
- "result.failed == true"
|
|
|
|
- name: stat the test after the validation failed
|
|
stat:
|
|
path: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: assert test checksum matches the previous after the validation failed
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == 'ab56c210ea82839a54487464800fed4878cb2608'"
|
|
|
|
- import_tasks: test_string01.yml
|
|
|
|
- name: use create=yes
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/new_test.txt"
|
|
create: yes
|
|
insertbefore: BOF
|
|
state: present
|
|
line: "This is a new file"
|
|
register: result
|
|
|
|
- name: assert that the new file was created
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- "result.msg == 'line added'"
|
|
|
|
- name: validate that the newly created file exists
|
|
stat:
|
|
path: "{{ output_dir }}/new_test.txt"
|
|
register: result
|
|
ignore_errors: yes
|
|
|
|
- name: assert the newly created test checksum matches
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == '038f10f9e31202451b093163e81e06fbac0c6f3a'"
|
|
|
|
- name: Create a file without a path
|
|
lineinfile:
|
|
dest: file.txt
|
|
create: yes
|
|
line: Test line
|
|
register: create_no_path_test
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: file.txt
|
|
register: create_no_path_file
|
|
|
|
- name: Ensure file was created
|
|
assert:
|
|
that:
|
|
- create_no_path_test is changed
|
|
- create_no_path_file.stat.exists
|
|
|
|
# Test EOF in cases where file has no newline at EOF
|
|
- name: testnoeof deploy the file for lineinfile
|
|
copy:
|
|
src: testnoeof.txt
|
|
dest: "{{ output_dir }}/testnoeof.txt"
|
|
register: result
|
|
|
|
- name: testnoeof insert a line at the end of the file
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/testnoeof.txt"
|
|
state: present
|
|
line: "New line at the end"
|
|
insertafter: "EOF"
|
|
register: result
|
|
|
|
- name: testempty assert that the line was inserted at the end of the file
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- "result.msg == 'line added'"
|
|
|
|
- name: insert a multiple lines at the end of the file
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test.txt"
|
|
state: present
|
|
line: "This is a line\nwith \\n character"
|
|
insertafter: "EOF"
|
|
register: result
|
|
|
|
- name: assert that the multiple lines was inserted
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- "result.msg == 'line added'"
|
|
|
|
- name: testnoeof stat the no newline EOF test after the insert at the end
|
|
stat:
|
|
path: "{{ output_dir }}/testnoeof.txt"
|
|
register: result
|
|
|
|
- name: testnoeof assert test checksum matches after the insert at the end
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == 'f9af7008e3cb67575ce653d094c79cabebf6e523'"
|
|
|
|
# Test EOF with empty file to make sure no unnecessary newline is added
|
|
- name: testempty deploy the testempty file for lineinfile
|
|
copy:
|
|
src: testempty.txt
|
|
dest: "{{ output_dir }}/testempty.txt"
|
|
register: result
|
|
|
|
- name: testempty insert a line at the end of the file
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/testempty.txt"
|
|
state: present
|
|
line: "New line at the end"
|
|
insertafter: "EOF"
|
|
register: result
|
|
|
|
- name: testempty assert that the line was inserted at the end of the file
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- "result.msg == 'line added'"
|
|
|
|
- name: testempty stat the test after the insert at the end
|
|
stat:
|
|
path: "{{ output_dir }}/testempty.txt"
|
|
register: result
|
|
|
|
- name: testempty assert test checksum matches after the insert at the end
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == 'f440dc65ea9cec3fd496c1479ddf937e1b949412'"
|
|
|
|
- stat:
|
|
path: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: assert test checksum matches after inserting multiple lines
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == 'fde683229429a4f05d670e6c10afc875e1d5c489'"
|
|
|
|
- name: replace a line with backrefs included in the line
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test.txt"
|
|
state: present
|
|
line: "New \\1 created with the backref"
|
|
backrefs: yes
|
|
regexp: "^This is (line 4)$"
|
|
register: result
|
|
|
|
- name: assert that the line with backrefs was changed
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- "result.msg == 'line replaced'"
|
|
|
|
- name: stat the test after the backref line was replaced
|
|
stat:
|
|
path: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: assert test checksum matches after backref line was replaced
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == '981ad35c4b30b03bc3a1beedce0d1e72c491898e'"
|
|
|
|
###################################################################
|
|
# issue 8535
|
|
|
|
- name: create a new file for testing quoting issues
|
|
file:
|
|
dest: "{{ output_dir }}/test_quoting.txt"
|
|
state: touch
|
|
register: result
|
|
|
|
- name: assert the new file was created
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
|
|
- name: use with_items to add code-like strings to the quoting txt file
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test_quoting.txt"
|
|
line: "{{ item }}"
|
|
insertbefore: BOF
|
|
with_items:
|
|
- "'foo'"
|
|
- "dotenv.load();"
|
|
- "var dotenv = require('dotenv');"
|
|
register: result
|
|
|
|
- name: assert the quote test file was modified correctly
|
|
assert:
|
|
that:
|
|
- result.results|length == 3
|
|
- result.results[0] is changed
|
|
- result.results[0].item == "'foo'"
|
|
- result.results[1] is changed
|
|
- result.results[1].item == "dotenv.load();"
|
|
- result.results[2] is changed
|
|
- result.results[2].item == "var dotenv = require('dotenv');"
|
|
|
|
- name: stat the quote test file
|
|
stat:
|
|
path: "{{ output_dir }}/test_quoting.txt"
|
|
register: result
|
|
|
|
- name: assert test checksum matches after backref line was replaced
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == '7dc3cb033c3971e73af0eaed6623d4e71e5743f1'"
|
|
|
|
- name: insert a line into the quoted file with a single quote
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test_quoting.txt"
|
|
line: "import g'"
|
|
register: result
|
|
|
|
- name: assert that the quoted file was changed
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
|
|
- name: stat the quote test file
|
|
stat:
|
|
path: "{{ output_dir }}/test_quoting.txt"
|
|
register: result
|
|
|
|
- name: assert test checksum matches after backref line was replaced
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == '73b271c2cc1cef5663713bc0f00444b4bf9f4543'"
|
|
|
|
- name: insert a line into the quoted file with many double quotation strings
|
|
lineinfile:
|
|
dest: "{{ output_dir }}/test_quoting.txt"
|
|
line: "\"quote\" and \"unquote\""
|
|
register: result
|
|
|
|
- name: assert that the quoted file was changed
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
|
|
- name: stat the quote test file
|
|
stat:
|
|
path: "{{ output_dir }}/test_quoting.txt"
|
|
register: result
|
|
|
|
- name: assert test checksum matches after backref line was replaced
|
|
assert:
|
|
that:
|
|
- "result.stat.checksum == 'b10ab2a3c3b6492680c8d0b1d6f35aa6b8f9e731'"
|
|
|
|
###################################################################
|
|
# Issue 28721
|
|
|
|
- name: Deploy the testmultiple file
|
|
copy:
|
|
src: testmultiple.txt
|
|
dest: "{{ output_dir }}/testmultiple.txt"
|
|
register: result
|
|
|
|
- name: Assert that the testmultiple file was deployed
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- result.checksum == '3e0090a34fb641f3c01e9011546ff586260ea0ea'
|
|
- result.state == 'file'
|
|
|
|
# Test insertafter
|
|
- name: Write the same line to a file inserted after different lines
|
|
lineinfile:
|
|
path: "{{ output_dir }}/testmultiple.txt"
|
|
insertafter: "{{ item.regex }}"
|
|
line: "{{ item.replace }}"
|
|
register: _multitest_1
|
|
with_items: "{{ test_regexp }}"
|
|
|
|
- name: Assert that the line is added once only
|
|
assert:
|
|
that:
|
|
- _multitest_1.results.0 is changed
|
|
- _multitest_1.results.1 is not changed
|
|
- _multitest_1.results.2 is not changed
|
|
- _multitest_1.results.3 is not changed
|
|
|
|
- name: Do the same thing again to check for changes
|
|
lineinfile:
|
|
path: "{{ output_dir }}/testmultiple.txt"
|
|
insertafter: "{{ item.regex }}"
|
|
line: "{{ item.replace }}"
|
|
register: _multitest_2
|
|
with_items: "{{ test_regexp }}"
|
|
|
|
- name: Assert that the line is not added anymore
|
|
assert:
|
|
that:
|
|
- _multitest_2.results.0 is not changed
|
|
- _multitest_2.results.1 is not changed
|
|
- _multitest_2.results.2 is not changed
|
|
- _multitest_2.results.3 is not changed
|
|
|
|
- name: Stat the insertafter file
|
|
stat:
|
|
path: "{{ output_dir }}/testmultiple.txt"
|
|
register: result
|
|
|
|
- name: Assert that the insertafter file matches expected checksum
|
|
assert:
|
|
that:
|
|
- result.stat.checksum == 'c6733b6c53ddd0e11e6ba39daa556ef8f4840761'
|
|
|
|
# Test insertbefore
|
|
|
|
- name: Deploy the testmultiple file
|
|
copy:
|
|
src: testmultiple.txt
|
|
dest: "{{ output_dir }}/testmultiple.txt"
|
|
register: result
|
|
|
|
- name: Assert that the testmultiple file was deployed
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- result.checksum == '3e0090a34fb641f3c01e9011546ff586260ea0ea'
|
|
- result.state == 'file'
|
|
|
|
- name: Write the same line to a file inserted before different lines
|
|
lineinfile:
|
|
path: "{{ output_dir }}/testmultiple.txt"
|
|
insertbefore: "{{ item.regex }}"
|
|
line: "{{ item.replace }}"
|
|
register: _multitest_3
|
|
with_items: "{{ test_regexp }}"
|
|
|
|
- name: Assert that the line is added once only
|
|
assert:
|
|
that:
|
|
- _multitest_3.results.0 is changed
|
|
- _multitest_3.results.1 is not changed
|
|
- _multitest_3.results.2 is not changed
|
|
- _multitest_3.results.3 is not changed
|
|
|
|
- name: Do the same thing again to check for changes
|
|
lineinfile:
|
|
path: "{{ output_dir }}/testmultiple.txt"
|
|
insertbefore: "{{ item.regex }}"
|
|
line: "{{ item.replace }}"
|
|
register: _multitest_4
|
|
with_items: "{{ test_regexp }}"
|
|
|
|
- name: Assert that the line is not added anymore
|
|
assert:
|
|
that:
|
|
- _multitest_4.results.0 is not changed
|
|
- _multitest_4.results.1 is not changed
|
|
- _multitest_4.results.2 is not changed
|
|
- _multitest_4.results.3 is not changed
|
|
|
|
- name: Stat the insertbefore file
|
|
stat:
|
|
path: "{{ output_dir }}/testmultiple.txt"
|
|
register: result
|
|
|
|
- name: Assert that the insertbefore file matches expected checksum
|
|
assert:
|
|
that:
|
|
- result.stat.checksum == '5d298651fbc377b45257da10308a9dc2fe1f8be5'
|
|
|
|
###################################################################
|
|
# Issue 36156
|
|
# Test insertbefore and insertafter with regexp
|
|
|
|
- name: Deploy the test.conf file
|
|
copy:
|
|
src: test.conf
|
|
dest: "{{ output_dir }}/test.conf"
|
|
register: result
|
|
|
|
- name: Assert that the test.conf file was deployed
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- result.checksum == '6037f13e419b132eb3fd20a89e60c6c87a6add38'
|
|
- result.state == 'file'
|
|
|
|
# Test instertafter
|
|
- name: Insert lines after with regexp
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test.conf"
|
|
regexp: "{{ item.regexp }}"
|
|
line: "{{ item.line }}"
|
|
insertafter: "{{ item.after }}"
|
|
with_items: "{{ test_befaf_regexp }}"
|
|
register: _multitest_5
|
|
|
|
- name: Do the same thing again and check for changes
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test.conf"
|
|
regexp: "{{ item.regexp }}"
|
|
line: "{{ item.line }}"
|
|
insertafter: "{{ item.after }}"
|
|
with_items: "{{ test_befaf_regexp }}"
|
|
register: _multitest_6
|
|
|
|
- name: Assert that the file was changed the first time but not the second time
|
|
assert:
|
|
that:
|
|
- item.0 is changed
|
|
- item.1 is not changed
|
|
with_together:
|
|
- "{{ _multitest_5.results }}"
|
|
- "{{ _multitest_6.results }}"
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/test.conf"
|
|
register: result
|
|
|
|
- name: Assert that the file contents match what is expected
|
|
assert:
|
|
that:
|
|
- result.stat.checksum == '06e2c456e5028dd7bcd0b117b5927a1139458c82'
|
|
|
|
- name: Do the same thing a third time without regexp and check for changes
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test.conf"
|
|
line: "{{ item.line }}"
|
|
insertafter: "{{ item.after }}"
|
|
with_items: "{{ test_befaf_regexp }}"
|
|
register: _multitest_7
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/test.conf"
|
|
register: result
|
|
|
|
- name: Assert that the file was changed when no regexp was provided
|
|
assert:
|
|
that:
|
|
- item is not changed
|
|
with_items: "{{ _multitest_7.results }}"
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/test.conf"
|
|
register: result
|
|
|
|
- name: Assert that the file contents match what is expected
|
|
assert:
|
|
that:
|
|
- result.stat.checksum == '06e2c456e5028dd7bcd0b117b5927a1139458c82'
|
|
|
|
# Test insertbefore
|
|
- name: Deploy the test.conf file
|
|
copy:
|
|
src: test.conf
|
|
dest: "{{ output_dir }}/test.conf"
|
|
register: result
|
|
|
|
- name: Assert that the test.conf file was deployed
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- result.checksum == '6037f13e419b132eb3fd20a89e60c6c87a6add38'
|
|
- result.state == 'file'
|
|
|
|
- name: Insert lines before with regexp
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test.conf"
|
|
regexp: "{{ item.regexp }}"
|
|
line: "{{ item.line }}"
|
|
insertbefore: "{{ item.before }}"
|
|
with_items: "{{ test_befaf_regexp }}"
|
|
register: _multitest_8
|
|
|
|
- name: Do the same thing again and check for changes
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test.conf"
|
|
regexp: "{{ item.regexp }}"
|
|
line: "{{ item.line }}"
|
|
insertbefore: "{{ item.before }}"
|
|
with_items: "{{ test_befaf_regexp }}"
|
|
register: _multitest_9
|
|
|
|
- name: Assert that the file was changed the first time but not the second time
|
|
assert:
|
|
that:
|
|
- item.0 is changed
|
|
- item.1 is not changed
|
|
with_together:
|
|
- "{{ _multitest_8.results }}"
|
|
- "{{ _multitest_9.results }}"
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/test.conf"
|
|
register: result
|
|
|
|
- name: Assert that the file contents match what is expected
|
|
assert:
|
|
that:
|
|
- result.stat.checksum == 'c3be9438a07c44d4c256cebfcdbca15a15b1db91'
|
|
|
|
- name: Do the same thing a third time without regexp and check for changes
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test.conf"
|
|
line: "{{ item.line }}"
|
|
insertbefore: "{{ item.before }}"
|
|
with_items: "{{ test_befaf_regexp }}"
|
|
register: _multitest_10
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/test.conf"
|
|
register: result
|
|
|
|
- name: Assert that the file was changed when no regexp was provided
|
|
assert:
|
|
that:
|
|
- item is not changed
|
|
with_items: "{{ _multitest_10.results }}"
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/test.conf"
|
|
register: result
|
|
|
|
- name: Assert that the file contents match what is expected
|
|
assert:
|
|
that:
|
|
- result.stat.checksum == 'c3be9438a07c44d4c256cebfcdbca15a15b1db91'
|
|
|
|
- name: Copy empty file to test with insertbefore
|
|
copy:
|
|
src: testempty.txt
|
|
dest: "{{ output_dir }}/testempty.txt"
|
|
|
|
- name: Add a line to empty file with insertbefore
|
|
lineinfile:
|
|
path: "{{ output_dir }}/testempty.txt"
|
|
line: top
|
|
insertbefore: '^not in the file$'
|
|
register: oneline_insbefore_test1
|
|
|
|
- name: Add a line to file with only one line using insertbefore
|
|
lineinfile:
|
|
path: "{{ output_dir }}/testempty.txt"
|
|
line: top
|
|
insertbefore: '^not in the file$'
|
|
register: oneline_insbefore_test2
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/testempty.txt"
|
|
register: oneline_insbefore_file
|
|
|
|
- name: Assert that insertebefore worked properly with a one line file
|
|
assert:
|
|
that:
|
|
- oneline_insbefore_test1 is changed
|
|
- oneline_insbefore_test2 is not changed
|
|
- oneline_insbefore_file.stat.checksum == '4dca56d05a21f0d018cd311f43e134e4501cf6d9'
|
|
|
|
- import_tasks: test_string02.yml
|
|
|
|
# Issue 29443
|
|
# When using an empty regexp, replace the last line (since it matches every line)
|
|
# but also provide a warning.
|
|
|
|
- name: Deploy the test file for lineinfile
|
|
copy:
|
|
src: test.txt
|
|
dest: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: Assert that the test file was deployed
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- result.checksum == '5feac65e442c91f557fc90069ce6efc4d346ab51'
|
|
- result.state == 'file'
|
|
|
|
- name: Insert a line in the file using an empty string as a regular expression
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test.txt"
|
|
regexp: ''
|
|
line: This is line 6
|
|
register: insert_empty_regexp
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/test.txt"
|
|
register: result
|
|
|
|
- name: Assert that the file contents match what is expected and a warning was displayed
|
|
assert:
|
|
that:
|
|
- insert_empty_regexp is changed
|
|
- warning_message in insert_empty_regexp.warnings
|
|
- result.stat.checksum == '23555a98ceaa88756b4c7c7bba49d9f86eed868f'
|
|
vars:
|
|
warning_message: >-
|
|
The regular expression is an empty string, which will match every line in the file.
|
|
This may have unintended consequences, such as replacing the last line in the file rather than appending.
|
|
If this is desired, use '^' to match every line in the file and avoid this warning.
|
|
|
|
###################################################################
|
|
# When using an empty search string, replace the last line (since it matches every line)
|
|
# but also provide a warning.
|
|
|
|
- name: Deploy the test file for lineinfile
|
|
copy:
|
|
src: teststring.txt
|
|
dest: "{{ output_dir }}/teststring.txt"
|
|
register: result
|
|
|
|
- name: Assert that the test file was deployed
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- result.checksum == '481c2b73fe062390afdd294063a4f8285d69ac85'
|
|
- result.state == 'file'
|
|
|
|
- name: Insert a line in the file using an empty string as a search string
|
|
lineinfile:
|
|
path: "{{ output_dir }}/teststring.txt"
|
|
search_string: ''
|
|
line: This is line 6
|
|
register: insert_empty_literal
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/teststring.txt"
|
|
register: result
|
|
|
|
- name: Assert that the file contents match what is expected and a warning was displayed
|
|
assert:
|
|
that:
|
|
- insert_empty_literal is changed
|
|
- warning_message in insert_empty_literal.warnings
|
|
- result.stat.checksum == 'eaa79f878557d4bd8d96787a850526a0facab342'
|
|
vars:
|
|
warning_message: >-
|
|
The search string is an empty string, which will match every line in the file.
|
|
This may have unintended consequences, such as replacing the last line in the file rather than appending.
|
|
|
|
- name: meta
|
|
meta: end_play
|
|
|
|
###################################################################
|
|
## Issue #58923
|
|
## Using firstmatch with insertafter and ensure multiple lines are not inserted
|
|
|
|
- name: Deploy the firstmatch test file
|
|
copy:
|
|
src: firstmatch.txt
|
|
dest: "{{ output_dir }}/firstmatch.txt"
|
|
register: result
|
|
|
|
- name: Assert that the test file was deployed
|
|
assert:
|
|
that:
|
|
- result is changed
|
|
- result.checksum == '1d644e5e2e51c67f1bd12d7bbe2686017f39923d'
|
|
- result.state == 'file'
|
|
|
|
- name: Insert a line before an existing line using firstmatch
|
|
lineinfile:
|
|
path: "{{ output_dir }}/firstmatch.txt"
|
|
line: INSERT
|
|
insertafter: line1
|
|
firstmatch: yes
|
|
register: insertafter1
|
|
|
|
- name: Insert a line before an existing line using firstmatch again
|
|
lineinfile:
|
|
path: "{{ output_dir }}/firstmatch.txt"
|
|
line: INSERT
|
|
insertafter: line1
|
|
firstmatch: yes
|
|
register: insertafter2
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/firstmatch.txt"
|
|
register: result
|
|
|
|
- name: Assert that the file was modified appropriately
|
|
assert:
|
|
that:
|
|
- insertafter1 is changed
|
|
- insertafter2 is not changed
|
|
- result.stat.checksum == '114aae024073a3ee8ec8db0ada03c5483326dd86'
|
|
|
|
########################################################################################
|
|
# Tests of fixing the same issue as above (#58923) by @Andersson007 <aaklychkov@mail.ru>
|
|
# and @samdoran <sdoran@redhat.com>:
|
|
|
|
# Test insertafter with regexp
|
|
- name: Deploy the test file
|
|
copy:
|
|
src: test_58923.txt
|
|
dest: "{{ output_dir }}/test_58923.txt"
|
|
register: initial_file
|
|
|
|
- name: Assert that the test file was deployed
|
|
assert:
|
|
that:
|
|
- initial_file is changed
|
|
- initial_file.checksum == 'b6379ba43261c451a62102acb2c7f438a177c66e'
|
|
- initial_file.state == 'file'
|
|
|
|
# Regarding the documentation:
|
|
# If regular expressions are passed to both regexp and
|
|
# insertafter, insertafter is only honored if no match for regexp is found.
|
|
# Therefore,
|
|
# when regular expressions are passed to both regexp and insertafter, then:
|
|
# 1. regexp was found -> ignore insertafter, replace the founded line
|
|
# 2. regexp was not found -> insert the line after 'insertafter' line
|
|
|
|
# Regexp is not present in the file, so the line must be inserted after ^#!/bin/sh
|
|
- name: Add the line using firstmatch, regexp, and insertafter
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
insertafter: '^#!/bin/sh'
|
|
regexp: ^export FISHEYE_OPTS
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertafter_test1
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
register: insertafter_test1_file
|
|
|
|
- name: Add the line using firstmatch, regexp, and insertafter again
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
insertafter: '^#!/bin/sh'
|
|
regexp: ^export FISHEYE_OPTS
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertafter_test2
|
|
|
|
# Check of the prev step.
|
|
# We tried to add the same line with the same playbook,
|
|
# so nothing has been added:
|
|
- name: Stat the file again
|
|
stat:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
register: insertafter_test2_file
|
|
|
|
- name: Assert insertafter tests gave the expected results
|
|
assert:
|
|
that:
|
|
- insertafter_test1 is changed
|
|
- insertafter_test1_file.stat.checksum == '9232aed6fe88714964d9e29d13e42cd782070b08'
|
|
- insertafter_test2 is not changed
|
|
- insertafter_test2_file.stat.checksum == '9232aed6fe88714964d9e29d13e42cd782070b08'
|
|
|
|
# Test insertafter without regexp
|
|
- name: Deploy the test file
|
|
copy:
|
|
src: test_58923.txt
|
|
dest: "{{ output_dir }}/test_58923.txt"
|
|
register: initial_file
|
|
|
|
- name: Assert that the test file was deployed
|
|
assert:
|
|
that:
|
|
- initial_file is changed
|
|
- initial_file.checksum == 'b6379ba43261c451a62102acb2c7f438a177c66e'
|
|
- initial_file.state == 'file'
|
|
|
|
- name: Insert the line using firstmatch and insertafter without regexp
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
insertafter: '^#!/bin/sh'
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertafter_test3
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
register: insertafter_test3_file
|
|
|
|
- name: Insert the line using firstmatch and insertafter without regexp again
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
insertafter: '^#!/bin/sh'
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertafter_test4
|
|
|
|
- name: Stat the file again
|
|
stat:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
register: insertafter_test4_file
|
|
|
|
- name: Assert insertafter without regexp tests gave the expected results
|
|
assert:
|
|
that:
|
|
- insertafter_test3 is changed
|
|
- insertafter_test3_file.stat.checksum == '9232aed6fe88714964d9e29d13e42cd782070b08'
|
|
- insertafter_test4 is not changed
|
|
- insertafter_test4_file.stat.checksum == '9232aed6fe88714964d9e29d13e42cd782070b08'
|
|
|
|
|
|
# Test insertbefore with regexp
|
|
- name: Deploy the test file
|
|
copy:
|
|
src: test_58923.txt
|
|
dest: "{{ output_dir }}/test_58923.txt"
|
|
register: initial_file
|
|
|
|
- name: Assert that the test file was deployed
|
|
assert:
|
|
that:
|
|
- initial_file is changed
|
|
- initial_file.checksum == 'b6379ba43261c451a62102acb2c7f438a177c66e'
|
|
- initial_file.state == 'file'
|
|
|
|
- name: Add the line using regexp, firstmatch, and insertbefore
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
insertbefore: '^#!/bin/sh'
|
|
regexp: ^export FISHEYE_OPTS
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertbefore_test1
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
register: insertbefore_test1_file
|
|
|
|
- name: Add the line using regexp, firstmatch, and insertbefore again
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
insertbefore: '^#!/bin/sh'
|
|
regexp: ^export FISHEYE_OPTS
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertbefore_test2
|
|
|
|
- name: Stat the file again
|
|
stat:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
register: insertbefore_test2_file
|
|
|
|
- name: Assert insertbefore with regexp tests gave the expected results
|
|
assert:
|
|
that:
|
|
- insertbefore_test1 is changed
|
|
- insertbefore_test1_file.stat.checksum == '3c6630b9d44f561ea9ad999be56a7504cadc12f7'
|
|
- insertbefore_test2 is not changed
|
|
- insertbefore_test2_file.stat.checksum == '3c6630b9d44f561ea9ad999be56a7504cadc12f7'
|
|
|
|
|
|
# Test insertbefore without regexp
|
|
- name: Deploy the test file
|
|
copy:
|
|
src: test_58923.txt
|
|
dest: "{{ output_dir }}/test_58923.txt"
|
|
register: initial_file
|
|
|
|
- name: Assert that the test file was deployed
|
|
assert:
|
|
that:
|
|
- initial_file is changed
|
|
- initial_file.checksum == 'b6379ba43261c451a62102acb2c7f438a177c66e'
|
|
- initial_file.state == 'file'
|
|
|
|
- name: Add the line using insertbefore and firstmatch
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
insertbefore: '^#!/bin/sh'
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertbefore_test3
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
register: insertbefore_test3_file
|
|
|
|
- name: Add the line using insertbefore and firstmatch again
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
insertbefore: '^#!/bin/sh'
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertbefore_test4
|
|
|
|
- name: Stat the file again
|
|
stat:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
register: insertbefore_test4_file
|
|
|
|
# Test when the line is presented in the file but
|
|
# not in the before/after spot and it does match the regexp:
|
|
- name: >
|
|
Add the line using insertbefore and firstmatch when the regexp line
|
|
is presented but not close to insertbefore spot
|
|
lineinfile:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
insertbefore: ' Darwin\*\) if \[ -z \"\$JAVA_HOME\" \] ; then'
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertbefore_test5
|
|
|
|
- name: Stat the file again
|
|
stat:
|
|
path: "{{ output_dir }}/test_58923.txt"
|
|
register: insertbefore_test5_file
|
|
|
|
- name: Assert insertbefore with regexp tests gave the expected results
|
|
assert:
|
|
that:
|
|
- insertbefore_test3 is changed
|
|
- insertbefore_test3_file.stat.checksum == '3c6630b9d44f561ea9ad999be56a7504cadc12f7'
|
|
- insertbefore_test4 is not changed
|
|
- insertbefore_test4_file.stat.checksum == '3c6630b9d44f561ea9ad999be56a7504cadc12f7'
|
|
- insertbefore_test5 is not changed
|
|
- insertbefore_test5_file.stat.checksum == '3c6630b9d44f561ea9ad999be56a7504cadc12f7'
|
|
|
|
########################################################################################
|
|
# Same tests for literal
|
|
|
|
# Test insertafter with literal
|
|
- name: Deploy the test file
|
|
copy:
|
|
src: teststring_58923.txt
|
|
dest: "{{ output_dir }}/teststring_58923.txt"
|
|
register: initial_file
|
|
|
|
- name: Assert that the test file was deployed
|
|
assert:
|
|
that:
|
|
- initial_file is changed
|
|
- initial_file.checksum == 'b6379ba43261c451a62102acb2c7f438a177c66e'
|
|
- initial_file.state == 'file'
|
|
|
|
# Regarding the documentation:
|
|
# If the search string is passed to both search_string and
|
|
# insertafter, insertafter is only honored if no match for search_string is found.
|
|
# Therefore,
|
|
# when search_string expressions are passed to both search_string and insertafter, then:
|
|
# 1. search_string was found -> ignore insertafter, replace the founded line
|
|
# 2. search_string was not found -> insert the line after 'insertafter' line
|
|
|
|
# literal is not present in the file, so the line must be inserted after ^#!/bin/sh
|
|
- name: Add the line using firstmatch, regexp, and insertafter
|
|
lineinfile:
|
|
path: "{{ output_dir }}/teststring_58923.txt"
|
|
insertafter: '^#!/bin/sh'
|
|
search_string: export FISHEYE_OPTS
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertafter_test1
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/teststring_58923.txt"
|
|
register: insertafter_test1_file
|
|
|
|
- name: Add the line using firstmatch, literal, and insertafter again
|
|
lineinfile:
|
|
path: "{{ output_dir }}/teststring_58923.txt"
|
|
insertafter: '^#!/bin/sh'
|
|
search_string: export FISHEYE_OPTS
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertafter_test2
|
|
|
|
# Check of the prev step.
|
|
# We tried to add the same line with the same playbook,
|
|
# so nothing has been added:
|
|
- name: Stat the file again
|
|
stat:
|
|
path: "{{ output_dir }}/teststring_58923.txt"
|
|
register: insertafter_test2_file
|
|
|
|
- name: Assert insertafter tests gave the expected results
|
|
assert:
|
|
that:
|
|
- insertafter_test1 is changed
|
|
- insertafter_test1_file.stat.checksum == '9232aed6fe88714964d9e29d13e42cd782070b08'
|
|
- insertafter_test2 is not changed
|
|
- insertafter_test2_file.stat.checksum == '9232aed6fe88714964d9e29d13e42cd782070b08'
|
|
|
|
# Test insertbefore with literal
|
|
- name: Deploy the test file
|
|
copy:
|
|
src: teststring_58923.txt
|
|
dest: "{{ output_dir }}/teststring_58923.txt"
|
|
register: initial_file
|
|
|
|
- name: Assert that the test file was deployed
|
|
assert:
|
|
that:
|
|
- initial_file is changed
|
|
- initial_file.checksum == 'b6379ba43261c451a62102acb2c7f438a177c66e'
|
|
- initial_file.state == 'file'
|
|
|
|
- name: Add the line using literal, firstmatch, and insertbefore
|
|
lineinfile:
|
|
path: "{{ output_dir }}/teststring_58923.txt"
|
|
insertbefore: '^#!/bin/sh'
|
|
search_string: export FISHEYE_OPTS
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertbefore_test1
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/teststring_58923.txt"
|
|
register: insertbefore_test1_file
|
|
|
|
- name: Add the line using literal, firstmatch, and insertbefore again
|
|
lineinfile:
|
|
path: "{{ output_dir }}/teststring_58923.txt"
|
|
insertbefore: '^#!/bin/sh'
|
|
search_string: export FISHEYE_OPTS
|
|
firstmatch: true
|
|
line: export FISHEYE_OPTS="-Xmx4096m -Xms2048m"
|
|
register: insertbefore_test2
|
|
|
|
- name: Stat the file again
|
|
stat:
|
|
path: "{{ output_dir }}/teststring_58923.txt"
|
|
register: insertbefore_test2_file
|
|
|
|
- name: Assert insertbefore with literal tests gave the expected results
|
|
assert:
|
|
that:
|
|
- insertbefore_test1 is changed
|
|
- insertbefore_test1_file.stat.checksum == '3c6630b9d44f561ea9ad999be56a7504cadc12f7'
|
|
- insertbefore_test2 is not changed
|
|
- insertbefore_test2_file.stat.checksum == '3c6630b9d44f561ea9ad999be56a7504cadc12f7'
|
|
|
|
# Test inserting a line at the end of the file using regexp with insertafter
|
|
# https://github.com/ansible/ansible/issues/63684
|
|
- name: Create a file by inserting a line
|
|
lineinfile:
|
|
path: "{{ output_dir }}/testend.txt"
|
|
create: yes
|
|
line: testline
|
|
register: testend1
|
|
|
|
- name: Insert a line at the end of the file
|
|
lineinfile:
|
|
path: "{{ output_dir }}/testend.txt"
|
|
insertafter: testline
|
|
regexp: line at the end
|
|
line: line at the end
|
|
register: testend2
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/testend.txt"
|
|
register: testend_file
|
|
|
|
- name: Assert inserting at the end gave the expected results.
|
|
assert:
|
|
that:
|
|
- testend1 is changed
|
|
- testend2 is changed
|
|
- testend_file.stat.checksum == 'ef36116966836ce04f6b249fd1837706acae4e19'
|
|
|
|
# Test inserting a line at the end of the file using search_string with insertafter
|
|
|
|
- name: Create a file by inserting a line
|
|
lineinfile:
|
|
path: "{{ output_dir }}/testendliteral.txt"
|
|
create: yes
|
|
line: testline
|
|
register: testend1
|
|
|
|
- name: Insert a line at the end of the file
|
|
lineinfile:
|
|
path: "{{ output_dir }}/testendliteral.txt"
|
|
insertafter: testline
|
|
search_string: line at the end
|
|
line: line at the end
|
|
register: testend2
|
|
|
|
- name: Stat the file
|
|
stat:
|
|
path: "{{ output_dir }}/testendliteral.txt"
|
|
register: testend_file
|
|
|
|
- name: Assert inserting at the end gave the expected results.
|
|
assert:
|
|
that:
|
|
- testend1 is changed
|
|
- testend2 is changed
|
|
- testend_file.stat.checksum == 'ef36116966836ce04f6b249fd1837706acae4e19'
|