*~
+*.pyc
.*.sw?
+.coverage
/docs_build/
/docs_output/
/releng/
.PHONY: python-tests
python-tests:
+ # clean previous coverage data
+ rm -rf ../tests/.coverage
+ rm -rf ../tests/htmlcov
# run nose tests
- cd ../tests && PYTHONPATH=../lib/python/ nosetests-3.4 . --with-coverage --cover-package apex
+ cd ../tests && PYTHONPATH=../lib/python/ nosetests-3.4 . --with-coverage --cover-package apex --cover-package apex_python_utils --cover-html --cover-min-percentage 85
+
# generate reports
- cd ../tests && coverage3 html --include '*lib/python/*'
cd ../tests && coverage3 report --include '*lib/python/*' -m
+#######################
+# PYTHON PEP8 CHECK #
+#######################
+
+.PHONY: python-pep8-check
+python-pep8-check:
+ pep8 ../lib/python
+ pep8 ../tests
###############
# UNDERCLOUD #
mkdir -p %{buildroot}%{_var}/opt/opnfv/lib/python/apex
install lib/common-functions.sh %{buildroot}%{_var}/opt/opnfv/lib/
install lib/utility-functions.sh %{buildroot}%{_var}/opt/opnfv/lib/
-install lib/python/apex-python-utils.py %{buildroot}%{_var}/opt/opnfv/lib/python/
+install lib/python/apex_python_utils.py %{buildroot}%{_var}/opt/opnfv/lib/python/
mkdir -p %{buildroot}%{python3_sitelib}/apex/
install lib/python/apex/__init__.py %{buildroot}%{python3_sitelib}/apex/
install lib/python/apex/deploy_env.py %{buildroot}%{python3_sitelib}/apex/
##parses network settings yaml into globals
parse_network_settings() {
local output
- if output=$(python3.4 -B $LIB/python/apex-python-utils.py parse-net-settings -s $NETSETS -i $net_isolation_enabled -e $CONFIG/network-environment.yaml); then
+ if output=$(python3.4 -B $LIB/python/apex_python_utils.py parse-net-settings -s $NETSETS -i $net_isolation_enabled -e $CONFIG/network-environment.yaml); then
echo -e "${blue}${output}${reset}"
eval "$output"
else
##parses deploy settings yaml into globals
parse_deploy_settings() {
local output
- if output=$(python3.4 -B $LIB/python/apex-python-utils.py parse-deploy-settings -f $DEPLOY_SETTINGS_FILE); then
+ if output=$(python3.4 -B $LIB/python/apex_python_utils.py parse-deploy-settings -f $DEPLOY_SETTINGS_FILE); then
echo -e "${blue}${output}${reset}"
eval "$output"
else
ovs_dpdk_bridge=''
fi
- if ! controller_nic_template=$(python3.4 -B $LIB/python/apex-python-utils.py nic-template -r controller -s $NETSETS -i $net_isolation_enabled -t $CONFIG/nics-template.yaml.jinja2 -n "$enabled_network_list" -e "br-ex" -af $ip_addr_family); then
+ if ! controller_nic_template=$(python3.4 -B $LIB/python/apex_python_utils.py nic-template -r controller -s $NETSETS -i $net_isolation_enabled -t $CONFIG/nics-template.yaml.jinja2 -n "$enabled_network_list" -e "br-ex" -af $ip_addr_family); then
echo -e "${red}ERROR: Failed to generate controller NIC heat template ${reset}"
exit 1
fi
- if ! compute_nic_template=$(python3.4 -B $LIB/python/apex-python-utils.py nic-template -r compute -s $NETSETS -i $net_isolation_enabled -t $CONFIG/nics-template.yaml.jinja2 -n "$enabled_network_list" -e $ext_net_type -af $ip_addr_family -d "$ovs_dpdk_bridge"); then
+ if ! compute_nic_template=$(python3.4 -B $LIB/python/apex_python_utils.py nic-template -r compute -s $NETSETS -i $net_isolation_enabled -t $CONFIG/nics-template.yaml.jinja2 -n "$enabled_network_list" -e $ext_net_type -af $ip_addr_family -d "$ovs_dpdk_bridge"); then
echo -e "${red}ERROR: Failed to generate compute NIC heat template ${reset}"
exit 1
fi
set -e
# Make sure python dependencies are installed
-for pkg in epel-release python34-devel python34-nose; do
+for pkg in epel-release python34-devel python34-nose python-pep8; do
if ! rpm -q ${pkg} > /dev/null; then
if ! sudo yum install -y ${pkg}; then
echo "Failed to install ${pkg} package..."
pushd ../build/ > /dev/null
make python-tests
-popd > /dev/null
-pushd ../tests/ > /dev/null
-percent=$(coverage3 report --include '*lib/python/*' -m | grep TOTAL | tr -s ' ' | awk '{ print $4 }' | cut -d % -f 1)
-if [[ percent -lt 80 ]]; then
- echo "Python Coverage: $percent"
- echo "Does not meet 80% requirement"
- exit 1
-fi
+make python-pep8-check
popd > /dev/null
return 1
fi
- python3.4 -B $LIB/python/apex-python-utils.py find-ip -i $1
+ python3.4 -B $LIB/python/apex_python_utils.py find-ip -i $1
}
##attach interface to OVS and set the network config correctly
OPT_DEPLOY_SETTINGS = ['performance']
VALID_ROLES = ['Controller', 'Compute', 'ObjectStorage']
-VALID_PERF_OPTS = ['kernel','nova']
-VALID_DATAPLANES = ['ovs','ovs_dpdk','fdio']
+VALID_PERF_OPTS = ['kernel', 'nova']
+VALID_DATAPLANES = ['ovs', 'ovs_dpdk', 'fdio']
+
class DeploySettings:
"""
if setting == 'dataplane':
if value not in VALID_DATAPLANES:
planes = ' '.join(VALID_DATAPLANES)
- raise DeploySettingsException("Invalid dataplane {} "
- "specified. Valid dataplanes:"
- " {}".format(value,planes))
+ raise DeploySettingsException(
+ "Invalid dataplane {} specified. Valid dataplanes:"
+ " {}".format(value, planes))
for req_set in REQ_DEPLOY_SETTINGS:
if req_set not in deploy_options:
if not isinstance(deploy_options['performance'], dict):
raise DeploySettingsException("Performance deploy_option"
"must be a dictionary.")
- for role,role_perf_sets in deploy_options['performance'].items():
+ for role, role_perf_sets in deploy_options['performance'].items():
if role not in VALID_ROLES:
raise DeploySettingsException("Performance role {}"
"is not valid, choose"
"from {}".format(
- role," ".join(VALID_ROLES)
+ role,
+ " ".join(VALID_ROLES)
))
for key in role_perf_sets:
if key not in VALID_PERF_OPTS:
- raise DeploySettingsException("Performance option {}"
+ raise DeploySettingsException("Performance option {} "
"is not valid, choose"
"from {}".format(
- key," ".join(
- VALID_PERF_OPTS)))
-
+ key,
+ " ".join(
+ VALID_PERF_OPTS)
+ ))
def _dump_performance(self):
"""
Creates performance settings string for bash consumption.
- Output will be in the form of a list that can be iterated over in bash,
- with each string being the direct input to the performance setting script
- in the form <role> <category> <key> <value> to facilitate modification of the
- correct image.
+ Output will be in the form of a list that can be iterated over in
+ bash, with each string being the direct input to the performance
+ setting script in the form <role> <category> <key> <value> to
+ facilitate modification of the correct image.
"""
bash_str = 'performance_options=(\n'
- for role,settings in self.deploy_settings['deploy_options']['performance'].items():
- for category,options in settings.items():
- for key,value in options.items():
- bash_str += "\"{} {} {} {}\"\n".format(role, category, key, value)
+ deploy_options = self.deploy_settings['deploy_options']
+ for role, settings in deploy_options['performance'].items():
+ for category, options in settings.items():
+ for key, value in options.items():
+ bash_str += "\"{} {} {} {}\"\n".format(role,
+ category,
+ key,
+ value)
bash_str += ')\n'
bash_str += '\n'
bash_str += 'performance_roles=(\n'
Creates deploy settings array in bash syntax.
"""
bash_str = ''
- for key,value in self.deploy_settings['deploy_options'].items():
+ for key, value in self.deploy_settings['deploy_options'].items():
if not isinstance(value, bool):
- bash_str += "deploy_options_array[{}]=\"{}\"\n".format(key, value)
+ bash_str += "deploy_options_array[{}]=\"{}\"\n".format(key,
+ value)
else:
- bash_str += "deploy_options_array[{}]={}\n".format(key, value)
+ bash_str += "deploy_options_array[{}]={}\n".format(key,
+ value)
return bash_str
def dump_bash(self, path=None):
space, and end_offset will be calculated from the interface IP.
2 of start_offset, end_offset and count options must be provided:
- - If start_offset and end_offset are provided, a range from start_offset
- to end_offset will be returned.
- - If count is provided, a range from either start_offset to (start_offset
- +count) or (end_offset-count) to end_offset will be returned. The
- IP range returned will be of size <count>.
+ - If start_offset and end_offset are provided, a range from
+ start_offset to end_offset will be returned.
+ - If count is provided, a range from either start_offset to
+ (start_offset+count) or (end_offset-count) to end_offset will be
+ returned. The IP range returned will be of size <count>.
Both start_offset and end_offset must be greater than 0.
Returns IP range in the format of "first_addr,second_addr" or exception
if cidr:
if count and start_offset and not end_offset:
start_index = start_offset
- end_index = start_offset + count -1
+ end_index = start_offset + count - 1
elif count and end_offset and not start_offset:
end_index = -1 - end_offset
start_index = -1 - end_index - count + 1
else:
if count and start_offset and not end_offset:
start_ip = network[start_offset]
- end_ip = start_ip + count -1
+ end_ip = start_ip + count - 1
elif count and end_offset and not start_offset:
end_ip = interface.ip - end_offset
start_ip = end_ip - count + 1
return str(ip)
-def generate_ip_range(args):
- """
- Generate IP range in string format for given CIDR.
- This function works for both IPv4 and IPv6.
-
- args is expected to contain the following members:
- CIDR: any valid CIDR representation.
- start_position: starting index, default to first address in subnet (1)
- end_position: ending index, default to last address in subnet (-1)
-
- Returns IP range in string format. A single IP is returned if start and
- end IPs are identical.
- """
- cidr = ipaddress.ip_network(args.CIDR)
- (start_index, end_index) = (args.start_position, args.end_position)
- if cidr[start_index] == cidr[end_index]:
- return str(cidr[start_index])
- else:
- return ','.join(sorted([str(cidr[start_index]), str(cidr[end_index])]))
-
-
def get_interface(nic, address_family=4):
"""
Returns interface object for a given NIC name in the system
return ipaddress.ip_interface(match.group())
else:
logging.info("interface ip not found! ip address output:\n{}"
- .format(output))
+ .format(output))
return None
"""
ip_range = "{},{}".format(start_ip, end_ip)
if end_ip <= start_ip:
- logging.warning("IP range {} is invalid: end_ip should be greater than "
- "starting ip".format(ip_range))
+ logging.warning("IP range {} is invalid: end_ip should be greater "
+ "than starting ip".format(ip_range))
return False
if start_ip not in ipaddress.ip_network(cidr):
logging.warning('start_ip {} is not in network {}'
import yaml
import re
-from .common import constants
+from .common.constants import ADMIN_NETWORK
+from .common.constants import PRIVATE_NETWORK
+from .common.constants import STORAGE_NETWORK
+from .common.constants import PUBLIC_NETWORK
+from .common.constants import API_NETWORK
PORTS = '/ports'
# Resources defined by <resource name>: <prefix>
if not tht_dir:
raise NetworkEnvException('Unable to parse THT Directory')
- admin_cidr = net_settings[constants.ADMIN_NETWORK]['cidr']
+ admin_cidr = net_settings[ADMIN_NETWORK]['cidr']
admin_prefix = str(admin_cidr.prefixlen)
self.netenv_obj[param_def]['ControlPlaneSubnetCidr'] = admin_prefix
self.netenv_obj[param_def]['ControlPlaneDefaultRoute'] = \
- net_settings[constants.ADMIN_NETWORK]['provisioner_ip']
- public_cidr = net_settings[constants.PUBLIC_NETWORK]['cidr']
+ net_settings[ADMIN_NETWORK]['provisioner_ip']
+ public_cidr = net_settings[PUBLIC_NETWORK]['cidr']
self.netenv_obj[param_def]['ExternalNetCidr'] = str(public_cidr)
- if net_settings[constants.PUBLIC_NETWORK]['vlan'] != 'native':
+ if net_settings[PUBLIC_NETWORK]['vlan'] != 'native':
self.netenv_obj[param_def]['ExternalNetworkVlanID'] = \
- net_settings[constants.PUBLIC_NETWORK]['vlan']
- public_range = net_settings[constants.PUBLIC_NETWORK][
- 'usable_ip_range'].split(',')
+ net_settings[PUBLIC_NETWORK]['vlan']
+ public_range = \
+ net_settings[PUBLIC_NETWORK]['usable_ip_range'].split(',')
self.netenv_obj[param_def]['ExternalAllocationPools'] = \
[{'start':
public_range[0],
'end': public_range[1]
}]
self.netenv_obj[param_def]['ExternalInterfaceDefaultRoute'] = \
- net_settings[constants.PUBLIC_NETWORK]['gateway']
+ net_settings[PUBLIC_NETWORK]['gateway']
self.netenv_obj[param_def]['EC2MetadataIp'] = \
- net_settings[constants.ADMIN_NETWORK]['provisioner_ip']
+ net_settings[ADMIN_NETWORK]['provisioner_ip']
self.netenv_obj[param_def]['DnsServers'] = net_settings['dns_servers']
if public_cidr.version == 6:
prefix = ''
self.netenv_obj[reg][key] = tht_dir + prefix + postfix
-
- if constants.PRIVATE_NETWORK in enabled_networks:
- priv_range = net_settings[constants.PRIVATE_NETWORK][
+ if PRIVATE_NETWORK in enabled_networks:
+ priv_range = net_settings[PRIVATE_NETWORK][
'usable_ip_range'].split(',')
self.netenv_obj[param_def]['TenantAllocationPools'] = \
[{'start':
priv_range[0],
'end': priv_range[1]
}]
- priv_cidr = net_settings[constants.PRIVATE_NETWORK]['cidr']
+ priv_cidr = net_settings[PRIVATE_NETWORK]['cidr']
self.netenv_obj[param_def]['TenantNetCidr'] = str(priv_cidr)
if priv_cidr.version == 6:
postfix = '/tenant_v6.yaml'
else:
postfix = '/tenant.yaml'
- if net_settings[constants.PRIVATE_NETWORK]['vlan'] != 'native':
+ if net_settings[PRIVATE_NETWORK]['vlan'] != 'native':
self.netenv_obj[param_def]['TenantNetworkVlanID'] = \
- net_settings[constants.PRIVATE_NETWORK]['vlan']
+ net_settings[PRIVATE_NETWORK]['vlan']
else:
postfix = '/noop.yaml'
prefix = ''
self.netenv_obj[reg][key] = tht_dir + prefix + postfix
- if constants.STORAGE_NETWORK in enabled_networks:
- storage_range = net_settings[constants.STORAGE_NETWORK][
+ if STORAGE_NETWORK in enabled_networks:
+ storage_range = net_settings[STORAGE_NETWORK][
'usable_ip_range'].split(',')
self.netenv_obj[param_def]['StorageAllocationPools'] = \
[{'start':
'end':
storage_range[1]
}]
- storage_cidr = net_settings[constants.STORAGE_NETWORK]['cidr']
+ storage_cidr = net_settings[STORAGE_NETWORK]['cidr']
self.netenv_obj[param_def]['StorageNetCidr'] = str(storage_cidr)
if storage_cidr.version == 6:
postfix = '/storage_v6.yaml'
else:
postfix = '/storage.yaml'
- if net_settings[constants.STORAGE_NETWORK]['vlan'] != 'native':
+ if net_settings[STORAGE_NETWORK]['vlan'] != 'native':
self.netenv_obj[param_def]['StorageNetworkVlanID'] = \
- net_settings[constants.STORAGE_NETWORK]['vlan']
+ net_settings[STORAGE_NETWORK]['vlan']
else:
postfix = '/noop.yaml'
prefix = ''
self.netenv_obj[reg][key] = tht_dir + prefix + postfix
- if constants.API_NETWORK in enabled_networks:
- api_range = net_settings[constants.API_NETWORK][
+ if API_NETWORK in enabled_networks:
+ api_range = net_settings[API_NETWORK][
'usable_ip_range'].split(',')
self.netenv_obj[param_def]['InternalApiAllocationPools'] = \
- [{'start':
- api_range[0],
- 'end':
- api_range[1]
+ [{'start': api_range[0],
+ 'end': api_range[1]
}]
- api_cidr = net_settings[constants.API_NETWORK]['cidr']
+ api_cidr = net_settings[API_NETWORK]['cidr']
self.netenv_obj[param_def]['InternalApiNetCidr'] = str(api_cidr)
if api_cidr.version == 6:
postfix = '/internal_api_v6.yaml'
else:
postfix = '/internal_api.yaml'
- if net_settings[constants.API_NETWORK]['vlan'] != 'native':
+ if net_settings[API_NETWORK]['vlan'] != 'native':
self.netenv_obj[param_def]['InternalApiNetworkVlanID'] = \
- net_settings[constants.API_NETWORK]['vlan']
+ net_settings[API_NETWORK]['vlan']
else:
postfix = '/noop.yaml'
This class parses APEX network settings yaml file into an object. It
generates or detects all missing fields for deployment.
- The resulting object will be used later to generate network environment file
- as well as configuring post deployment networks.
+ The resulting object will be used later to generate network environment
+ file as well as configuring post deployment networks.
Currently the parsed object is dumped into a bash global definition file
for deploy.sh consumption. This object will later be used directly as
"""
if constants.ADMIN_NETWORK not in self.settings_obj or \
not utils.str2bool(self.settings_obj[constants.ADMIN_NETWORK].get(
- 'enabled')):
+ 'enabled')):
raise NetworkSettingsException("You must enable admin_network "
"and configure it explicitly or "
"use auto-detection")
def __str__(self):
return self.value
-
-
-
vlans_vals = map(lambda x: settings[x]['vlan'], net_list)
vlans = dict(zip(net_list, vlans_vals))
- print(template.render(
- enabled_networks=args.enabled_networks,
- role=args.role,
- vlans=vlans,
- external_net_type=args.ext_net_type,
- external_net_af=args.address_family,
- ovs_dpdk_bridge=args.ovs_dpdk_bridge))
+ print(template.render(enabled_networks=args.enabled_networks,
+ role=args.role,
+ vlans=vlans,
+ external_net_type=args.ext_net_type,
+ external_net_af=args.address_family,
+ ovs_dpdk_bridge=args.ovs_dpdk_bridge))
-def parse_args():
+def get_parser():
parser = argparse.ArgumentParser()
parser.add_argument('--debug', action='store_true', default=False,
help="Turn on debug messages")
nic_template.set_defaults(func=build_nic_template)
deploy_settings = subparsers.add_parser('parse-deploy-settings',
- help='Parse deploy settings file')
- deploy_settings.add_argument('-f', '--file', default='deploy_settings.yaml',
- help='path to deploy settings file')
+ help='Parse deploy settings file')
+ deploy_settings.add_argument('-f', '--file',
+ default='deploy_settings.yaml',
+ help='path to deploy settings file')
deploy_settings.set_defaults(func=parse_deploy_settings)
+ return parser
+
+
+def main():
+ parser = get_parser()
args = parser.parse_args(sys.argv[1:])
if args.debug:
logging.basicConfig(level=logging.DEBUG)
format='%(asctime)s %(levelname)s: %(message)s',
datefmt='%m/%d/%Y %I:%M:%S %p',
level=logging.DEBUG)
- return parser, args
-
-
-def main(parser, args):
if hasattr(args, 'func'):
args.func(args)
else:
exit(1)
if __name__ == "__main__":
- parser, args = parse_args()
- main(parser, args)
+ main()
'os-onos-nofeature-ha.yaml')
test_deploy_content = (
-'global_params:',
-'deploy_options: string',
-"""deploy_options: string
+ 'global_params:',
+ 'deploy_options: string',
+ """deploy_options: string
global_params:""",
-"""global_params:
+ """global_params:
deploy_options:
error: error
""",
-"""global_params:
+ """global_params:
deploy_options:
performance: string
""",
-"""global_params:
+ """global_params:
deploy_options:
dataplane: invalid
""",
-"""global_params:
+ """global_params:
deploy_options:
performance:
Controller:
f = open('/tmp/apex_deploy_test_file', 'w')
f.write(c)
f.close()
- assert_raises(DeploySettingsException, DeploySettings, '/tmp/apex_deploy_test_file')
+ assert_raises(DeploySettingsException,
+ DeploySettings, '/tmp/apex_deploy_test_file')
def test_dump_bash(self):
# the performance file has the most use of the function
def test_get_interface(self):
assert_equal(get_interface(''), None)
assert_equal(get_interface('notreal'), None)
- assert_is_instance(get_interface(
- self.iface_name,
- address_family=4), IPv4Address)
+ assert_is_instance(get_interface(self.iface_name,
+ address_family=4),
+ IPv4Address)
# assert_is_instance(get_interface(
# self.iface_name,
# address_family=6), IPv6Address)
assert_regexp_matches(get_ip_range(interface=self.iface, end_offset=20,
count=10), ip4_range_pattern)
- @staticmethod
- def test_get_ip_range_with_cidr():
+ def test_get_ip_range_with_cidr(self):
cidr = ip_network('10.10.10.0/24')
assert_raises(IPUtilsException, get_ip_range, cidr=cidr)
assert_regexp_matches(get_ip_range(cidr=cidr, start_offset=1,
"""This method is run once after _each_ test method is executed"""
def test_init(self):
- assert_raises(NetworkEnvException, NetworkEnvironment, None, '../build/network-environment.yaml')
+ assert_raises(NetworkEnvException, NetworkEnvironment,
+ None, '../build/network-environment.yaml')
def test_get_netenv_settings(self):
ns = NetworkSettings('../config/network/network_settings.yaml', True)
--- /dev/null
+##############################################################################
+# Copyright (c) 2016 Dan Radez (Red Hat)
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+
+import sys
+
+from test_apex_ip_utils import get_default_gateway_linux
+from apex_python_utils import main
+from apex_python_utils import get_parser
+from apex_python_utils import parse_net_settings
+from apex_python_utils import parse_deploy_settings
+from apex_python_utils import find_ip
+from apex_python_utils import build_nic_template
+
+from nose.tools import assert_equal
+from nose.tools import assert_raises
+
+
+net_sets = '../config/network/network_settings.yaml'
+net_env = '../build/network-environment.yaml'
+deploy_sets = '../config/deploy/deploy_settings.yaml'
+nic_template = '../build/nics-template.yaml.jinja2'
+
+
+class TestCommonUtils(object):
+ @classmethod
+ def setup_class(klass):
+ """This method is run once for each class before any tests are run"""
+ klass.parser = get_parser()
+ klass.iface_name = get_default_gateway_linux()
+
+ @classmethod
+ def teardown_class(klass):
+ """This method is run once for each class _after_ all tests are run"""
+
+ def setUp(self):
+ """This method is run once before _each_ test method is executed"""
+
+ def teardown(self):
+ """This method is run once after _each_ test method is executed"""
+
+ def test_main(self):
+ sys.argv = ['apex_python_utils', '-l', '/dev/null']
+ assert_raises(SystemExit, main)
+ sys.argv = ['apex_python_utils', '--debug', '-l', '/dev/null']
+ assert_raises(SystemExit, main)
+ sys.argv = ['apex_python_utils', '-l', '/dev/null',
+ 'parse-deploy-settings',
+ '-f', deploy_sets]
+ assert_equal(main(), None)
+
+ def test_parse_net_settings(self):
+ args = self.parser.parse_args(['parse-net-settings',
+ '-s', net_sets,
+ '-i', 'True',
+ '-e', net_env])
+ assert_equal(parse_net_settings(args), None)
+
+ def test_parse_deploy_settings(self):
+ args = self.parser.parse_args(['parse-deploy-settings',
+ '-f', deploy_sets])
+ assert_equal(parse_deploy_settings(args), None)
+
+ def test_find_ip(self):
+ args = self.parser.parse_args(['find-ip',
+ '-i', self.iface_name])
+ assert_equal(find_ip(args), None)
+
+ def test_build_nic_template(self):
+ args = self.parser.parse_args(['nic-template',
+ '-s', net_sets,
+ '-r', 'compute',
+ '-t', nic_template,
+ '-n', 'admin_network'])
+ assert_equal(build_nic_template(args), None)
Code Review / apex.git / commitdiff