cache/tests/cache.html

	cache.html revision c28f85fdfe5f4318a887f384ac1e58d40414fdba
2N/A<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
2N/A<html>
2N/A<head>
2N/A<title>Cache Tests</title>
2N/A<script type="text/javascript" src="/build/yui/yui.js"></script>
2N/A<script type="text/javascript" src="/build/cache/cache-debug.js"></script>
2N/A</head>
2N/A
2N/A<body class="yui3-skin-sam">
2N/A<h1>Cache Tests</h1>
2N/A<p><input type="button" value="Run Tests" id="btnRun" disabled=true></p>
2N/A
2N/A<script type="text/javascript">
2N/A(function() {
2N/A    YUI({
2N/A        base: "/build/",
2N/A        //filter: "debug",
2N/A        logInclude:{"TestRunner":true},
2N/A        useConsole: true
2N/A    }).use("console", "test", "dump", "cache", function(Y) {
2N/A
2N/A        // Set up the page
2N/A        var ASSERT = Y.Assert,
2N/A            ARRAYASSERT = Y.ArrayAssert,
2N/A            BTNRUN = Y.get("#btnRun");
2N/A        BTNRUN.set("disabled", false);
2N/A        Y.on("click", function(e){
2N/A            Y.Test.Runner.run();
2N/A        }, BTNRUN);
2N/A        var myConsole = new Y.Console().render();
2N/A
2N/A
2N/A        var testClass = new Y.Test.Case({
2N/A            name: "Class Tests",
2N/A
2N/A            testDefaults: function() {
2N/A                // TODO: remove empty config
2N/A                var cache = new Y.Cache({});
2N/A                cache.add(1, "a");
2N/A                ASSERT.isInstanceOf(Y.Cache, cache, "Expected instance of Y.Cache.");
2N/A                ASSERT.areSame(0, cache.get("max"), "Expected default max of 0.");
2N/A                ARRAYASSERT.isEmpty(cache.get("entries"), "Expected empty array.");
2N/A            },
2N/A
2N/A            testDestructor: function() {
2N/A                // TODO: remove empty config
2N/A                var cache = new Y.Cache({});
2N/A                cache.destroy();
2N/A                ASSERT.isNull(cache.get("entries"), "Expected null array.");
2N/A            }
2N/A        });
2N/A
2N/A        var testBasic = new Y.Test.Case({
2N/A            name: "Basic Tests",
2N/A
2N/A            testmax0: function() {
2N/A                // TODO: remove empty config
2N/A                var cache = new Y.Cache({});
2N/A                ASSERT.areSame(0, cache.get("max"), "Expected max to be 0.");
2N/A
2N/A                cache.add(1, "a");
                ASSERT.areSame(0, cache.get("size"), "Expected 0 entries.");
                ASSERT.isNull(cache.retrieve(1), "Expected null cached response.");
            },

            testmax2: function() {
                var cache = new Y.Cache({max:2});
                ASSERT.areSame(2, cache.get("max"), "Expected max to be 2.");

                cache.add(1, "a");
                ASSERT.areSame(1, cache.get("size"), "Expected 1 entry.");
                cache.add(2, "b");
                ASSERT.areSame(2, cache.get("size"), "Expected 2 entries.");
                cache.add(3, "c");
                ASSERT.areSame(2, cache.get("size"), "Expected 2 entries (still).");
            },

            testmax2to1: function() {
                var cache = new Y.Cache({max:2});
                cache.add(1, "a");
                cache.add(2, "b");
                cache.set("max", 1);
                ASSERT.areSame(1, cache.get("size"), "Expected 1 entry.");

                cache.add(3, "c");
                ASSERT.areSame(1, cache.get("size"), "Expected 1 entry (still).");
            },

            testmax2to0: function() {
                var cache = new Y.Cache({max:2});
                cache.add(1, "a");
                cache.add(2, "b");
                cache.set("max", 0);
                ARRAYASSERT.isEmpty(cache.get("entries"), "Expected empty array.");
                cache.add(3, "c");
                ARRAYASSERT.isEmpty(cache.get("entries"), "Expected empty array (still).");
            },

            testmax2toNegative: function() {
                var cache = new Y.Cache({max:2});
                cache.add(1, "a");
                cache.add(2, "b");
                cache.set("max", -5);
                ARRAYASSERT.isEmpty(cache.get("entries"), "Expected empty array.");
                cache.add(3, "c");
                ARRAYASSERT.isEmpty(cache.get("entries"), "Expected empty array (still).");
                ASSERT.areSame(-5, cache.get("max"), "Expected negative value normalized to 0.");
            },

            testRetrieve: function() {
                var cache = new Y.Cache({max:2}),
                    cachedresponse;
                cache.add(1, "a");
                cache.add("b", "c");
                cachedresponse = cache.retrieve(1).response;
                ASSERT.areSame("a", cachedresponse, "Expected first cached response.");

                cachedresponse = cache.retrieve("b").response;
                ASSERT.areSame("c", cachedresponse, "Expected second cached response.");
            },

            testNoMatch: function() {
                var cache = new Y.Cache({max:2}),
                    cachedentry;
                cache.add("a", "b");
                cachedentry = cache.retrieve("c");
                ASSERT.areSame(null, cachedentry, "Expected no match.");
            },

            testFlush: function() {
                var cache = new Y.Cache({max:2});
                cache.add(1, "a");
                cache.add(2, "b");
                cache.flush();
                ASSERT.areSame(0, cache.get("size"), "Expected empty cache.");
            }
        });

        var testEvents = new Y.Test.Case({
            name: "Event Tests",

            testAdd: function() {
                var cache = new Y.Cache({max:2});
                cache.on("add", function(e) {
                    this.resume(function() {
                        ASSERT.areSame(1, e.entry.request);
                        ASSERT.areSame("a", e.entry.response);
                    });
                }, this, true);
                cache.add(1, "a");
                this.wait();
            },

            testFlush: function() {
                var cache = new Y.Cache({max:2});
                cache.on("flush", function(e) {
                    this.resume(function() {
                        // This function intentionally left blank
                    });
                }, this, true);
                cache.add(1, "a");
                cache.flush()
                this.wait();
            },

            testRequest: function() {
                var cache = new Y.Cache({max:2});
                cache.on("request", function(e) {
                    this.resume(function() {
                        ASSERT.areSame(2, e.request);
                    });
                }, this, true);
                cache.add(1, "a");
                cache.retrieve(2)
                this.wait();
            },

            testRetrieveSuccess: function() {
                var cache = new Y.Cache({max:2});
                cache.on("retrieve", function(e) {
                    this.resume(function() {
                        ASSERT.areSame(1, e.entry.request);
                        ASSERT.areSame("a", e.entry.response);
                    });
                }, this, true);
                cache.add(1, "a");
                cache.retrieve(1)
                this.wait();
            },

            testRetrieveFailure: function() {
                var cache = new Y.Cache({max:2});
                cache.on("retrieve", function(e) {
                    this.resume(function() {
                        ASSERT.fail();
                    });
                }, this, true);
                cache.add(1, "a");
                cache.retrieve(2)
                this.wait(function() {
                    // This function intentionally left blank
                }, 0);
            },

            testCancelAdd: function() {
                var cache = new Y.Cache({max:2});
                cache.on("add", function(e) {
                    e.preventDefault();
                }, this, true);
                cache.add(1, "a");

                // Test the cancel
                ASSERT.areSame(0, cache.get("size"), "Expected 0 entries.");
            },

            testCancelFlush: function() {
                var cache = new Y.Cache({max:2});
                cache.on("flush", function(e) {
                    e.preventDefault();
                }, this, true);
                cache.add(1, "a");
                cache.flush();

                // Test the cancel
                ASSERT.areSame(1, cache.get("size"), "Expected 1 entry.");
            }
        });

        var testEntryManagement = new Y.Test.Case({
            name: "Entry Management Tests",

            testNonUniqueKeys: function() {
                var cache = new Y.Cache({max:3});
                cache.add(1, "a");
                cache.add(2, "b");
                cache.add(1, "c");
                ASSERT.areSame(3, cache.get("size"), "Expected 3 entries.");
            },

            testUniqueKeys: function() {
                var cache = new Y.Cache({max:3,uniqueKeys:true});
                cache.add(1, "a");
                cache.add(2, "b");
                cache.add(1, "c");
                ASSERT.areSame(2, cache.get("size"), "Expected 2 entries.");
            },

            testFreshness: function() {
                var cache = new Y.Cache({max:3});
                cache.add(1, "a");
                cache.add(2, "b");
                cache.add(3, "c");
                cache.retrieve(1);
                ASSERT.areSame(3, cache.get("size"), "Expected 3 entries.");
                ASSERT.areSame(1, cache.get("entries")[2].request, "Expected entry to be refreshed.");
            },

            testPayload: function() {
                //TODO
            }
        });

        var testBoundaryValues = new Y.Test.Case({
            name: "Invalid Value Tests",

            testUndefinedRequest: function() {
                var cache = new Y.Cache({max:3});
                cache.add(undefined, "a");
                cache.add(undefined, "b");
                ASSERT.areSame("b", cache.retrieve().response, "Expected cached response.");
            },

            testNullRequest: function() {
                var cache = new Y.Cache({max:3});
                cache.add(null, "a");
                cache.add(null, "b");
                ASSERT.areSame("b", cache.retrieve(null).response, "Expected cached response.");
            },

            testNaNRequest: function() {
                var cache = new Y.Cache({max:3});
                cache.add(NaN, "a");
                cache.add(NaN, "b");
                ASSERT.areSame(0, cache.get("size"), "Expected 0 entries.");
            },

            testEmptyStringRequest: function() {
                var cache = new Y.Cache({max:3});
                cache.add("", "a");
                cache.add("", "b");
                ASSERT.areSame("b", cache.retrieve("").response, "Expected cached response.");
            }
        });

        Y.Test.Runner.add(testClass);
        Y.Test.Runner.add(testBasic);
        Y.Test.Runner.add(testEvents);
        Y.Test.Runner.add(testEntryManagement);
        Y.Test.Runner.add(testBoundaryValues);
        Y.Test.Runner.run();
    });
})();
</script>
</body>
</html>