''' Tests for the Scheduler class, its built-in coroutines, and its coroutine handling.

coroutineCalls = []

@staticmethod

def dummyCoroutineFunc(start=1, end=5):

for i in range(start, end):

TestCoroutine.coroutineCalls.append(i)

Coroutine.wait();

@staticmethod

def dummyCoroutineFuncThatDoesCleanup():

for i in range(1, 6):

TestCoroutine.coroutineCalls.append(i)

try:

Coroutine.wait()

finally:

TestCoroutine.coroutineCalls.append( -1 )

def setUp(self):

TestCoroutine.coroutineCalls = []

TestCoroutine.oldCurrentTimeMillis = Coroutine.currentTimeMillis

Coroutine.currentTimeMillis = Mock(side_effect = [1,10,500,1200])

def tearDown(self):

Coroutine.currentTimeMillis = TestCoroutine.oldCurrentTimeMillis

def testCoroutinesGetCalledUntilDone(self):

# When we start a coroutine

f = TestCoroutine.dummyCoroutineFunc

coroutine = Coroutine( f )

# It's a daemon thread

self.assertTrue( coroutine.isDaemon())

# It's alive

self.assertTrue(coroutine.is_alive())

# But it doesn't run until we call it.

self.assertEqual(TestCoroutine.coroutineCalls, [] )

# Each call gets one iteration

coroutine.call()

self.assertEqual(TestCoroutine.coroutineCalls, [1] )

# And when we run it until finished...

for i in range(0,10):

coroutine.call()

# It has completed

self.assertEqual(TestCoroutine.coroutineCalls, [1,2,3,4] )

self.assertFalse( coroutine.isAlive() )

def testCoroutinesGetStoppedAndCleanedUp(self):

# When we start a coroutine

coroutine = Coroutine(TestCoroutine.dummyCoroutineFuncThatDoesCleanup)

# run it for a bit then stop it

coroutine.call()

coroutine.stop()

# It has stopped and cleaned up

self.assertFalse( coroutine.isAlive())

self.assertEquals( TestCoroutine.coroutineCalls, [1,-1] )

def testCoroutineExceptionLogging(self):

def dummyCoroutineFuncThatThrowsException():

raise Exception("Hello")

coroutine = Coroutine(dummyCoroutineFuncThatThrowsException)

coroutine.logger = Mock()

coroutine.call()

self.assertTrue(coroutine.logger.info.called)

firstParam = coroutine.logger.info.call_args[0][0]

self.assertRegexpMatches(firstParam, "Coroutine - caught exception: .*Exception.*")

self.assertRegexpMatches(coroutine.logger.debug.call_args[0][0], "Traceback.*")

def testCoroutineWaitMilliseconds(self):

def dummyCoroutineFuncWaiting1Sec():

Coroutine.waitMilliseconds(1000)

coroutine = Coroutine(dummyCoroutineFuncWaiting1Sec)

for i in range(1,3):

coroutine.call()

self.assertTrue(coroutine.is_alive(),"Coroutine dead at call %d" % i)

# Don't understand why this is failing!

coroutine.call()

self.assertFalse(coroutine.is_alive(), "Coroutine should have finished")

def testCoroutineCanHaveParameters(self):

def func(*args, **kwargs):

self.assertEquals(args, (1,))

self.assertEquals(kwargs, {"extra": 2})

coroutine = Coroutine(func, 1, extra=2)

coroutine.call()

def testWaitCanPassAndReceiveParameters(self):

def cofunc():

result = Coroutine.wait(1)

# the parameter passed in was right.

self.assertEquals(result, 2)

coroutine = Coroutine(cofunc)

#After we start the coroutine

coroutine.call()

#The next call returns the result we're expecting

self.assertEquals(coroutine.call(2), 1)

#And running it has caused the result parameter to be checked correctly before the coroutine terminated

self.assertFalse(coroutine.is_alive())

def testRunCoroutinesUntilFirstCompletes(self):

coroutine = Coroutine.runTillFirstCompletes(Coroutine(TestCoroutine.dummyCoroutineFunc,1,3),

Coroutine(TestCoroutine.dummyCoroutineFunc,1,6))

for i in range(1,10):

coroutine.call()

self.assertEquals(TestCoroutine.coroutineCalls, [1,1,2,2])

def testRunCoroutinesUntilAllComplete(self):

coroutine = Coroutine.runTillAllComplete(Coroutine(TestCoroutine.dummyCoroutineFunc,1,3),

Coroutine(TestCoroutine.dummyCoroutineFunc,1,6))

for i in range(1,10):

coroutine.call()

self.assertEquals(TestCoroutine.coroutineCalls, [1,1,2,2,3,4,5])

def testWithTimeout(self):

coroutine = Coroutine(TestCoroutine.dummyCoroutineFunc,1,20).withTimeout(1000)

for i in range(1,20):

coroutine.call()