Move integration test suite from molecule to ansible-test (#392)

Move integration test suite from molecule to ansible-test

SUMMARY

molecule has been replaced with ansible-test
some test cases have been updated

k8s_apply : remove duplicated tasks increasing the running time of the test
helm: use different namespaces for different test cases in order to wait for the namespace deletion before moving to the next test.
all: remove wait: yes at the end of each test when deleting namespace, the role used to create namespace will ensure that it is deleted before if existing.


ISSUE TYPE


Feature Pull Request

COMPONENT NAME

integration testing

Reviewed-by: Mike Graves <mgraves@redhat.com>
Reviewed-by: Gonéri Le Bouder <goneri@lebouder.net>
Reviewed-by: None <None>

tests/integration/targets/k8s_copy/tasks/main.yml

@@ -0,0 +1,34 @@
+---
+- set_fact:
+    copy_namespace: "{{ test_namespace }}"
+
+- block:
+    # Ensure namespace and create pod to perform tests on
+    - name: Ensure namespace exists
+      k8s:
+        definition:
+          apiVersion: v1
+          kind: Namespace
+          metadata:
+            name: "{{ copy_namespace }}"
+
+    - name: Create Pods
+      k8s:
+        namespace: '{{ copy_namespace }}'
+        wait: yes
+        template: pods_definition.j2
+
+    - include_tasks: test_copy_errors.yml
+    - include_tasks: test_copy_file.yml
+    - include_tasks: test_multi_container_pod.yml
+    - include_tasks: test_copy_directory.yml
+    - include_tasks: test_copy_large_file.yml
+
+  always:
+
+    - name: Remove namespace
+      k8s:
+        kind: Namespace
+        name: "{{ copy_namespace }}"
+        state: absent
+      ignore_errors: true

tests/integration/targets/k8s_copy/tasks/test_copy_directory.yml

@@ -0,0 +1,81 @@
+---
+- block:
+  - name: copy directory into remote Pod (create new directory)
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /dest_data
+      local_path: files/data
+      state: to_pod
+
+  - name: compare directories
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /dest_data
+      local_path: '{{ role_path }}/files/data'
+
+  - name: copy directory into remote Pod (existing directory)
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp
+      local_path: files/data
+      state: to_pod
+
+  - name: compare directories
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/data
+      local_path: '{{ role_path }}/files/data'
+
+  - name: copy directory from Pod into local filesystem (new directory to create)
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/data
+      local_path: /tmp/test
+      state: from_pod
+
+  - name: compare directories
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/data
+      local_path: /tmp/test
+
+  - name: copy directory from Pod into local filesystem (existing directory)
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/data
+      local_path: /tmp
+      state: from_pod
+
+  - name: compare directories
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/data
+      local_path: /tmp/data
+
+  always:
+  - name: Remove directories created into remote Pod
+    k8s_exec:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      command: 'rm -rf {{ item }}'
+    ignore_errors: true
+    with_items:
+    - /dest_data
+    - /tmp/data
+
+  - name: Remove local directories
+    file:
+      path: '{{ item }}'
+      state: absent
+    ignore_errors: true
+    with_items:
+    - /tmp/data
+    - /tmp/test

tests/integration/targets/k8s_copy/tasks/test_copy_errors.yml

@@ -0,0 +1,69 @@
+---
+# copy non-existent local file should fail
+- name: copy non-existent file into remote Pod
+  k8s_cp:
+    namespace: '{{ copy_namespace }}'
+    pod: '{{ pod_with_one_container.name }}'
+    remote_path: /tmp
+    local_path: this_file_does_not_exist
+    state: to_pod
+  ignore_errors: true
+  register: copy_non_existent
+
+- name: check that error message is as expected
+  assert:
+    that:
+      - copy_non_existent is failed
+      - copy_non_existent.msg == "this_file_does_not_exist does not exist in local filesystem"
+
+# copy non-existent pod file should fail
+- name: copy of non-existent file from remote pod should fail
+  k8s_cp:
+    namespace: '{{ copy_namespace }}'
+    pod: '{{ pod_with_one_container.name }}'
+    remote_path: /this_file_does_not_exist
+    local_path: /tmp
+    state: from_pod
+  ignore_errors: true
+  register: copy_non_existent
+
+- name: check that error message is as expected
+  assert:
+    that:
+      - copy_non_existent is failed
+      - copy_non_existent.msg == "/this_file_does_not_exist does not exist in remote pod filesystem"
+
+# copy file into multiple container pod without specifying the container should fail
+- name: copy file into multiple container pod
+  k8s_cp:
+    namespace: '{{ copy_namespace }}'
+    pod: '{{ pod_with_two_container.name }}'
+    remote_path: /tmp
+    local_path: files/simple_file.txt
+    state: to_pod
+  ignore_errors: true
+  register: copy_multi_container
+
+- name: check that error message is as expected
+  assert:
+    that:
+      - copy_multi_container is failed
+      - copy_multi_container.msg == "Pod contains more than 1 container, option 'container' should be set"
+
+# copy using non-existent container from pod should failed
+- name: copy file into multiple container pod
+  k8s_cp:
+    namespace: '{{ copy_namespace }}'
+    pod: '{{ pod_with_two_container.name }}'
+    remote_path: /tmp
+    local_path: files/simple_file.txt
+    state: to_pod
+    container: this_is_a_fake_container
+  ignore_errors: true
+  register: copy_fake_container
+
+- name: check that error message is as expected
+  assert:
+    that:
+      - copy_fake_container is failed
+      - copy_fake_container.msg == "Pod has no container this_is_a_fake_container"

tests/integration/targets/k8s_copy/tasks/test_copy_file.yml

@@ -0,0 +1,199 @@
+---
+- block:
+  # Text file
+  - name: copy text file into remote pod
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp
+      local_path: files/simple_file.txt
+      state: to_pod
+
+  - name: Compare files
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/simple_file.txt
+      content: "{{ lookup('file', 'simple_file.txt')}}"
+
+  - name: Copy simple text file from Pod
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/simple_file.txt
+      local_path: /tmp/copy_from_pod.txt
+      state: from_pod
+
+  - name: Compare files
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/simple_file.txt
+      local_path: /tmp/copy_from_pod.txt
+
+  # Binary file
+
+  - name: Create temp binary file
+    tempfile:
+      state: file
+    register: binfile
+
+  - name: Generate random binary content
+    command: dd if=/dev/urandom of={{ binfile.path }} bs=1M count=1
+
+  - name: Copy executable into Pod
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/hello.exe
+      local_path: "{{ binfile.path }}"
+      state: to_pod
+
+  - name: Get remote hash
+    kubernetes.core.k8s_exec:
+      namespace: "{{ copy_namespace }}"
+      pod: "{{ pod_with_one_container.name }}"
+      command: sha256sum -b /tmp/hello.exe
+    register: remote_hash
+
+  - name: Get local hash
+    command: sha256sum -b {{ binfile.path }}
+    register: local_hash
+
+  - assert:
+      that:
+      - remote_hash.stdout.split()[0] == local_hash.stdout.split()[0]
+
+  - name: Generate tempfile
+    tempfile:
+      state: file
+    register: binfile
+
+  - name: Copy executable from Pod
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/hello.exe
+      local_path: "{{ binfile.path }}"
+      state: from_pod
+
+  - name: Get remote hash
+    kubernetes.core.k8s_exec:
+      namespace: "{{ copy_namespace }}"
+      pod: "{{ pod_with_one_container.name }}"
+      command: sha256sum -b /tmp/hello.exe
+    register: remote_hash
+
+  - name: Get local hash
+    command: sha256sum -b {{ binfile.path }}
+    register: local_hash
+
+  - assert:
+      that:
+      - remote_hash.stdout.split()[0] == local_hash.stdout.split()[0]
+
+  # zip files
+  - name: copy zip file into remote pod
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp
+      local_path: files/simple_zip_file.txt.gz
+      state: to_pod
+
+  - name: compare zip files
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/simple_zip_file.txt.gz
+      local_path: '{{ role_path }}/files/simple_zip_file.txt.gz'
+
+  - name: copy zip file from pod into local filesystem
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/simple_zip_file.txt.gz
+      local_path: /tmp/copied_from_pod.txt.gz
+      state: from_pod
+
+  - name: compare zip files
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/simple_zip_file.txt.gz
+      local_path: /tmp/copied_from_pod.txt.gz
+
+  # tar files
+  - name: copy archive into remote pod
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp
+      local_path: files/archive.tar
+      state: to_pod
+
+  - name: compare archive
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/archive.tar
+      local_path: '{{ role_path }}/files/archive.tar'
+
+  - name: copy archive from remote pod into local filesystem
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/archive.tar
+      local_path: /tmp/local_archive.tar
+      state: from_pod
+
+  - name: compare archive
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /tmp/archive.tar
+      local_path: /tmp/local_archive.tar
+
+  # Copy into Pod using content option
+  - name: set content to be copied into Pod
+    set_fact:
+      pod_content: "{{ lookup('password', '/dev/null chars=ascii_lowercase,digits,punctuation length=128') }}"
+
+  - name: copy archive into remote pod
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /this_content.txt
+      content: '{{ pod_content }}'
+      state: to_pod
+
+  - name: Assert that content is as expected into Pod
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /this_content.txt
+      content: '{{ pod_content }}'
+
+  always:
+  - name: Delete file created on Pod
+    k8s_exec:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      command: 'rm {{ item }}'
+    ignore_errors: true
+    with_items:
+    - /tmp/simple_file.txt
+    - /tmp/hello.exe
+    - /tmp/simple_zip_file.txt.gz
+    - /tmp/archive.tar
+    - /this_content.txt
+
+  - name: Delete file created locally
+    file:
+      path: '{{ item }}'
+      state: absent
+    with_items:
+    - /tmp/copy_from_pod.txt
+    - /tmp/hello
+    - /tmp/copied_from_pod.txt.gz
+    - /tmp/local_archive.tar

tests/integration/targets/k8s_copy/tasks/test_copy_large_file.yml

@@ -0,0 +1,101 @@
+---
+- name: test copy of large binary and text files
+  block:
+  - set_fact:
+      test_directory: "/tmp/test_k8scp_large_files"
+    no_log: true
+
+  - name: create temporary directory for local files
+    ansible.builtin.file:
+      path: "{{ test_directory }}"
+      state: directory
+
+  - name: create large text file
+    k8s_create_file:
+      path: "{{ test_directory }}/large_text_file.txt"
+      size: 150
+
+  - name: create large binary file
+    k8s_create_file:
+      path: "{{ test_directory }}/large_bin_file.bin"
+      size: 200
+      binary: true
+
+  # Copy large text file from/to local filesystem to Pod
+  - name: copy large file into remote Pod
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /large_text_file.txt
+      local_path: "{{ test_directory }}/large_text_file.txt"
+      state: to_pod
+
+  - name: Compare files
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /large_text_file.txt
+      local_path: "{{ test_directory }}/large_text_file.txt"
+
+  - name: copy large file from Pod into local filesystem
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /large_text_file.txt
+      local_path: "{{ test_directory }}/large_text_file_from_pod.txt"
+      state: from_pod
+
+  - name: Compare files
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /large_text_file.txt
+      local_path: "{{ test_directory }}/large_text_file_from_pod.txt"
+
+  # Copy large binary file from/to local filesystem to Pod
+  - name: copy large file into remote Pod
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /large_bin_file.bin
+      local_path: "{{ test_directory }}/large_bin_file.bin"
+      state: to_pod
+
+  - name: Compare executable, local vs remote
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /large_bin_file.bin
+      local_path: "{{ test_directory }}/large_bin_file.bin"
+
+  - name: copy executable from pod into local filesystem
+    k8s_cp:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /large_bin_file.bin
+      local_path: "{{ test_directory }}/large_bin_file_from_pod.bin"
+      state: from_pod
+
+  - name: Compare executable, local vs remote
+    kubectl_file_compare:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      remote_path: /large_bin_file.bin
+      local_path: "{{ test_directory }}/large_bin_file_from_pod.bin"
+
+  always:
+  - name: Delete temporary directory created for the test
+    ansible.builtin.file:
+      path: "{{ test_directory }}"
+      state: absent
+    ignore_errors: true
+
+  - name: Delete file created on Pod
+    k8s_exec:
+      namespace: '{{ copy_namespace }}'
+      pod: '{{ pod_with_one_container.name }}'
+      command: 'rm {{ item }}'
+    ignore_errors: true
+    with_items:
+    - /large_text_file.txt
+    - /large_bin_file.bin

tests/integration/targets/k8s_copy/tasks/test_multi_container_pod.yml

@@ -0,0 +1,67 @@
+---
+- set_fact:
+    random_content: "{{ lookup('password', '/dev/null chars=ascii_lowercase,digits,punctuation length=128') }}"
+
+- name: Copy content into first pod's container
+  k8s_cp:
+    namespace: '{{ copy_namespace }}'
+    pod: '{{ pod_with_two_container.name }}'
+    remote_path: /file_from_localhost.txt
+    content: '{{ random_content }}'
+    container: '{{ pod_with_two_container.container[0] }}'
+    state: to_pod
+
+- name: Assert that content has been copied into first container
+  kubectl_file_compare:
+    namespace: '{{ copy_namespace }}'
+    pod: '{{ pod_with_two_container.name }}'
+    remote_path: /file_from_localhost.txt
+    container: '{{ pod_with_two_container.container[0] }}'
+    content: '{{ random_content }}'
+
+- name: Assert that content has not been copied into second container
+  kubectl_file_compare:
+    namespace: '{{ copy_namespace }}'
+    pod: '{{ pod_with_two_container.name }}'
+    remote_path: /file_from_localhost.txt
+    container: '{{ pod_with_two_container.container[1] }}'
+    content: '{{ random_content }}'
+  register: diff
+  ignore_errors: true
+
+- name: check that diff failed
+  assert:
+    that:
+      - diff is failed
+
+- name: Copy content into second's pod container
+  k8s_cp:
+    namespace: '{{ copy_namespace }}'
+    pod: '{{ pod_with_two_container.name }}'
+    remote_path: /file_from_localhost_01.txt
+    content: '{{ random_content }}-secondpod'
+    container: '{{ pod_with_two_container.container[1] }}'
+    state: to_pod
+
+- name: Assert that content has not been copied into first container
+  kubectl_file_compare:
+    namespace: '{{ copy_namespace }}'
+    pod: '{{ pod_with_two_container.name }}'
+    remote_path: /file_from_localhost_01.txt
+    container: '{{ pod_with_two_container.container[0] }}'
+    content: '{{ random_content }}-secondpod'
+  ignore_errors: true
+  register: diff_1
+
+- name: check that diff failed
+  assert:
+    that:
+      - diff_1 is failed
+
+- name: Assert that content has been copied into second container
+  kubectl_file_compare:
+    namespace: '{{ copy_namespace }}'
+    pod: '{{ pod_with_two_container.name }}'
+    remote_path: /file_from_localhost_01.txt
+    container: '{{ pod_with_two_container.container[1] }}'
+    content: '{{ random_content }}-secondpod'