tests.unit.commands.test_napps_api

Complexity

Total Complexity

19

Size/Duplication

Total Lines	225
Duplicated Lines	0 %

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	TestNAppsAPI.test_install_napps()	0	12	1
A	TestNAppsAPI.test_install_napp()	0	9	1
A	TestNAppsAPI.test_delete()	0	12	1
A	TestNAppsAPI.test_uninstall()	0	13	1
A	TestNAppsAPI.test_reload__any()	0	11	1
A	TestNAppsAPI.test_disable_napp()	0	9	1
A	TestNAppsAPI.test_enable_napp__success()	0	8	1
A	TestNAppsAPI.test_enable__all()	0	15	1
A	TestNAppsAPI.test_enable__any()	0	13	1
A	TestNAppsAPI.test_install()	0	13	1
A	TestNAppsAPI.test_reload__all()	0	10	1
A	TestNAppsAPI.test_enable_napp__error()	0	8	1
A	TestNAppsAPI.test_create()	0	6	1
A	TestNAppsAPI.test_disable__any()	0	12	1
A	TestNAppsAPI.setUp()	0	3	1
A	TestNAppsAPI.test_prepare()	0	9	1
A	TestNAppsAPI.test_upload()	0	6	1
A	TestNAppsAPI.test_disable__all()	0	14	1
A	TestNAppsAPI.test_enable_napps()	0	13	1

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