import unittest

from iro.main import runReactor

import iro.error as IroError

import time

from xmlrpclib import Server as xServer, ServerProxy, Fault

#activates all logging we can get.

observer = log.PythonLoggingObserver()

observer.start()

class XMLRPCTest(unittest.TestCase):

    """tests for the xmlrpc interface"""

    def setUp(self):

        self.s = Process(target=startReactor, args=(md.engine,))

        self.s.start()

        #the new process needs time to get stated, so this process has to sleep

        time.sleep(.2)

    def tearDown(self):

        self.__debug().stop()

        time.sleep(.2)

        self.s.join()

    def __debug(self):

        return xServer('http://localhost:7080/debug')

    def __rpc2(self):

        return ServerProxy('http://localhost:7080/RPC2')

    def testDebugHello(self):

        '''simple test for the connection to xmlrpc server'''

        ret=self.__debug().hello()

        self.failUnlessEqual(ret,'hello')

    def testListMethods(self):

        '''list of all offical Methods, that can be executed'''

        ret=self.__rpc2().listMethods()

        self.failUnlessEqual(ret, ['listMethods', 'status', 'stop', 'sms', 'fax', 'mail', 'routes', 'defaultRoute', 'statistic'])

    def testStatus(self):

        ret = self.__rpc2().status('abcdef123456789')

        self.failUnlessEqual(ret, "<User('test','abcdef123456789')>")

    def testNoSuchUser(self):

        '''a unknown user should raise a UserNotNound Exception

        bewcause xmlrpc only has a Fault exception this Exception has to be deliverd through a xmlrpclib.Fault Exception'''

        with self.assertRaises(Fault) as fault:

            self.__rpc2().status('abcdef123456788')

        exc = fault.exception

        unf=IroError.UserNotFound()

        self.failUnlessEqual(exc.faultCode, unf.code)

        self.failUnlessEqual(exc.faultString, unf.msg)

    def testNoSuchMethod(self):

        '''a unknown mothod should raise a Exception '''

        with self.assertRaises(Fault) as fault:

            self.__rpc2().nosuchmethod()

        exc = fault.exception

        self.failUnlessEqual(exc.faultCode, 8001)

        self.failUnlessEqual(exc.faultString, "procedure nosuchmethod not found")

    def testValidation(self):

        '''a validate Exception should be translated to a xmlrpclib.Fault.'''

        with self.assertRaises(Fault) as fault:

            self.__rpc2().status('xxx')

        exc = fault.exception

        self.failUnlessEqual(exc.faultCode, 700)

        self.failUnlessEqual(exc.faultString, "Validation of 'apikey' failed.")

def startReactor(engine):

    """starts the Rector with a special debug Clild, so that the reactor can be stopped remotly. """

    from twisted.web import xmlrpc, resource

    from iro.view.xmlrpc import appendResource

            reactor.callLater(0.1,reactor.stop)

        def xmlrpc_hello(self):

            return "hello"

    root = resource.Resource()

    root = appendResource(root)

    runReactor(reactor, engine, root)

class ModuleData:

    def __init__(self):

        self.tdir = mkdtemp(prefix='iro-mysql-')

        self.server = Server('%s/my.cnf'%self.tdir)

        self.db = SampleDatabase("test","test",'%s/my.cnf'%self.tdir)

        self.engine = create_engine('mysql://test:test@localhost/test?unix_socket=%s/socket'%self.tdir,

                poolclass = pool.SingletonThreadPool,  pool_size=DB_POOL_SIZE, )

    def setUp(self):

        with open('%s/my.cnf'%self.tdir,'w') as cnf:

            cnf.write(createConfig(self.tdir))

        self.server.create()

        self.server.start()

        self.db.create()

        Base.metadata.create_all(self.engine)

        with WithSession(self.engine, autocommit=True) as session:

            session.add(User(name='test',apikey='abcdef123456789'))

    def tearDown(self):

        self.server.stop()

        shutil.rmtree(self.tdir)

md=ModuleData()

def setUpModule():

    md.setUp()

def tearDownModule():

    md.tearDown()

        unittest.main()