from mock import patch, Mock
from twisted.trial import unittest
import signal
import io
import ConfigParser
from  iro import config, error 
from iro.offer.provider import Provider, providers

class TestConfig(unittest.TestCase):
    '''test config class'''
    
    def setUp(self):
        self._reloadList=config.configParser.reloadList
        config.configParser.reloadList=[]

    def tearDown(self):
        config.configParser.reloadList = self._reloadList

    @patch('iro.config.main')
    @patch('iro.config.configParser')
    def testReadConfig(self,pConfig,pMain):
        pMain.read = False
        config.readConfig()
        self.assertEqual([i[0] for i in pConfig.method_calls],["read","reload","items"])
        pConfig.read.assert_called_once_with(config.confFiles)
        pConfig.items.assert_called_once_with("main")
        pConfig.reload.assert_called_once_with()
        self.assertEqual(pMain.load.called,1)

    @patch('signal.signal')
    @patch('iro.config.readConfig')
    def testRegisterSignal(self, pReadConfig, pSignal):
        config.registerSignal()
        self.assertEqual(pSignal.call_args[0][0],signal.SIGUSR2)
        self.assertEqual(pReadConfig.called,0)
        pSignal.call_args[0][1](None, None)
        pReadConfig.assert_called_once_with()

    def testRegisterReload(self):
        def x():
            pass
        config.configParser.registerReload(x)
        self.assertEqual(config.configParser.reloadList,[x])

    def testReload(self):
        x = Mock()
        config.configParser.reloadList = [x] 
        config.configParser.reload_()
        x.assert_called_once_with()


class TestRead(unittest.TestCase):

    def tearDown(self):
        for s in config.configParser.sections():
            config.configParser.remove_section(s)

    @patch('iro.config.ConfigParser.read')
    def testMain(self,pRead):
        sample_config = """[main]
port = 8000
dburl = sdfdsafgsfdg
"""
        config.configParser.readfp(io.BytesIO(sample_config))
        config.configParser.read([])
        pRead.assert_called_once_with(config.configParser,[])

    @patch('iro.config.ConfigParser.read')
    def testMainBadPort(self,pRead):
        sample_config = """[main]
port = -8000
dburl = sadfaserasg
"""
        config.configParser.readfp(io.BytesIO(sample_config))
        self.assertRaises(error.ValidateException, config.configParser.read, [])

    @patch('iro.config.ConfigParser.read')
    def testMainNoMust(self,pRead):
        sample_config = """[main]
port = 8000
"""
        config.configParser.readfp(io.BytesIO(sample_config))
        self.assertRaises(config.NeededOption, config.configParser.read, [])

    @patch('iro.config.ConfigParser.read')
    def testMust(self,pRead):
        v=Mock()
        config.main.options["test"] = config.Option(v)
        try:
            sample_config = """[main]
dburl = sdfawersdf
port = 8000
"""
            config.configParser.readfp(io.BytesIO(sample_config))
            config.configParser.read([])
            self.assertEqual(v.called,0)
            sample_config = """[main]
dburl = adfgsdftsfg
port = 8000
test = foohu
    """
            config.configParser.readfp(io.BytesIO(sample_config))
            config.configParser.read([])
            v.assert_called_once_with("foohu","test")
        finally:
            del(config.main.options["test"])

    @patch('iro.config.ConfigParser.read')
    def testProviders(self, pRead):
        v=Mock()
        class TestProvider(Provider):
            def __init__(self,name):
                Provider.__init__(self,name)
                self.options.update({"test":config.Option(v)})
        providers["test"]=TestProvider
        try:
            sample_config = """[p]
"""
            config.configParser.readfp(io.BytesIO(sample_config))
            self.assertRaises(ConfigParser.NoOptionError, config.configParser.read, [])  
            self.assertEqual(v.called,0)
            sample_config = """[p]
typ= test
test= foo
"""
            config.configParser.readfp(io.BytesIO(sample_config))
            config.configParser.read([])
            v.assert_called_once_with("foo","test")
        finally:
            del(providers["test"])