@ -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