import unittest
import os
from shutil import rmtree
from copy import copy
from cPickle import dumps

from src.cache import ADMINISTRATION_FILE, assert_file_exists, to_dir, Cache


class TestCache(unittest.TestCase):
    def setUp(self):
        if os.path.exists('baz'):
            rmtree('baz')

        os.mkdir('baz')

        for name in ('foo', 'bar', 'baz'):
            f = open('baz/' + name, 'w')
            f.write(name)
            f.close()

        self.c = Cache(files=['foo', 'bar'], root='baz')

    def tearDown(self):
        rmtree('baz')

        if os.path.exists('cached'):
            rmtree('cached')

    def test_assert_file_exists(self):
        assert_file_exists('baz/foo')
        self.assertRaises(IOError, assert_file_exists, 'foobar')

    def test_to_dir(self):
        self.assertEqual(to_dir(''), '')
        self.assertEqual(to_dir('foo'), 'foo/')
        self.assertEqual(to_dir('foo/'), 'foo/')

    def test___init__(self):
        self.assertTrue(hasattr(self.c, 'root'))
        self.assertEqual(self.c.root, 'baz/')
        self.assertTrue(hasattr(self.c, 'files'))
        self.assertEqual(self.c.files, ['baz/foo', 'baz/bar'])
        self.assertTrue(hasattr(self.c, 'cached'))
        self.assertEqual(self.c.cached, 'cached/')

    def test___init___custom_root(self):
        c = Cache(root='foo')
        self.assertTrue(hasattr(c, 'root'))
        self.assertEqual(c.root, 'foo/')

    def test___init___custom_cached_dir(self):
        c = Cache(cached='foo')
        self.assertTrue(hasattr(c, 'cached'))
        self.assertEqual(c.cached, 'foo/')

    def test___init___non_existant_file(self):
        self.assertRaises(IOError, Cache, files=['foo'])

    def test_add(self):
        self.c.add('baz')
        self.assertIn('baz/baz', self.c.files)

    def test_add_non_relative(self):
        self.c.add('baz', absolute=True)
        self.assertIn('baz', self.c.files)

    def test_remove(self):
        self.c.remove('foo')
        self.assertNotIn('baz/foo', self.c.files)

    def test_remove_non_relative(self):
        self.c.remove('baz/foo', absolute=True)
        self.assertNotIn('baz/foo', self.c.files)

    def test_assert_modification_dates_exist(self):
        self.c.assert_modification_dates_exist()
        self.assertIn('baz/foo', self.c.modified)
        self.assertEqual(self.c.modified['baz/foo'],
                         os.path.getmtime('baz/foo'))
        modified = copy(self.c.modified)

        self.c.assert_modification_dates_exist()
        self.assertEqual(self.c.modified, modified)

    def test_assert_cached_folder_exist(self):
        self.assertFalse(os.path.exists('cached'))
        self.c.assert_cached_folder_exist()
        self.assertTrue(os.path.exists('cached'))

    def test_save_administration(self):
        self.c.save_administration()
        path = 'cached/' + ADMINISTRATION_FILE
        self.assertTrue(os.path.exists(path))
        f = open(path, 'r')
        pickled = f.read()
        f.close()
        self.assertEqual(pickled, dumps(self.c.modified))