import logging
import platform

logging.basicConfig()
logger = logging.getLogger(name=__name__)

try:
    import unittest2 as unittest
except ImportError:
    import unittest

from mock import Mock, patch  # MagicMock

from leap.eip import vpnmanager  # import OpenVPNManager

_system = platform.system()


class NotImplementedError(Exception):
    pass


@patch('vpnmanager.OpenVPNManager.connect')
class MockedOpenVPNManager(vpnmanager.OpenVPNManager):
    def __init__(self, *args, **kwargs):
        self.mock_UDSTelnet = Mock()
        super(MockedOpenVPNManager, self).__init__(
            *args, **kwargs)
        self.tn = self.mock_UDSTelnet(self.host, self.port)


class OpenVPNManagerTest(unittest.TestCase):

    __name__ = "openvpn_manager_tests"

    def setUp(self):
        self.manager = MockedOpenVPNManager()

    def tearDown(self):
        del self.manager

    #
    # helpers
    #

    # XXX hey, refactor this to basetestclass

    def _missing_test_for_plat(self, do_raise=False):
        if do_raise:
            raise NotImplementedError(
                "This test is not implemented "
                "for the running platform: %s" %
                _system)

    #
    # tests
    #

    @unittest.skipIf(_system == "Windows", "lin/mac only")
    def test_lin_mac_default_init(self):
        """
        check default host for management iface
        """
        self.assertEqual(self.manager.host, '/tmp/.eip.sock')
        self.assertEqual(self.manager.port, 'unix')

    @unittest.skipUnless(_system == "Windows", "win only")
    def test_win_default_init(self):
        """
        check default host for management iface
        """
        # XXX should we make the platform specific switch
        # here or in the vpn command string building?
        self.assertEqual(self.manager.host, 'localhost')
        self.assertEqual(self.manager.port, 7777)

    def test_port_types_init(self):
        self.manager = MockedOpenVPNManager(port="42")
        self.assertEqual(self.manager.port, 42)
        self.manager = MockedOpenVPNManager()
        self.assertEqual(self.manager.port, "unix")
        self.manager = MockedOpenVPNManager(port="bad")
        self.assertEqual(self.manager.port, None)

    def test_connect_raises_missing_socket(self):
        self.manager = vpnmanager.OpenVPNManager()
        with self.assertRaises(vpnmanager.MissingSocketError):
            self.manager.connect()

    def test_uds_telnet_called_on_connect(self):
        # XXX patch UDSTelnet!
        manager = self.manager
        self.mock_UDSTelnet = Mock()
        self.manager.tn = self.mock_UDSTelnet(manager.host, manager.port)
        self.manager.connect()
        self.manager.tn.assert_called_with(
            self.manager.port,
            port=self.manager.port)

    def test_connect(self):
        pass
        # XXX calls close
        # calls UDSTelnet

    # XXX
    # tests to write:
    # UDSTelnet (for real?)
    # - raise MissingSocket
    # - raise ConnectionRefusedError
    # - test send command
    #   - tries connect
    #   - ... tries?
    #   - ... calls _seek_to_eof
    #   - ... read_until --> return value
    #   - ...


if __name__ == "__main__":
    unittest.main()