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

TestNAppsAPI.test_enable_napp__success() A
last analyzed 2021-05-31 20:20 UTC

↳ Parent: tests.unit.commands.test_napps_api

Complexity

Conditions

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	5
nop	1
dl	0
loc	8
rs	10
c	0
b	0
f	0

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

import requests

from kytos.cli.commands.napps.api import NAppsAPI
from kytos.utils.exceptions import KytosException


# 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.utils.napps.NAppsManager')

    def test_install_napp_error_404(self, mgr):
        """Test install_napp method."""
        mgr = MagicMock()

        url = 'napps.kytos.io'
        msg = 'The NApp were not found at server.'
        code = 404
        hdrs = 'The HTTP response headers'
        filep = None
        mgr.remote_install.side_effect = HTTPError(url, code, msg, hdrs, filep)
        with self.assertRaises(KytosException):
            self.napps_api.install_napp(mgr)

    @patch('kytos.utils.napps.NAppsManager')

    def test_install_napp_error_400(self, mgr):
        """Test install_napp method."""
        mgr = MagicMock()

        url = 'napps.kytos.io'
        msg = 'The NApp were not found at server.'
        code = 400
        hdrs = 'The HTTP response headers'
        filep = None
        mgr.remote_install.side_effect = HTTPError(url, code, msg, hdrs, filep)

        with self.assertRaises(KytosException):
            self.napps_api.install_napp(mgr)

    @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('os.popen')
    @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, mock_popen) = args
        napps = [('kytos', 'mef_eline')]

        mock_test = MagicMock()
        mock_test.read.return_value = '1000 1000'
        mock_popen.return_value = mock_test

        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.LOG')
    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_delete__error(self, *args):
        """Test delete method to error case."""
        (mock_napps_manager, mock_logger) = args
        response_1 = MagicMock(status_code=405, content='{"error": "info"}')
        response_2 = MagicMock(status_code=500, content='{"error": "info"}')
        mgr = MagicMock()
        mgr.delete.side_effect = [requests.HTTPError(response=response_1),
                                  requests.HTTPError(response=response_2)]
        mock_napps_manager.return_value = mgr

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

        self.napps_api.delete(args)
        self.napps_api.delete(args)

        self.assertEqual(mock_logger.error.call_count, 2)

    @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)

    @patch('kytos.cli.commands.napps.api.LOG')
    @patch('kytos.cli.commands.napps.api.NAppsManager')
    def test_reload__error(self, *args):
        """Test reload method to error case."""
        (mock_napps_manager, mock_logger) = args
        response = MagicMock(status_code=500, content='{"error": "info"}')
        mgr = MagicMock()
        mgr.reload.side_effect = requests.HTTPError(response=response)
        mock_napps_manager.return_value = mgr

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

        self.assertEqual(mock_logger.error.call_count, 1)


1		"""kytos.cli.commands.napps.api.NAppsAPI tests."""
2		import unittest
3		from unittest.mock import MagicMock, call, patch
4		from urllib.error import HTTPError
5
6		import requests
7
8		from kytos.cli.commands.napps.api import NAppsAPI
9		from kytos.utils.exceptions import KytosException
10
11
12		# pylint: disable=too-many-public-methods
13		class TestNAppsAPI(unittest.TestCase):
14		"""Test the class NAppsAPI."""
15
16		def setUp(self):
17		"""Execute steps before each tests."""
18		self.napps_api = NAppsAPI()
19
20		@patch('kytos.cli.commands.napps.api.NAppsManager')
21		def test_disable__all(self, mock_napps_manager):
22		"""Test disable method to all napps."""
23		napp = ('user', 'napp', 'version')
24
25		mgr = MagicMock()
26		mgr.get_enabled.return_value = [napp]
27		mock_napps_manager.return_value = mgr
28
29		args = {'all': True}
30		self.napps_api.disable(args)
31
32		mgr.set_napp.assert_called_with(*napp)
33		mgr.disable.assert_called()
34
35		@patch('kytos.cli.commands.napps.api.NAppsManager')
36		def test_disable__any(self, mock_napps_manager):
37		"""Test disable method to any napp."""
38		mgr = MagicMock()
39		mock_napps_manager.return_value = mgr
40
41		napp = ('user', 'napp', 'version')
42		args = {'all': False, '<napp>': [napp]}
43		self.napps_api.disable(args)
44
45		mgr.set_napp.assert_called_with(*napp)
46		mgr.disable.assert_called()
47
48		def test_disable_napp(self):
49		"""Test disable_napp method."""
50		mgr = MagicMock()
51		mgr.is_enabled.side_effect = [True, False]
52
53		self.napps_api.disable_napp(mgr)
54		self.napps_api.disable_napp(mgr)
55
56		mgr.disable.assert_called_once()
57
58		@patch('kytos.cli.commands.napps.api.NAppsManager')
59		def test_enable__all(self, mock_napps_manager):
60		"""Test enable method to all napps."""
61		napp = ('user', 'napp', 'version')
62
63		mgr = MagicMock()
64		mgr.is_enabled.return_value = False
65		mgr.get_disabled.return_value = [napp]
66		mock_napps_manager.return_value = mgr
67
68		args = {'all': True}
69		self.napps_api.enable(args)
70
71		mgr.set_napp.assert_called_with(*napp)
72		mgr.enable.assert_called()
73
74		@patch('kytos.cli.commands.napps.api.NAppsManager')
75		def test_enable__any(self, mock_napps_manager):
76		"""Test enable method to any napp."""
77		mgr = MagicMock()
78		mgr.is_enabled.return_value = False
79		mock_napps_manager.return_value = mgr
80
81		napp = ('user', 'napp', 'version')
82		args = {'all': False, '<napp>': [napp]}
83		self.napps_api.enable(args)
84
85		mgr.set_napp.assert_called_with(*napp)
86		mgr.enable.assert_called()
87
88		def test_enable_napp__success(self):
89		"""Test enable_napp method to success case."""
90		mgr = MagicMock()
91		mgr.is_enabled.return_value = False
92
93		self.napps_api.enable_napp(mgr)
94
95		mgr.enable.assert_called()
96
97		def test_enable_napp__error(self):
98		"""Test enable_napp method to error case."""
99		mgr = MagicMock()
100		mgr.is_enabled.return_value = True
101
102		self.napps_api.enable_napp(mgr)
103
104		mgr.enable.assert_not_called()
105
106		@patch('kytos.cli.commands.napps.api.NAppsManager')
107		@patch('kytos.cli.commands.napps.api.NAppsAPI.enable_napp')
108		def test_enable_napps(self, *args):
109		"""Test enable_napps method."""
110		(mock_enable_napp, mock_napps_manager) = args
111		mgr = MagicMock()
112		mock_napps_manager.return_value = mgr
113
114		napp = ('user', 'napp', 'version')
115		self.napps_api.enable_napps([napp])
116
117		mgr.set_napp.assert_called_with(*napp)
118		mock_enable_napp.assert_called_with(mgr)
119
120		@patch('kytos.cli.commands.napps.api.NAppsManager.create_napp')
121		def test_create(self, mock_create_napp):
122		"""Test create method."""
123		self.napps_api.create({})
124
125		mock_create_napp.assert_called()
126
127		@patch('kytos.cli.commands.napps.api.NAppsManager.upload')
128		def test_upload(self, mock_upload):
129		"""Test upload method."""
130		self.napps_api.upload({})
131
132		mock_upload.assert_called()
133
134		@patch('kytos.cli.commands.napps.api.NAppsManager')
135		def test_uninstall(self, mock_napps_manager):
136		"""Test uninstall method."""
137		mgr = MagicMock()
138		mgr.is_installed.return_value = True
139		mock_napps_manager.return_value = mgr
140
141		napp = ('user', 'napp', 'version')
142		args = {'<napp>': [napp]}
143		self.napps_api.uninstall(args)
144
145		mgr.set_napp.assert_called_with(*napp)
146		mgr.remote_uninstall.assert_called()
147
148		@patch('kytos.cli.commands.napps.api.NAppsManager')
149		def test_install(self, mock_napps_manager):
150		"""Test install method."""
151		mgr = MagicMock()
152		mgr.is_installed.return_value = False
153		mock_napps_manager.return_value = mgr
154
155		napp = ('user', 'napp', 'version')
156		args = {'<napp>': [napp]}
157		self.napps_api.install(args)
158
159		mgr.set_napp.assert_called_with(*napp)
160		mgr.remote_install.assert_called()
161
162		@patch('kytos.cli.commands.napps.api.NAppsManager')
163		def test_install_napps(self, mock_napps_manager):
164		"""Test prepare method."""
165		mgr = MagicMock()
166		mgr.is_installed.return_value = False
167		mock_napps_manager.return_value = mgr
168
169		napp = ('user', 'napp', 'version')
170		self.napps_api.install_napps([napp])
171
172		mgr.set_napp.assert_called_with(*napp)
173		mgr.remote_install.assert_called()
174
175		@patch('kytos.cli.commands.napps.api.NAppsManager')
176		def test_install_napp(self, mock_napps_manager):
177		"""Test install_napp method."""
178		mgr = MagicMock()
179		mock_napps_manager.return_value = mgr
180
181		self.napps_api.install_napp(mgr)
182
183		mgr.remote_install.assert_called()
184
185	View Code Duplication	@patch('kytos.utils.napps.NAppsManager')
		0 ignored issues – show Duplication introduced 2020-08-14 00:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
186		def test_install_napp_error_404(self, mgr):
187		"""Test install_napp method."""
188		mgr = MagicMock()
189
190		url = 'napps.kytos.io'
191		msg = 'The NApp were not found at server.'
192		code = 404
193		hdrs = 'The HTTP response headers'
194		filep = None
195		mgr.remote_install.side_effect = HTTPError(url, code, msg, hdrs, filep)
196		with self.assertRaises(KytosException):
197		self.napps_api.install_napp(mgr)
198
199	View Code Duplication	@patch('kytos.utils.napps.NAppsManager')
		0 ignored issues – show Duplication introduced 2020-08-14 00:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
200		def test_install_napp_error_400(self, mgr):
201		"""Test install_napp method."""
202		mgr = MagicMock()
203
204		url = 'napps.kytos.io'
205		msg = 'The NApp were not found at server.'
206		code = 400
207		hdrs = 'The HTTP response headers'
208		filep = None
209		mgr.remote_install.side_effect = HTTPError(url, code, msg, hdrs, filep)
210
211		with self.assertRaises(KytosException):
212		self.napps_api.install_napp(mgr)
213
214		@patch('kytos.cli.commands.napps.api.NAppsManager.search')
215		@patch('kytos.cli.commands.napps.api.NAppsAPI._print_napps')
216		def test_search(self, *args):
217		"""Test search method."""
218		(mock_print, mock_search) = args
219		mock_search.return_value = [{'username': 'kytos', 'name': 'mef_eline',
220		'description': '', 'tags': ['A', 'B']}]
221
222		args = {'<pattern>': '^[a-z]+'}
223		self.napps_api.search(args)
224
225		mock_print.assert_called_with({(('kytos', 'mef_eline'), '')})
226
227		@patch('os.popen')
228		@patch('builtins.print')
229		@patch('kytos.cli.commands.napps.api.NAppsManager')
230		def test_print_napps(self, *args):
231		"""Test _print_napps method."""
232		(mock_napps_manager, mock_print, mock_popen) = args
233		napps = [('kytos', 'mef_eline')]
234
235		mock_test = MagicMock()
236		mock_test.read.return_value = '1000 1000'
237		mock_popen.return_value = mock_test
238
239		mgr = MagicMock()
240		mgr.get_enabled.return_value = napps
241		mgr.get_installed.return_value = napps
242		mock_napps_manager.return_value = mgr
243
244		# pylint: disable=protected-access
245		self.napps_api._print_napps({(('kytos', 'mef_eline'), 'desc')})
246		# pylint: enable=protected-access
247
248		mock_print.assert_has_calls([call(' [ie] \| kytos/mef_eline \| desc')])
249
250		@patch('kytos.cli.commands.napps.api.NAppsManager')
251		@patch('kytos.cli.commands.napps.api.NAppsAPI.print_napps')
252		def test_list(self, *args):
253		"""Test list method."""
254		(mock_print, mock_napps_manager) = args
255		napps = [('kytos', 'mef_eline')]
256
257		mgr = MagicMock()
258		mgr.get_version.return_value = '123'
259		mgr.get_description.return_value = 'desc'
260		mgr.get_enabled.return_value = napps
261		mgr.get_installed.return_value = napps
262		mock_napps_manager.return_value = mgr
263
264		self.napps_api.list({})
265
266		expected = [('[ie]', 'kytos/mef_eline:123', 'desc')]
267		mock_print.assert_called_with(expected)
268
269		@patch('kytos.cli.commands.napps.api.NAppsManager')
270		def test_delete(self, mock_napps_manager):
271		"""Test delete method."""
272		mgr = MagicMock()
273		mock_napps_manager.return_value = mgr
274
275		napp = ('user', 'napp', 'version')
276		args = {'<napp>': [napp]}
277		self.napps_api.delete(args)
278
279		mgr.set_napp.assert_called_with(*napp)
280		mgr.delete.assert_called()
281
282		@patch('kytos.cli.commands.napps.api.LOG')
283		@patch('kytos.cli.commands.napps.api.NAppsManager')
284		def test_delete__error(self, *args):
285		"""Test delete method to error case."""
286		(mock_napps_manager, mock_logger) = args
287		response_1 = MagicMock(status_code=405, content='{"error": "info"}')
288		response_2 = MagicMock(status_code=500, content='{"error": "info"}')
289		mgr = MagicMock()
290		mgr.delete.side_effect = [requests.HTTPError(response=response_1),
291		requests.HTTPError(response=response_2)]
292		mock_napps_manager.return_value = mgr
293
294		napp = ('user', 'napp', 'version')
295		args = {'<napp>': [napp]}
296
297		self.napps_api.delete(args)
298		self.napps_api.delete(args)
299
300		self.assertEqual(mock_logger.error.call_count, 2)
301
302		@patch('kytos.cli.commands.napps.api.NAppsManager')
303		def test_prepare(self, mock_napps_manager):
304		"""Test prepare method."""
305		mgr = MagicMock()
306		mock_napps_manager.return_value = mgr
307
308		self.napps_api.prepare(None)
309
310		mgr.prepare.assert_called()
311
312		@patch('kytos.cli.commands.napps.api.NAppsManager')
313		def test_reload__all(self, mock_napps_manager):
314		"""Test reload method to all napps."""
315		mgr = MagicMock()
316		mock_napps_manager.return_value = mgr
317
318		args = {'all': True}
319		self.napps_api.reload(args)
320
321		mgr.reload.assert_called()
322
323		@patch('kytos.cli.commands.napps.api.NAppsManager')
324		def test_reload__any(self, mock_napps_manager):
325		"""Test reload method to any napp."""
326		mgr = MagicMock()
327		mock_napps_manager.return_value = mgr
328
329		napps = ['A', 'B', 'C']
330		args = {'all': False, '<napp>': napps}
331		self.napps_api.reload(args)
332
333		mgr.reload.assert_called_with(napps)
334
335		@patch('kytos.cli.commands.napps.api.LOG')
336		@patch('kytos.cli.commands.napps.api.NAppsManager')
337		def test_reload__error(self, *args):
338		"""Test reload method to error case."""
339		(mock_napps_manager, mock_logger) = args
340		response = MagicMock(status_code=500, content='{"error": "info"}')
341		mgr = MagicMock()
342		mgr.reload.side_effect = requests.HTTPError(response=response)
343		mock_napps_manager.return_value = mgr
344
345		args = {'all': True}
346		self.napps_api.reload(args)
347
348		self.assertEqual(mock_logger.error.call_count, 1)
349

kytos / kytos-utils

TestNAppsAPI.test_enable_napp__success() A last analyzed 2021-05-31 20:20 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

TestNAppsAPI.test_enable_napp__success() A
last analyzed 2021-05-31 20:20 UTC