Add OpenNebula one_vm module (#37825)

* Add OpenNebula one_vm module

* `one_vm` - module for managing VM instances instances on OpenNebula

* Add integration tests

test/legacy/opennebula.yml

@@ -0,0 +1,4 @@
+---
+- hosts: localhost
+  roles:
+    - { role: one_vm, tags: test_one_vm }

test/legacy/roles/one_vm/defaults/main.yml

@@ -0,0 +1,56 @@
+---
+# This is a role for running integration test of the one_vm module.
+# For this role to be used you need to meet the following prerequisites:
+#   1. Environment variables ONE_URL, ONE_USERNAME and ONE_PASSWORD
+#      need to be set.
+#   2. VM template needs to exist. Here is an example of VM template:
+#
+#        CONTEXT = [
+#          NETWORK = "YES",
+#          REPORT_READY = "YES",
+#          SET_HOSTNAME = "$NAME",
+#          SSH_PUBLIC_KEY = "$USER[SSH_PUBLIC_KEY]",
+#          TOKEN = "YES" ]
+#        CPU = "0.2"
+#        CPU_COST = ".0890000000"
+#        DISK = [
+#          IMAGE = "CentOS 7",
+#          IMAGE_UNAME = "oneadmin" ]
+#        DISK_COST = ".0000005853"
+#        GRAPHICS = [
+#          LISTEN = "0.0.0.0",
+#          TYPE = "VNC" ]
+#        HYPERVISOR = "kvm"
+#        LOGO = "images/logos/centos.png"
+#        MEMORY = "1024"
+#        MEMORY_COST = ".0000003560"
+#        SCHED_DS_REQUIREMENTS = "NAME=local_system"
+#        USER_INPUTS = [
+#          CPU = "O|fixed|| |0.2",
+#          MEMORY = "M|list||1024,2048,4096,8192,16384,24576,32768,49152,65536|1024",
+#          VCPU = "O|list||1,2,4,6,8,10|1" ]
+#        VCPU = "1"
+#
+#   3. Play vars need to be set bellow to reflect the vm IDs, networks, template IDs, etc.
+
+one_template_id: 15
+one_template_name: 'CentOS 7'
+one_template_name_with_2_disks: 'Centos_2_disks'
+one_memory: '4 GB'
+one_cpu: 0.1
+one_vcpu: 4
+
+one_incorrect_memory: '123ABC'
+one_incorrect_disk_size: '12344FFB'
+one_disk_size: '32.4 GB'
+
+one_networks_good:
+  - NETWORK: "default-test-private"
+    NETWORK_UNAME: "oneadmin"
+    SECURITY_GROUPS: "10"
+  - NETWORK_ID: 27
+
+one_networks_bad:
+  - NETWORK_ID: 999
+  - IP: '9.9.9'
+one_vm_name: 'foo123'

test/legacy/roles/one_vm/tasks/main.yml

@@ -0,0 +1,924 @@
+---
+- name: 'Deploy a VM in check-mode with template_id'
+  one_vm:
+    template_id: '{{ one_template_id }}'
+  register: deployed_vm1
+  check_mode: yes
+
+- name: Check if deployment in check-mode with template_id returns 'changed'
+  assert:
+    that:
+      - deployed_vm1 is changed
+    msg: Check mode doesn't return as 'changed' when deploying in check-mode with specified template_id
+
+- name: Deploy a VM in check-mode with template_name
+  one_vm:
+    template_name: '{{ one_template_name }}'
+  register: deployed_vm2
+  check_mode: yes
+
+- name: Check if deployment in check-mode with template_name returns 'changed'
+  assert:
+    that:
+      - deployed_vm2 is changed
+    msg: Check mode doesn't return as 'changed' when deploying in check-mode with specified template_name
+
+- name: Deploy a VM in check-mode with non-existent template_name
+  one_vm:
+    template_name: 'unknown'
+  register: template_bad
+  failed_when: not template_bad is failed
+  
+- name: Check if it fails if we try to access a non-existent VM in check-mode
+  one_vm:
+    instance_ids: non-existent-vm-{{ ansible_date_time.iso8601_basic_short }}
+  register: vm_missing
+  failed_when: not vm_missing is failed
+  check_mode: yes
+
+- name: Check if it fails if we try to access a non-existent VM
+  one_vm:
+    instance_ids: non-existent-vm-{{ ansible_date_time.iso8601_basic_short }}
+  register: vm_missing
+  failed_when: not vm_missing is failed
+
+- block:
+    - name: Deploy a VM with networks, memory and cpu
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        networks: '{{ one_networks_good }}'
+        memory: '{{ one_memory }}'
+        cpu: '{{ one_cpu }}'
+      register: deployed_vm
+
+    - name: Verify deploying of the VM
+      assert:
+        that:
+          - deployed_vm is changed
+          - deployed_vm.instances_ids|length == 1
+          - deployed_vm.instances|length == 1
+          - deployed_vm.instances[0].vm_id == deployed_vm.instances_ids[0]
+          - deployed_vm.instances[0].networks|length == one_networks_good|length
+          - deployed_vm.instances[0].memory == "4096 MB"
+          - deployed_vm.instances[0].cpu == "{{ one_cpu }}"
+          - deployed_vm.instances[0].state == "ACTIVE"
+          - deployed_vm.instances[0].lcm_state == "RUNNING"
+
+    - name: Delete a VM in check-mode
+      one_vm:
+        instance_ids: '{{ deployed_vm.instances[0].vm_id }}'
+        state: absent
+      register: delete_vm
+      check_mode: yes
+
+    - name: Check if delete in check-mode returns 'changed'
+      assert:
+        that: delete_vm is changed
+
+    - name: Wait for the VM to become RUNNING
+      one_vm:
+        attributes:
+          name: '{{ deployed_vm.instances[0].vm_name }}'
+        state: running
+
+  always:
+    - name: Delete the VM
+      one_vm:
+        instance_ids: 
+          - '{{ deployed_vm.instances[0].vm_id }}'
+        state: absent
+        hard: yes
+      register: delete_vm
+
+- name: Check if deletion has done
+  assert:
+    that: 
+      - delete_vm is changed
+      - delete_vm.instances_ids|length == 1
+      - delete_vm.instances_ids[0] == deployed_vm.instances_ids[0]
+    msg: 'Deletion has not done'
+
+- name: Delete the VM again to test idempotence
+  one_vm:
+    instance_ids:
+      - '{{ deployed_vm.instances[0].vm_id }}'
+    state: absent
+  register: delete_vm_idempotent
+
+- name: Check if deletion is idempotent
+  assert:
+    that: 
+      - not delete_vm_idempotent is changed
+    msg: 'Deletion is not idempotent'
+  
+- name: Delete a non-existent VM
+  one_vm:
+    instance_ids:
+     - non-existent-vm-{{ ansible_date_time.iso8601_basic_short }}
+    state: absent
+  register: delete_non_existent_vm
+     
+- name: Check if deletion is not executed
+  assert:
+    that: 
+      - not delete_non_existent_vm is changed
+    msg: 'Deletion is bad, task has deleted non existent VM'
+
+- block:
+    - name: Set the unique name of the VM
+      set_fact:
+        vm_unique_name: test-vm-name-{{ ansible_date_time.iso8601_basic_short }}  
+
+    - name: Try to deploy an unique VM with exact_count but without count_attributes and count_labels
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: '{{ vm_unique_name }}'
+        exact_count: 1
+      register: one_exact_count_without_count_attrs
+      failed_when: not one_exact_count_without_count_attrs is failed
+
+    - name: Deploy an unique VM in check mode
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: '{{ vm_unique_name }}'
+        exact_count: 1
+        count_attributes: 
+          name: '{{ vm_unique_name }}'
+      register: unique_vm_check_mode
+      check_mode: yes
+
+    - name: Check if deployment in check-mode returns as 'changed'
+      assert:
+        that:
+          - unique_vm_check_mode is changed
+        msg: 'Deploying an unique VM, that does not exist, in check-mode should return as changed.'
+
+    - name: Really deploy an unique VM
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: '{{ vm_unique_name }}'
+        exact_count: 1
+        count_attributes: 
+          name: '{{ vm_unique_name }}'
+      register: unique_vm
+
+    - name: Verify deploying with unique name
+      assert:
+        that:
+          - unique_vm is changed
+          - unique_vm.instances_ids|length == 1
+          - unique_vm.instances|length == 1
+          - unique_vm.instances[0].vm_name == "{{ vm_unique_name }}"
+        msg: Deployment of the unique VM doesn't return as 'changed'
+    
+    - name: Deploy an unique VM again to check idempotence
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: '{{ vm_unique_name }}'
+        exact_count: 1
+        count_attributes: 
+          name: '{{ vm_unique_name }}'
+      register: unique_vm_idempotent
+
+    - name: Check idempotence of deployment with unique name
+      assert:
+        that:
+          - not unique_vm_idempotent is changed
+        msg: Deployment with unique name isn't idempotent
+
+  always:
+    - name: Delete the unique VM
+      one_vm:
+        instance_ids:
+          - '{{ unique_vm.tagged_instances[0].vm_id }}'
+        state: absent
+        hard: yes
+
+- name: Try to deploy a VM with incorrect networks
+  one_vm:
+    template_name: '{{ one_template_name }}'
+    networks: '{{ one_networks_bad }}'
+  register: vm_with_bad_networks
+  failed_when: not vm_with_bad_networks is failed
+
+- name: Try to deploy a VM with incorrect memory size
+  one_vm:
+    template_name: '{{ one_template_name }}'
+    memory: '{{ one_incorrect_memory }}'
+  register: vm_with_bad_memory_param
+  failed_when: not vm_with_bad_memory_param is failed
+
+- name: Try to deploy a VM with incorrect disk size
+  one_vm:
+    template_name: '{{ one_template_name }}'
+    disk_size: '{{ one_incorrect_disk_size }}'
+  register: vm_with_bad_disk_size_param
+  failed_when: not vm_with_bad_disk_size_param is failed
+
+- name: Try to deploy a VM, with disk size, whose template has more than one DISK
+  one_vm:
+    template_name: '{{ one_template_name_with_2_disks }}'
+    disk_size: '{{ one_disk_size }}'
+  register: vm_with_disk_size_and_more_disks
+  failed_when: not vm_with_disk_size_and_more_disks is failed
+
+- name: Try to deploy a VM with incorrect name's format
+  one_vm:
+    template_name: '{{ one_template_name }}'
+    attributes:
+      name: 'foo#Vm###'
+  register: vm_with_bad_name
+  failed_when: not vm_with_bad_name is failed
+
+- name: Try to deploy a VM with incorrect name's format
+  one_vm:
+    template_name: '{{ one_template_name }}'
+    attributes:
+      name: '###'
+  register: vm_with_bad_name
+  failed_when: not vm_with_bad_name is failed
+
+- block:
+    - name: Deploy a VM and wait for it to become RUNNING
+      one_vm:
+        template_id: '{{ one_template_id }}'
+      register: vm_register
+
+    - name: Power-off the VM and wait for it to become POWEROFF
+      one_vm:
+        instance_ids:
+          - '{{ vm_register.instances[0].vm_id }}'
+        state: poweredoff
+        hard: yes
+      register: power_off_vm
+
+    - name: Check if VM went down properly
+      assert:
+        that:
+          - power_off_vm is changed
+          - power_off_vm.instances|length == 1
+          - power_off_vm.instances[0].state == "POWEROFF"
+        msg: Power-off of the VM doesn't work
+
+    - name: Power-off the VM again to check idempotence
+      one_vm:
+        instance_ids:
+          - '{{ vm_register.instances[0].vm_id }}'
+        state: poweredoff
+      register: power_off_vm_idempotent
+
+    - name: Check if power-off is idempotent
+      assert:
+        that:
+          - not power_off_vm_idempotent is changed
+        msg: Power-off of the VM is not idempotent
+
+    - name: Run a VM again in check-mode
+      one_vm:
+        instance_ids:
+          - '{{ vm_register.instances[0].vm_id }}'
+        state: running
+      register: run_vm_check_mode
+      check_mode: yes
+
+    - name: Check if running in check-mode returns as 'changed'
+      assert:
+        that:
+          - run_vm_check_mode is changed
+
+    - name: Run a VM and wait for it to become RUNNING
+      one_vm:
+        instance_ids:
+          - '{{ vm_register.instances[0].vm_id }}'
+        state: running
+      register: run_vm
+
+    - name: Check if VM is running again
+      assert:
+        that:
+          - run_vm is changed
+          - run_vm.instances_ids|length == 1
+          - run_vm.instances_ids[0] == vm_register.instances[0].vm_id
+          - run_vm.instances|length == 1
+          - run_vm.instances[0].state == "ACTIVE"
+          - run_vm.instances[0].lcm_state == "RUNNING"
+
+    - name: Reboot the running VM
+      one_vm:
+        instance_ids:
+          - '{{ vm_register.instances[0].vm_id }}'
+        state: rebooted
+      register: reboot_running_vm
+
+    - name: Check if reboot returns as changed
+      assert:
+        that:
+          - reboot_running_vm is changed
+        msg: Reboot should be done anyway
+
+    - name: Power-off the VM and wait for it to become POWEROFF
+      one_vm:
+        instance_ids:
+          - '{{ vm_register.instances[0].vm_id }}'
+        state: poweredoff
+        hard: yes
+
+    - name: Reboot the extinguished VM and wait for it to become RUNNING
+      one_vm:
+        instance_ids:
+          - '{{ vm_register.instances[0].vm_id }}'
+        state: rebooted
+      register: reboot_extinguished_vm
+
+    - name: Check if reboot started VM again
+      assert:
+        that:
+          - reboot_extinguished_vm is changed
+          - reboot_extinguished_vm.instances|length == 1
+          - reboot_extinguished_vm.instances[0].state == "ACTIVE"
+          - reboot_extinguished_vm.instances[0].lcm_state == "RUNNING"
+        msg: Rebooting the extinguished VM should run it
+
+  always:
+    - name: Delete the VM
+      one_vm:
+        instance_ids:
+          - '{{ vm_register.instances[0].vm_id }}'
+        state: absent      
+        hard: yes
+
+- block:
+    - name: Deploy 2 VMs with attributes in check-mode
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: aero
+          key: value
+        count: 2
+      register: deploy_vms_with_count_check_mode
+      check_mode: yes
+
+    - name: Check if deployment in check-mode returns as 'changed'
+      assert:
+        that: 
+          - deploy_vms_with_count_check_mode is changed
+
+    - name: Deploy 2 VMs with attributes
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: aero
+          key: value
+        count: 2
+      register: deploy_vms_with_count
+
+    - name: Check if deployment in returns as 'changed'
+      assert:
+        that: 
+          - deploy_vms_with_count is changed
+          - deploy_vms_with_count.instances_ids|length == 2
+          - deploy_vms_with_count.instances|length == 2
+          - deploy_vms_with_count.tagged_instances|length == 2
+          - deploy_vms_with_count.tagged_instances[0].vm_name == "aero"
+          - deploy_vms_with_count.tagged_instances[1].vm_name == "aero"
+        
+    - name: Deploy 2 VMs with attributes to check it is not idempotent
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: aero
+          key: value
+        count: 2
+      register: deploy_vms_with_count_check_idempotence
+
+    - name: Check if deployment with count is not idempotent
+      assert:
+        that: 
+          - deploy_vms_with_count_check_idempotence is changed
+          - deploy_vms_with_count_check_idempotence.instances_ids|length == 2
+          - deploy_vms_with_count_check_idempotence.instances|length == 2
+
+  always:
+    - name: Delete all VMs
+      one_vm:
+        instance_ids: '{{ deploy_vms_with_count.instances_ids | union(deploy_vms_with_count_check_idempotence.instances_ids) }}'
+        state: absent
+        hard: yes
+      register: delete_all_vms
+
+    - name: Verify deletion
+      assert:
+        that:
+          - delete_all_vms is changed
+          - delete_all_vms.instances_ids|length == 4
+          - delete_all_vms.instances|length == 4
+          - delete_all_vms.tagged_instances|length == 0
+
+- block:
+    - name: Set VMs indexed format name
+      set_fact:
+        vms_indexed_name: 'aero-##'
+
+    - name: Terminate all VMs with name's format 'aero-##'
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        count_attributes:
+          name: '{{ vms_indexed_name }}'
+        hard: yes
+        exact_count: 0
+
+    - name: Terminate all VMs with name's format 'aero-##' again to check-idempotence
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        count_attributes:
+          name: '{{ vms_indexed_name }}'
+        hard: yes
+        exact_count: 0
+
+    - name: Terminate all VMs with name's format 'aero'
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        exact_count: 0
+        count_attributes:
+          name: aero
+        hard: yes
+
+    - name: Fetch all VMs with name's format 'aero-##' 
+      one_vm:
+        attributes:
+          name: '{{ vms_indexed_name }}'
+      register: all_aero_vms
+      failed_when: all_aero_vms.instances_ids|length > 0
+
+    - name: Deploy exact 3 instances with name's format 'aero-##'
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: '{{ vms_indexed_name }}'
+        exact_count: 3
+        count_attributes: 
+          name: '{{ vms_indexed_name }}'
+      register: vms_with_hash
+
+    - name: Deploy exact 2 instances with name's format 'aero'
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: aero
+        exact_count: 2
+        count_attributes: 
+          name: aero
+      register: vms_without_hash
+
+    - name: Fetch all VMs with name's format 'aero-#' 
+      one_vm:
+        attributes:
+          name: aero-#
+      register: all_aero_vms_with_hash
+
+    - name: Check there are exactly 3 instances with name's format 'aero-#'
+      assert:
+        that: 
+          - not all_aero_vms_with_hash is changed
+          - all_aero_vms_with_hash.tagged_instances|length == 3
+
+    - name: Decrement count of 'aero-#' instances
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        exact_count: 2
+        count_attributes:
+          name: aero-#
+      register: aero_vms_with_hash_decremented
+
+    - name: Check if we terminated oldest one VM
+      assert:
+        that:
+          - aero_vms_with_hash_decremented is changed
+          - aero_vms_with_hash_decremented.instances_ids|length == 1
+          - vms_with_hash.instances_ids|min == aero_vms_with_hash_decremented.instances_ids[0]
+
+    - name: Deploy new one with name's format 'aero-#'
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: 'aero-#'
+      register: new_vm_with_hash
+
+    - name: Check if new VM has index 0 
+      assert:
+        that: 
+          - new_vm_with_hash is changed
+          - new_vm_with_hash.instances_ids|length == 1
+          - new_vm_with_hash.instances|length == 1
+          - new_vm_with_hash.tagged_instances|length == 1
+          - new_vm_with_hash.instances[0].vm_name|regex_replace('(\d+)$','\1')|int == 0
+
+  always:
+    - name: Terminate all VMs with name's format 'aero-##'
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        count_attributes:
+          name: '{{ vms_indexed_name }}'
+        exact_count: 0
+        hard: yes
+
+    - name: Terminate all VMs with name's format 'aero'
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        count_attributes:
+          name: aero
+        exact_count: 0
+        hard: yes
+
+- block:
+    - name: Try to create negative count of VMs
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        count: -3
+      register: negative_count_of_vms
+      failed_when: not negative_count_of_vms is failed
+
+    - name: Verify the fail message
+      assert:
+        that:
+          - negative_count_of_vms.msg == "`count` has to be grater than 0"
+
+    - name: Try to use hard parameter for running state
+      one_vm:
+        instance_ids:
+          - 123
+          - 456
+        hard: yes
+        state: running
+      register: hard_with_running
+      failed_when: not hard_with_running is failed
+
+    - name: Try to use count with count_attributes/count_labels
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        count: 2
+        count_attributes:
+          key: val
+        count_labels:
+          - foo
+      register: use_count_with_count_attrs
+      failed_when: not use_count_with_count_attrs is failed
+
+    - name: Terminate all VMs with label 'foo'
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        count_labels:
+          - foo
+        exact_count: 0
+        hard: yes
+
+    - name: Deploy exact 3 VMs with label 'foo'
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        labels:
+          - foo
+        exact_count: 3
+        count_labels:
+          - foo
+      register: vms_with_foo_label
+
+    - name:
+      assert:
+        that:
+          - vms_with_foo_label is changed
+          - vms_with_foo_label.tagged_instances|length == 3
+          - vms_with_foo_label.tagged_instances[0].labels|length == 1
+          - vms_with_foo_label.tagged_instances[0].labels[0] == "foo"
+
+    - name: Try to use ids with exact_count and check if it fails
+      one_vm:
+        instance_ids: '{{ vms_with_foo_label.instances_ids }}'
+        exact_count: 2
+      register: failed_ids_and_exact_count
+      failed_when: not failed_ids_and_exact_count is failed
+
+    - name: Set special label for a new instance
+      set_fact:
+        vm_spec_label: spec-label-{{ ansible_date_time.iso8601_basic_short }} 
+
+    - name: Add a new instance in the group of instances with label 'foo'
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        labels:
+          - foo
+          - '{{ vm_spec_label }}'
+        exact_count: 4
+        count_labels:
+          - foo
+      register: new_vm_with_label
+      
+    - name: Fetch all instances with special label
+      one_vm:
+        labels:
+          - '{{ vm_spec_label }}'
+      register: vm_with_special_label
+
+    - name: Check there is only one VM with the special label
+      assert:
+        that:
+          - not vm_with_special_label is changed
+          - vm_with_special_label.tagged_instances|length == 1
+          - vm_with_special_label.instances_ids|length == 1
+          - vm_with_special_label.instances_ids[0] == new_vm_with_label.instances_ids[0]
+
+  always:
+    - name: Fetch all VMs with label 'foo'
+      one_vm:
+        labels:
+          - foo
+      register: all_foo_instances
+
+    - name: Terminate all VMs with label 'foo'
+      one_vm:
+        instance_ids: '{{ all_foo_instances.instances_ids }}'
+        state: absent
+        hard: yes
+      when: all_foo_instances.instances_ids|length > 0
+
+- block:
+    - name: Fetch all VMs with 'foo_app' key
+      one_vm:
+        attributes:
+          foo_app:
+      register: foo_app_instances
+
+    - name: Terminate all VMs with 'foo_app' key
+      one_vm:
+        instance_ids: '{{ foo_app_instances.instances_ids }}'
+        state: absent
+        hard: yes
+      when: foo_app_instances.instances_ids|length > 0
+
+    - name: Terminate all instances with name's format 'aeroXYZ-##' to test name parsing later
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        exact_count: 0
+        count_attributes:
+          name: 'aeroXYZ-##'
+        hard: yes
+
+    - name: Deploy 2 instances with attributes
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: 'aero-###'
+          foo_app: foo
+        count: 2
+    
+    - name: Deploy 2 instances with different value for attribute
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: 'aero-###'
+          foo_app: bar
+        count: 2
+
+    - name: Get all instances with attribute's key
+      one_vm:
+        attributes:
+          foo_app:
+      register: all_foo_app_vms
+      
+    - name: Check there are 4 VMs with 'foo_app' key
+      assert:
+        that:
+          - all_foo_app_vms.tagged_instances|length == 4
+    
+    - name: Decrement count of VMs with 'foo_app' key
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        exact_count: 2
+        count_attributes:
+          foo_app:
+      register: foo_app_vms
+
+      # instances list contains affected instances
+      # tagged_instances list contains the remaining instances with the appropriate attributes
+    - name: Check are there 2 elements in instances list and 2 elements in tagged_instances list
+      assert:
+        that:
+          - foo_app_vms is changed
+          - foo_app_vms.instances|length == 2
+          - foo_app_vms.tagged_instances|length == 2
+
+    - name: Fetch all instances with name's format 'aeroXYZ-##' to check parsing
+      one_vm:
+        attributes:
+          name: 'aeroXYZ-##'
+      register: check_there_are_no_vms
+      failed_when: check_there_are_no_vms.instances_ids|length > 0
+
+  always:
+    - name: Fetch all VMs with 'foo_app' key
+      one_vm:
+        attributes:
+          foo_app:
+      register: foo_app_instances
+
+    - name: Terminate all VMs with 'foo_app' key
+      one_vm:
+        instance_ids: '{{ foo_app_instances.instances_ids }}'
+        state: absent
+        hard: yes
+      when: foo_app_instances.instances_ids|length > 0
+
+- block:
+    - name: Set labels list
+      set_fact:
+        labels_list:
+           - bar1
+           - bar2
+      
+    - name: Deploy an instance with name 'app1', attribute 'foo app' and labels 'bar1' and 'bar2'
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        attributes:
+          name: app1
+          foo: app
+        labels: '{{ labels_list }}'
+      register: instance_with_labels
+
+    - name: Fetch the current instance
+      one_vm:
+        attributes:
+          name: app1
+          foo: app
+        labels: '{{ labels_list }}'
+      register: current_instance
+
+    - name: Check that the instance is fetched
+      assert:
+        that: current_instance.instances|length == 1
+        msg: There is no instance
+
+    - name: Check that labels are set correctly
+      assert:
+        that: instance_with_labels.instances[0].labels|difference(labels_list)|length == 0
+        msg: Labels are not correct
+    
+    - name: Check that name is correct
+      assert:
+        that: instance_with_labels.instances[0].vm_name == 'app1'
+        msg: The instance name is incorrect
+
+  always:
+    - name: Terminate the instance
+      one_vm:
+        instance_ids: '{{ instance_with_labels.instances_ids }}'
+        state: absent
+        hard: yes
+
+- name: Try to use letters for ids option
+  one_vm:
+    instance_ids: 
+      - asd
+      - 123
+    state: running
+  register: ids_with_letters
+  failed_when: not ids_with_letters is failed 
+
+- name: Try to use letters for ids option when terminate vms
+  one_vm:
+    instance_ids: 
+      - asd
+      - 123
+    state: absent
+  register: ids_with_letters
+  failed_when: ids_with_letters is failed 
+
+- name: Try to use restricted attributes when deploying
+  one_vm:
+    template_id: '{{ one_template_id }}'
+    attributes:
+      disk: 34 GB
+      template: foo
+  register: restricted_attributes
+  failed_when: not restricted_attributes is failed
+
+- name: Verify the fail message
+  assert:
+    that:
+      - restricted_attributes.msg == "Restricted attribute `DISK` cannot be used when filtering VMs."
+
+- name: Test images creation
+  block:
+    - name: Set fact image name
+      set_fact:
+        image_name: test-image-name-{{ ansible_date_time.iso8601_basic_short }}
+    
+    - name: Deploy VM
+      one_vm:
+        template_id: '{{ one_template_id }}'
+        labels:
+          - test-image
+        attributes:
+          name: test-vm-image
+      register: vm_image
+
+    - name: Try to use disk_saveas option with labels and attributes
+      one_vm:
+        labels:
+          - test-image
+        attributes:
+          name: test-vm-image
+        disk_saveas:
+          name: '{{ image_name }}'
+      register: save_disk_labels
+      failed_when: not save_disk_labels is failed
+        
+    - name: Try to save disk in running state to check if it will fail
+      one_vm:
+        instance_ids: '{{ vm_image.instances_ids }}'
+        disk_saveas:
+          name: '{{ image_name }}'
+      register: disk_save_as_running
+      failed_when: not disk_save_as_running
+
+    - name: Verify the fail message
+      assert:
+        that:
+          - disk_save_as_running.msg == "'disksaveas' option can be used only when the VM is in 'POWEROFF' state"
+
+    - name: Try to save disk without specified image name
+      one_vm:
+        instance_ids: '{{ vm_image.instances_ids }}'
+        disk_saveas: {}
+      register: disk_save_without_name
+      failed_when: not disk_save_without_name is failed
+
+    - name: Try to save disk of non-existent VM
+      one_vm:
+        attributes:
+          name: test-vm-{{ ansible_date_time.iso8601_basic_short }}
+        disk_saveas:
+          name: '{{ image_name }}'
+      register: disk_save_no_vm
+      failed_when: not disk_save_no_vm is failed
+
+    - name: Save disk of powered-off VM in check-mode
+      one_vm:
+        instance_ids: '{{ vm_image.instances_ids }}'
+        state: poweredoff
+        hard: yes
+        disk_saveas:
+          name: '{{ image_name }}'
+      check_mode: yes
+      register: vm_disk_saveas_check_mode
+
+    - name: Check if disk saving in check-mode is returned as 'changed'
+      assert:
+        that:
+          - vm_disk_saveas_check_mode is changed
+
+    - name: Check that image doesn't exist
+      one_image:
+        name: '{{ image_name }}'
+      failed_when: no
+
+    - name: Save disk of powered-off VM
+      one_vm:
+        instance_ids: '{{ vm_image.instances_ids }}'
+        state: poweredoff
+        hard: yes
+        disk_saveas:
+          name: '{{ image_name }}'
+      register: vm_disk_saveas
+
+    - name: Check if disk saving is returned as 'changed'
+      assert:
+        that:
+          - vm_disk_saveas is changed
+
+    - name: Check if image is created
+      one_image:
+        name: '{{ image_name }}'
+
+    - name: Try to save disk again with the same name
+      one_vm:
+        instance_ids: '{{ vm_image.instances_ids }}'
+        disk_saveas:
+          name: '{{ image_name }}'
+      register: disk_save_as_fail
+      failed_when: not disk_save_as_fail is failed
+
+  always:
+    - name: Delete the image
+      one_image:
+        name: '{{ image_name }}'
+        state: absent
+
+    - name: Delete the VM
+      one_vm:
+        instance_ids: '{{ vm_image.instances_ids }}'
+        state: absent
+        hard: yes
+  tags: test-image