local-test-operator.yml

---
- name: Test the operator on a kind/OCP 4.0 cluster with OLM
  hosts: all
  become: false
  gather_facts: false

  vars:
    run_prereqs: true
    run_upstream: false
    run_lint: true
    run_catalog_init: true
    run_deploy: true
    run_scorecard: true
    run_imagesource: true
    run_cleanup: true
    run_remove_catalog_repo: true
    run_manifest_test: false
    scorecard_first_cr: true
    openshift_namespace: "test-operator"
    work_dir: "/tmp/operator-test"
    testing_bin_path: "{{ work_dir }}/bin"
    current_channel: >
      ''    # Added to avoid a potential
      bug with undefined variables
    olm_ver: 0.14.1
    events_file_path: "{{ work_dir }}/events.json"

  environment:
    PATH: "{{ ansible_env.PATH }}:{{ ansible_env.HOME }}/.local/bin"
    when: run_upstream|bool

  pre_tasks:
    - setup:
      tags:
        - always
      when: run_upstream|bool
  tasks:
    - set_fact:
        operator_work_dir: "{{ work_dir }}/operator-files"
        olm_operator_files_path: "{{ work_dir }}/olm-operator-files"
        scorecard_cr_dir: "{{ work_dir }}/scorecard-cr-files"
        kube_objects_dir: "{{ work_dir }}/kube_objects"
        testing_bin_path: "{{ work_dir }}/bin"
        oc_bin_path: >
          '{{ ''kubectl'' if run_upstream else
          "{{ testing_bin_path }}/oc" }}'
        jq_bin_path: "{{ testing_bin_path }}/jq"
        yq_bin_path: "{{ testing_bin_path }}/yq"
        go_bin_path: "{{ testing_bin_path }}/go/bin/go"
        operator_sdk_bin_path: "{{ testing_bin_path }}/operator-sdk"

    - name: "Clear the operator working directory"
      file:
        path: "{{ operator_work_dir }}"
        state: absent

    - name: "Clear the scorecard CR directory"
      file:
        path: "{{ scorecard_cr_dir }}"
        state: absent
      when:
        - run_scorecard|bool
        - not run_upstream|bool

    - name: "Create the scorecard CR directory"
      file:
        path: "{{ scorecard_cr_dir }}"
        state: directory
        mode: 0744
      when:
        - run_scorecard|bool
        - not run_upstream|bool

    - name: "Install operator testing prerequisites"
      include_role:
        name: install_operator_prereqs
      when: run_prereqs|bool

    - name: "OLM"
      block:
        - name: "Check if OLM is needed"
          shell: "{{ oc_bin_path }} api-resources | grep -o operatorgroup"
          register: olm_needed
          ignore_errors: true

        - name: "Install OLM"
          block:
            - name: "Installing OLM"
              shell: >
                "{{ operator_sdk_bin_path }}
                olm install --version {{ olm_ver }}"

            - name: "Delete catalogsource"
              shell: >
                "{{ oc_bin_path }} delete catalogsource
                operatorhubio-catalog -n olm"
              ignore_errors: true
          when:
            - olm_needed.stdout != "operatorgroup"
      when: run_upstream|bool

    - name: "Build upstream catalog"
      include_role:
        name: build_catalog_upstream
      when: run_upstream|bool

    - name: >
        "Run operator-courier nest to copy the
        operator metadata in nested format to the work dir"
      shell: "operator-courier nest {{ operator_dir }} {{ operator_work_dir }}"
      when: not run_upstream|bool

    - name: Copy the operator metadata in nested format to the work dir
      copy:
        src: "{{ operator_dir }}/"
        dest: "{{ operator_work_dir }}"
        remote_src: true
        mode: 0644
      when: run_upstream|bool

    - name: "Parse operator metadata needed to run the tests (Openshift)"
      include_role:
        name: parse_operator_metadata

    - name: >
        "Run linting tests with operator-courier
        verify on the deployed operator"
      include_role:
        name: operator_courier_verify
      when: run_lint|bool

    - name: "Run catalog initialization test on operator metadata"
      include_role:
        name: operator_catalog_initialization_test
      when:
        - run_catalog_init|bool
        - not run_upstream|bool

    - name: "Operator deployment and scorecard/imagesource tests"
      block:
        - name: "Inject operator scorecard data into the operator metadata"
          include_role:
            name: inject_scorecard_metadata
          when:
            - run_scorecard|bool
            - not run_upstream|bool

        - name: >
            "Get all registry images on the OpenShift
            cluster before deploying the operator"
          shell: >
            "{{ oc_bin_path }} get is --all-namespaces
            -o json | jq '.items[].spec.tags[] |
            select(.from.kind == \"DockerImage\") |
            .from.name' --raw-output | sort -u"
          register: os_registry_is_result_before
          environment:
            KUBECONFIG: "{{ kubeconfig_path }}"
          no_log: true
          when: not run_upstream|bool

        - name: >
            "Get all pod images on the OpenShift
            cluster before deploying the operator"
          shell: >
            "{{ oc_bin_path }} get pods --all-namespaces
            -o json | jq '.items[].spec.containers[].image'
            --raw-output | sort -u"
          register: os_pod_is_result_before
          environment:
            KUBECONFIG: "{{ kubeconfig_path }}"
          no_log: true
          when: not run_upstream|bool

        - set_fact:
            openshift_images_before: >
              " {{ os_registry_is_result_before.stdout_lines
              }} + {{ os_pod_is_result_before.stdout_lines }}"
          when: not run_upstream|bool

        - name: "Set the deployment start time"
          shell: "date -u '+%Y-%m-%dT%H:%M:%SZ'"
          register: start_time
          when:
            - run_deploy|bool
            - not run_upstream|bool

        - name: "Deploy the operator on the OpenShift 4.0 with OLM"
          include_role:
            name: deploy_olm_operator
          when:
            - run_deploy|bool
            - not run_upstream|bool

        - name: "Collect the names of the images modified during the deployment"
          include_role:
            name: collect_modified_images
          vars:
            deployment_start_time: "{{ start_time }}"
            events_file_path: "{{ events_file_path }}"
            kubeconfig_path: "{{ kubeconfig_path }}"
          when:
            - run_deploy|bool
            - not run_upstream|bool

        - name: "Deploy the operator on the Kind cluster with OLM"
          include_role:
            name: deploy_olm_operator_upstream
          when:
            - run_deploy|bool
            - run_upstream|bool

        - name: "Get all openshift registry images"
          shell: >
            "{{ oc_bin_path }} get is --all-namespaces
            -o json | jq '.items[].spec.tags[] |
            select(.from.kind == \"DockerImage\") |
            .from.name' --raw-output | sort -u"
          register: os_registry_is_result_after
          environment:
            KUBECONFIG: "{{ kubeconfig_path }}"
          no_log: true
          when: not run_upstream|bool

        - name: "Get all OpenShift pod images"
          shell: >
            "{{ oc_bin_path }} get pods --all-namespaces
            -o json | jq '.items[].spec.containers[].image'
            --raw-output | sort -u"
          register: os_pod_is_result_after
          environment:
            KUBECONFIG: "{{ kubeconfig_path }}"
          no_log: true
          when: not run_upstream|bool

        - set_fact:
            openshift_images_after: >
              "{{ os_registry_is_result_after.stdout_lines }}
              + {{ os_pod_is_result_after.stdout_lines }}"
          when: not run_upstream|bool

        - name: "Scorecard test"
          block:
            - name: "Find all extracted CRs from alm-examples"
              shell: >
                "find \"{{ scorecard_cr_dir }}\"
                -name \"*.cr.yaml\" -print"
              register: scorecard_cr_files_result
              when:
                - run_scorecard|bool
                - run_deploy|bool

            - name: "Run scorecard tests on the deployed operator"
              include_role:
                name: operator_scorecard_tests
              with_items: "{{ scorecard_cr_files_result.stdout_lines }}"
              loop_control:
                loop_var: cr_path
              when:
                - run_scorecard|bool
                - run_deploy|bool
          always:
            - name: >
                "Get the pod container logs of the
                operator after running scorecard tests"
              shell: >
                "{{ oc_bin_path }} get --output=name pods
                | grep {{ operator_pod_name }} | xargs -I{}
                {{ oc_bin_path }} logs {} -c {{
                operator_container_name }}"
              register: operator_container_result
              ignore_errors: true
              environment:
                KUBECONFIG: "{{ kubeconfig_path }}"
              no_log: true

            - name: "Output the operator container log to a debug file"
              copy:
                content: "{{ operator_container_result.stdout }}"
                dest: "{{ work_dir }}/scorecard-operator-container-debug.txt"
              when:
                - operator_container_result.stdout != ""

          when: not run_upstream|bool

        - name: >
            "Test image sources of containers
            introduced with the testing operator"
          include_role:
            name: operator_imagesource_test
          vars:
            operator_images: >
              "{{ openshift_images_after |
              difference(openshift_images_before) | list }}"
          when:
            - run_imagesource|bool
            - run_deploy|bool
            - not run_upstream|bool

      when:
        - run_deploy|bool

      always:
        - name: "Cleanup created resources on the OCP/kind cluster"
          include_role:
            name: cleanup_operator_resources
          when:
            - run_cleanup|bool
            - run_deploy|bool

        - name: >
            "Remove the quay release of the
            test operator in the testing namespace"
          shell: >
            "curl -s -H \"Authorization: basic {{ quay_token }}\"
            -X DELETE https://quay.io/cnr/api/v1/packages/{{
            quay_namespace }}/{{ package_name }}-test/{{
            quay_release }}/helm"
          when:
            - quay_release is defined
            - package_name is defined
            - run_cleanup|bool
            - run_deploy|bool
            - not run_upstream|bool
          no_log: true