hetzner.hcloud/tests/integration/targets/server/tasks/test_basic.yml

- name: test create server with check mode
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    server_type: "{{ hcloud_server_type_name }}"
    image: "{{ hcloud_image_name }}"
    location: "{{ hcloud_location_name }}"
    state: present
  register: result
  check_mode: true
- name: test create server server
  assert:
    that:
      - result is changed

- name: test create server
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name}}"
    server_type: "{{ hcloud_server_type_name }}"
    image: "{{ hcloud_image_name }}"
    location: "{{ hcloud_location_name }}"
    enable_ipv6: False
    state: started
  register: main_server
- name: verify create server
  assert:
    that:
      - main_server is changed
      - main_server.hcloud_server.name == hcloud_server_name
      - main_server.hcloud_server.server_type == hcloud_server_type_name
      - main_server.hcloud_server.status == "running"
      - main_server.root_password != ""

- name: test create server idempotence
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    state: started
  register: result
- name: verify create server idempotence
  assert:
    that:
      - result is not changed

- name: test stop server with check mode
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    state: stopped
  register: result
  check_mode: true
- name: verify stop server with check mode
  assert:
    that:
      - result is changed
      - result.hcloud_server.status == "running"

- name: test stop server
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    state: stopped
  register: result
- name: verify stop server
  assert:
    that:
      - result is changed
      - result.hcloud_server.status == "off"

- name: test start server with check mode
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    state: started
  register: result
  check_mode: true
- name: verify start server with check mode
  assert:
    that:
      - result is changed

- name: test start server
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    state: started
  register: result
- name: verify start server
  assert:
    that:
      - result is changed
      - result.hcloud_server.status == "running"

- name: test start server idempotence
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    state: started
  register: result
- name: verify start server idempotence
  assert:
    that:
      - result is not changed
      - result.hcloud_server.status == "running"

- name: test stop server by its id
  hetzner.hcloud.server:
    id: "{{ main_server.hcloud_server.id }}"
    state: stopped
  register: result
- name: verify stop server by its id
  assert:
    that:
      - result is changed
      - result.hcloud_server.status == "off"

- name: test resize server running without force
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    server_type: "{{ hcloud_server_type_upgrade_name }}"
    state: present
  register: result
  check_mode: true
- name: verify test resize server running without force
  assert:
    that:
      - result is changed
      - result.hcloud_server.server_type == hcloud_server_type_name

- name: test resize server with check mode
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    server_type: "{{ hcloud_server_type_upgrade_name }}"
    state: stopped
  register: result
  check_mode: true
- name: verify resize server with check mode
  assert:
    that:
      - result is changed

- name: test resize server without disk
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    server_type: "{{ hcloud_server_type_upgrade_name }}"
    state: stopped
  register: result
- name: verify resize server without disk
  assert:
    that:
      - result is changed
      - result.hcloud_server.server_type == hcloud_server_type_upgrade_name

- name: test resize server idempotence
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    server_type: "{{ hcloud_server_type_upgrade_name }}"
    state: stopped
  register: result
- name: verify resize server idempotence
  assert:
    that:
      - result is not changed

- name: test resize server to smaller plan
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    server_type: "{{ hcloud_server_type_name }}"
    state: stopped
  register: result
- name: verify resize server to smaller plan
  assert:
    that:
      - result is changed
      - result.hcloud_server.server_type == hcloud_server_type_name

- name: test resize server with disk
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    server_type: "{{ hcloud_server_type_upgrade_name }}"
    upgrade_disk: true
    state: stopped
  register: result
- name: verify resize server with disk
  assert:
    that:
      - result is changed
      - result.hcloud_server.server_type == hcloud_server_type_upgrade_name

- name: test enable backups with check mode
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    backups: true
    state: stopped
  register: result
  check_mode: true
- name: verify enable backups with check mode
  assert:
    that:
      - result is changed

- name: test enable backups
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    backups: true
    state: stopped
  register: result
- name: verify enable backups
  assert:
    that:
      - result is changed
      - result.hcloud_server.backup_window != ""

- name: test enable backups idempotence
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    backups: true
    state: stopped
  register: result
- name: verify enable backups idempotence
  assert:
    that:
      - result is not changed
      - result.hcloud_server.backup_window != ""

- name: test backups are not accidentally disabled
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    # Make sure that backups are not disabled because a partial server object without "backups" was supplied somewhere
    # to update some unrelated properties.
    # Regression test for https://github.com/ansible-collections/hetzner.hcloud/pull/196
    # backups: true
    state: stopped
  register: result
- name: verify backups are not accidentally disabled
  assert:
    that:
      - result is not changed
      - result.hcloud_server.backup_window != ""

- name: test rebuild server
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    image: "{{ hcloud_image_name }}"
    state: rebuild
  register: result_after_test
- name: verify rebuild server
  assert:
    that:
      - result_after_test is changed
      - result.hcloud_server.id == result_after_test.hcloud_server.id

- name: test rebuild server with check mode
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    image: "{{ hcloud_image_name }}"
    state: rebuild
  register: result_after_test
  check_mode: true
- name: verify rebuild server with check mode
  assert:
    that:
      - result_after_test is changed

- name: test update server protection booth protection arguments are required
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    delete_protection: true
    state: present
  register: result_after_test
  ignore_errors: true
- name: verify update server protection booth protection arguments are required
  assert:
    that:
      - result_after_test is failed
      - 'result_after_test.msg == "parameters are required together: delete_protection, rebuild_protection"'

- name: test update server protection fails if they are not the same
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    delete_protection: true
    rebuild_protection: false
    state: present
  register: result_after_test
  ignore_errors: true
- name: verify update server protection fails if they are not the same
  assert:
    that:
      - result_after_test is failed

- name: test update server protection
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    delete_protection: true
    rebuild_protection: true
    state: present
  register: result_after_test
  ignore_errors: true
- name: verify update server protection
  assert:
    that:
      - result_after_test is changed
      - result_after_test.hcloud_server.delete_protection is sameas true
      - result_after_test.hcloud_server.rebuild_protection is sameas true

- name: test server without protection set to be idempotent
  hetzner.hcloud.server:
    name: "{{hcloud_server_name}}"
  register: result_after_test
- name: verify test server without protection set to be idempotent
  assert:
    that:
      - result_after_test is not changed
      - result_after_test.hcloud_server.delete_protection is sameas true
      - result_after_test.hcloud_server.rebuild_protection is sameas true

- name: test delete server fails if it is protected
  hetzner.hcloud.server:
    name: "{{hcloud_server_name}}"
    state: absent
  ignore_errors: true
  register: result
- name: verify delete server fails if it is protected
  assert:
    that:
      - result is failed
      - result.failure.code == "protected"

- name: test rebuild server fails if it is protected
  hetzner.hcloud.server:
    name: "{{hcloud_server_name}}"
    image: "{{ hcloud_image_name }}"
    state: rebuild
  ignore_errors: true
  register: result
- name: verify rebuild server fails if it is protected
  assert:
    that:
      - result is failed
      - result.failure.code == "protected"

- name: test remove server protection
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    delete_protection: false
    rebuild_protection: false
    state: present
  register: result_after_test
  ignore_errors: true
- name: verify remove server protection
  assert:
    that:
      - result_after_test is changed
      - result_after_test.hcloud_server.delete_protection is sameas false
      - result_after_test.hcloud_server.rebuild_protection is sameas false

- name: absent server
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    state: absent
  register: result
- name: verify absent server
  assert:
    that:
      - result is success

- name: test create server with ssh key
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name}}"
    server_type: "{{ hcloud_server_type_name }}"
    image: "{{ hcloud_image_name }}"
    ssh_keys:
      - "{{ hcloud_ssh_key_name }}"
    state: started
  register: main_server
- name: verify create server with ssh key
  assert:
    that:
      - main_server is changed
      - main_server.hcloud_server.name == hcloud_server_name
      - main_server.hcloud_server.server_type == hcloud_server_type_name
      - main_server.hcloud_server.status == "running"
      - main_server.root_password != ""

- name: test activate rescue mode with check_mode
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    rescue_mode: "linux64"
    ssh_keys:
      - "{{ hcloud_ssh_key_name }}"
    state: present
  register: main_server
  check_mode: true
- name: verify activate rescue mode
  assert:
    that:
      - main_server is changed

- name: test activate rescue mode
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    rescue_mode: "linux64"
    ssh_keys:
      - "{{ hcloud_ssh_key_name }}"
    state: present
  register: main_server
- name: verify activate rescue mode
  assert:
    that:
      - main_server is changed
      - main_server.hcloud_server.rescue_enabled is sameas true

- name: test disable rescue mode
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    ssh_keys:
      - "{{ hcloud_ssh_key_name }}"
    state: present
  register: main_server
- name: verify activate rescue mode
  assert:
    that:
      - main_server is changed
      - main_server.hcloud_server.rescue_enabled is sameas false

- name: test activate rescue mode without ssh keys
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    rescue_mode: "linux64"
    state: present
  register: main_server
- name: verify activate rescue mode without ssh keys
  assert:
    that:
      - main_server is changed
      - main_server.hcloud_server.rescue_enabled is sameas true

- name: absent server
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    state: absent
  register: result
- name: verify absent server
  assert:
    that:
      - result is success

- name: test create server with rescue_mode
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name}}"
    server_type: "{{ hcloud_server_type_name }}"
    image: "{{ hcloud_image_name }}"
    location: "{{ hcloud_location_name }}"
    ssh_keys:
      - "{{ hcloud_ssh_key_name }}"
    rescue_mode: "linux64"
    state: started
  register: main_server
- name: verify create server with rescue_mode
  assert:
    that:
      - main_server is changed
      - main_server.hcloud_server.name == hcloud_server_name
      - main_server.hcloud_server.server_type == hcloud_server_type_name
      - main_server.hcloud_server.status == "running"
      - main_server.root_password != ""
      - main_server.hcloud_server.rescue_enabled is sameas true

- name: absent server
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    state: absent
  register: result
- name: verify absent server
  assert:
    that:
      - result is success
- name: test create server with labels
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name}}"
    server_type: "{{ hcloud_server_type_name }}"
    image: "{{ hcloud_image_name }}"
    location: "{{ hcloud_location_name }}"
    ssh_keys:
      - "{{ hcloud_ssh_key_name }}"
    labels:
      key: value
      mylabel: "val123"
    state: started
  register: main_server
- name: verify create server with labels
  assert:
    that:
      - main_server is changed
      - main_server.hcloud_server.labels.key == "value"
      - main_server.hcloud_server.labels.mylabel == "val123"

- name: test update server with labels
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name}}"
    server_type: "{{ hcloud_server_type_name }}"
    image: "{{ hcloud_image_name }}"
    ssh_keys:
      - "{{ hcloud_ssh_key_name }}"
    labels:
      key: other
      mylabel: "val123"
    state: started
  register: main_server
- name: verify update server with labels
  assert:
    that:
      - main_server is changed
      - main_server.hcloud_server.labels.key == "other"
      - main_server.hcloud_server.labels.mylabel == "val123"

- name: test update server with labels in other order
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name}}"
    server_type: "{{ hcloud_server_type_name }}"
    image: "{{ hcloud_image_name }}"
    ssh_keys:
      - "{{ hcloud_ssh_key_name }}"
    labels:
      mylabel: "val123"
      key: other
    state: started
  register: main_server
- name: verify update server with labels in other order
  assert:
    that:
      - main_server is not changed

- name: cleanup with labels
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    state: absent
  register: result
- name: verify cleanup
  assert:
    that:
      - result is success

- name: test create server with enabled backups
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    server_type: "{{ hcloud_server_type_name }}"
    backups: true
    image: "{{ hcloud_image_name }}"
    ssh_keys:
      - "{{ hcloud_ssh_key_name }}"
    state: present
  register: result
- name: verify enable backups
  assert:
    that:
      - result is changed
      - result.hcloud_server.backup_window != ""

- name: cleanup test create server with enabled backups
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    state: absent
  register: result
- name: verify cleanup
  assert:
    that:
      - result is success

- name: test create server with protection
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    delete_protection: true
    rebuild_protection: true
    server_type: "{{ hcloud_server_type_name }}"
    image: "{{ hcloud_image_name }}"
    location: "{{ hcloud_location_name }}"
    ssh_keys:
      - "{{ hcloud_ssh_key_name }}"
    state: present
  register: result_after_test
  ignore_errors: true
- name: verify create server with protection
  assert:
    that:
      - result_after_test is changed
      - result_after_test.hcloud_server.delete_protection is sameas true
      - result_after_test.hcloud_server.rebuild_protection is sameas true

- name: test delete server fails if it is protected
  hetzner.hcloud.server:
    name: "{{hcloud_server_name}}"
    state: absent
  ignore_errors: true
  register: result
- name: verify delete server fails if it is protected
  assert:
    that:
      - result is failed
      - result.failure.code == "protected"

- name: remove protection from server
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    delete_protection: false
    rebuild_protection: false
    state: present
  register: result_after_test
  ignore_errors: true
- name: verify update server protection
  assert:
    that:
      - result_after_test is changed
      - result_after_test.hcloud_server.delete_protection is sameas false
      - result_after_test.hcloud_server.rebuild_protection is sameas false

- name: cleanup
  hetzner.hcloud.server:
    name: "{{ hcloud_server_name }}"
    state: absent
  register: result
- name: verify cleanup
  assert:
    that:
      - result is success