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

import unittest

import logging

from time import sleep

from multiprocessing import Queue

from multiprocessing.managers import BaseManager, ListProxy

from iro.worker import Worker

from iro.job import Job, SMSJob

from iro.anbieter.anbieter import anbieter

from iro.anbieter.content import SMS

from iro.providerlist import Providerlist

from logging.handlers import BufferingHandler

class MyHandler(BufferingHandler):

    def __init__(self,buffer=None):

        '''BufferingHandler takes a "capacity" argument

        so as to know when to flush. As we're overriding

        shouldFlush anyway, we can set a capacity of zero.

        You can call flush() manually to clear out the

        buffer.

            buffer: log messages to this buffer, needed f.ex for processes or threads'''

        BufferingHandler.__init__(self, 0)

        self.buffer=buffer

    def shouldFlush(self):

        return False

    def emit(self, record):

        if record.exc_info:                                                      #sonst geht das append schief, weil nicht picklebar

            record.exc_info=record.exc_info[:-1]                                              

        self.buffer.append(record.__dict__)

class BadJob(Job):

    def start(self,id=None):

        Job.start(self,id)

        raise Exception("Error")

#einen Manager anlegen, der Job und eine Liste anbietet

class MyManager(BaseManager):

    pass

MyManager.register('Job', Job) 

MyManager.register('SMSJob', SMSJob) 

MyManager.register('BadJob', BadJob) 

MyManager.register('list', list, ListProxy)

MyManager.register('Providerlist',Providerlist) 

class TestWorker(unittest.TestCase):

    def setUp(self):

        #erstelle eine Queue&Manager

        self.manager = MyManager()

        self.queue = Queue()

        #manager starten, damit wir Logging anpassen können

        self.manager.start()

        self.setUpLogging()

        self.providerlist=self.manager.Providerlist()

        self.providerlist.add("test", anbieter() , ["sms",  ])

        #eigentlich Workerprocess starten

        self.worker= Worker(self.queue)

        self.worker.start()

    def tearDown(self):

        #Thread&Queue stoppen

        self.stop()

        #Logging änderungen rückgängig

        self.tearDownLogging()

        self.manager.shutdown()

    def stop(self):

        self.queue.close()

        self.queue.join_thread()

        self.worker.terminate()

    def setUpLogging(self):

        '''Logging so umbasteln, das wir alle logging Meldung in self.buf sind'''

        #wir brauchen eine threadsichere liste

        self.buffer=self.manager.list()

        #Handler erstellen, der in den Buffer schreibt

        self.handler = h = MyHandler(self.buffer)

        self.logger =l= logging.getLogger()

        #Level anpassen 

        l.setLevel(logging.DEBUG)

        h.setLevel(logging.DEBUG)

        l.addHandler(h)

    def tearDownLogging(self):

        '''crazy logging hacks wieder entfernen'''

        self.logger.removeHandler(self.handler)

        self.logger.setLevel(logging.NOTSET)

        self.handler.close()

    def testJob(self):

        '''einen Job verarbeiten'''

        job=self.manager.Job(None,None,"test")

        self.assertEqual(job.getStatus(),("init",{}))

        self.queue.put(job)

        sleep(.1)

        self.stop()

        self.assertEqual(job.getStatus(),("started",{}))

        self.assertEqual([(l['levelno'],l['msg']) for l in self.buffer if l['name']=="iro.worker"],

                [(20,'Workerprocess läuft nun...'),

                 (20,'ein neuer Job(1)'),

                 (20,'Job(1) fertig ;)')])

    def testBadJob(self):

        '''einen Job verarbeiten, der fehlschlägt'''

        job=self.manager.BadJob(None,None,"test")

        self.assertEqual(job.getStatus(),("init",{}))

        self.queue.put(job)

        sleep(.1)

        self.stop()

        self.assertEqual(job.getStatus(),("error",{}))

        self.assertEqual([(l['levelno'],l['msg']) for l in self.buffer if l['name']=="iro.worker"],

                [(20,'Workerprocess läuft nun...'),

                 (20,'ein neuer Job(1)'),

                 (40,'Job(1) fehlgeschlagen :(')])

        error=Exception('Error')

        self.assertEqual(self.buffer[-1]['exc_info'][0],type(error))

        self.assertEqual(str(self.buffer[-1]['exc_info'][1]),str(error))

    def testSMSJob(self):

        job=self.manager.SMSJob(self.providerlist, "test", "name", SMS("message"),[012345])

        self.assertEqual(job.getStatus(),("init",{}))

        self.queue.put(job)

        sleep(.1)

        self.stop()

        self.assertEqual(job.getStatus(),("sended",{'failed': [], 'good': []}))

        self.assertEqual([(l['levelno'],l['msg']) for l in self.buffer if l['name']=="iro.worker"],

                [(20,'Workerprocess läuft nun...'),

                 (20,'ein neuer Job(1)'),

                 (20,'Job(1) fertig ;)')])

if __name__ == "__main__":

    unittest.main()