# -*- coding: utf-8 -*-

import unittest, ConfigParser
import iro
from job import SMSJob, FAXJob, MailJob
from joblist import Joblist
from providerlist import Providerlist
import threading, xmlrpclib
from multiprocessing import Queue
from multiprocessing.managers import BaseManager

class StoppableXMLRPCServer(iro.SecureUserDBXMLRPCServer, threading.Thread):
    running=True
    def __init__(self, *args, **kwargs):
        iro.SecureUserDBXMLRPCServer.__init__(self, *args, **kwargs)
        threading.Thread.__init__(self)
   
   
    def run(self):
        # *serve_forever* muss in einem eigenen Thread laufen, damit man es
        # unterbrechen kann!
        while (self.running):
            self.handle_request()
   
   
    def stop(self):
        self.running=False
        self.server_close()


def init_server():
    userlist=[{"name":"test","password":"test",  "class":iro.User},
              {"name":"test2","password":"test2", "class": iro.User},
              {"name":"admin","password":"admin", "class": iro.Admin}]


    
    class MyManager(BaseManager):
        pass
    
    MyManager.register('SMSJob', SMSJob) 
    MyManager.register('FAXob', FAXJob) 
    MyManager.register('MailJob',MailJob) 
    MyManager.register('Providerlist',Providerlist) 
    manager = MyManager()
    manager.start()
    
    
    #anbieter erzeugen und konfigurieren
    import anbieter
    sip=anbieter.sipgate()
    sip.read_basic_config("iro.conf")
    
    localhost=iro.MySMTP()
    localhost.read_basic_config("iro.conf")

    smstrade=iro.MySmstrade()
    smstrade.read_basic_config("iro.conf")

    #Benutzerdatenbank erstellen
    queue = Queue()
    provider=Providerlist()
    provider.add("sipgate", sip, ["sms", "fax", ])
    provider.add("smstrade", smstrade, ["sms", ])
    provider.add("geonet", None, ["sms", "fax", ])
    provider.add("fax.de", None, ["sms", "fax", ])
    provider.add("localhost", localhost, ["mail", ])
    provider.setDefault("sms","smstrade")
    provider.setDefault("fax","sipgate")
    provider.setDefault("mail","localhost")
    jobqueue=Joblist(manager,  queue, provider)
    userdb=iro.MyUserDB(userlist,jobqueue)


    #Server starten
    cp = ConfigParser.ConfigParser()
    cp.read(["iro.conf"])
    cert=cp.get('server', 'cert')
    key=cp.get('server', 'key')
    serv = StoppableXMLRPCServer(addr=("localhost", 8000), 
                                      userdb=userdb,
                                      certificate=cert,privatekey=key)
    serv.relam="xmlrpc"
    return serv
 
    
class TestServer(unittest.TestCase):
    
    def setUp(self):
      self.serv = init_server()
      self.serv.start()

    def tearDown(self):
      self.serv.stop()
      xmlrpclib.Server("https://test:test@localhost:8000").status()			#letzte nachricht abrufen, damit richt geschlossen wird

    def testLogin(self):
        self.assertEqual(xmlrpclib.Server("https://test:test@localhost:8000").status(), {})
        self.assertEqual(xmlrpclib.Server("https://test2:test2@localhost:8000").status(), {})
        self.assertRaises(xmlrpclib.ProtocolError, xmlrpclib.Server("https://test2:test@localhost:8000").status)
        self.assertRaises(xmlrpclib.ProtocolError,xmlrpclib.Server ("https://test:test2@localhost:8000").status)
    
    def testsendSMS(self):
        servstr="https://test:test@localhost:8000"
        client=xmlrpclib.Server(servstr)
        id=client.startSMS("test",["01234", ] )
        self.assertEqual(client.status(id),{id: {'status': ['init',{}], 'name':  'test'}} )
        
    def testTwoUser(self):
        u1="https://test:test@localhost:8000"
        u2="https://test2:test2@localhost:8000"
        admin="https://admin:admin@localhost:8000"
        client1=xmlrpclib.Server(u1)
        client2=xmlrpclib.Server(u2)
        admin=xmlrpclib.Server(admin)
        id1=client1.startSMS("test",["01234"] )
        self.assertEqual(client2.status(),{} ) 
        self.assertEqual(admin.status(id1),{id1: {'status': ['init',{}], 'name':  'test'}} )
        id2=client2.startSMS("test2",["01234"] )
        self.assertNotEqual(id1, id2)
        self.assertEqual(client1.status(),{id1: {'status': ['init',{}], 'name':  'test'}})
        self.assertEqual(client2.status(),{id2: {'status': ['init',{}], 'name':  'test2'}})
        self.assertEqual(admin.status(),{id1: {'status': ['init',{}], 'name':   'test'},
                        id2: {'status': ['init',{}], 'name':   'test2'}} )
        
        self.assertEqual(client2.status(id1), {})
        self.assertEqual(client1.status(id2), {})
        
    def testGetProvider(self):
        servstr="https://test:test@localhost:8000"
        client=xmlrpclib.Server(servstr)       
        self.assertEqual(client.getProvider("sms"), ["fax.de","geonet", "sipgate", "smstrade"])
        self.assertEqual(client.getProvider("fax"), ["fax.de","geonet", "sipgate"])
        self.assertEqual(client.getProvider("mail"), ["localhost"])
        
        self.assertRaises(xmlrpclib.Fault,client.getProvider, "temp")
    
    def testGetDefault(self):
        servstr="https://test:test@localhost:8000"
        client=xmlrpclib.Server(servstr)       
        self.assertEqual(client.getDefaultProvider("sms"), "smstrade")
        self.assertEqual(client.getDefaultProvider("fax"),"sipgate")
        self.assertEqual(client.getDefaultProvider("mail"), "localhost")       
        
        self.assertRaises(xmlrpclib.Fault,client.getDefaultProvider, "temp")        

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