webcache/tests/test_cache.py

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

from cache import ADMINISTRATION_FILE, assert_file_exists, to_dir, Cache


d = os.path.realpath('') + '/'


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(''), d)
        self.assertEqual(to_dir('foo'), d)
        self.assertEqual(to_dir('foo/'), d + 'foo/')
        self.assertEqual(to_dir('foo/bar.txt'), d + 'foo/')

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

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

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

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

    def test_add(self):
        self.c.add('baz')
        self.assertIn(d + '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(d + 'baz/foo', self.c.files)

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

    def test_assert_modification_dates_exist(self):
        self.c.assert_modification_dates_exist()
        self.assertIn(d + 'baz/foo', self.c.modified)
        self.assertEqual(self.c.modified[d + '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))