Modules to manage ICX devices (#58969)

* new module

* new terminal

* new terminal

* new cliconf

* cliconf

* icx cliconf

* icx_cliconf

* icx test units module

* icx units module

* icx banner unit test

* PR changes resolved

* changes resolved

* Changes Resolved

* check_running_config changes resolved

* added notes

* removed icx rst

* new commit

* new changes

* deleted icx rst

* icx .rst

* modified platform_index.rst

* modified platform_index.rst

* changes resolved

* PR comments resolved

* Update platform_index.rst

PR comment resolved

.github/BOTMETA.yml

@@ -334,6 +334,7 @@ files:
     maintainers: $team_iosxr
   $modules/network/ironware/: paulquack
   $modules/network/junos/: Qalthos ganeshrn
+  $modules/network/icx/: sushma-alethea
   $modules/network/layer2/: $team_networking
   $modules/network/layer3/: $team_networking
   $modules/network/meraki/: &meraki

docs/docsite/rst/network/user_guide/platform_icx.rst

@@ -0,0 +1,69 @@
+.. _icx_platform_options:
+
+***************************************
+ICX Platform Options
+***************************************
+
+ICX supports Enable Mode (Privilege Escalation). This page offers details on how to use Enable Mode on ICX in Ansible.
+
+.. contents:: Topics
+
+Connections Available
+================================================================================
+
++---------------------------+-----------------------------------------------+
+|..                         | CLI                                           |
++===========================+===============================================+
+| **Protocol**              |  SSH                                          |
++---------------------------+-----------------------------------------------+
+| | **Credentials**         | | uses SSH keys / SSH-agent if present        |
+| |                         | | accepts ``-u myuser -k`` if using password  |
++---------------------------+-----------------------------------------------+
+| **Indirect Access**       | via a bastion (jump host)                     |
++---------------------------+-----------------------------------------------+
+| | **Connection Settings** | | ``ansible_connection: network_cli``         |
+| |                         | |                                             |
+| |                         | |                                             |
++---------------------------+-----------------------------------------------+
+| | **Enable Mode**         | | supported - use ``ansible_become: yes``     |
+| | (Privilege Escalation)  | | with ``ansible_become_method: enable``      |
+| |                         | | and ``ansible_become_password:``            |
++---------------------------+-----------------------------------------------+
+| **Returned Data Format**  | ``stdout[0].``                                |
++---------------------------+-----------------------------------------------+
+
+
+Using CLI in Ansible
+====================
+
+Example CLI ``group_vars/icx.yml``
+----------------------------------
+
+.. code-block:: yaml
+
+   ansible_connection: network_cli
+   ansible_network_os: icx
+   ansible_user: myuser
+   ansible_password: !vault...
+   ansible_become: yes
+   ansible_become_method: enable
+   ansible_become_password: !vault...
+   ansible_ssh_common_args: '-o ProxyCommand="ssh -W %h:%p -q bastion01"'
+
+
+- If you are using SSH keys (including an ssh-agent) you can remove the ``ansible_password`` configuration.
+- If you are accessing your host directly (not through a bastion/jump host) you can remove the ``ansible_ssh_common_args`` configuration.
+- If you are accessing your host through a bastion/jump host, you cannot include your SSH password in the ``ProxyCommand`` directive. To prevent secrets from leaking out (for example in ``ps`` output), SSH does not support providing passwords via environment variables.
+
+Example CLI Task
+----------------
+
+.. code-block:: yaml
+
+   - name: Backup current switch config (icx)
+     icx_config:
+       backup: yes
+     register: backup_icx_location
+     when: ansible_network_os == 'icx'
+
+.. include:: shared_snippets/SSH_warning.txt

docs/docsite/rst/network/user_guide/platform_index.rst

@@ -17,6 +17,7 @@ Some Ansible Network platforms support multiple connection types, privilege esca
    platform_enos
    platform_eos
    platform_exos
+   platform_icx
    platform_ios
    platform_ironware
    platform_junos
@@ -80,6 +81,8 @@ Settings by Platform
 +-------------------+-------------------------+-------------+---------+---------+----------+
 | Pluribus Netvisor | ``netvisor``            | ✓           |         |         |          |
 +-------------------+-------------------------+-------------+---------+---------+----------+
+| Ruckus ICX*       | ``icx``                 | ✓           |         |         |          |
++-------------------+-------------------------+-------------+---------+---------+----------+
 | VyOS*             | ``vyos``                | ✓           |         |         | ✓        |
 +-------------------+-------------------------+-------------+---------+---------+----------+
 | OS that supports  | ``<network-os>``        |             | ✓       |         | ✓        |

lib/ansible/module_utils/network/icx/icx.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+# Copyright: (c) 2019, Ansible Project
+# Simplified BSD License (see licenses/simplified_bsd.txt or https://opensource.org/licenses/BSD-2-Clause)
+
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+import json
+from ansible.module_utils._text import to_text
+from ansible.module_utils.basic import env_fallback
+from ansible.module_utils.network.common.utils import to_list
+from ansible.module_utils.connection import Connection, ConnectionError
+
+_DEVICE_CONFIGS = {}
+
+
+def get_connection(module):
+    return Connection(module._socket_path)
+
+
+def load_config(module, commands):
+    connection = get_connection(module)
+
+    try:
+        resp = connection.edit_config(candidate=commands)
+        return resp.get('response')
+    except ConnectionError as exc:
+        module.fail_json(msg=to_text(exc))
+
+
+def run_commands(module, commands, check_rc=True):
+    connection = get_connection(module)
+    try:
+        return connection.run_commands(commands=commands, check_rc=check_rc)
+    except ConnectionError as exc:
+        module.fail_json(msg=to_text(exc))
+
+
+def exec_scp(module, command):
+    connection = Connection(module._socket_path)
+    return connection.scp(**command)
+
+
+def get_config(module, flags=None, compare=None):
+    flag_str = ' '.join(to_list(flags))
+    try:
+        return _DEVICE_CONFIGS[flag_str]
+    except KeyError:
+        connection = get_connection(module)
+        try:
+            out = connection.get_config(flags=flags, compare=compare)
+        except ConnectionError as exc:
+            module.fail_json(msg=to_text(exc, errors='surrogate_then_replace'))
+        cfg = to_text(out, errors='surrogate_then_replace').strip()
+        _DEVICE_CONFIGS[flag_str] = cfg
+        return cfg
+
+
+def check_args(module, warnings):
+    pass
+
+
+def get_defaults_flag(module):
+    connection = get_connection(module)
+    try:
+        out = connection.get_defaults_flag()
+    except ConnectionError as exc:
+        module.fail_json(msg=to_text(exc, errors='surrogate_then_replace'))
+    return to_text(out, errors='surrogate_then_replace').strip()

lib/ansible/modules/network/icx/icx_banner.py

@@ -0,0 +1,216 @@
+#!/usr/bin/python
+# Copyright: Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+
+ANSIBLE_METADATA = {'metadata_version': '1.1',
+                    'status': ['preview'],
+                    'supported_by': 'community'}
+
+
+DOCUMENTATION = """
+---
+module: icx_banner
+version_added: "2.9"
+author: "Ruckus Wireless (@Commscope)"
+short_description: Manage multiline banners on Ruckus ICX 7000 series switches
+description:
+  - This will configure both login and motd banners on remote
+    ruckus ICX 7000 series switches. It allows playbooks to add or remove
+    banner text from the active running configuration.
+notes:
+  - Tested against ICX 10.1
+options:
+  banner:
+    description:
+      - Specifies which banner should be configured on the remote device.
+    type: str
+    required: true
+    choices: ['motd', 'exec', 'incoming']
+  text:
+    description:
+      - The banner text that should be
+        present in the remote device running configuration.
+        This argument accepts a multiline string, with no empty lines.
+    type: str
+  state:
+    description:
+      - Specifies whether or not the configuration is
+        present in the current devices active running configuration.
+    type: str
+    default: present
+    choices: ['present', 'absent']
+  enterkey:
+    description:
+      - Specifies whether or not the motd configuration should accept
+        the require-enter-key
+    type: bool
+    default: no
+  check_running_config:
+    description:
+      - Check running configuration. This can be set as environment variable.
+       Module will use environment variable value(default:True), unless it is overriden,
+       by specifying it as module parameter.
+    type: bool
+    default: yes
+
+"""
+
+EXAMPLES = """
+- name: configure the motd banner
+  icx_banner:
+    banner: motd
+    text: |
+        this is my motd banner
+        that contains a multiline
+        string
+    state: present
+
+- name: remove the motd banner
+  icx_banner:
+    banner: motd
+    state: absent
+
+- name: configure require-enter-key for motd
+  icx_banner:
+    banner: motd
+    enterkey: True
+
+- name: remove require-enter-key for motd
+  icx_banner:
+    banner: motd
+    enterkey: False
+"""
+
+RETURN = """
+commands:
+ description: The list of configuration mode commands to send to the device
+ returned: always
+ type: list
+ sample:
+    - banner motd
+    - this is my motd banner
+    - that contains a multiline
+    - string
+"""
+
+import re
+from ansible.module_utils._text import to_text
+from ansible.module_utils.connection import exec_command
+from ansible.module_utils.basic import AnsibleModule, env_fallback
+from ansible.module_utils.network.icx.icx import load_config, get_config
+from ansible.module_utils.connection import Connection, ConnectionError
+
+
+def map_obj_to_commands(updates, module):
+    commands = list()
+    state = module.params['state']
+    want, have = updates
+
+    if module.params['banner'] != 'motd' and module.params['enterkey']:
+        module.fail_json(msg=module.params['banner'] + " banner can have text only, got enterkey")
+
+    if state == 'absent':
+        if 'text' in have.keys() and have['text']:
+            commands.append('no banner %s' % module.params['banner'])
+        if(module.params['enterkey'] is False):
+            commands.append('no banner %s require-enter-key' % module.params['banner'])
+
+    elif state == 'present':
+        if module.params['text'] is None and module.params['enterkey'] is None:
+            module.fail_json(msg=module.params['banner'] + " one of the following is required: text, enterkey:only if motd")
+
+        if module.params["banner"] == "motd" and want['enterkey'] != have['enterkey']:
+            if(module.params['enterkey']):
+                commands.append('banner %s require-enter-key' % module.params['banner'])
+
+        if want['text'] and (want['text'] != have.get('text')):
+            module.params["enterkey"] = None
+            banner_cmd = 'banner %s' % module.params['banner']
+            banner_cmd += ' $\n'
+            banner_cmd += module.params['text'].strip()
+            banner_cmd += '\n$'
+            commands.append(banner_cmd)
+    return commands
+
+
+def map_config_to_obj(module):
+    compare = module.params.get('check_running_config')
+    obj = {'banner': module.params['banner'], 'state': 'absent', 'enterkey': False}
+    exec_command(module, 'skip')
+    output_text = ''
+    output_re = ''
+    out = get_config(module, flags=['| begin banner %s'
+                                    % module.params['banner']], compare=module.params['check_running_config'])
+    if out:
+        try:
+            output_re = re.search(r'banner %s( require-enter-key)' % module.params['banner'], out, re.S).group(0)
+            obj['enterkey'] = True
+        except BaseException:
+            pass
+        try:
+            output_text = re.search(r'banner %s (\$([^\$])+\$){1}' % module.params['banner'], out, re.S).group(1).strip('$\n')
+        except BaseException:
+            pass
+
+    else:
+        output_text = None
+    if output_text:
+        obj['text'] = output_text
+        obj['state'] = 'present'
+    if module.params['check_running_config'] is False:
+        obj = {'banner': module.params['banner'], 'state': 'absent', 'enterkey': False, 'text': 'JUNK'}
+    return obj
+
+
+def map_params_to_obj(module):
+    text = module.params['text']
+    if text:
+        text = str(text).strip()
+
+    return {
+        'banner': module.params['banner'],
+        'text': text,
+        'state': module.params['state'],
+        'enterkey': module.params['enterkey']
+    }
+
+
+def main():
+    """entry point for module execution
+    """
+    argument_spec = dict(
+        banner=dict(required=True, choices=['motd', 'exec', 'incoming']),
+        text=dict(),
+        enterkey=dict(type='bool'),
+        state=dict(default='present', choices=['present', 'absent']),
+        check_running_config=dict(default=True, type='bool', fallback=(env_fallback, ['ANSIBLE_CHECK_ICX_RUNNING_CONFIG']))
+    )
+
+    required_one_of = [['text', 'enterkey', 'state']]
+    module = AnsibleModule(argument_spec=argument_spec,
+                           required_one_of=required_one_of,
+                           supports_check_mode=True)
+
+    warnings = list()
+    results = {'changed': False}
+
+    want = map_params_to_obj(module)
+    have = map_config_to_obj(module)
+    commands = map_obj_to_commands((want, have), module)
+    results['commands'] = commands
+
+    if commands:
+        if not module.check_mode:
+            response = load_config(module, commands)
+
+        results['changed'] = True
+
+    module.exit_json(**results)
+
+
+if __name__ == '__main__':
+    main()

lib/ansible/plugins/cliconf/icx.py

@@ -0,0 +1,315 @@
+# Copyright: (c) 2019, Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = """
+---
+author: Ruckus Wireless (@Commscope)
+cliconf: icx
+short_description: Use icx cliconf to run command on Ruckus ICX platform
+description:
+  - This icx plugin provides low level abstraction APIs for
+    sending and receiving CLI commands from Ruckus ICX network devices.
+version_added: "2.9"
+"""
+
+
+import re
+import time
+import json
+import os
+
+from itertools import chain
+from ansible.errors import AnsibleConnectionFailure
+from ansible.module_utils._text import to_text
+from ansible.module_utils.six import iteritems
+from ansible.module_utils.network.common.config import NetworkConfig, dumps
+from ansible.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+from ansible.module_utils.common._collections_compat import Mapping
+
+
+class Cliconf(CliconfBase):
+
+    @enable_mode
+    def get_config(self, source='running', flags=None, format=None, compare=None):
+        if source not in ('running', 'startup'):
+            raise ValueError("fetching configuration from %s is not supported" % source)
+
+        if format:
+            raise ValueError("'format' value %s is not supported for get_config" % format)
+
+        if not flags:
+            flags = []
+
+        if compare is False:
+            return ''
+        else:
+            if source == 'running':
+                cmd = 'show running-config '
+            else:
+                cmd = 'show configuration '
+
+            cmd += ' '.join(to_list(flags))
+            cmd = cmd.strip()
+
+            return self.send_command(cmd)
+
+    def get_diff(self, candidate=None, running=None, diff_match='line', diff_ignore_lines=None, path=None, diff_replace='line'):
+        """
+        Generate diff between candidate and running configuration. If the
+        remote host supports onbox diff capabilities ie. supports_onbox_diff in that case
+        candidate and running configurations are not required to be passed as argument.
+        In case if onbox diff capability is not supported candidate argument is mandatory
+        and running argument is optional.
+        :param candidate: The configuration which is expected to be present on remote host.
+        :param running: The base configuration which is used to generate diff.
+        :param diff_match: Instructs how to match the candidate configuration with current device configuration
+                      Valid values are 'line', 'strict', 'exact', 'none'.
+                      'line' - commands are matched line by line
+                      'strict' - command lines are matched with respect to position
+                      'exact' - command lines must be an equal match
+                      'none' - will not compare the candidate configuration with the running configuration
+        :param diff_ignore_lines: Use this argument to specify one or more lines that should be
+                                  ignored during the diff.  This is used for lines in the configuration
+                                  that are automatically updated by the system.  This argument takes
+                                  a list of regular expressions or exact line matches.
+        :param path: The ordered set of parents that uniquely identify the section or hierarchy
+                     the commands should be checked against.  If the parents argument
+                     is omitted, the commands are checked against the set of top
+                    level or global commands.
+        :param diff_replace: Instructs on the way to perform the configuration on the device.
+                        If the replace argument is set to I(line) then the modified lines are
+                        pushed to the device in configuration mode.  If the replace argument is
+                        set to I(block) then the entire command block is pushed to the device in
+                        configuration mode if any line is not correct.
+        :return: Configuration diff in  json format.
+               {
+                   'config_diff': '',
+                   'banner_diff': {}
+               }
+
+        """
+        diff = {}
+        device_operations = self.get_device_operations()
+        option_values = self.get_option_values()
+
+        if candidate is None and device_operations['supports_generate_diff']:
+            raise ValueError("candidate configuration is required to generate diff")
+
+        if diff_match not in option_values['diff_match']:
+            raise ValueError("'match' value %s in invalid, valid values are %s" % (diff_match, ', '.join(option_values['diff_match'])))
+
+        if diff_replace not in option_values['diff_replace']:
+            raise ValueError("'replace' value %s in invalid, valid values are %s" % (diff_replace, ', '.join(option_values['diff_replace'])))
+
+        # prepare candidate configuration
+        candidate_obj = NetworkConfig(indent=1)
+        want_src, want_banners = self._extract_banners(candidate)
+        candidate_obj.load(want_src)
+
+        if running and diff_match != 'none':
+            # running configuration
+            have_src, have_banners = self._extract_banners(running)
+
+            running_obj = NetworkConfig(indent=1, contents=have_src, ignore_lines=diff_ignore_lines)
+            configdiffobjs = candidate_obj.difference(running_obj, path=path, match=diff_match, replace=diff_replace)
+
+        else:
+            configdiffobjs = candidate_obj.items
+            have_banners = {}
+
+        diff['config_diff'] = dumps(configdiffobjs, 'commands') if configdiffobjs else ''
+
+        banners = self._diff_banners(want_banners, have_banners)
+        diff['banner_diff'] = banners if banners else {}
+        return diff
+
+    @enable_mode
+    def edit_config(self, candidate=None, commit=True, replace=None, comment=None):
+        resp = {}
+        operations = self.get_device_operations()
+        self.check_edit_config_capability(operations, candidate, commit, replace, comment)
+
+        results = []
+        requests = []
+        if commit:
+            prompt = self._connection.get_prompt()
+            if (b'(config-if' in prompt) or (b'(config' in prompt) or (b'(config-lag-if' in prompt):
+                self.send_command('end')
+
+            self.send_command('configure terminal')
+
+            for line in to_list(candidate):
+                if not isinstance(line, Mapping):
+                    line = {'command': line}
+
+                cmd = line['command']
+                if cmd != 'end' and cmd[0] != '!':
+                    results.append(self.send_command(**line))
+                    requests.append(cmd)
+
+            self.send_command('end')
+        else:
+            raise ValueError('check mode is not supported')
+
+        resp['request'] = requests
+        resp['response'] = results
+        return resp
+
+    def get(self, command=None, prompt=None, answer=None, sendonly=False, output=None, check_all=False):
+        if not command:
+            raise ValueError('must provide value of command to execute')
+        if output:
+            raise ValueError("'output' value %s is not supported for get" % output)
+
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, check_all=check_all)
+
+    def scp(self, command=None, scp_user=None, scp_pass=None):
+        if not command:
+            raise ValueError('must provide value of command to execute')
+        prompt = ["User name:", "Password:"]
+        if(scp_pass is None):
+            answer = [scp_user, self._connection._play_context.password]
+        else:
+            answer = [scp_user, scp_pass]
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=False, check_all=True)
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'icx'
+        reply = self.get(command='show version')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'Version (\S+)', data)
+        if match:
+            device_info['network_os_version'] = match.group(1).strip(',')
+
+        match = re.search(r'^Cisco (.+) \(revision', data, re.M)
+        if match:
+            device_info['network_os_model'] = match.group(1)
+
+        match = re.search(r'^(.+) uptime', data, re.M)
+        if match:
+            device_info['network_os_hostname'] = match.group(1)
+
+        return device_info
+
+    def get_device_operations(self):
+        return {
+            'supports_diff_replace': True,
+            'supports_commit': False,
+            'supports_rollback': False,
+            'supports_defaults': True,
+            'supports_onbox_diff': False,
+            'supports_commit_comment': False,
+            'supports_multiline_delimiter': True,
+            'supports_diff_match': True,
+            'supports_diff_ignore_lines': True,
+            'supports_generate_diff': True,
+            'supports_replace': False
+        }
+
+    def get_option_values(self):
+        return {
+            'format': ['text'],
+            'diff_match': ['line', 'strict', 'exact', 'none'],
+            'diff_replace': ['line', 'block'],
+            'output': []
+        }
+
+    def get_capabilities(self):
+        result = dict()
+        result['rpc'] = self.get_base_rpc() + ['edit_banner', 'get_diff', 'run_commands', 'get_defaults_flag']
+        result['network_api'] = 'cliconf'
+        result['device_operations'] = self.get_device_operations()
+        result.update(self.get_option_values())
+        return json.dumps(result)
+
+    def edit_banner(self, candidate=None, multiline_delimiter="@", commit=True):
+        """
+        Edit banner on remote device
+        :param banners: Banners to be loaded in json format
+        :param multiline_delimiter: Line delimiter for banner
+        :param commit: Boolean value that indicates if the device candidate
+               configuration should be  pushed in the running configuration or discarded.
+        :param diff: Boolean flag to indicate if configuration that is applied on remote host should
+                     generated and returned in response or not
+        :return: Returns response of executing the configuration command received
+             from remote host
+        """
+        resp = {}
+        banners_obj = json.loads(candidate)
+        results = []
+        requests = []
+        if commit:
+            for key, value in iteritems(banners_obj):
+                key += ' %s' % multiline_delimiter
+                self.send_command('config terminal', sendonly=True)
+                for cmd in [key, value, multiline_delimiter]:
+                    obj = {'command': cmd, 'sendonly': True}
+                    results.append(self.send_command(**obj))
+                    requests.append(cmd)
+
+                self.send_command('end', sendonly=True)
+                time.sleep(0.1)
+                results.append(self.send_command('\n'))
+                requests.append('\n')
+
+        resp['request'] = requests
+        resp['response'] = results
+
+        return resp
+
+    def run_commands(self, commands=None, check_rc=True):
+        if commands is None:
+            raise ValueError("'commands' value is required")
+
+        responses = list()
+        for cmd in to_list(commands):
+            if not isinstance(cmd, Mapping):
+                cmd = {'command': cmd}
+
+            output = cmd.pop('output', None)
+            if output:
+                raise ValueError("'output' value %s is not supported for run_commands" % output)
+
+            try:
+                out = self.send_command(**cmd)
+            except AnsibleConnectionFailure as e:
+                if check_rc:
+                    raise
+                out = getattr(e, 'err', to_text(e))
+
+            responses.append(out)
+
+        return responses
+
+    def _extract_banners(self, config):
+        banners = {}
+        banner_cmds = re.findall(r'^banner (\w+)', config, re.M)
+        for cmd in banner_cmds:
+            regex = r'banner %s \$(.+?)(?=\$)' % cmd
+            match = re.search(regex, config, re.S)
+            if match:
+                key = 'banner %s' % cmd
+                banners[key] = match.group(1).strip()
+
+        for cmd in banner_cmds:
+            regex = r'banner %s \$(.+?)(?=\$)' % cmd
+            match = re.search(regex, config, re.S)
+            if match:
+                config = config.replace(str(match.group(1)), '')
+
+        config = re.sub(r'banner \w+ \$\$', '!! banner removed', config)
+        return config, banners
+
+    def _diff_banners(self, want, have):
+        candidate = {}
+        for key, value in iteritems(want):
+            if value != have.get(key):
+                candidate[key] = value
+        return candidate

lib/ansible/plugins/terminal/icx.py

@@ -0,0 +1,81 @@
+# Copyright: (c) 2019, Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import re
+
+from ansible.plugins.terminal import TerminalBase
+from ansible.errors import AnsibleConnectionFailure
+from ansible.module_utils._text import to_text, to_bytes
+import json
+
+
+class TerminalModule(TerminalBase):
+
+    terminal_stdout_re = [
+        re.compile(br"[\r\n]?[\w\+\-\.:\/\[\]]+(?:\([^\)]+\)){0,3}(?:[>#]) ?$")
+    ]
+
+    terminal_stderr_re = [
+        re.compile(br"% ?Error"),
+        re.compile(br"% ?Bad secret"),
+        re.compile(br"[\r\n%] Bad passwords"),
+        re.compile(br"invalid input", re.I),
+        re.compile(br"(?:incomplete|ambiguous) command", re.I),
+        re.compile(br"connection timed out", re.I),
+        re.compile(br"[^\r\n]+ not found"),
+        re.compile(br"'[^']' +returned error code: ?\d+"),
+        re.compile(br"Bad mask", re.I),
+        re.compile(br"% ?(\S+) ?overlaps with ?(\S+)", re.I),
+        re.compile(br"[%\S] ?Error: ?[\s]+", re.I),
+        re.compile(br"[%\S] ?Informational: ?[\s]+", re.I),
+        re.compile(br"Command authorization failed"),
+        re.compile(br"Error - *"),
+        re.compile(br"Error - Incorrect username or password."),
+        re.compile(br"Invalid input"),
+        re.compile(br"Already a http operation is in progress"),
+        re.compile(br"Flash access in progress. Please try later"),
+        re.compile(br"Error: .*"),
+        re.compile(br"^Error: .*", re.I),
+        re.compile(br"^Ambiguous input"),
+        re.compile(br"Errno")
+    ]
+
+    def on_open_shell(self):
+        pass
+
+    def __del__(self):
+        try:
+            self.close()
+        except AnsibleConnectionFailure:
+            raise AnsibleConnectionFailure('unable to set terminal parameters')
+
+    def on_become(self, passwd=None):
+        if self._get_prompt().endswith(b'#'):
+            return
+
+        cmd = {u'command': u'enable'}
+        cmd[u'prompt'] = to_text(r"[\r\n](?:Local_)?[Pp]assword: ?$", errors='surrogate_or_strict')
+        cmd[u'answer'] = passwd
+        cmd[u'prompt_retry_check'] = True
+        try:
+            self._exec_cli_command(to_bytes(json.dumps(cmd), errors='surrogate_or_strict'))
+            prompt = self._get_prompt()
+            if prompt is None or not prompt.endswith(b'#'):
+                raise AnsibleConnectionFailure('failed to elevate privilege to enable mode still at prompt [%s]' % prompt)
+        except AnsibleConnectionFailure as e:
+            prompt = self._get_prompt()
+            raise AnsibleConnectionFailure('unable to elevate privilege to enable mode, at prompt [%s] with error: %s' % (prompt, e.message))
+
+    def on_unbecome(self):
+        prompt = self._get_prompt()
+        if prompt is None:
+            return
+
+        if b'(config' in prompt:
+            self._exec_cli_command(b'exit')
+
+        elif prompt.endswith(b'#'):
+            self._exec_cli_command(b'exit')

test/units/modules/network/icx/fixtures/icx_banner_show_banner.txt

@@ -0,0 +1,16 @@
+banner motd require-enter-key
+banner motd $
+welcome
+new user
+$
+!
+interface ethernet 1/1/1
+ port-name port name
+ disable
+ speed-duplex 10-full
+ inline power power-limit 7000
+!
+interface ethernet 1/1/2
+ speed-duplex 10-full
+ inline power power-limit 3000
+!

test/units/modules/network/icx/icx_module.py

@@ -0,0 +1,93 @@
+# Copyright: (c) 2019, Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import os
+import json
+
+from units.modules.utils import AnsibleExitJson, AnsibleFailJson, ModuleTestCase
+
+
+fixture_path = os.path.join(os.path.dirname(__file__), 'fixtures')
+fixture_data = {}
+
+
+def load_fixture(name):
+    path = os.path.join(fixture_path, name)
+
+    if path in fixture_data:
+        return fixture_data[path]
+
+    with open(path) as f:
+        data = f.read()
+
+    try:
+        data = json.loads(data)
+    except Exception:
+        pass
+
+    fixture_data[path] = data
+    return data
+
+
+class TestICXModule(ModuleTestCase):
+    ENV_ICX_USE_DIFF = True
+
+    def set_running_config(self):
+        self.ENV_ICX_USE_DIFF = self.get_running_config()
+
+    def get_running_config(self, compare=None):
+        if compare is not None:
+            diff = compare
+        elif os.environ.get('ANSIBLE_CHECK_ICX_RUNNING_CONFIG') is not None:
+            if os.environ.get('ANSIBLE_CHECK_ICX_RUNNING_CONFIG') == 'False':
+                diff = False
+            else:
+                diff = True
+        else:
+            diff = True
+        return diff
+
+    def execute_module(self, failed=False, changed=False, commands=None, sort=True, defaults=False, fields=None):
+
+        self.load_fixtures(commands)
+
+        if failed:
+            result = self.failed()
+            self.assertTrue(result['failed'], result)
+        else:
+            result = self.changed(changed)
+            self.assertEqual(result['changed'], changed, result)
+
+        if commands is not None:
+            if sort:
+                self.assertEqual(sorted(commands), sorted(result['commands']))
+            else:
+                self.assertEqual(commands, result['commands'], result['commands'])
+
+        if fields is not None:
+            for key in fields:
+                if fields.get(key) is not None:
+                    self.assertEqual(fields.get(key), result.get(key))
+
+        return result
+
+    def failed(self):
+        with self.assertRaises(AnsibleFailJson) as exc:
+            self.module.main()
+
+        result = exc.exception.args[0]
+        self.assertTrue(result['failed'], result)
+        return result
+
+    def changed(self, changed=False):
+        with self.assertRaises(AnsibleExitJson) as exc:
+            self.module.main()
+
+        result = exc.exception.args[0]
+        self.assertEqual(result['changed'], changed, result)
+        return result
+
+    def load_fixtures(self, commands=None):
+        pass

test/units/modules/network/icx/test_icx_banner.py

@@ -0,0 +1,96 @@
+# Copyright: (c) 2019, Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+from units.compat.mock import patch
+from ansible.modules.network.icx import icx_banner
+from units.modules.utils import set_module_args
+from .icx_module import TestICXModule, load_fixture
+
+
+class TestICXBannerModule(TestICXModule):
+
+    module = icx_banner
+
+    def setUp(self):
+        super(TestICXBannerModule, self).setUp()
+        self.mock_exec_command = patch('ansible.modules.network.icx.icx_banner.exec_command')
+        self.exec_command = self.mock_exec_command.start()
+
+        self.mock_load_config = patch('ansible.modules.network.icx.icx_banner.load_config')
+        self.load_config = self.mock_load_config.start()
+
+        self.mock_get_config = patch('ansible.modules.network.icx.icx_banner.get_config')
+        self.get_config = self.mock_get_config.start()
+
+        self.set_running_config()
+
+    def tearDown(self):
+        super(TestICXBannerModule, self).tearDown()
+        self.mock_exec_command.stop()
+        self.mock_load_config.stop()
+        self.mock_get_config.stop()
+
+    def load_fixtures(self, commands=None):
+        compares = None
+
+        def load_file(*args, **kwargs):
+            module = args
+            for arg in args:
+                if arg.params['check_running_config'] is True:
+                    return load_fixture('icx_banner_show_banner.txt').strip()
+                else:
+                    return ''
+
+        self.exec_command.return_value = (0, '', None)
+        self.get_config.side_effect = load_file
+        self.load_config.return_value = dict(diff=None, session='session')
+
+    def test_icx_banner_create(self):
+        if not self.ENV_ICX_USE_DIFF:
+            set_module_args(dict(banner='motd', text='welcome\nnew user'))
+            commands = ['banner motd $\nwelcome\nnew user\n$']
+            self.execute_module(changed=True, commands=commands)
+        else:
+            for banner_type in ('motd', 'exec', 'incoming'):
+                set_module_args(dict(banner=banner_type, text='test\nbanner\nstring'))
+                commands = ['banner {0} $\ntest\nbanner\nstring\n$'.format(banner_type)]
+                self.execute_module(changed=True, commands=commands)
+
+    def test_icx_banner_remove(self):
+        set_module_args(dict(banner='motd', state='absent'))
+        if not self.ENV_ICX_USE_DIFF:
+            commands = ['no banner motd']
+            self.execute_module(changed=True, commands=commands)
+        else:
+            commands = ['no banner motd']
+            self.execute_module(changed=True, commands=commands)
+
+    def test_icx_banner_motd_enter_set(self):
+        set_module_args(dict(banner='motd', enterkey=True))
+
+        if not self.ENV_ICX_USE_DIFF:
+            commands = ['banner motd require-enter-key']
+            self.execute_module(changed=True, commands=commands)
+        else:
+            self.execute_module(changed=False)
+
+    def test_icx_banner_motd_enter_remove(self):
+        set_module_args(dict(banner='motd', state='absent', enterkey=False))
+        if not self.ENV_ICX_USE_DIFF:
+            commands = ['no banner motd', 'no banner motd require-enter-key']
+            self.execute_module(changed=True, commands=commands)
+
+        else:
+            commands = ['no banner motd', 'no banner motd require-enter-key']
+            self.execute_module(changed=True, commands=commands)
+
+    def test_icx_banner_remove_compare(self):
+        set_module_args(dict(banner='incoming', state='absent', check_running_config='True'))
+        if self.get_running_config(compare=True):
+            if not self.ENV_ICX_USE_DIFF:
+                commands = []
+                self.execute_module(changed=False, commands=commands)
+            else:
+                commands = []
+                self.execute_module()