tests.unit.commands.test_napps_api.TestNAppsAPI.test_list() - Code Metrics - Inspection of "Improve unit tests" - kytos/kytos-utils - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#277)

by Gleyberson

created 2020-06-11 17:44 UTC

TestNAppsAPI.test_list() A

↳ Parent: tests.unit.commands.test_napps_api

Complexity

Conditions

Size

Total Lines	18
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	14
nop	2
dl	0
loc	18
rs	9.7
c	0
b	0
f	0

"""kytos.cli.commands.napps.api.NAppsAPI tests."""
import unittest
from unittest.mock import MagicMock, call, patch

from kytos.cli.commands.napps.api import NAppsAPI


# pylint: disable=too-many-public-methods
class TestNAppsAPI(unittest.TestCase):
    """Test the class NAppsAPI."""

    def setUp(self):
        """Execute steps before each tests."""
        self.napps_api = NAppsAPI()

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_disable__all(self, mock_napps_manager):
        """Test disable method to all napps."""
        napp = ('user', 'napp', 'version')

        mgr = MagicMock()
        mgr.get_enabled.return_value = [napp]
        mock_napps_manager.return_value = mgr

        args = {'all': True}
        self.napps_api.disable(args)

        mgr.set_napp.assert_called_with(*napp)
        mgr.disable.assert_called()

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_disable__any(self, mock_napps_manager):
        """Test disable method to any napp."""
        mgr = MagicMock()
        mock_napps_manager.return_value = mgr

        napp = ('user', 'napp', 'version')
        args = {'all': False, '<napp>': [napp]}
        self.napps_api.disable(args)

        mgr.set_napp.assert_called_with(*napp)
        mgr.disable.assert_called()

    def test_disable_napp(self):
        """Test disable_napp method."""
        mgr = MagicMock()
        mgr.is_enabled.side_effect = [True, False]

        self.napps_api.disable_napp(mgr)
        self.napps_api.disable_napp(mgr)

        mgr.disable.assert_called_once()

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_enable__all(self, mock_napps_manager):
        """Test enable method to all napps."""
        napp = ('user', 'napp', 'version')

        mgr = MagicMock()
        mgr.is_enabled.return_value = False
        mgr.get_disabled.return_value = [napp]
        mock_napps_manager.return_value = mgr

        args = {'all': True}
        self.napps_api.enable(args)

        mgr.set_napp.assert_called_with(*napp)
        mgr.enable.assert_called()

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_enable__any(self, mock_napps_manager):
        """Test enable method to any napp."""
        mgr = MagicMock()
        mgr.is_enabled.return_value = False
        mock_napps_manager.return_value = mgr

        napp = ('user', 'napp', 'version')
        args = {'all': False, '<napp>': [napp]}
        self.napps_api.enable(args)

        mgr.set_napp.assert_called_with(*napp)
        mgr.enable.assert_called()

    def test_enable_napp__success(self):
        """Test enable_napp method to success case."""
        mgr = MagicMock()
        mgr.is_enabled.return_value = False

        self.napps_api.enable_napp(mgr)

        mgr.enable.assert_called()

    def test_enable_napp__error(self):
        """Test enable_napp method to error case."""
        mgr = MagicMock()
        mgr.is_enabled.return_value = True

        self.napps_api.enable_napp(mgr)

        mgr.enable.assert_not_called()

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    @patch('kytos.cli.commands.napps.api.NAppsAPI.enable_napp')
    def test_enable_napps(self, *args):
        """Test enable_napps method."""
        (mock_enable_napp, mock_napps_manager) = args
        mgr = MagicMock()
        mock_napps_manager.return_value = mgr

        napp = ('user', 'napp', 'version')
        self.napps_api.enable_napps([napp])

        mgr.set_napp.assert_called_with(*napp)
        mock_enable_napp.assert_called_with(mgr)

    @patch('kytos.cli.commands.napps.api.NAppsManager.create_napp')
    def test_create(self, mock_create_napp):
        """Test create method."""
        self.napps_api.create({})

        mock_create_napp.assert_called()

    @patch('kytos.cli.commands.napps.api.NAppsManager.upload')
    def test_upload(self, mock_upload):
        """Test upload method."""
        self.napps_api.upload({})

        mock_upload.assert_called()

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_uninstall(self, mock_napps_manager):
        """Test uninstall method."""
        mgr = MagicMock()
        mgr.is_installed.return_value = True
        mock_napps_manager.return_value = mgr

        napp = ('user', 'napp', 'version')
        args = {'<napp>': [napp]}
        self.napps_api.uninstall(args)

        mgr.set_napp.assert_called_with(*napp)
        mgr.remote_uninstall.assert_called()

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_install(self, mock_napps_manager):
        """Test install method."""
        mgr = MagicMock()
        mgr.is_installed.return_value = False
        mock_napps_manager.return_value = mgr

        napp = ('user', 'napp', 'version')
        args = {'<napp>': [napp]}
        self.napps_api.install(args)

        mgr.set_napp.assert_called_with(*napp)
        mgr.remote_install.assert_called()

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_install_napps(self, mock_napps_manager):
        """Test prepare method."""
        mgr = MagicMock()
        mgr.is_installed.return_value = False
        mock_napps_manager.return_value = mgr

        napp = ('user', 'napp', 'version')
        self.napps_api.install_napps([napp])

        mgr.set_napp.assert_called_with(*napp)
        mgr.remote_install.assert_called()

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_install_napp(self, mock_napps_manager):
        """Test install_napp method."""
        mgr = MagicMock()
        mock_napps_manager.return_value = mgr

        self.napps_api.install_napp(mgr)

        mgr.remote_install.assert_called()

    @patch('kytos.cli.commands.napps.api.NAppsManager.search')
    @patch('kytos.cli.commands.napps.api.NAppsAPI._print_napps')
    def test_search(self, *args):
        """Test search method."""
        (mock_print, mock_search) = args
        mock_search.return_value = [{'username': 'kytos', 'name': 'mef_eline',
                                     'description': '', 'tags': ['A', 'B']}]

        args = {'<pattern>': '^[a-z]+'}
        self.napps_api.search(args)

        mock_print.assert_called_with({(('kytos', 'mef_eline'), '')})

    @patch('builtins.print')
    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_print_napps(self, *args):
        """Test _print_napps method."""
        (mock_napps_manager, mock_print) = args
        napps = [('kytos', 'mef_eline')]

        mgr = MagicMock()
        mgr.get_enabled.return_value = napps
        mgr.get_installed.return_value = napps
        mock_napps_manager.return_value = mgr

        # pylint: disable=protected-access
        self.napps_api._print_napps({(('kytos', 'mef_eline'), 'desc')})
        # pylint: enable=protected-access

        mock_print.assert_has_calls([call(' [ie]  | kytos/mef_eline | desc')])

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    @patch('kytos.cli.commands.napps.api.NAppsAPI.print_napps')
    def test_list(self, *args):
        """Test list method."""
        (mock_print, mock_napps_manager) = args
        napps = [('kytos', 'mef_eline')]

        mgr = MagicMock()
        mgr.get_version.return_value = '123'
        mgr.get_description.return_value = 'desc'
        mgr.get_enabled.return_value = napps
        mgr.get_installed.return_value = napps
        mock_napps_manager.return_value = mgr

        self.napps_api.list({})

        expected = [('[ie]', 'kytos/mef_eline:123', 'desc')]
        mock_print.assert_called_with(expected)

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_delete(self, mock_napps_manager):
        """Test delete method."""
        mgr = MagicMock()
        mock_napps_manager.return_value = mgr

        napp = ('user', 'napp', 'version')
        args = {'<napp>': [napp]}
        self.napps_api.delete(args)

        mgr.set_napp.assert_called_with(*napp)
        mgr.delete.assert_called()

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_prepare(self, mock_napps_manager):
        """Test prepare method."""
        mgr = MagicMock()
        mock_napps_manager.return_value = mgr

        self.napps_api.prepare(None)

        mgr.prepare.assert_called()

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_reload__all(self, mock_napps_manager):
        """Test reload method to all napps."""
        mgr = MagicMock()
        mock_napps_manager.return_value = mgr

        args = {'all': True}
        self.napps_api.reload(args)

        mgr.reload.assert_called()

    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_reload__any(self, mock_napps_manager):
        """Test reload method to any napp."""
        mgr = MagicMock()
        mock_napps_manager.return_value = mgr

        napps = ['A', 'B', 'C']
        args = {'all': False, '<napp>': napps}
        self.napps_api.reload(args)

        mgr.reload.assert_called_with(napps)


1			"""kytos.cli.commands.napps.api.NAppsAPI tests."""
2			import unittest
3			from unittest.mock import MagicMock, call, patch
4
5			from kytos.cli.commands.napps.api import NAppsAPI
6
7
8			# pylint: disable=too-many-public-methods
9			class TestNAppsAPI(unittest.TestCase):
10			"""Test the class NAppsAPI."""
11
12			def setUp(self):
13			"""Execute steps before each tests."""
14			self.napps_api = NAppsAPI()
15
16			@patch('kytos.cli.commands.napps.api.NAppsManager')
17			def test_disable__all(self, mock_napps_manager):
18			"""Test disable method to all napps."""
19			napp = ('user', 'napp', 'version')
20
21			mgr = MagicMock()
22			mgr.get_enabled.return_value = [napp]
23			mock_napps_manager.return_value = mgr
24
25			args = {'all': True}
26			self.napps_api.disable(args)
27
28			mgr.set_napp.assert_called_with(*napp)
29			mgr.disable.assert_called()
30
31			@patch('kytos.cli.commands.napps.api.NAppsManager')
32			def test_disable__any(self, mock_napps_manager):
33			"""Test disable method to any napp."""
34			mgr = MagicMock()
35			mock_napps_manager.return_value = mgr
36
37			napp = ('user', 'napp', 'version')
38			args = {'all': False, '<napp>': [napp]}
39			self.napps_api.disable(args)
40
41			mgr.set_napp.assert_called_with(*napp)
42			mgr.disable.assert_called()
43
44			def test_disable_napp(self):
45			"""Test disable_napp method."""
46			mgr = MagicMock()
47			mgr.is_enabled.side_effect = [True, False]
48
49			self.napps_api.disable_napp(mgr)
50			self.napps_api.disable_napp(mgr)
51
52			mgr.disable.assert_called_once()
53
54			@patch('kytos.cli.commands.napps.api.NAppsManager')
55			def test_enable__all(self, mock_napps_manager):
56			"""Test enable method to all napps."""
57			napp = ('user', 'napp', 'version')
58
59			mgr = MagicMock()
60			mgr.is_enabled.return_value = False
61			mgr.get_disabled.return_value = [napp]
62			mock_napps_manager.return_value = mgr
63
64			args = {'all': True}
65			self.napps_api.enable(args)
66
67			mgr.set_napp.assert_called_with(*napp)
68			mgr.enable.assert_called()
69
70			@patch('kytos.cli.commands.napps.api.NAppsManager')
71			def test_enable__any(self, mock_napps_manager):
72			"""Test enable method to any napp."""
73			mgr = MagicMock()
74			mgr.is_enabled.return_value = False
75			mock_napps_manager.return_value = mgr
76
77			napp = ('user', 'napp', 'version')
78			args = {'all': False, '<napp>': [napp]}
79			self.napps_api.enable(args)
80
81			mgr.set_napp.assert_called_with(*napp)
82			mgr.enable.assert_called()
83
84			def test_enable_napp__success(self):
85			"""Test enable_napp method to success case."""
86			mgr = MagicMock()
87			mgr.is_enabled.return_value = False
88
89			self.napps_api.enable_napp(mgr)
90
91			mgr.enable.assert_called()
92
93			def test_enable_napp__error(self):
94			"""Test enable_napp method to error case."""
95			mgr = MagicMock()
96			mgr.is_enabled.return_value = True
97
98			self.napps_api.enable_napp(mgr)
99
100			mgr.enable.assert_not_called()
101
102			@patch('kytos.cli.commands.napps.api.NAppsManager')
103			@patch('kytos.cli.commands.napps.api.NAppsAPI.enable_napp')
104			def test_enable_napps(self, *args):
105			"""Test enable_napps method."""
106			(mock_enable_napp, mock_napps_manager) = args
107			mgr = MagicMock()
108			mock_napps_manager.return_value = mgr
109
110			napp = ('user', 'napp', 'version')
111			self.napps_api.enable_napps([napp])
112
113			mgr.set_napp.assert_called_with(*napp)
114			mock_enable_napp.assert_called_with(mgr)
115
116			@patch('kytos.cli.commands.napps.api.NAppsManager.create_napp')
117			def test_create(self, mock_create_napp):
118			"""Test create method."""
119			self.napps_api.create({})
120
121			mock_create_napp.assert_called()
122
123			@patch('kytos.cli.commands.napps.api.NAppsManager.upload')
124			def test_upload(self, mock_upload):
125			"""Test upload method."""
126			self.napps_api.upload({})
127
128			mock_upload.assert_called()
129
130			@patch('kytos.cli.commands.napps.api.NAppsManager')
131			def test_uninstall(self, mock_napps_manager):
132			"""Test uninstall method."""
133			mgr = MagicMock()
134			mgr.is_installed.return_value = True
135			mock_napps_manager.return_value = mgr
136
137			napp = ('user', 'napp', 'version')
138			args = {'<napp>': [napp]}
139			self.napps_api.uninstall(args)
140
141			mgr.set_napp.assert_called_with(*napp)
142			mgr.remote_uninstall.assert_called()
143
144			@patch('kytos.cli.commands.napps.api.NAppsManager')
145			def test_install(self, mock_napps_manager):
146			"""Test install method."""
147			mgr = MagicMock()
148			mgr.is_installed.return_value = False
149			mock_napps_manager.return_value = mgr
150
151			napp = ('user', 'napp', 'version')
152			args = {'<napp>': [napp]}
153			self.napps_api.install(args)
154
155			mgr.set_napp.assert_called_with(*napp)
156			mgr.remote_install.assert_called()
157
158			@patch('kytos.cli.commands.napps.api.NAppsManager')
159			def test_install_napps(self, mock_napps_manager):
160			"""Test prepare method."""
161			mgr = MagicMock()
162			mgr.is_installed.return_value = False
163			mock_napps_manager.return_value = mgr
164
165			napp = ('user', 'napp', 'version')
166			self.napps_api.install_napps([napp])
167
168			mgr.set_napp.assert_called_with(*napp)
169			mgr.remote_install.assert_called()
170
171			@patch('kytos.cli.commands.napps.api.NAppsManager')
172			def test_install_napp(self, mock_napps_manager):
173			"""Test install_napp method."""
174			mgr = MagicMock()
175			mock_napps_manager.return_value = mgr
176
177			self.napps_api.install_napp(mgr)
178
179			mgr.remote_install.assert_called()
180
181			@patch('kytos.cli.commands.napps.api.NAppsManager.search')
182			@patch('kytos.cli.commands.napps.api.NAppsAPI._print_napps')
183			def test_search(self, *args):
184			"""Test search method."""
185			(mock_print, mock_search) = args
186			mock_search.return_value = [{'username': 'kytos', 'name': 'mef_eline',
187			'description': '', 'tags': ['A', 'B']}]
188
189			args = {'<pattern>': '^[a-z]+'}
190			self.napps_api.search(args)
191
192			mock_print.assert_called_with({(('kytos', 'mef_eline'), '')})
193
194			@patch('builtins.print')
195			@patch('kytos.cli.commands.napps.api.NAppsManager')
196			def test_print_napps(self, *args):
197			"""Test _print_napps method."""
198			(mock_napps_manager, mock_print) = args
199			napps = [('kytos', 'mef_eline')]
200
201			mgr = MagicMock()
202			mgr.get_enabled.return_value = napps
203			mgr.get_installed.return_value = napps
204			mock_napps_manager.return_value = mgr
205
206			# pylint: disable=protected-access
207			self.napps_api._print_napps({(('kytos', 'mef_eline'), 'desc')})
208			# pylint: enable=protected-access
209
210			mock_print.assert_has_calls([call(' [ie] \| kytos/mef_eline \| desc')])
211
212			@patch('kytos.cli.commands.napps.api.NAppsManager')
213			@patch('kytos.cli.commands.napps.api.NAppsAPI.print_napps')
214			def test_list(self, *args):
215			"""Test list method."""
216			(mock_print, mock_napps_manager) = args
217			napps = [('kytos', 'mef_eline')]
218
219			mgr = MagicMock()
220			mgr.get_version.return_value = '123'
221			mgr.get_description.return_value = 'desc'
222			mgr.get_enabled.return_value = napps
223			mgr.get_installed.return_value = napps
224			mock_napps_manager.return_value = mgr
225
226			self.napps_api.list({})
227
228			expected = [('[ie]', 'kytos/mef_eline:123', 'desc')]
229			mock_print.assert_called_with(expected)
230
231			@patch('kytos.cli.commands.napps.api.NAppsManager')
232			def test_delete(self, mock_napps_manager):
233			"""Test delete method."""
234			mgr = MagicMock()
235			mock_napps_manager.return_value = mgr
236
237			napp = ('user', 'napp', 'version')
238			args = {'<napp>': [napp]}
239			self.napps_api.delete(args)
240
241			mgr.set_napp.assert_called_with(*napp)
242			mgr.delete.assert_called()
243
244			@patch('kytos.cli.commands.napps.api.NAppsManager')
245			def test_prepare(self, mock_napps_manager):
246			"""Test prepare method."""
247			mgr = MagicMock()
248			mock_napps_manager.return_value = mgr
249
250			self.napps_api.prepare(None)
251
252			mgr.prepare.assert_called()
253
254			@patch('kytos.cli.commands.napps.api.NAppsManager')
255			def test_reload__all(self, mock_napps_manager):
256			"""Test reload method to all napps."""
257			mgr = MagicMock()
258			mock_napps_manager.return_value = mgr
259
260			args = {'all': True}
261			self.napps_api.reload(args)
262
263			mgr.reload.assert_called()
264
265			@patch('kytos.cli.commands.napps.api.NAppsManager')
266			def test_reload__any(self, mock_napps_manager):
267			"""Test reload method to any napp."""
268			mgr = MagicMock()
269			mock_napps_manager.return_value = mgr
270
271			napps = ['A', 'B', 'C']
272			args = {'all': False, '<napp>': napps}
273			self.napps_api.reload(args)
274
275			mgr.reload.assert_called_with(napps)
276

kytos / kytos-utils

Pull Request — master (#277)

TestNAppsAPI.test_list() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like