"""Test diskcache.recipes."""

import shutil
import threading
import time
import unittest

from main import Cache, Averager, Lock, RLock, BoundedSemaphore, memoize_stampede


class TestDiskCacheRecipes(unittest.TestCase):

    def setUp(self):
        self.cache = Cache()
    
    def tearDown(self):
        shutil.rmtree(self.cache.directory, ignore_errors=True)
    
    def test_averager(self):
        nums = Averager(self.cache, 'nums')
        for i in range(10):
            nums.add(i)
        self.assertEqual(nums.get(), 4.5)
        self.assertEqual(nums.pop(), 4.5)
        for i in range(20):
            nums.add(i)
        self.assertEqual(nums.get(), 9.5)
        self.assertEqual(nums.pop(), 9.5)

    def test_lock(self):
        state = {'num': 0}
        lock = Lock(self.cache, 'demo')

        def worker():
            state['num'] += 1
            with lock:
                self.assertTrue(lock.locked())
                state['num'] += 1
                time.sleep(0.1)

        with lock:
            thread = threading.Thread(target=worker)
            thread.start()
            time.sleep(0.1)
            self.assertEqual(state['num'], 1)
        thread.join()
        self.assertEqual(state['num'], 2)

    def test_rlock(self):
        state = {'num': 0}
        rlock = RLock(self.cache, 'demo')

        def worker():
            state['num'] += 1
            with rlock:
                with rlock:
                    state['num'] += 1
                    time.sleep(0.1)

        with rlock:
            thread = threading.Thread(target=worker)
            thread.start()
            time.sleep(0.1)
            self.assertEqual(state['num'], 1)
        thread.join()
        self.assertEqual(state['num'], 2)

    def test_semaphore(self):
        state = {'num': 0}
        semaphore = BoundedSemaphore(self.cache, 'demo', value=3)

        def worker():
            state['num'] += 1
            with semaphore:
                state['num'] += 1
                time.sleep(0.1)

        semaphore.acquire()
        semaphore.acquire()
        with semaphore:
            thread = threading.Thread(target=worker)
            thread.start()
            time.sleep(0.1)
            self.assertEqual(state['num'], 1)
        thread.join()
        self.assertEqual(state['num'], 2)
        semaphore.release()
        semaphore.release()

    def test_memoize_stampede(self):
        state = {'num': 0}

        @memoize_stampede(self.cache, 0.1)
        def worker(num):
            time.sleep(0.01)
            state['num'] += 1
            return num

        start = time.time()
        while (time.time() - start) < 1:
            worker(100)
        self.assertGreater(state['num'], 0)


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