/*
 * Copyright 2005 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.wamblee.cache;

import junit.framework.TestCase;

import net.sf.ehcache.CacheException;

import org.wamblee.io.TestResource;

import org.wamblee.test.TimingUtils;

import java.io.IOException;


/**
 * Cached object test.
 *
 * @author Erik Brakkee
 */
public class CachedObjectTest extends TestCase {
    /**
     *
     */
    private static final String EHCACHE_CONFIG = "ehcache.xml";
    private static final int OBJECT_KEY = 10;
    private CachedObject.Computation<Integer, Integer> computation;
    private int ncomputations;

    /* (non-Javadoc)
     * @see junit.framework.TestCase#setUp()
     */
    @Override
    protected void setUp() throws Exception {
        super.setUp();
        computation = new CachedObject.Computation<Integer, Integer>() {
                    public Integer getObject(Integer aObjectKey) {
                        ncomputations++;

                        return compute(aObjectKey);
                    }
                    ;
                };
        ncomputations = 0;
    }

    private int compute(int aValue) {
        return aValue + 10;
    }

    private CachedObject<Integer, Integer> createCached(
        Cache<Integer, Integer> aCache) {
        return new CachedObject<Integer, Integer>(aCache, OBJECT_KEY,
            computation);
    }

    /**
     * Verifies that upon first use, the cached object uses the computation to
     * retrieve the object.
     *
     */
    public void testComputation() {
        CachedObject<Integer, Integer> cached = createCached(new ZeroCache<Integer, Integer>());
        int value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(1, ncomputations);
    }

    public void testInvalidateCache() {
        CachedObject<Integer, Integer> cached = createCached(new ForeverCache<Integer, Integer>());
        int value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(1, ncomputations);
        cached.invalidate();
        value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(2, ncomputations);
    }

    public void testBehaviorEhCache() throws CacheException, IOException {
        Cache<Integer, Integer> cache = new EhCache<Integer, Integer>(new TestResource(
                    CachedObjectTest.class, EHCACHE_CONFIG), "test");
        CachedObject<Integer, Integer> cached = createCached(cache);

        assertTrue(cache == cached.getCache());

        int value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(1, ncomputations);
        // The value must still be cached. 
        value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(1, ncomputations);

        // Cache expiry. 
        TimingUtils.sleep(6000);
        value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(2, ncomputations);

        // Should still be cached now.
        value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(2, ncomputations);

        // explicit invalidation.
        cached.invalidate();
        value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(3, ncomputations);
    }

    public void testBehaviorEhCacheDefault() throws CacheException, IOException {
        Cache<Integer, Integer> cache = new EhCache<Integer, Integer>(new TestResource(
                    CachedObjectTest.class, EHCACHE_CONFIG), "undefined");
        CachedObject<Integer, Integer> cached = createCached(cache);

        assertTrue(cache == cached.getCache());

        int value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(1, ncomputations);
        // The value must still be cached. 
        value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(1, ncomputations);

        // Cache expiry. 
        TimingUtils.sleep(6000);
        value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(2, ncomputations);

        // Should still be cached now.
        value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(2, ncomputations);
    }

    public void testBehaviorForeverCache() {
        CachedObject<Integer, Integer> cached = createCached(new ForeverCache<Integer, Integer>());
        int value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(1, ncomputations);

        for (int ncomp = 2; ncomp <= 100; ncomp++) {
            value = cached.get();
            assertEquals(compute(OBJECT_KEY), value);
            assertEquals(1, ncomputations);
        }
    }

    public void testBehaviorZeroCache() {
        CachedObject<Integer, Integer> cached = createCached(new ZeroCache<Integer, Integer>());
        int value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(1, ncomputations);

        for (int ncomp = 2; ncomp <= 100; ncomp++) {
            value = cached.get();
            assertEquals(compute(OBJECT_KEY), value);
            assertEquals(ncomp, ncomputations);
        }

        cached.invalidate();
        value = cached.get();
        assertEquals(compute(OBJECT_KEY), value);
        assertEquals(101, ncomputations);
    }
}