archive
/
ansible
mirror of https://github.com/ansible/ansible.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

fix rediscache/firewall tests (#54933)

Browse Source 
* cleaned up tagging to prevent long-running tasks in CI
pull/54935/head
Matt Davis 5 years ago committed by GitHub
parent 1de1d081a5
commit 2b9b5f5bb7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 185 additions and 182 deletions
Show Stats Download Patch File Download Diff File

367
test/integration/targets/azure_rm_rediscache/tasks/main.yml
Unescape Escape View File

@ -52,7 +52,6 @@
- facts.rediscaches[0].sku.name == 'basic' - facts.rediscaches[0].sku.name == 'basic'
- facts.rediscaches[0].sku.size == 'C1' - facts.rediscaches[0].sku.size == 'C1'
- name: Update the redis cache (idempotent) - name: Update the redis cache (idempotent)
azure_rm_rediscache: azure_rm_rediscache:
resource_group: "{{ resource_group }}" resource_group: "{{ resource_group }}"
@ -67,96 +66,117 @@
that: that:
- not output.changed - not output.changed
# creating redis Cache costs about 20 mins async operation, - name: long-running rediscache tests [run with `--tags long_run,untagged` to enable]
# need to poll status from Creating to Running, then able to perform updating/deleting operation, # creating redis Cache costs about 20 mins async operation,
# otherwise, will met error: # need to poll status from Creating to Running, then able to perform updating/deleting operation,
# "The resource '<resource_id>' is busy processing a previous update request or is undergoing system maintenance. # otherwise, will met error:
# As such, it is currently unable to accept the update request. Please try again later." # "The resource '<resource_id>' is busy processing a previous update request or is undergoing system maintenance.
# comment out updating/deleting tests for test efficiency. # As such, it is currently unable to accept the update request. Please try again later."
# - name: Update redis cache block:
# azure_rm_rediscache: - name: Wait for Redis provisioning to complete
# resource_group: "{{ resource_group }}" azure_rm_rediscache_facts:
# name: "{{ redis_name }}" resource_group: "{{ resource_group }}"
# sku: name: "{{ redis_name }}"
# name: basic register: facts
# size: C1 until: facts.rediscaches[0]['provisioning_state'] == 'Succeeded'
# enable_non_ssl_port: true retries: 30
# tags: delay: 60
# testing: foo
# register: output - name: (actually) update redis cache
azure_rm_rediscache:
# - name: assert output changed resource_group: "{{ resource_group }}"
# assert: name: "{{ redis_name }}"
# that: sku:
# - output.changed name: basic
size: C1
# - name: Update redis cache configuration enable_non_ssl_port: true
# azure_rm_rediscache: tags:
# resource_group: "{{ resource_group }}" testing: foo
# name: "{{ redis_name }}" register: output
# sku:
# name: basic - name: assert output changed
# size: C1 assert:
# enable_non_ssl_port: true that:
# maxmemory_policy: allkeys_lru - output.changed
# tags:
# testing: foo - name: Update redis cache configuration
# register: output azure_rm_rediscache:
resource_group: "{{ resource_group }}"
# - name: assert output changed name: "{{ redis_name }}"
# assert: sku:
# that: name: basic
# - output.changed size: C1
enable_non_ssl_port: true
# - name: Scale up the redis cache maxmemory_policy: allkeys_lru
# azure_rm_rediscache: tags:
# resource_group: "{{ resource_group }}" testing: foo
# name: "{{ redis_name }}" register: output
# sku:
# name: standard - name: assert output changed
# size: C1 assert:
# tags: that:
# testing: foo - output.changed
# register: output
- name: Scale up the redis cache
# - assert: azure_rm_rediscache:
# that: resource_group: "{{ resource_group }}"
# - output.changed name: "{{ redis_name }}"
sku:
# - name: Force reboot redis cache name: standard
# azure_rm_rediscache: size: C1
# resource_group: "{{ resource_group }}" tags:
# name: "{{ redis_name }}" testing: foo
# reboot: register: output
# reboot_type: all
# register: output - assert:
that:
# - assert: - output.changed
# that:
# - output.changed - name: Wait for Redis provisioning to complete
azure_rm_rediscache_facts:
# - name: Delete the redis cache (Check Mode) resource_group: "{{ resource_group }}"
# azure_rm_rediscache: name: "{{ redis_name }}"
# resource_group: "{{ resource_group }}" register: facts
# name: "{{ redis_name }}" until: facts.rediscaches[0]['provisioning_state'] == 'Succeeded'
# state: absent retries: 30
# check_mode: yes delay: 60
# register: output
- name: Force reboot redis cache
# - name: assert deleting redis cache check mode azure_rm_rediscache:
# assert: resource_group: "{{ resource_group }}"
# that: output.changed name: "{{ redis_name }}"
reboot:
# - name: Delete the redis cache reboot_type: all
# azure_rm_rediscache: register: output
# resource_group: "{{ resource_group }}"
# name: "{{ redis_name }}" - assert:
# state: absent that:
# register: output - output.changed
# - assert: - name: Delete the redis cache (Check Mode)
# that: azure_rm_rediscache:
# - output.changed resource_group: "{{ resource_group }}"
name: "{{ redis_name }}"
state: absent
check_mode: yes
register: output
- name: assert deleting redis cache check mode
assert:
that: output.changed
- name: Delete the redis cache
azure_rm_rediscache:
resource_group: "{{ resource_group }}"
name: "{{ redis_name }}"
state: absent
register: output
- assert:
that:
- output.changed
tags: [long_run, never]
- name: Create virtual network - name: Create virtual network
azure_rm_virtualnetwork: azure_rm_virtualnetwork:
@ -203,17 +223,6 @@
- facts.rediscaches[0].subnet != None - facts.rediscaches[0].subnet != None
- facts.rediscaches[0].access_keys.primary != None - facts.rediscaches[0].access_keys.primary != None
- name: Wait for Redis provisioning to complete
azure_rm_rediscache_facts:
resource_group: "{{ resource_group }}"
name: "{{ redis_name }}2"
register: facts
until: "{{ facts.rediscaches[0]['provisioning_state'] == 'Succeeded' }}"
retries: 30
delay: 60
tags:
- long_run
- name: Create firewall rule (Check mode) - name: Create firewall rule (Check mode)
azure_rm_rediscachefirewallrule: azure_rm_rediscachefirewallrule:
resource_group: "{{ resource_group }}" resource_group: "{{ resource_group }}"
@ -229,89 +238,83 @@
that: that:
- output.changed - output.changed
- name: long-running rediscachefirewallrule tests [run with `--tags long_run,untagged` to enable]
# Creating firewall rule need Redis status is running, while creating redis Cache costs about 20 mins async operation, # Creating firewall rule need Redis status is running, while creating redis Cache costs about 20 mins async operation,
# need to poll status from Creating to Running, then able to perform firewall rule creating, # need to poll status from Creating to Running, then able to perform firewall rule creating,
# otherwise, will met error: # otherwise, will met error:
# "Error creating/updating Firewall rule of Azure Cache for Redis: Azure Error: Conflict\nMessage: The resource # "Error creating/updating Firewall rule of Azure Cache for Redis: Azure Error: Conflict\nMessage: The resource
# '/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myResourceGroup/providers/Microsoft.Cache/Redis/myRedis' is busy processing # '/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myResourceGroup/providers/Microsoft.Cache/Redis/myRedis' is busy processing
# a previous update request or is undergoing system maintenance. As such, it is currently unable to accept the update request. Please try again later." # a previous update request or is undergoing system maintenance. As such, it is currently unable to accept the update request. Please try again later."
# comment out firewall rule tests for test efficiency. block:
- name: Create firewall rule - name: Wait for Redis provisioning to complete
azure_rm_rediscachefirewallrule: azure_rm_rediscache_facts:
resource_group: "{{ resource_group }}" resource_group: "{{ resource_group }}"
cache_name: "{{ redis_name }}2" name: "{{ redis_name }}2"
name: "{{ rule_name }}" register: facts
start_ip_address: 192.168.1.1 until: facts.rediscaches[0]['provisioning_state'] == 'Succeeded'
end_ip_address: 192.168.1.4 retries: 30
register: output delay: 60
tags:
- long_run - name: Create firewall rule
azure_rm_rediscachefirewallrule:
- name: Assert creation resource_group: "{{ resource_group }}"
assert: cache_name: "{{ redis_name }}2"
that: name: "{{ rule_name }}"
- output.changed start_ip_address: 192.168.1.1
- output.id end_ip_address: 192.168.1.4
tags: register: output
- long_run
- name: Assert creation
- name: Update firewall rule idempotence assert:
azure_rm_rediscachefirewallrule: that:
resource_group: "{{ resource_group }}" - output.changed
cache_name: "{{ redis_name }}2" - output.id
name: "{{ rule_name }}"
start_ip_address: 192.168.1.1 - name: Update firewall rule idempotence
end_ip_address: 192.168.1.4 azure_rm_rediscachefirewallrule:
register: output resource_group: "{{ resource_group }}"
tags: cache_name: "{{ redis_name }}2"
- long_run name: "{{ rule_name }}"
start_ip_address: 192.168.1.1
- name: Assert idempotence end_ip_address: 192.168.1.4
assert: register: output
that:
- output.changed == False - name: Assert idempotence
tags: assert:
- long_run that:
- output.changed == False
- name: Update firewall rule
azure_rm_rediscachefirewallrule: - name: Update firewall rule
resource_group: "{{ resource_group }}" azure_rm_rediscachefirewallrule:
cache_name: "{{ redis_name }}2" resource_group: "{{ resource_group }}"
name: "{{ rule_name }}" cache_name: "{{ redis_name }}2"
end_ip_address: 192.168.1.5 name: "{{ rule_name }}"
register: output end_ip_address: 192.168.1.5
tags: register: output
- long_run
- name: Assert updating
- name: Assert updating assert:
assert: that:
that: - output.changed
- output.changed
tags: - name: Delete firewall rule
- long_run azure_rm_rediscachefirewallrule:
resource_group: "{{ resource_group }}"
- name: Delete firewall rule cache_name: "{{ redis_name }}2"
azure_rm_rediscachefirewallrule: name: "{{ rule_name }}"
resource_group: "{{ resource_group }}" state: absent
cache_name: "{{ redis_name }}2" register: output
name: "{{ rule_name }}"
state: absent - name: Assert deletion
register: output assert:
tags: that:
- long_run - output.changed
- name: Assert deletion - name: Delete the redis cache
assert: azure_rm_rediscache:
that: resource_group: "{{ resource_group }}"
- output.changed name: "{{ redis_name }}2"
tags: state: absent
- long_run register: output
tags: [long_run, never]
- name: Delete the redis cache
azure_rm_rediscache:
resource_group: "{{ resource_group }}"
name: "{{ redis_name }}2"
state: absent
register: output
tags:
- long_run
Write Preview
Loading…
Cancel
Save