Release 0.22.0 (#193)

* Dbarrosop/framework test bug (#170)

* Test framework failed to run tests properly against real device

* eval() doesn't like objects

* Replaced eval with ast.literal_eval

* Fix pylama

* You can now use regular expressions to validate data (#176)

* Dbarrosop/validate getter args (#175)

* Dbarrosop/fix signatures (#154)

* Fix method signatures

* Use defaults from constants

* Version bump

* Python3 doesnt like relative imports

* Validate now support getters with args

* testing mocked method is in C.ACTION_TYPE_METHODS

* Adding ACTION_TYPE_METHODS to constants file

* Validate reports if a method is not implemented rather than failing (#179)

* Validate reports if a method is not implemented rather than failing

* Adapting string comparison to regexp

* Update test status to reflect NAPALM distributions that have release Python3 support (#177)

* Incrementing to add napalm-eos to PY3

* Add NXOS to python3

* Updating list of PY3 supported drivers

* Add second ios-xr reference

* Add additional napalm packages for PY3

* Add vyos to get network driver test

* Updating test requirements files adding vyos

* Adding napalm-ros to supported drivers

* Fixing line-length pylama issue

* Fix PY2 issue with long/int type mismatch

* Correct errors in fix to handle long data type

* Fixing pylama issue

* Added reference to '_' as bgp group name

* Fixed and issue comparing lists of dicts (#181)

* Fixed and issue comparing lists of dicts

* Merge develop

* Correctly process lists of dicts

* Better output for comparing lists of dicts

* Correctly process lists of dicts

* Comparing lists of dicts properly

* Added special keyword _name to override name in the report (#191)

* Added special keyword _name to override name in the report

* Fix pylama

* Bump version (#192)

Author: dbarrosop

.travis.yml

@@ -24,5 +24,5 @@ script:
   - nosetests ./test/unit/TestGetNetworkDriver.py
   - nosetests ./test/unit/TestHelpers.py
   - nosetests ./test/unit/TestNapalmTestFramework.py
-  - py.test test/unit/validate/test_validate.py
+  - py.test test/unit/validate
   - pylama .

napalm_base/base.py

@@ -49,7 +49,7 @@ def __init__(self, hostname, username, password, timeout=60, optional_args=None)
     def __enter__(self):
         try:
             self.open()
-        except:
+        except:  # noqa
             exc_info = sys.exc_info()
             self.__raise_clean_exception(exc_info[0], exc_info[1], exc_info[2])
         return self
@@ -471,7 +471,7 @@ def get_bgp_config(self, group='', neighbor=''):
         :param neighbor: Returns the configuration of a specific BGP neighbor.
 
         Main dictionary keys represent the group name and the values represent a dictionary having
-        the following keys:
+        the keys below. Neighbors which aren't members of a group will be stored in a key named "_":
             * type (string)
             * description (string)
             * apply_groups (string list)

napalm_base/constants.py

@@ -7,6 +7,8 @@
 
 INTERFACE_NULL_SPEED = -1
 
+ACTION_TYPE_METHODS = ('ping', 'traceroute', )
+
 BGP_NEIGHBOR_NULL_COUNTER = -1
 
 SNMP_AUTHORIZATION_MODE_MAP = {

napalm_base/helpers.py

@@ -177,7 +177,7 @@ def convert(to, who, default=u''):
         return default
     try:
         return to(who)
-    except:
+    except:  # noqa
         return default
 
 

napalm_base/test/conftest.py

@@ -4,10 +4,12 @@
 from __future__ import print_function
 from __future__ import unicode_literals
 
+import ast
+
 import json
 import os
 
-NAPALM_TEST_MOCK = eval("{}".format(os.getenv('NAPALM_TEST_MOCK', default=True)))
+NAPALM_TEST_MOCK = ast.literal_eval(os.getenv('NAPALM_TEST_MOCK', default="1"))
 NAPALM_HOSTNAME = os.getenv('NAPALM_HOSTNAME', default='127.0.0.1')
 NAPALM_USERNAME = os.getenv('NAPALM_USERNAME', default='vagrant')
 NAPALM_PASSWORD = os.getenv('NAPALM_PASSWORD', default='vagrant')

napalm_base/test/getters.py

@@ -12,7 +12,6 @@
 
 import inspect
 import json
-import os
 
 import pytest
 from napalm_base.test import helpers
@@ -22,8 +21,7 @@
 # text_type is 'unicode' for py2 and 'str' for py3
 from napalm_base.utils.py23_compat import text_type
 
-
-NAPALM_TEST_MOCK = os.getenv('NAPALM_TEST_MOCK', default=True)
+from napalm_base.test import conftest
 
 
 def list_dicts_diff(prv, nxt):
@@ -63,7 +61,7 @@ def wrap_test_cases(func):
     func.__dict__['build_test_cases'] = True
 
     @functools.wraps(func)
-    def wrapper(cls, test_case):
+    def mock_wrapper(cls, test_case):
         for patched_attr in cls.device.patched_attrs:
             attr = getattr(cls.device, patched_attr)
             attr.current_test = func.__name__
@@ -85,19 +83,18 @@ def wrapper(cls, test_case):
         # This is an ugly, ugly, ugly hack because some python objects don't load
         # as expected. For example, dicts where integers are strings
 
-        if NAPALM_TEST_MOCK:
-            try:
-                expected_result = attr.expected_result
-            except IOError as e:
-                raise Exception("{}. Actual result was: {}".format(e, json.dumps(result)))
-            if isinstance(result, list):
-                diff = list_dicts_diff(result, expected_result)
-            else:
-                diff = dict_diff(result, expected_result)
-            if diff:
-                print("Resulting JSON object was: {}".format(json.dumps(result)))
-                raise AssertionError("Expected result varies on some keys {}".format(
-                                                                            json.dumps(diff)))
+        try:
+            expected_result = attr.expected_result
+        except IOError as e:
+            raise Exception("{}. Actual result was: {}".format(e, json.dumps(result)))
+        if isinstance(result, list):
+            diff = list_dicts_diff(result, expected_result)
+        else:
+            diff = dict_diff(result, expected_result)
+        if diff:
+            print("Resulting JSON object was: {}".format(json.dumps(result)))
+            raise AssertionError("Expected result varies on some keys {}".format(
+                                                                        json.dumps(diff)))
 
         for patched_attr in cls.device.patched_attrs:
             attr = getattr(cls.device, patched_attr)
@@ -106,7 +103,18 @@ def wrapper(cls, test_case):
 
         return result
 
-    return wrapper
+    @functools.wraps(func)
+    def real_wrapper(cls, test_case):
+        try:
+            return func(cls, test_case)
+        except NotImplementedError:
+            pytest.skip("Method not implemented")
+            return
+
+    if conftest.NAPALM_TEST_MOCK:
+        return mock_wrapper
+    else:
+        return real_wrapper
 
 
 class BaseTestGetters(object):

napalm_base/test/helpers.py

@@ -4,6 +4,8 @@
 from __future__ import print_function
 from __future__ import unicode_literals
 
+from napalm_base.utils import py23_compat
+
 
 def test_model(model, data):
     """Return if the dictionary `data` complies with the `model`."""
@@ -14,9 +16,12 @@ def test_model(model, data):
 
     correct_class = True
     for key, instance_class in model.items():
-        same_class = isinstance(data[key], instance_class)
-        correct_class = correct_class and same_class
-        if not same_class:
+        correct_class = isinstance(data[key], instance_class)
+        # Properly handle PY2 long
+        if py23_compat.PY2:
+            if isinstance(data[key], long) and isinstance(1, instance_class):  # noqa
+                correct_class = True
+        if not correct_class:
             print("key: {}\nmodel_class: {}\ndata_class: {}".format(
                                                     key, instance_class, data[key].__class__))
 

napalm_base/validate.py

@@ -8,6 +8,10 @@
 import yaml
 
 from napalm_base.exceptions import ValidationException
+from napalm_base.utils import py23_compat
+
+import copy
+import re
 
 
 def _get_validation_file(validation_file):
@@ -36,13 +40,22 @@ def _compare_getter_list(src, dst, mode):
     result = {"complies": True, "present": [], "missing": [], "extra": []}
     for src_element in src:
         found = False
-        for index, dst_element in enumerate(dst):
-            intermediate_match = _compare_getter(src_element, dst_element)
-            if intermediate_match:
-                found = True
-                result["present"].append(src_element)
-                dst.pop(index)
+
+        i = 0
+        while True:
+            try:
+                intermediate_match = _compare_getter(src_element, dst[i])
+                if isinstance(intermediate_match, dict) and intermediate_match["complies"] or \
+                   not isinstance(intermediate_match, dict) and intermediate_match:
+                    found = True
+                    result["present"].append(src_element)
+                    dst.pop(i)
+                    break
+                else:
+                    i += 1
+            except IndexError:
                 break
+
         if not found:
             result["complies"] = False
             result["missing"].append(src_element)
@@ -56,6 +69,7 @@ def _compare_getter_list(src, dst, mode):
 
 def _compare_getter_dict(src, dst, mode):
     result = {"complies": True, "present": {}, "missing": [], "extra": []}
+    dst = copy.deepcopy(dst)  # Otherwise we are going to modify a "live" object
 
     for key, src_element in src.items():
         try:
@@ -93,8 +107,8 @@ def _compare_getter_dict(src, dst, mode):
 
 
 def _compare_getter(src, dst):
-    if isinstance(src, str):
-        src = u'{}'.format(src)
+    if isinstance(src, py23_compat.string_types):
+        src = py23_compat.text_type(src)
 
     if isinstance(src, dict):
         mode = _mode(src.pop('_mode', ''))
@@ -106,7 +120,11 @@ def _compare_getter(src, dst):
             return _compare_getter_list(src['list'], dst, mode)
         return _compare_getter_dict(src, dst, mode)
     else:
-        return src == dst
+        if isinstance(src, py23_compat.string_types):
+            m = re.search(src, py23_compat.text_type(dst))
+            return m is not None
+        else:
+            return src == dst
 
 
 def compliance_report(cls, validation_file=None):
@@ -118,8 +136,16 @@ def compliance_report(cls, validation_file=None):
             # TBD
             pass
         else:
-            actual_results = getattr(cls, getter)()
-            report[getter] = _compare_getter(expected_results, actual_results)
+            key = expected_results.pop("_name", "") or getter
 
-    report["complies"] = all([e["complies"] for e in report.values()])
+            try:
+                kwargs = expected_results.pop('_kwargs', {})
+                actual_results = getattr(cls, getter)(**kwargs)
+                report[key] = _compare_getter(expected_results, actual_results)
+            except NotImplementedError:
+                report[key] = {"skipped": True, "reason": "NotImplemented"}
+
+    complies = all([e.get("complies", True) for e in report.values()])
+    report["skipped"] = [k for k, v in report.items() if v.get("skipped", False)]
+    report["complies"] = complies
     return report

setup.py

@@ -12,7 +12,7 @@
 
 setup(
     name="napalm-base",
-    version='0.21.0',
+    version='0.22.0',
     packages=find_packages(),
     author="David Barroso",
     author_email="[email protected]",

test/unit/TestGetNetworkDriver.py

@@ -15,13 +15,15 @@
 class TestGetNetworkDriver(unittest.TestCase):
     """Test the method get_network_driver."""
 
+    drivers_common = ('eos', 'ios', 'iosxr', 'IOS-XR', 'junos', 'ros', 'nxos',
+                      'pluribus', 'panos', 'vyos')
+    drivers_py2_only = ('fortios', 'ibm')
     if PY2:
         # All drivers support python2
-        network_drivers = ('eos', 'eos', 'fortios', 'ibm', 'ios', 'iosxr', 'IOS-XR', 'junos',
-                           'nxos', 'pluribus', 'panos')
+        network_drivers = drivers_common + drivers_py2_only
     elif PY3:
         # Drivers that support python2 and python3
-        network_drivers = ('ios',)
+        network_drivers = drivers_common
 
     @data(*network_drivers)
     def test_get_network_driver(self, driver):