tests.unit.test_core.test_napps_manager.TestNAppsManager.setUp() - Code Metrics - Inspection of "Replace `unittest` with `pytest`" - kytos-ng/kytos - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#449)

by Vinicius

created 2024-02-08 12:44 UTC

TestNAppsManager.setUp() A

↳ Parent: tests.unit.test_core.test_napps_manager

Complexity

Conditions

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	7
nop	1
dl	0
loc	9
ccs	7
cts	7
cp	1
crap	1
rs	10
c	0
b	0
f	0

"""kytos.core.napps tests."""
from unittest.mock import MagicMock, patch

from kytos.core import Controller
from kytos.core.config import KytosConfig
from kytos.core.napps import NAppsManager


# pylint: disable=protected-access, too-many-public-methods
class TestNAppsManager:
    """NAppsManager tests."""

    def setup_method(self):
        """Execute steps before each tests."""
        self.options = KytosConfig().options['daemon']
        self.controller = Controller(self.options)
        self.controller.log = MagicMock()
        self.controller.load_napp = MagicMock()
        self.controller.unload_napp = MagicMock()

        self.napps_manager = NAppsManager(self.controller)

    @staticmethod
    def get_path(files):
        """Return a Path mock."""
        path = MagicMock()
        path.exists.return_value = True
        path.glob.return_value = files
        return path

    @staticmethod
    def get_napp_mock(username='kytos', name='napp'):
        """Return a NApp mock."""
        napp = MagicMock()
        napp.username = username
        napp.name = name
        return napp

    @staticmethod
    def get_new_napps_manager():
        """Return a NewNappsManager mock."""
        napp = MagicMock()
        napp.napp_dependencies = ['file://any/kytos/napp2:1.0']

        napp_2 = MagicMock()
        napp_2.napp_dependencies = []

        new_napp_manager = MagicMock()
        new_napp_manager.napps = {'kytos/napp': napp, 'kytos/napp2': napp_2}
        return new_napp_manager

    @patch('shutil.rmtree')
    @patch('shutil.move')
    @patch('kytos.core.napps.NApp.create_from_json')
    @patch('kytos.core.napps.NApp.create_from_uri')
    @patch('kytos.core.napps.NAppsManager.get_all_napps')
    @patch('kytos.core.napps.NAppsManager._find_napp')
    def test_install(self, *args):
        """Test install method."""
        (_, _, mock_create_from_uri, mock_create_from_json, _, _) = args
        napp = MagicMock()
        mock_create_from_uri.return_value = napp
        mock_create_from_json.return_value = napp

        uri = 'file://any/kytos/napp:1.0'
        self.napps_manager._installed_path = self.get_path(['json'])
        installed = self.napps_manager.install(uri, False)

        assert installed

    @patch('shutil.rmtree')
    @patch('shutil.move')
    @patch('kytos.core.napps.NApp.create_from_json')
    @patch('kytos.core.napps.NApp.create_from_uri')
    @patch('kytos.core.napps.NAppsManager.enable')
    @patch('kytos.core.napps.NAppsManager.get_all_napps')
    @patch('kytos.core.napps.NAppsManager._find_napp')
    def test_install_and_enable(self, *args):
        """Test install method enabling the napp."""
        (_, _, mock_enable, mock_create_from_uri, mock_create_from_json, _,
         _) = args
        napp = MagicMock()
        napp.username = 'kytos'
        napp.name = 'napp'
        mock_create_from_uri.return_value = napp
        mock_create_from_json.return_value = napp

        uri = 'file://any/kytos/napp:1.0'
        self.napps_manager._installed_path = self.get_path(['json'])
        installed = self.napps_manager.install(uri, True)

        assert installed
        mock_enable.assert_called_with('kytos', 'napp')

    @patch('kytos.core.napps.NApp.create_from_uri')
    @patch('kytos.core.napps.NAppsManager.get_all_napps')
    def test_install__installed(self, *args):
        """Test install method when napp is already installed."""
        (mock_get_all_napps, mock_create_from_uri) = args
        napp = MagicMock()
        mock_create_from_uri.return_value = napp
        mock_get_all_napps.return_value = [napp]

        uri = 'file://any/kytos/napp:1.0'
        installed = self.napps_manager.install(uri, False)

        assert not installed

    @patch('kytos.core.napps.NAppsManager.is_installed', return_value=True)
    @patch('kytos.core.napps.manager.NewNAppManager')
    def test_uninstall(self, *args):
        """Test uninstall method."""
        (mock_new_napp_manager, _) = args
        mock_new_napp_manager.return_value = self.get_new_napps_manager()

        self.napps_manager._installed_path = self.get_path(['json'])
        uninstalled = self.napps_manager.uninstall('kytos', 'napp')

        assert uninstalled

    @patch('kytos.core.napps.NAppsManager.is_installed', return_value=False)
    @patch('kytos.core.napps.manager.NewNAppManager')
    def test_uninstall__not_installed(self, *args):
        """Test uninstall method when napp is not installed."""
        (mock_new_napp_manager, _) = args
        mock_new_napp_manager.return_value = self.get_new_napps_manager()

        uninstalled = self.napps_manager.uninstall('kytos', 'napp')

        assert uninstalled

    @patch('kytos.core.napps.NAppsManager.is_enabled', return_value=True)
    def test_uninstall__enabled(self, _):
        """Test uninstall method when napp is enabled."""
        uninstalled = self.napps_manager.uninstall('kytos', 'napp')

        assert not uninstalled

    @patch('kytos.core.napps.manager.NewNAppManager')
    def test_enable(self, mock_new_napp_manager):
        """Test enable method."""
        mock_new_napp_manager.return_value = self.get_new_napps_manager()

        self.napps_manager._installed_path = self.get_path(['json'])
        self.napps_manager._enabled_path = self.get_path(['json'])

        (self.napps_manager._installed_path / 'kytos/napp').is_dir. \
            return_value = True
        (self.napps_manager._enabled_path / 'kytos/napp').exists. \
            return_value = False

        enabled = self.napps_manager.enable('kytos', 'napp')

        assert enabled

    @patch('kytos.core.napps.manager.NewNAppManager')
    def test_disable(self, mock_new_napp_manager):
        """Test disable method."""
        mock_new_napp_manager.return_value = self.get_new_napps_manager()

        self.napps_manager._enabled_path = self.get_path(['json'])

        disabled = self.napps_manager.disable('kytos', 'napp')

        assert disabled

    @patch('kytos.core.napps.NAppsManager.enable')
    @patch('kytos.core.napps.NAppsManager.get_disabled_napps')
    def test_enable_all(self, *args):
        """Test enable_all method."""
        (mock_get_disabled_napps, mock_enable) = args
        napp = self.get_napp_mock()
        mock_get_disabled_napps.return_value = [napp]

        self.napps_manager.enable_all()

        mock_enable.assert_called_once()

    @patch('kytos.core.napps.NAppsManager.disable')
    @patch('kytos.core.napps.NAppsManager.get_enabled_napps')
    def test_disable_all(self, *args):
        """Test disable_all method."""
        (mock_get_enabled_napps, mock_disable) = args
        napp = self.get_napp_mock()
        mock_get_enabled_napps.return_value = [napp]

        self.napps_manager.disable_all()

        mock_disable.assert_called_once()

    @patch('kytos.core.napps.NApp.create_from_uri')
    @patch('kytos.core.napps.NAppsManager.get_enabled_napps')
    def test_is_enabled(self, *args):
        """Test is_enabled method."""
        (mock_get_enabled_napps, mock_create_from_uri) = args
        napp = MagicMock()
        mock_create_from_uri.return_value = napp
        mock_get_enabled_napps.return_value = [napp]

        is_enabled = self.napps_manager.is_enabled('kytos', 'napp')

        mock_create_from_uri.assert_called_with('kytos/napp')
        assert is_enabled

    @patch('kytos.core.napps.NApp.create_from_uri')
    @patch('kytos.core.napps.NAppsManager.get_installed_napps')
    def test_is_installed(self, *args):
        """Test is_installed method."""
        (mock_get_installed_napps, mock_create_from_uri) = args
        napp = MagicMock()
        mock_create_from_uri.return_value = napp
        mock_get_installed_napps.return_value = [napp]

        is_installed = self.napps_manager.is_installed('kytos', 'napp')

        mock_create_from_uri.assert_called_with('kytos/napp')
        assert is_installed

    def test_get_napp_fullname_from_uri(self):
        """Test get_napp_fullname_from_uri method."""
        uri = 'file://any/kytos/napp:1.0'
        username, name = self.napps_manager.get_napp_fullname_from_uri(uri)

        assert username == 'kytos'
        assert name == 'napp'

    @patch('kytos.core.napps.NApp.create_from_json')
    def test_get_all_napps(self, mock_create_from_json):
        """Test get_all_napps method."""
        napp = MagicMock()
        mock_create_from_json.return_value = napp

        json1 = MagicMock()
        json1.stat.return_value = MagicMock(st_mtime=2)

        self.napps_manager._installed_path = self.get_path([json1])
        napps = self.napps_manager.get_all_napps()

        assert napps == [napp]

    @patch('kytos.core.napps.NApp.create_from_json')
    def test_get_enabled_napps(self, mock_create_from_json):
        """Test get_enabled_napps method."""
        napp = MagicMock()
        napp.enabled = False
        mock_create_from_json.return_value = napp

        self.napps_manager._enabled_path = self.get_path([MagicMock()])
        napps = self.napps_manager.get_enabled_napps()

        assert napps == [napp]
        assert napp.enabled

    @patch('kytos.core.napps.NApp.create_from_json')
    def test_get_disabled_napps(self, mock_create_from_json):
        """Test get_disabled_napps method."""
        napp_1 = MagicMock()
        napp_2 = MagicMock()
        mock_create_from_json.side_effect = [napp_1, napp_2, napp_1]

        json1 = MagicMock()
        json1.stat.return_value = MagicMock(st_mtime=1)
        json2 = MagicMock()
        json2.stat.return_value = MagicMock(st_mtime=1)
        self.napps_manager._installed_path = self.get_path([json1, json2])
        self.napps_manager._enabled_path = self.get_path([MagicMock()])
        napps = self.napps_manager.get_disabled_napps()

        assert napps == [napp_2]

    @patch('kytos.core.napps.NApp.create_from_json')
    def test_get_installed_napps(self, mock_create_from_json):
        """Test get_installed_napps method."""
        napp = MagicMock()
        mock_create_from_json.return_value = napp

        self.napps_manager._installed_path = self.get_path([MagicMock()])
        napps = self.napps_manager.get_installed_napps()

        assert napps == [napp]

    @patch('pathlib.Path.open')
    def test_get_napp_metadata__success(self, mock_open):
        """Test get_napp_metadata method to success case."""
        data_file = MagicMock()
        data_file.read.return_value = '{"username": "kytos", \
                                        "name": "napp", \
                                        "version": "1.0"}'
        mock_open.return_value.__enter__.return_value = data_file

        meta = self.napps_manager.get_napp_metadata('kytos', 'napp', 'version')

        assert meta == '1.0'

    def test_get_napp_metadata__error(self):
        """Test get_napp_metadata method to error case."""
        meta = self.napps_manager.get_napp_metadata('kytos', 'napp', 'key')

        assert not meta

    def test_get_napps_from_path__error(self):
        """Test get_napps_from_path method to error case."""
        path = MagicMock()
        path.exists.return_value = False
        napps = self.napps_manager.get_napps_from_path(path)

        assert not napps

    @patch('kytos.core.napps.NApp.create_from_json')
    def test_get_napps_from_path__success(self, mock_create_from_json):
        """Test get_napps_from_path method to success case."""
        napp = MagicMock()
        mock_create_from_json.return_value = napp

        path = self.get_path([MagicMock()])
        napps = self.napps_manager.get_napps_from_path(path)

        assert napps == [napp]

    def test_create_module(self):
        """Test _create_module method."""
        path = MagicMock()
        path.exists.return_value = False
        self.napps_manager._create_module(path)

        path.mkdir.assert_called()
        (path / '__init__.py').touch.assert_called()

    @patch('pathlib.Path.open')
    @patch('pathlib.Path.parent', 'parent')
    @patch('pathlib.Path.exists', return_value=True)
    def test_find_napp(self, *args):
        """Test _find_napp method."""
        (_, mock_open) = args
        data_file = MagicMock()
        data_file.read.return_value = '{"username": "kytos", \
                                        "name": "napp", \
                                        "version": "1.0"}'
        mock_open.return_value.__enter__.return_value = data_file

        napp = self.get_napp_mock()
        folder = self.napps_manager._find_napp(napp)

        assert folder == 'parent'


1		"""kytos.core.napps tests."""
2	1	from unittest.mock import MagicMock, patch
3
4	1	from kytos.core import Controller
5	1	from kytos.core.config import KytosConfig
6	1	from kytos.core.napps import NAppsManager
7
8
9		# pylint: disable=protected-access, too-many-public-methods
10	1	class TestNAppsManager:
11		"""NAppsManager tests."""
12
13	1	def setup_method(self):
14		"""Execute steps before each tests."""
15	1	self.options = KytosConfig().options['daemon']
16	1	self.controller = Controller(self.options)
17	1	self.controller.log = MagicMock()
18	1	self.controller.load_napp = MagicMock()
19	1	self.controller.unload_napp = MagicMock()
20
21	1	self.napps_manager = NAppsManager(self.controller)
22
23	1	@staticmethod
24	1	def get_path(files):
25		"""Return a Path mock."""
26	1	path = MagicMock()
27	1	path.exists.return_value = True
28	1	path.glob.return_value = files
29	1	return path
30
31	1	@staticmethod
32	1	def get_napp_mock(username='kytos', name='napp'):
33		"""Return a NApp mock."""
34	1	napp = MagicMock()
35	1	napp.username = username
36	1	napp.name = name
37	1	return napp
38
39	1	@staticmethod
40	1	def get_new_napps_manager():
41		"""Return a NewNappsManager mock."""
42	1	napp = MagicMock()
43	1	napp.napp_dependencies = ['file://any/kytos/napp2:1.0']
44
45	1	napp_2 = MagicMock()
46	1	napp_2.napp_dependencies = []
47
48	1	new_napp_manager = MagicMock()
49	1	new_napp_manager.napps = {'kytos/napp': napp, 'kytos/napp2': napp_2}
50	1	return new_napp_manager
51
52	1	@patch('shutil.rmtree')
53	1	@patch('shutil.move')
54	1	@patch('kytos.core.napps.NApp.create_from_json')
55	1	@patch('kytos.core.napps.NApp.create_from_uri')
56	1	@patch('kytos.core.napps.NAppsManager.get_all_napps')
57	1	@patch('kytos.core.napps.NAppsManager._find_napp')
58	1	def test_install(self, *args):
59		"""Test install method."""
60	1	(_, _, mock_create_from_uri, mock_create_from_json, _, _) = args
61	1	napp = MagicMock()
62	1	mock_create_from_uri.return_value = napp
63	1	mock_create_from_json.return_value = napp
64
65	1	uri = 'file://any/kytos/napp:1.0'
66	1	self.napps_manager._installed_path = self.get_path(['json'])
67	1	installed = self.napps_manager.install(uri, False)
68
69	1	assert installed
70
71	1	@patch('shutil.rmtree')
72	1	@patch('shutil.move')
73	1	@patch('kytos.core.napps.NApp.create_from_json')
74	1	@patch('kytos.core.napps.NApp.create_from_uri')
75	1	@patch('kytos.core.napps.NAppsManager.enable')
76	1	@patch('kytos.core.napps.NAppsManager.get_all_napps')
77	1	@patch('kytos.core.napps.NAppsManager._find_napp')
78	1	def test_install_and_enable(self, *args):
79		"""Test install method enabling the napp."""
80	1	(_, _, mock_enable, mock_create_from_uri, mock_create_from_json, _,
81		_) = args
82	1	napp = MagicMock()
83	1	napp.username = 'kytos'
84	1	napp.name = 'napp'
85	1	mock_create_from_uri.return_value = napp
86	1	mock_create_from_json.return_value = napp
87
88	1	uri = 'file://any/kytos/napp:1.0'
89	1	self.napps_manager._installed_path = self.get_path(['json'])
90	1	installed = self.napps_manager.install(uri, True)
91
92	1	assert installed
93	1	mock_enable.assert_called_with('kytos', 'napp')
94
95	1	@patch('kytos.core.napps.NApp.create_from_uri')
96	1	@patch('kytos.core.napps.NAppsManager.get_all_napps')
97	1	def test_install__installed(self, *args):
98		"""Test install method when napp is already installed."""
99	1	(mock_get_all_napps, mock_create_from_uri) = args
100	1	napp = MagicMock()
101	1	mock_create_from_uri.return_value = napp
102	1	mock_get_all_napps.return_value = [napp]
103
104	1	uri = 'file://any/kytos/napp:1.0'
105	1	installed = self.napps_manager.install(uri, False)
106
107	1	assert not installed
108
109	1	@patch('kytos.core.napps.NAppsManager.is_installed', return_value=True)
110	1	@patch('kytos.core.napps.manager.NewNAppManager')
111	1	def test_uninstall(self, *args):
112		"""Test uninstall method."""
113	1	(mock_new_napp_manager, _) = args
114	1	mock_new_napp_manager.return_value = self.get_new_napps_manager()
115
116	1	self.napps_manager._installed_path = self.get_path(['json'])
117	1	uninstalled = self.napps_manager.uninstall('kytos', 'napp')
118
119	1	assert uninstalled
120
121	1	@patch('kytos.core.napps.NAppsManager.is_installed', return_value=False)
122	1	@patch('kytos.core.napps.manager.NewNAppManager')
123	1	def test_uninstall__not_installed(self, *args):
124		"""Test uninstall method when napp is not installed."""
125	1	(mock_new_napp_manager, _) = args
126	1	mock_new_napp_manager.return_value = self.get_new_napps_manager()
127
128	1	uninstalled = self.napps_manager.uninstall('kytos', 'napp')
129
130	1	assert uninstalled
131
132	1	@patch('kytos.core.napps.NAppsManager.is_enabled', return_value=True)
133	1	def test_uninstall__enabled(self, _):
134		"""Test uninstall method when napp is enabled."""
135	1	uninstalled = self.napps_manager.uninstall('kytos', 'napp')
136
137	1	assert not uninstalled
138
139	1	@patch('kytos.core.napps.manager.NewNAppManager')
140	1	def test_enable(self, mock_new_napp_manager):
141		"""Test enable method."""
142	1	mock_new_napp_manager.return_value = self.get_new_napps_manager()
143
144	1	self.napps_manager._installed_path = self.get_path(['json'])
145	1	self.napps_manager._enabled_path = self.get_path(['json'])
146
147	1	(self.napps_manager._installed_path / 'kytos/napp').is_dir. \
148		return_value = True
149	1	(self.napps_manager._enabled_path / 'kytos/napp').exists. \
150		return_value = False
151
152	1	enabled = self.napps_manager.enable('kytos', 'napp')
153
154	1	assert enabled
155
156	1	@patch('kytos.core.napps.manager.NewNAppManager')
157	1	def test_disable(self, mock_new_napp_manager):
158		"""Test disable method."""
159	1	mock_new_napp_manager.return_value = self.get_new_napps_manager()
160
161	1	self.napps_manager._enabled_path = self.get_path(['json'])
162
163	1	disabled = self.napps_manager.disable('kytos', 'napp')
164
165	1	assert disabled
166
167	1	@patch('kytos.core.napps.NAppsManager.enable')
168	1	@patch('kytos.core.napps.NAppsManager.get_disabled_napps')
169	1	def test_enable_all(self, *args):
170		"""Test enable_all method."""
171	1	(mock_get_disabled_napps, mock_enable) = args
172	1	napp = self.get_napp_mock()
173	1	mock_get_disabled_napps.return_value = [napp]
174
175	1	self.napps_manager.enable_all()
176
177	1	mock_enable.assert_called_once()
178
179	1	@patch('kytos.core.napps.NAppsManager.disable')
180	1	@patch('kytos.core.napps.NAppsManager.get_enabled_napps')
181	1	def test_disable_all(self, *args):
182		"""Test disable_all method."""
183	1	(mock_get_enabled_napps, mock_disable) = args
184	1	napp = self.get_napp_mock()
185	1	mock_get_enabled_napps.return_value = [napp]
186
187	1	self.napps_manager.disable_all()
188
189	1	mock_disable.assert_called_once()
190
191	1	@patch('kytos.core.napps.NApp.create_from_uri')
192	1	@patch('kytos.core.napps.NAppsManager.get_enabled_napps')
193	1	def test_is_enabled(self, *args):
194		"""Test is_enabled method."""
195	1	(mock_get_enabled_napps, mock_create_from_uri) = args
196	1	napp = MagicMock()
197	1	mock_create_from_uri.return_value = napp
198	1	mock_get_enabled_napps.return_value = [napp]
199
200	1	is_enabled = self.napps_manager.is_enabled('kytos', 'napp')
201
202	1	mock_create_from_uri.assert_called_with('kytos/napp')
203	1	assert is_enabled
204
205	1	@patch('kytos.core.napps.NApp.create_from_uri')
206	1	@patch('kytos.core.napps.NAppsManager.get_installed_napps')
207	1	def test_is_installed(self, *args):
208		"""Test is_installed method."""
209	1	(mock_get_installed_napps, mock_create_from_uri) = args
210	1	napp = MagicMock()
211	1	mock_create_from_uri.return_value = napp
212	1	mock_get_installed_napps.return_value = [napp]
213
214	1	is_installed = self.napps_manager.is_installed('kytos', 'napp')
215
216	1	mock_create_from_uri.assert_called_with('kytos/napp')
217	1	assert is_installed
218
219	1	def test_get_napp_fullname_from_uri(self):
220		"""Test get_napp_fullname_from_uri method."""
221	1	uri = 'file://any/kytos/napp:1.0'
222	1	username, name = self.napps_manager.get_napp_fullname_from_uri(uri)
223
224	1	assert username == 'kytos'
225	1	assert name == 'napp'
226
227	1	@patch('kytos.core.napps.NApp.create_from_json')
228	1	def test_get_all_napps(self, mock_create_from_json):
229		"""Test get_all_napps method."""
230	1	napp = MagicMock()
231	1	mock_create_from_json.return_value = napp
232
233	1	json1 = MagicMock()
234	1	json1.stat.return_value = MagicMock(st_mtime=2)
235
236	1	self.napps_manager._installed_path = self.get_path([json1])
237	1	napps = self.napps_manager.get_all_napps()
238
239	1	assert napps == [napp]
240
241	1	@patch('kytos.core.napps.NApp.create_from_json')
242	1	def test_get_enabled_napps(self, mock_create_from_json):
243		"""Test get_enabled_napps method."""
244	1	napp = MagicMock()
245	1	napp.enabled = False
246	1	mock_create_from_json.return_value = napp
247
248	1	self.napps_manager._enabled_path = self.get_path([MagicMock()])
249	1	napps = self.napps_manager.get_enabled_napps()
250
251	1	assert napps == [napp]
252	1	assert napp.enabled
253
254	1	@patch('kytos.core.napps.NApp.create_from_json')
255	1	def test_get_disabled_napps(self, mock_create_from_json):
256		"""Test get_disabled_napps method."""
257	1	napp_1 = MagicMock()
258	1	napp_2 = MagicMock()
259	1	mock_create_from_json.side_effect = [napp_1, napp_2, napp_1]
260
261	1	json1 = MagicMock()
262	1	json1.stat.return_value = MagicMock(st_mtime=1)
263	1	json2 = MagicMock()
264	1	json2.stat.return_value = MagicMock(st_mtime=1)
265	1	self.napps_manager._installed_path = self.get_path([json1, json2])
266	1	self.napps_manager._enabled_path = self.get_path([MagicMock()])
267	1	napps = self.napps_manager.get_disabled_napps()
268
269	1	assert napps == [napp_2]
270
271	1	@patch('kytos.core.napps.NApp.create_from_json')
272	1	def test_get_installed_napps(self, mock_create_from_json):
273		"""Test get_installed_napps method."""
274	1	napp = MagicMock()
275	1	mock_create_from_json.return_value = napp
276
277	1	self.napps_manager._installed_path = self.get_path([MagicMock()])
278	1	napps = self.napps_manager.get_installed_napps()
279
280	1	assert napps == [napp]
281
282	1	@patch('pathlib.Path.open')
283	1	def test_get_napp_metadata__success(self, mock_open):
284		"""Test get_napp_metadata method to success case."""
285	1	data_file = MagicMock()
286	1	data_file.read.return_value = '{"username": "kytos", \
287		"name": "napp", \
288		"version": "1.0"}'
289	1	mock_open.return_value.__enter__.return_value = data_file
290
291	1	meta = self.napps_manager.get_napp_metadata('kytos', 'napp', 'version')
292
293	1	assert meta == '1.0'
294
295	1	def test_get_napp_metadata__error(self):
296		"""Test get_napp_metadata method to error case."""
297	1	meta = self.napps_manager.get_napp_metadata('kytos', 'napp', 'key')
298
299	1	assert not meta
300
301	1	def test_get_napps_from_path__error(self):
302		"""Test get_napps_from_path method to error case."""
303	1	path = MagicMock()
304	1	path.exists.return_value = False
305	1	napps = self.napps_manager.get_napps_from_path(path)
306
307	1	assert not napps
308
309	1	@patch('kytos.core.napps.NApp.create_from_json')
310	1	def test_get_napps_from_path__success(self, mock_create_from_json):
311		"""Test get_napps_from_path method to success case."""
312	1	napp = MagicMock()
313	1	mock_create_from_json.return_value = napp
314
315	1	path = self.get_path([MagicMock()])
316	1	napps = self.napps_manager.get_napps_from_path(path)
317
318	1	assert napps == [napp]
319
320	1	def test_create_module(self):
321		"""Test _create_module method."""
322	1	path = MagicMock()
323	1	path.exists.return_value = False
324	1	self.napps_manager._create_module(path)
325
326	1	path.mkdir.assert_called()
327	1	(path / '__init__.py').touch.assert_called()
328
329	1	@patch('pathlib.Path.open')
330	1	@patch('pathlib.Path.parent', 'parent')
331	1	@patch('pathlib.Path.exists', return_value=True)
332	1	def test_find_napp(self, *args):
333		"""Test _find_napp method."""
334	1	(_, mock_open) = args
335	1	data_file = MagicMock()
336	1	data_file.read.return_value = '{"username": "kytos", \
337		"name": "napp", \
338		"version": "1.0"}'
339	1	mock_open.return_value.__enter__.return_value = data_file
340
341	1	napp = self.get_napp_mock()
342	1	folder = self.napps_manager._find_napp(napp)
343
344		assert folder == 'parent'
345

kytos-ng / kytos

Pull Request — master (#449)

TestNAppsManager.setUp() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like