internet/community.general
3
0
Fork 0
mirror of https://github.com/ansible-collections/community.general.git synced 2026-05-06 21:32:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

New module for managing NetApp E-Series iSCSI Interfaces (#39877)

Browse Source 
* New module for NTAP E-Series iSCSI Interfaces

Define a new module for configuring NetApp E-Series iSCSI interfaces.

* Improve netapp_e_iscsi_interface integration tests

Restructured integration test to set all iscsi ports to disabled, then
defines the ports either statically or with dhcp, next updates the ports
with the other definition type (static <-> dhcp), and lastly disables
all ports.  Each netapp_eseries_iscsi_interface call is verified with the
array.
This commit is contained in:
Michael Price
2018-08-28 11:39:14 -05:00
committed by John R Barker
parent d38bccfc3e
commit 97157cf876
5 changed files with 1112 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
test/integration/targets/netapp_eseries_iscsi_interface/aliases Normal file
View File

@@ -0,0 +1,10 @@
# This test is not enabled by default, but can be utilized by defining required variables in integration_config.yml
# Example integration_config.yml:
# ---
#netapp_e_api_host: 10.113.1.111:8443
#netapp_e_api_username: admin
#netapp_e_api_password: myPass
#netapp_e_ssid: 1
unsupported
netapp/eseries

1
test/integration/targets/netapp_eseries_iscsi_interface/tasks/main.yml Normal file
View File

@@ -0,0 +1 @@
- include_tasks: run.yml

448
test/integration/targets/netapp_eseries_iscsi_interface/tasks/run.yml Normal file
View File

@@ -0,0 +1,448 @@
---
# Test code for the netapp_e_iscsi_interface module
# (c) 2018, NetApp, Inc
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
# ***********************
# *** Local test data ***
# ***********************
- name: NetApp Test iSCSI Interface module
fail:
msg: 'Please define netapp_e_api_username, netapp_e_api_password, netapp_e_api_host, and netapp_e_ssid.'
when: netapp_e_api_username is undefined or netapp_e_api_password is undefined
or netapp_e_api_host is undefined or netapp_e_ssid is undefined
vars:
credentials: &creds
api_url: "https://{{ netapp_e_api_host }}/devmgr/v2"
api_username: "{{ netapp_e_api_username }}"
api_password: "{{ netapp_e_api_password }}"
ssid: "{{ netapp_e_ssid }}"
validate_certs: no
array: &array
subnet: 255.255.255.0
gateway: 10.10.10.1
A:
- channel: 1
max_frame_size: 1500
- channel: 2
max_frame_size: 2000
- channel: 3
max_frame_size: 9000
- channel: 4
max_frame_size: 1500
- channel: 5
max_frame_size: 2000
- channel: 6
max_frame_size: 9000
B:
- channel: 1
max_frame_size: 9000
- channel: 2
max_frame_size: 1500
- channel: 3
max_frame_size: 2000
- channel: 4
max_frame_size: 9000
- channel: 5
max_frame_size: 1500
- channel: 6
max_frame_size: 2000
# ***************************************************
# *** Ensure python jmespath package is installed ***
# ***************************************************
- name: Ensure that jmespath is installed
pip:
name: jmespath
state: enabled
register: jmespath
- fail:
msg: "Restart playbook, the jmespath package was installed and is need for the playbook's execution."
when: jmespath.changed
# ************************************
# *** Set local playbook test data ***
# ************************************
- name: set credentials
set_fact:
credentials: *creds
- name: set array
set_fact:
array: *array
- name: Show some debug information
debug:
msg: "Using user={{ credentials.api_username }} on server={{ credentials.api_url }}."
# *****************************************
# *** Disable all controller A channels ***
# *****************************************
- name: Disable all controller A ports
netapp_e_iscsi_interface:
<<: *creds
controller: "A"
channel: "{{ item.channel }}"
state: disabled
loop: "{{ lookup('list', array.A) }}"
# Delay to give time for the asynchronous symbol call has complete
- pause:
seconds: 30
# Request all controller's iscsi host interface information
- name: Collect iscsi port information
uri:
url: "{{ xpath_filter_url }}?query=controller/hostInterfaces//iscsi"
user: "{{ credentials.api_username }}"
password: "{{ credentials.api_password }}"
body_format: json
validate_certs: no
register: result
vars:
xpath_filter_url: "{{ credentials.api_url }}/storage-systems/{{ credentials.ssid }}/graph/xpath-filter"
# Extract controller A's port information from the iscsi host interfaces list
# Note: min filter is used because there are only two controller ids and the smaller corresponds with controller A
- name: Get controller A's controllerId
set_fact:
controller_a_id: "{{ result | json_query('json[*].controllerId') | min }}"
# Collect all port information associated with controller A
- name: Get controller A's port information
set_fact:
controller_a: "{{ result | json_query(controller_a_query) }}"
vars:
controller_a_query: "json[?controllerId=='{{ controller_a_id }}']"
# Confirm controller A's ports are disabled
- name: Verify all controller A ports are disabled
assert:
that: "{{ item.ipv4Enabled == false }}"
msg: "Controller A, channel {{ item.channel }} is not disabled"
loop: "{{ controller_a }}"
# *****************************************
# *** Disable all controller B channels ***
# *****************************************
- name: Disable all controller B ports
netapp_e_iscsi_interface:
<<: *creds
controller: "B"
channel: "{{ item.channel }}"
state: disabled
loop: "{{ lookup('list', array.B) }}"
# Delay to give time for the asynchronous symbol call has complete
- pause:
seconds: 30
# Request all controller's iscsi host interface information
- name: Collect iscsi port information
uri:
url: "{{ xpath_filter_url }}?query=controller/hostInterfaces//iscsi"
user: "{{ credentials.api_username }}"
password: "{{ credentials.api_password }}"
body_format: json
validate_certs: no
register: result
vars:
xpath_filter_url: "{{ credentials.api_url }}/storage-systems/{{ credentials.ssid }}/graph/xpath-filter"
# Extract controller B's port information from the iscsi host interfaces list
# Note: min filter is used because there are only two controller ids and the smaller corresponds with controller B
- name: Get controller B's controllerId
set_fact:
controller_b_id: "{{ result | json_query('json[*].controllerId') | max }}"
# Collect all port information associated with controller B
- name: Get controller B's port information
set_fact:
controller_b: "{{ result | json_query(controller_b_query) }}"
vars:
controller_b_query: "json[?controllerId=='{{ controller_b_id }}']"
# Confirm controller B's ports are disabled
- name: Verify all controller B ports are disabled
assert:
that: "{{ item.ipv4Enabled == false }}"
msg: "Controller B, channel {{ item.channel }} is not disabled"
loop: "{{ controller_b }}"
# *****************************************************
# *** Configure all controller A's ports statically ***
# *****************************************************
- name: Configure controller A's port to use a static configuration method
netapp_e_iscsi_interface:
<<: *creds
controller: "A"
channel: "{{ item.channel }}"
state: enabled
config_method: static
address: "{{ array.gateway.split('.')[:3] | join('.') }}.{{ item.channel }}"
subnet_mask: "{{ array.subnet }}"
gateway: "{{ array.gateway }}"
max_frame_size: "{{ item.max_frame_size }}"
loop: "{{ lookup('list', array.A) }}"
# Delay to give time for the asynchronous symbol call has complete
- pause:
seconds: 30
# Request a list of iscsi host interfaces
- name: Collect array information
uri:
url: "{{ xpath_filter }}?query=controller/hostInterfaces//iscsi"
user: "{{ credentials.api_username }}"
password: "{{ credentials.api_password }}"
body_format: json
validate_certs: no
register: result
vars:
xpath_filter: "{{ credentials.api_url }}/storage-systems/{{ credentials.ssid }}/graph/xpath-filter"
# Extract controller A's port information from the iscsi host interfaces list
# Note: min filter is used because there are only two controller ids and the smaller corresponds with controller A
- name: Get controller A's controllerId
set_fact:
controller_a_id: "{{ result | json_query('json[*].controllerId') | min }}"
# Compile any iscsi port information associated with controller A
- name: Get controller A's port information
set_fact:
controller_a: "{{ result | json_query(controller_a_query) }}"
vars:
controller_a_query: "json[?controllerId=='{{ controller_a_id }}']"
# Confirm that controller A ports are statically defined with the expected MTU, gateway, subnet and ipv4 address
- name: Verify expected controller A's port configuration
assert:
that: "{{ item[0].channel != item[1].channel or
( item[0].ipv4Data.ipv4AddressConfigMethod == 'configStatic' and
item[0].interfaceData.ethernetData.maximumFramePayloadSize == item[1].max_frame_size and
item[0].ipv4Data.ipv4AddressData.ipv4GatewayAddress == array.gateway and
item[0].ipv4Data.ipv4AddressData.ipv4SubnetMask == array.subnet and
item[0].ipv4Data.ipv4AddressData.ipv4Address == partial_address + item[1].channel | string ) }}"
msg: "Failed to configure controller A, channel {{ item[0].channel }}"
loop: "{{ query('nested', lookup('list', controller_a), lookup('list', array.A) ) }}"
vars:
partial_address: "{{ array.gateway.split('.')[:3] | join('.') + '.' }}"
# *******************************************************************************************
# *** Configure controller B's channels for dhcp and specific frame maximum payload sizes ***
# *******************************************************************************************
- name: Configure controller B's ports to use dhcp with different MTU
netapp_e_iscsi_interface:
<<: *creds
controller: "B"
channel: "{{ item.channel }}"
state: enabled
config_method: dhcp
max_frame_size: "{{ item.max_frame_size }}"
loop: "{{ lookup('list', array.B) }}"
# Delay to give time for the asynchronous symbol call has complete
- pause:
seconds: 30
# request a list of iscsi host interfaces
- name: Collect array information
uri:
url: "{{ xpath_filter_url }}?query=controller/hostInterfaces//iscsi"
user: "{{ credentials.api_username }}"
password: "{{ credentials.api_password }}"
body_format: json
validate_certs: no
register: result
vars:
xpath_filter_url: "{{ credentials.api_url }}/storage-systems/{{ credentials.ssid }}/graph/xpath-filter"
# Extract controller B's port information from the iscsi host interfaces list
# Note: max filter is used because there are only two controller ids and the larger corresponds with controller B
- name: Get controller B's controllerId
set_fact:
controller_b_id: "{{ result | json_query('json[*].controllerId') | max }}"
- name: Get controller B port information list
set_fact:
controller_b: "{{ result | json_query(controller_b_query) }}"
vars:
controller_b_query: "json[?controllerId=='{{ controller_b_id }}']"
# Using a nested loop of array information and expected information, verify that each channel has the appropriate max
# frame payload size and is configured for dhcp
- name: Verify expected controller B's port configuration
assert:
that: "{{ item[0].channel != item[1].channel or
( item[0].ipv4Data.ipv4AddressConfigMethod == 'configDhcp' and
item[0].interfaceData.ethernetData.maximumFramePayloadSize == item[1].max_frame_size ) }}"
msg: >
Failed to configure controller channel {{ item[0].channel }} for dhcp
and/or maximum frame size of {{ item[1].max_frame_size }}!
loop: "{{ query('nested', lookup('list', controller_b), lookup('list', array.B)) }}"
# *******************************************************************************************
# *** Configure controller A's channels for dhcp and specific frame maximum payload sizes ***
# *******************************************************************************************
- name: Configure controller A's ports to use dhcp with different MTU
netapp_e_iscsi_interface:
<<: *creds
controller: "A"
channel: "{{ item.channel }}"
state: enabled
config_method: dhcp
max_frame_size: "{{ item.max_frame_size }}"
loop: "{{ lookup('list', array.A) }}"
# Delay to give time for the asynchronous symbol call has complete
- pause:
seconds: 30
# Request a list of iscsi host interfaces
- name: Collect array information
uri:
url: "{{ xpath_filter_url }}?query=controller/hostInterfaces//iscsi"
user: "{{ credentials.api_username }}"
password: "{{ credentials.api_password }}"
body_format: json
validate_certs: no
register: result
vars:
xpath_filter_url: "{{ credentials.api_url }}/storage-systems/{{ credentials.ssid }}/graph/xpath-filter"
# Extract controller A's port information from the iscsi host interfaces list
# Note: min filter is used because there are only two controller ids and the larger corresponds with controller A
- name: Get controller A's controllerId
set_fact:
controller_a_id: "{{ result | json_query('json[*].controllerId') | min }}"
- name: Get controller A port information list
set_fact:
controller_a: "{{ result | json_query(controller_a_query) }}"
vars:
controller_a_query: "json[?controllerId=='{{ controller_a_id }}']"
# Using a nested loop of array information and expected information, verify that each channel has the appropriate max
# frame payload size and is configured for dhcp
- name: Verify expected controller A's port configuration
assert:
that: "{{ item[0].channel != item[1].channel or
( item[0].ipv4Data.ipv4AddressConfigMethod == 'configDhcp' and
item[0].interfaceData.ethernetData.maximumFramePayloadSize == item[1].max_frame_size ) }}"
msg: >
Failed to configure controller channel {{ item[0].channel }} for dhcp
and/or maximum frame size of {{ item[1].max_frame_size }}!
loop: "{{ query('nested', lookup('list', controller_a), lookup('list', array.A)) }}"
# *****************************************************
# *** Configure all controller B's ports statically ***
# *****************************************************
- name: Configure controller B's ports to use a static configuration method
netapp_e_iscsi_interface:
<<: *creds
controller: "B"
channel: "{{ item.channel }}"
state: enabled
config_method: static
address: "{{ array.gateway.split('.')[:3] | join('.') }}.{{ item.channel }}"
subnet_mask: "{{ array.subnet }}"
gateway: "{{ array.gateway }}"
max_frame_size: "{{ item.max_frame_size }}"
loop: "{{ lookup('list', array.B) }}"
# Delay to give time for the asynchronous symbol call has complete
- pause:
seconds: 30
# request a list of iscsi host interfaces
- name: Collect array information
uri:
url: "{{ xpath_filter }}?query=controller/hostInterfaces//iscsi"
user: "{{ credentials.api_username }}"
password: "{{ credentials.api_password }}"
body_format: json
validate_certs: no
register: result
vars:
xpath_filter: "{{ credentials.api_url }}/storage-systems/{{ credentials.ssid }}/graph/xpath-filter"
# Extract controller B's port information from the iscsi host interfaces list
# Note: min filter is used because there are only two controller ids and the smaller corresponds with controller B
- name: Get controller B's controllerId
set_fact:
controller_b_id: "{{ result | json_query('json[*].controllerId') | max }}"
# Compile any iscsi port information associated with controller B
- name: Get controller B's port information
set_fact:
controller_b: "{{ result | json_query(controller_b_query) }}"
vars:
controller_b_query: "json[?controllerId=='{{ controller_b_id }}']"
# Confirm that controller B ports are statically defined with the expected MTU, gateway, subnet and ipv4 address
- name: Verify expected controller B's port configuration
assert:
that: "{{ item[0].channel != item[1].channel or
( item[0].ipv4Data.ipv4AddressConfigMethod == 'configStatic' and
item[0].interfaceData.ethernetData.maximumFramePayloadSize == item[1].max_frame_size and
item[0].ipv4Data.ipv4AddressData.ipv4GatewayAddress == array.gateway and
item[0].ipv4Data.ipv4AddressData.ipv4SubnetMask == array.subnet and
item[0].ipv4Data.ipv4AddressData.ipv4Address == partial_address + item[1].channel | string ) }}"
msg: "Failed to configure controller B, channel {{ item[0].channel }}"
loop: "{{ query('nested', lookup('list', controller_b), lookup('list', array.B) ) }}"
vars:
partial_address: "{{ array.gateway.split('.')[:3] | join('.') + '.' }}"
# **************************************
# *** Disable all controller B ports ***
# **************************************
- name: Disable all controller B's ports
netapp_e_iscsi_interface:
<<: *creds
controller: "B"
channel: "{{ item.channel }}"
state: disabled
loop: "{{ lookup('list', array.B) }}"
# Delay to give time for the asynchronous symbol call has complete
- pause:
seconds: 30
# Request controller iscsi host interface information
- name: Collect iscsi port information
uri:
url: "{{ xpath_filter_url }}?query=controller/hostInterfaces//iscsi"
user: "{{ credentials.api_username }}"
password: "{{ credentials.api_password }}"
body_format: json
validate_certs: no
register: result
vars:
xpath_filter_url: "{{ credentials.api_url }}/storage-systems/{{ credentials.ssid }}/graph/xpath-filter"
# Extract controller A's port information from the iscsi host interfaces list
# Note: min filter is used because there are only two controller ids and the smaller corresponds with controller B
- name: Get controller B's controllerId
set_fact:
controller_b_id: "{{ result | json_query('json[*].controllerId') | max }}"
# Compile any iscsi port information associated with controller B
- name: Get controller B's port information
set_fact:
controller_b: "{{ result | json_query(controller_b_query) }}"
vars:
controller_b_query: "json[?controllerId=='{{ controller_b_id }}']"
# Confirm that all of controller B's ports are disabled
- name: Verify all controller B ports are disabled
assert:
that: "{{ item.ipv4Enabled == false }}"
msg: "Controller B, channel {{ item.channel }} is not disabled"
loop: "{{ controller_b }}"

255
test/units/modules/storage/netapp/test_netapp_e_iscsi_interface.py Normal file
View File

@@ -0,0 +1,255 @@
# (c) 2018, NetApp Inc.
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from mock import MagicMock
from ansible.module_utils import basic, netapp
from ansible.modules.storage.netapp import netapp_e_host
from ansible.modules.storage.netapp.netapp_e_host import Host
from ansible.modules.storage.netapp.netapp_e_iscsi_interface import IscsiInterface
from units.modules.utils import AnsibleExitJson, AnsibleFailJson, ModuleTestCase, set_module_args
__metaclass__ = type
import unittest
import mock
import pytest
import json
from ansible.compat.tests.mock import patch
from ansible.module_utils._text import to_bytes
class IscsiInterfaceTest(ModuleTestCase):
REQUIRED_PARAMS = {
'api_username': 'rw',
'api_password': 'password',
'api_url': 'http://localhost',
'ssid': '1',
'state': 'disabled',
'name': 1,
'controller': 'A',
}
REQ_FUNC = 'ansible.modules.storage.netapp.netapp_e_iscsi_interface.request'
def _set_args(self, args=None):
module_args = self.REQUIRED_PARAMS.copy()
if args is not None:
module_args.update(args)
set_module_args(module_args)
def test_validate_params(self):
"""Ensure we can pass valid parameters to the module"""
# Provide a range of valid values for each
for controller in ['A', 'B']:
for i in range(1, 10):
for mtu in [1500, 2500, 9000]:
self._set_args(dict(
state='disabled',
name=i,
controller=controller,
mtu=mtu,
))
iface = IscsiInterface()
def test_invalid_params(self):
"""Ensure that our input validation catches invalid parameters"""
# Currently a 'C' controller is invalid
self._set_args(dict(
state='disabled',
name=1,
controller="C",
))
with self.assertRaises(AnsibleFailJson) as result:
iface = IscsiInterface()
# Each of these mtu values are invalid
for mtu in [500, 1499, 9001]:
self._set_args({
'state': 'disabled',
'name': 1,
'controller': 'A',
'mtu': mtu
})
with self.assertRaises(AnsibleFailJson) as result:
iface = IscsiInterface()
def test_interfaces(self):
"""Validate that we are processing the interface list properly"""
self._set_args()
interfaces = [
dict(interfaceType='iscsi',
iscsi=dict()),
dict(interfaceType='iscsi',
iscsi=dict()),
dict(interfaceType='fc', )
]
# Ensure we filter out anything without an interfaceType of iscsi
expected = [iface['iscsi'] for iface in interfaces if iface['interfaceType'] == 'iscsi']
# We expect a single call to the API: retrieve the list of interfaces from the objectGraph.
with mock.patch(self.REQ_FUNC, return_value=(200, interfaces)):
iface = IscsiInterface()
interfaces = iface.interfaces
self.assertEquals(interfaces, expected)
def test_interfaces_fail(self):
"""Ensure we fail gracefully on an error to retrieve the interfaces"""
self._set_args()
with self.assertRaises(AnsibleFailJson) as result:
# Simulate a failed call to the API
with mock.patch(self.REQ_FUNC, side_effect=Exception("Failure")):
iface = IscsiInterface()
interfaces = iface.interfaces
def test_fetch_target_interface_bad_channel(self):
"""Ensure we fail correctly when a bad channel is provided"""
self._set_args()
interfaces = list(dict(channel=1, controllerId='1'))
with self.assertRaisesRegexp(AnsibleFailJson, r".*?channels include.*"):
with mock.patch.object(IscsiInterface, 'interfaces', return_value=interfaces):
iface = IscsiInterface()
interfaces = iface.fetch_target_interface()
def test_make_update_body_dhcp(self):
"""Ensure the update body generates correctly for a transition from static to dhcp"""
self._set_args(dict(state='enabled',
config_method='dhcp')
)
iface = dict(id='1',
ipv4Enabled=False,
ipv4Data=dict(ipv4AddressData=dict(ipv4Address="0.0.0.0",
ipv4SubnetMask="0.0.0.0",
ipv4GatewayAddress="0.0.0.0", ),
ipv4AddressConfigMethod='configStatic', ),
interfaceData=dict(ethernetData=dict(maximumFramePayloadSize=1500, ), ),
)
# Test a transition from static to dhcp
inst = IscsiInterface()
update, body = inst.make_update_body(iface)
self.assertTrue(update, msg="An update was expected!")
self.assertEquals(body['settings']['ipv4Enabled'][0], True)
self.assertEquals(body['settings']['ipv4AddressConfigMethod'][0], 'configDhcp')
def test_make_update_body_static(self):
"""Ensure the update body generates correctly for a transition from dhcp to static"""
iface = dict(id='1',
ipv4Enabled=False,
ipv4Data=dict(ipv4AddressConfigMethod='configDhcp',
ipv4AddressData=dict(ipv4Address="0.0.0.0",
ipv4SubnetMask="0.0.0.0",
ipv4GatewayAddress="0.0.0.0", ), ),
interfaceData=dict(ethernetData=dict(maximumFramePayloadSize=1500, ), ), )
self._set_args(dict(state='enabled',
config_method='static',
address='10.10.10.10',
subnet_mask='255.255.255.0',
gateway='1.1.1.1'))
inst = IscsiInterface()
update, body = inst.make_update_body(iface)
self.assertTrue(update, msg="An update was expected!")
self.assertEquals(body['settings']['ipv4Enabled'][0], True)
self.assertEquals(body['settings']['ipv4AddressConfigMethod'][0], 'configStatic')
self.assertEquals(body['settings']['ipv4Address'][0], '10.10.10.10')
self.assertEquals(body['settings']['ipv4SubnetMask'][0], '255.255.255.0')
self.assertEquals(body['settings']['ipv4GatewayAddress'][0], '1.1.1.1')
CONTROLLERS = dict(A='1', B='2')
def test_update_bad_controller(self):
"""Ensure a bad controller fails gracefully"""
self._set_args(dict(controller='B'))
inst = IscsiInterface()
with self.assertRaises(AnsibleFailJson) as result:
with mock.patch.object(inst, 'get_controllers', return_value=dict(A='1')) as get_controllers:
inst()
@mock.patch.object(IscsiInterface, 'get_controllers', return_value=CONTROLLERS)
def test_update(self, get_controllers):
"""Validate the good path"""
self._set_args()
inst = IscsiInterface()
with self.assertRaises(AnsibleExitJson):
with mock.patch(self.REQ_FUNC, return_value=(200, "")) as request:
with mock.patch.object(inst, 'fetch_target_interface', side_effect=[{}, mock.MagicMock()]):
with mock.patch.object(inst, 'make_update_body', return_value=(True, {})):
inst()
request.assert_called_once()
@mock.patch.object(IscsiInterface, 'get_controllers', return_value=CONTROLLERS)
def test_update_not_required(self, get_controllers):
"""Ensure we don't trigger the update if one isn't required or if check mode is enabled"""
self._set_args()
# make_update_body will report that no change is required, so we should see no call to the API.
inst = IscsiInterface()
with self.assertRaises(AnsibleExitJson) as result:
with mock.patch(self.REQ_FUNC, return_value=(200, "")) as request:
with mock.patch.object(inst, 'fetch_target_interface', side_effect=[{}, mock.MagicMock()]):
with mock.patch.object(inst, 'make_update_body', return_value=(False, {})):
inst()
request.assert_not_called()
self.assertFalse(result.exception.args[0]['changed'], msg="No change was expected.")
# Since check_mode is enabled, we will run everything normally, but not make a request to the API
# to perform the actual change.
inst = IscsiInterface()
inst.check_mode = True
with self.assertRaises(AnsibleExitJson) as result:
with mock.patch(self.REQ_FUNC, return_value=(200, "")) as request:
with mock.patch.object(inst, 'fetch_target_interface', side_effect=[{}, mock.MagicMock()]):
with mock.patch.object(inst, 'make_update_body', return_value=(True, {})):
inst()
request.assert_not_called()
self.assertTrue(result.exception.args[0]['changed'], msg="A change was expected.")
@mock.patch.object(IscsiInterface, 'get_controllers', return_value=CONTROLLERS)
def test_update_fail_busy(self, get_controllers):
"""Ensure we fail correctly on receiving a busy response from the API."""
self._set_args()
inst = IscsiInterface()
with self.assertRaisesRegexp(AnsibleFailJson, r".*?busy.*") as result:
with mock.patch(self.REQ_FUNC, return_value=(422, dict(retcode="3"))) as request:
with mock.patch.object(inst, 'fetch_target_interface', side_effect=[{}, mock.MagicMock()]):
with mock.patch.object(inst, 'make_update_body', return_value=(True, {})):
inst()
request.assert_called_once()
@mock.patch.object(IscsiInterface, 'get_controllers', return_value=CONTROLLERS)
@mock.patch.object(IscsiInterface, 'make_update_body', return_value=(True, {}))
def test_update_fail(self, get_controllers, make_body):
"""Ensure we fail correctly on receiving a normal failure from the API."""
self._set_args()
inst = IscsiInterface()
# Test a 422 error with a non-busy status
with self.assertRaisesRegexp(AnsibleFailJson, r".*?Failed to modify.*") as result:
with mock.patch(self.REQ_FUNC, return_value=(422, mock.MagicMock())) as request:
with mock.patch.object(inst, 'fetch_target_interface', side_effect=[{}, mock.MagicMock()]):
inst()
request.assert_called_once()
# Test a 401 (authentication) error
with self.assertRaisesRegexp(AnsibleFailJson, r".*?Failed to modify.*") as result:
with mock.patch(self.REQ_FUNC, return_value=(401, mock.MagicMock())) as request:
with mock.patch.object(inst, 'fetch_target_interface', side_effect=[{}, mock.MagicMock()]):
inst()
request.assert_called_once()
# Test with a connection failure
with self.assertRaisesRegexp(AnsibleFailJson, r".*?Connection failure.*") as result:
with mock.patch(self.REQ_FUNC, side_effect=Exception()) as request:
with mock.patch.object(inst, 'fetch_target_interface', side_effect=[{}, mock.MagicMock()]):
inst()
request.assert_called_once()