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 TestModuleConfig(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._init = True
        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('iro.config.main')
    @patch('iro.config.configParser')
    def testReadConfigInit(self,pConfig,pMain):
        pConfig.items.return_value = [('dburl',''),("port",1000)]
        pMain._init = False
        config.readConfig()
        self.assertEqual([i[0] for i in pConfig.method_calls],["read","reload_","items"])
        self.assertEqual([i[0] for i in pMain.method_calls],["same"])
        sa = pMain.same.call_args_list[0][0][0]
        self.assertEqual(sa.port,1000)
        self.assertEqual(sa.dburl,'')
        pMain.same.return_value = False
        self.assertRaises(Exception,config.readConfig,)

    @patch('iro.config.main')
    @patch('iro.config.configParser')
    def testInit(self,pConfig,pMain):
        pMain._init = False
        config.init()
        self.assertEqual([i[0] for i in pConfig.method_calls],["read", "items"])
        pConfig.read.assert_called_once_with(config.confFiles)
        pConfig.items.assert_called_once_with("main")
        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,default="jehei")
        try:
            sample_config = """[main]
dburl = sdfawersdf
port = 8000
"""
            config.configParser.readfp(io.BytesIO(sample_config))
            config.configParser.read([])
            self.assertEqual(v.called,0)
            config.main.load(config.configParser.items("main"))
            self.assertEqual(config.main.test,'jehei')
            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"])


class TestConfig(unittest.TestCase):
    def testSame(self):
        c1 = config.Config("1")
        c1.port = 1
        c1.dburl = "dburl1"
        c2 = config.Config("2")
        c2.port = 1
        c2.dburl = "dburl1"
        self.assertTrue(c1.same(c2))
        self.assertTrue(c1.same(c1))
        self.assertTrue(c2.same(c1))
        c2.port = 2
        self.assertFalse(c2.same(c1))
        self.assertFalse(c1.same(c2))
        c2.port = 1
        c2.dburl = "dburl2"
        self.assertFalse(c2.same(c1))
        self.assertFalse(c1.same(c2))

    def testSampleConf(self):
        c1 = config.Config("1")
        self.assertEqual(c1.sampleConf(),["[1]",
            "# Connection URL to database",
            "dburl = ","",
            "# Port under that twisted is running",
            "port = ",""])

    def testsampleConfDefault(self):
        c1 = config.Config("1")
        c1.options["port"].default = 12345
        c1.options["port"].must = False
        c1.options["dburl"].default = True
        self.assertEqual(c1.sampleConf(),["[1]",
            "# Connection URL to database",
            "dburl = True","",
            "# Port under that twisted is running",
            "# port = 12345",""])