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

Completed

Pull Request — master (#277)

by Gleyberson

created 2020-06-08 18:55 UTC

TestNAppsAPI.test_enable__all() A

↳ Parent: tests.unit.commands.test_napps_api

Complexity

Conditions

Size

Total Lines	15
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	11
nop	2
dl	0
loc	15
rs	9.85
c	0
b	0
f	0

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

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


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')
    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, patch
4
5			from kytos.cli.commands.napps.api import NAppsAPI
6
7
8			class TestNAppsAPI(unittest.TestCase):
9			"""Test the class NAppsAPI."""
10
11			def setUp(self):
12			"""Execute steps before each tests."""
13			self.napps_api = NAppsAPI()
14
15			@patch('kytos.cli.commands.napps.api.NAppsManager')
16			def test_disable__all(self, mock_napps_manager):
17			"""Test disable method to all napps."""
18			napp = ('user', 'napp', 'version')
19
20			mgr = MagicMock()
21			mgr.get_enabled.return_value = [napp]
22			mock_napps_manager.return_value = mgr
23
24			args = {'all': True}
25			self.napps_api.disable(args)
26
27			mgr.set_napp.assert_called_with(*napp)
28			mgr.disable.assert_called()
29
30			@patch('kytos.cli.commands.napps.api.NAppsManager')
31			def test_disable__any(self, mock_napps_manager):
32			"""Test disable method to any napp."""
33			mgr = MagicMock()
34			mock_napps_manager.return_value = mgr
35
36			napp = ('user', 'napp', 'version')
37			args = {'all': False, '<napp>': [napp]}
38			self.napps_api.disable(args)
39
40			mgr.set_napp.assert_called_with(*napp)
41			mgr.disable.assert_called()
42
43			def test_disable_napp(self):
44			"""Test disable_napp method."""
45			mgr = MagicMock()
46			mgr.is_enabled.side_effect = [True, False]
47
48			self.napps_api.disable_napp(mgr)
49			self.napps_api.disable_napp(mgr)
50
51			mgr.disable.assert_called_once()
52
53			@patch('kytos.cli.commands.napps.api.NAppsManager')
54			def test_enable__all(self, mock_napps_manager):
55			"""Test enable method to all napps."""
56			napp = ('user', 'napp', 'version')
57
58			mgr = MagicMock()
59			mgr.is_enabled.return_value = False
60			mgr.get_disabled.return_value = [napp]
61			mock_napps_manager.return_value = mgr
62
63			args = {'all': True}
64			self.napps_api.enable(args)
65
66			mgr.set_napp.assert_called_with(*napp)
67			mgr.enable.assert_called()
68
69			@patch('kytos.cli.commands.napps.api.NAppsManager')
70			def test_enable__any(self, mock_napps_manager):
71			"""Test enable method to any napp."""
72			mgr = MagicMock()
73			mgr.is_enabled.return_value = False
74			mock_napps_manager.return_value = mgr
75
76			napp = ('user', 'napp', 'version')
77			args = {'all': False, '<napp>': [napp]}
78			self.napps_api.enable(args)
79
80			mgr.set_napp.assert_called_with(*napp)
81			mgr.enable.assert_called()
82
83			def test_enable_napp__success(self):
84			"""Test enable_napp method to success case."""
85			mgr = MagicMock()
86			mgr.is_enabled.return_value = False
87
88			self.napps_api.enable_napp(mgr)
89
90			mgr.enable.assert_called()
91
92			def test_enable_napp__error(self):
93			"""Test enable_napp method to error case."""
94			mgr = MagicMock()
95			mgr.is_enabled.return_value = True
96
97			self.napps_api.enable_napp(mgr)
98
99			mgr.enable.assert_not_called()
100
101			@patch('kytos.cli.commands.napps.api.NAppsManager')
102			@patch('kytos.cli.commands.napps.api.NAppsAPI.enable_napp')
103			def test_enable_napps(self, *args):
104			"""Test enable_napps method."""
105			(mock_enable_napp, mock_napps_manager) = args
106			mgr = MagicMock()
107			mock_napps_manager.return_value = mgr
108
109			napp = ('user', 'napp', 'version')
110			self.napps_api.enable_napps([napp])
111
112			mgr.set_napp.assert_called_with(*napp)
113			mock_enable_napp.assert_called_with(mgr)
114
115			@patch('kytos.cli.commands.napps.api.NAppsManager.create_napp')
116			def test_create(self, mock_create_napp):
117			"""Test create method."""
118			self.napps_api.create({})
119
120			mock_create_napp.assert_called()
121
122			@patch('kytos.cli.commands.napps.api.NAppsManager.upload')
123			def test_upload(self, mock_upload):
124			"""Test upload method."""
125			self.napps_api.upload({})
126
127			mock_upload.assert_called()
128
129			@patch('kytos.cli.commands.napps.api.NAppsManager')
130			def test_uninstall(self, mock_napps_manager):
131			"""Test uninstall method."""
132			mgr = MagicMock()
133			mgr.is_installed.return_value = True
134			mock_napps_manager.return_value = mgr
135
136			napp = ('user', 'napp', 'version')
137			args = {'<napp>': [napp]}
138			self.napps_api.uninstall(args)
139
140			mgr.set_napp.assert_called_with(*napp)
141			mgr.remote_uninstall.assert_called()
142
143			@patch('kytos.cli.commands.napps.api.NAppsManager')
144			def test_install(self, mock_napps_manager):
145			"""Test install method."""
146			mgr = MagicMock()
147			mgr.is_installed.return_value = False
148			mock_napps_manager.return_value = mgr
149
150			napp = ('user', 'napp', 'version')
151			args = {'<napp>': [napp]}
152			self.napps_api.install(args)
153
154			mgr.set_napp.assert_called_with(*napp)
155			mgr.remote_install.assert_called()
156
157			@patch('kytos.cli.commands.napps.api.NAppsManager')
158			def test_install_napps(self, mock_napps_manager):
159			"""Test prepare method."""
160			mgr = MagicMock()
161			mgr.is_installed.return_value = False
162			mock_napps_manager.return_value = mgr
163
164			napp = ('user', 'napp', 'version')
165			self.napps_api.install_napps([napp])
166
167			mgr.set_napp.assert_called_with(*napp)
168			mgr.remote_install.assert_called()
169
170			@patch('kytos.cli.commands.napps.api.NAppsManager')
171			def test_install_napp(self, mock_napps_manager):
172			"""Test install_napp method."""
173			mgr = MagicMock()
174			mock_napps_manager.return_value = mgr
175
176			self.napps_api.install_napp(mgr)
177
178			mgr.remote_install.assert_called()
179
180			@patch('kytos.cli.commands.napps.api.NAppsManager')
181			def test_delete(self, mock_napps_manager):
182			"""Test delete method."""
183			mgr = MagicMock()
184			mock_napps_manager.return_value = mgr
185
186			napp = ('user', 'napp', 'version')
187			args = {'<napp>': [napp]}
188			self.napps_api.delete(args)
189
190			mgr.set_napp.assert_called_with(*napp)
191			mgr.delete.assert_called()
192
193			@patch('kytos.cli.commands.napps.api.NAppsManager')
194			def test_prepare(self, mock_napps_manager):
195			"""Test prepare method."""
196			mgr = MagicMock()
197			mock_napps_manager.return_value = mgr
198
199			self.napps_api.prepare(None)
200
201			mgr.prepare.assert_called()
202
203			@patch('kytos.cli.commands.napps.api.NAppsManager')
204			def test_reload__all(self, mock_napps_manager):
205			"""Test reload method to all napps."""
206			mgr = MagicMock()
207			mock_napps_manager.return_value = mgr
208
209			args = {'all': True}
210			self.napps_api.reload(args)
211
212			mgr.reload.assert_called()
213
214			@patch('kytos.cli.commands.napps.api.NAppsManager')
215			def test_reload__any(self, mock_napps_manager):
216			"""Test reload method to any napp."""
217			mgr = MagicMock()
218			mock_napps_manager.return_value = mgr
219
220			napps = ['A', 'B', 'C']
221			args = {'all': False, '<napp>': napps}
222			self.napps_api.reload(args)
223
224			mgr.reload.assert_called_with(napps)
225

kytos / kytos-utils

Pull Request — master (#277)

TestNAppsAPI.test_enable__all() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like