[qa] Add mocks to unit tests

docs/source/topics/usage.rst

@@ -30,24 +30,24 @@ Further example will be found inside dedicated docs for every backend
 Running tests
 *************
 
-Install nose::
+Install test reqirements::
 
-    pip install nose
+    pip install -r reqirements.txt
+    pip install -r requirements-test.txt
 
 Clone repo::
 
     git clone git://github.com/openwisp/netengine
 
-    cd netengine/
+    ./runtests.py
 
-Edit settings json file according to your network::
+To run tests on real devices, first copy the settings file::
 
     cp test-settings.example.json test-settings.json
-    vim test-settings.json
 
-Run tests with::
+Then change the credentials accordingly, now run tests with::
 
-    nosetests
+    DISABLE_MOCKS=1 TEST_SETTINGS_FILE='test-settings.json' ./runtests.py
 
 See test coverage with::
 
@@ -62,3 +62,6 @@ Run specific tests by specifying the relative path::
     nosetests tests.snmp
     # snmp openwrt specific tests
     nosetests tests.snmp.openwrt
+
+    # run without mocks with a custom test file
+    DISABLE_MOCKS=1 TEST_SETTINGS_FILE='test-settings.json' nosetests tests.snmp

netengine/backends/base.py

@@ -1,7 +1,7 @@
 import json
 
 from netengine.shortcuts import OrderedDict
-from netaddr import EUI, NotRegisteredError, AddrFormatError
+from netaddr import EUI, NotRegisteredError
 
 
 __all__ = [
@@ -135,7 +135,9 @@ def get_interfaces(self):
 
     def get_manufacturer(self, mac_address):
         """ returns the manufacturer of the network interface """
+        if not mac_address:
+            return ''
         try:
             return EUI(mac_address).oui.registration().org
-        except (NotRegisteredError, AddrFormatError):
-            return None
+        except NotRegisteredError:
+            return ''

requirements-test.txt

@@ -0,0 +1,2 @@
+nose
+coverage

requirements.txt

@@ -1,4 +1,5 @@
 netaddr
 pysnmp
 ipaddress
-argparse
+argparse
+mock

runtests.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+try:
+    import nose
+except:
+    message = """nose package not installed, install test requirements with:
+    pip install -r requirements-test.txt
+    """
+    raise ImportError(message)
+
+if __name__ == "__main__":
+    file_path = os.path.abspath(__file__)
+    tests_path = os.path.join(os.path.abspath(os.path.dirname(file_path)), "tests")
+    result = nose.run(
+        argv=[
+            os.path.abspath(__file__),
+            "--with-cov",
+            "--cover-package=netengine",
+            tests_path
+        ]
+    )

test-settings.example.json

@@ -1,17 +1,17 @@
 {
     "base-snmp": {
-        "host": "yourhost",
+        "host": "0.0.0.0",
         "community": "public",
         "port": 161
     },
     "airos-snmp": {
-        "host": "your_airos_device",
+        "host": "0.0.0.0",
         "community": "public",
         "port": 161
     },
     "openwrt-snmp": {
-        "host": "your_openwrt_device",
+        "host": "0.0.0.0",
         "community": "public",
         "port": 161
     }
-}
+}

tests/base.py

@@ -2,7 +2,7 @@
 
 from netengine import get_version, __version__
 from netengine.backends import BaseBackend
-from netengine.exceptions import NetEngineError
+from netaddr import AddrFormatError
 
 
 __all__ = ['TestBaseBackend']
@@ -89,4 +89,5 @@ def test_base_backend(self):
 
     def test_get_manufacturer_unicode(self):
         device = BaseBackend()
-        self.assertIsNone(device.get_manufacturer(u"wrong MAC"))
+        with self.assertRaises(AddrFormatError):
+            device.get_manufacturer(u"wrong MAC")

tests/settings.py

@@ -1,3 +1,6 @@
 import json
+import os
 
-settings = json.loads(open('./test-settings.json').read())
+settings_file = os.getenv('TEST_SETTINGS_FILE', './test-settings.example.json')
+settings = json.loads(open(settings_file).read())
+settings['disable_mocks'] = os.getenv('DISABLE_MOCKS', '0') is '1'

tests/snmp/airos.py

@@ -1,27 +1,49 @@
 import unittest
 from netengine.backends.snmp import AirOS
 from netengine.exceptions import NetEngineError
+from pysnmp.entity.rfc3413.oneliner import cmdgen
+from pysnmp.smi.error import NoSuchObjectError
 
 from ..settings import settings
+from ..utils import MockOutputMixin, SpyMock
 
 
 __all__ = ['TestSNMPAirOS']
 
 
-class TestSNMPAirOS(unittest.TestCase):
+class TestSNMPAirOS(unittest.TestCase, MockOutputMixin):
 
     def setUp(self):
         self.host = settings['airos-snmp']['host']
         self.community = settings['airos-snmp']['community']
         self.port = settings['airos-snmp'].get('port', 161)
-
         self.device = AirOS(self.host, self.community, port=self.port)
+
+        # mock calls being made to devices
+        self.oid_mock_data = self._load_mock_json('/static/test-airos-snmp.json')
+        self.nextcmd_patcher = SpyMock._patch(
+            target=cmdgen.CommandGenerator,
+            attribute='nextCmd',
+            wrap_obj=self.device._command,
+            return_value=[0, 0, 0, [[[0, 1]]] * 5]
+        )
+        self.getcmd_patcher = SpyMock._patch(
+            target=cmdgen.CommandGenerator,
+            attribute='getCmd',
+            wrap_obj=self.device._command,
+            side_effect=lambda *args: self._get_mocked_getcmd(
+                data=self.oid_mock_data, input=args
+            ),
+        )
+        self.getcmd_patcher.start()
 
     def test_get_value_error(self):
-        with self.assertRaises(NetEngineError):
+        self.getcmd_patcher.stop()
+        with self.assertRaises(NoSuchObjectError):
             self.device.get_value('.')
 
     def test_validate_negative_result(self):
+        self.getcmd_patcher.stop()
         wrong = AirOS('10.40.0.254', 'wrong', 'wrong')
         self.assertRaises(NetEngineError, wrong.validate)
 
@@ -31,10 +53,8 @@ def test_validate_positive_result(self):
     def test_get(self):
         with self.assertRaises(AttributeError):
             self.device.get({})
-
         with self.assertRaises(AttributeError):
             self.device.get(object)
-
         self.device.get('1,3,6,1,2,1,1,5,0')
         self.device.get(u'1,3,6,1,2,1,1,5,0')
         self.device.get((1,3,6,1,2,1,1,5,0))
@@ -51,67 +71,101 @@ def test_properties(self):
         device.uptime_tuple
 
     def test_name(self):
-        self.assertTrue(type(self.device.name) == str)
+        self.assertIsInstance(self.device.name, str)
 
     def test_os(self):
-        self.assertTrue(type(self.device.os) == tuple)
+        self.assertIsInstance(self.device.os, tuple)
 
     def test_get_interfaces(self):
-        self.assertTrue(type(self.device.get_interfaces()) == list)
+        with self.nextcmd_patcher:
+            self.assertIsInstance(self.device.get_interfaces(), list)
 
     def test_get_interfaces_mtu(self):
-        self.assertTrue(type(self.device.interfaces_mtu) == list)
+        with self.nextcmd_patcher:
+            self.assertIsInstance(self.device.interfaces_mtu, list)
 
     def test_interfaces_state(self):
-        self.assertTrue(type(self.device.interfaces_state) == list)
+        with self.nextcmd_patcher:
+            self.assertIsInstance(self.device.interfaces_state, list)
 
     def test_interfaces_speed(self):
-        self.assertTrue(type(self.device.interfaces_speed) == list)
+        with self.nextcmd_patcher:
+            self.assertIsInstance(self.device.interfaces_speed, list)
 
     def test_interfaces_bytes(self):
-        self.assertTrue(type(self.device.interfaces_bytes) == list)
+        with self.nextcmd_patcher:
+            self.assertIsInstance(self.device.interfaces_bytes, list)
 
     def test_interfaces_MAC(self):
-        self.assertTrue(type(self.device.interfaces_MAC) == list)
+        with self.nextcmd_patcher:
+            self.assertIsInstance(self.device.interfaces_MAC, list)
 
     def test_interfaces_type(self):
-        self.assertTrue(type(self.device.interfaces_type) == list)
+        with self.nextcmd_patcher:
+            self.assertIsInstance(self.device.interfaces_type, list)
 
     def test_interfaces_to_dict(self):
-        self.assertTrue(type(self.device.interfaces_to_dict) == list)
-
+        with self.nextcmd_patcher:
+            self.assertIsInstance(self.device.interfaces_to_dict, list)
+
     def test_wireless_dbm(self):
-        self.assertTrue(type(self.device.wireless_dbm) == list)
+        with self.nextcmd_patcher:
+            self.assertIsInstance(self.device.wireless_dbm, list)
 
     def test_interfaces_number(self):
-        self.assertTrue(type(self.device.interfaces_number) == int)
+        self.assertIsInstance(self.device.interfaces_number, int)
 
     def test_wireless_to_dict(self):
-        self.assertTrue(type(self.device.wireless_links) == list)
+        with self.nextcmd_patcher as np:
+            SpyMock._update_patch(
+                np,
+                _mock_side_effect=lambda *args: self._get_mocked_wireless_links(
+                    data=args
+                ),
+            )
+            self.assertIsInstance(self.device.wireless_links, list)
 
     def test_RAM_free(self):
-        self.assertTrue(type(self.device.RAM_free) == int)
+        self.assertIsInstance(self.device.RAM_free, int)
 
     def test_RAM_total(self):
-        self.assertTrue(type(self.device.RAM_total) == int)
+        self.assertIsInstance(self.device.RAM_total, int)
 
     def test_to_dict(self):
-        self.assertTrue(isinstance(self.device.to_dict(), dict))
+        with self.nextcmd_patcher as np:
+            SpyMock._update_patch(
+                np,
+                _mock_side_effect=lambda *args: self._get_mocked_wireless_links(
+                    data=args
+                ),
+            )
+            self.assertTrue(isinstance(self.device.to_dict(), dict))
 
     def test_manufacturer_to_dict(self):
-        self.assertIsNotNone(self.device.to_dict()['manufacturer'])
+        with self.nextcmd_patcher as np:
+            SpyMock._update_patch(
+                np,
+                _mock_side_effect=lambda *args: self._get_mocked_wireless_links(
+                    data=args
+                ),
+            )
+            self.assertIsNotNone(self.device.to_dict()['manufacturer'])
 
     def test_manufacturer(self):
-        self.assertIsNotNone(self.device.manufacturer)
+        with self.nextcmd_patcher:
+            self.assertIsNotNone(self.device.manufacturer)
 
     def test_model(self):
-        self.assertTrue(type(self.device.model) == str)
+        self.assertIsInstance(self.device.model, str)
 
     def test_firmware(self):
-        self.assertTrue(type(self.device.firmware) == str)
+        self.assertIsInstance(self.device.firmware, str)
 
     def test_uptime(self):
-        self.assertTrue(type(self.device.uptime) == int)
+        self.assertIsInstance(self.device.uptime, int)
 
     def test_uptime_tuple(self):
-        self.assertTrue(type(self.device.uptime_tuple) == tuple)
+        self.assertIsInstance(self.device.uptime_tuple, tuple)
+
+    def tearDown(self):
+        self.getcmd_patcher.stop()