You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@olingo.apache.org by ko...@apache.org on 2015/02/23 11:11:15 UTC
[08/41] olingo-odata4-js git commit: [OLINGO-541] Move the odatajs
branch one directory up
http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/503b4417/tests/odata-cache-filter-functional-tests.js
----------------------------------------------------------------------
diff --git a/tests/odata-cache-filter-functional-tests.js b/tests/odata-cache-filter-functional-tests.js
new file mode 100644
index 0000000..5b344b8
--- /dev/null
+++ b/tests/odata-cache-filter-functional-tests.js
@@ -0,0 +1,431 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+
+(function (window, undefined) {
+ OData.defaultHandler.accept = "application/json;q=0.9, */*;q=0.1";
+ var feeds = [
+ { feed: "./endpoints/FoodStoreDataServiceV4.svc/Foods" }
+ ];
+
+ var itemsInCollection = 16;
+
+ var pageSize = 3;
+ var readRangeStart = pageSize + 1;
+ var readRangeTake = pageSize;
+
+ // Indices for filterForward after an initial readRange has partially filled the cache
+ var filterForwardAfterReadIndices = [
+ readRangeStart - 1, // before items in the cache
+ readRangeStart, // beginning of items in the cache
+ readRangeStart + readRangeTake, // last item prefetched in the cache
+ readRangeStart + readRangeTake + 1 // past range already in cache
+ ];
+
+ // Indices for filterBack after an initial readRange has partially filled the cache
+ var filterBackAfterReadIndices = [
+ readRangeStart - 1, // before items in the cache
+ readRangeStart, // beginning of items in the cache
+ readRangeStart + readRangeTake, // last item prefetched in the cache
+ readRangeStart + readRangeTake + 1 // past range already in cache
+ ];
+
+ // Counts for filterForward after a readRange has partially filled the cache
+ var filterForwardAfterReadCounts = [
+ -5, // Get all items
+ 3, // Subset of all items found in the cache
+ itemsInCollection
+ ];
+
+ // Counts for filterBack after a readRange has partially filled the cache
+ var filterBackAfterReadCounts = [
+ -5, // Get all items
+ 3, // Subset of all items found in the cache
+ itemsInCollection
+ ];
+
+ // Indices for single filterForward
+ var singleFilterForwardIndices = [
+ -5,
+ itemsInCollection - 1,
+ itemsInCollection, // beyond the end of the collection
+ itemsInCollection + pageSize // more than one page beyond the collection
+ ];
+
+ // Indices for single filterBack
+ var singleFilterBackIndices = [
+ -1,
+ 0,
+ itemsInCollection - 1
+ ];
+
+ // Count for single filterForward
+ var singleFilterForwardCounts = [
+ 5,
+ itemsInCollection + 1 // more than number of items in collection
+ ];
+
+ // Count for single filterBack
+ var singleFilterBackCounts = [
+ 5,
+ itemsInCollection + 1 // more than number of items in collection
+ ];
+
+ // Index/count variations for multiple filterForwards
+ var multipleFilterForwards = [
+ { index: 0, count: -1 }, // everything
+ {index: 2, count: 5 }, // range in first half
+ {index: 4, count: 7 }, // range in the middle to overlap first and second half
+ {index: 9, count: 4} // range in second half
+ ];
+
+ // Index/count variations for multiple filterBacks
+ var multipleFilterBacks = [
+ { index: itemsInCollection - 1, count: -1 }, // everything
+ {index: itemsInCollection - 2, count: 5 }, // range in second half
+ {index: itemsInCollection - 4, count: 7 }, // range in the middle to overlap first and second half
+ {index: itemsInCollection - 9, count: 4} // range in first half
+ ];
+
+
+ var invalidIndices = [NaN, undefined, Infinity, "not a valid value"];
+ var invalidCounts = [NaN, undefined, Infinity, "not a valid value"];
+
+ // Predicate which returns all items in the collection
+ var getAllItemsPredicate = function (item) {
+ return true;
+ };
+
+ // Predicate which returns none of the items in the collection
+ var getNoItemsPredicate = function (item) {
+ return false;
+ };
+
+ var getEveryThirdPredicate = function (item) {
+ return ((item.FoodID % 3) === 0);
+ };
+
+ var filterPredicates = [
+ getAllItemsPredicate,
+ getNoItemsPredicate,
+ getEveryThirdPredicate
+ ];
+
+ var expectException = function (cache) {
+ djstest.assert(false, "We should not get here because the an exception is expected.");
+ djstest.destroyCacheAndDone(cache);
+ };
+
+ var makeUnexpectedErrorHandler = function (cache) {
+ return function (err) {
+ djstest.assert(false, "Unexpected call to error handler with error: " + djstest.toString(err));
+ if (cache) {
+ djstest.destroyCacheAndDone(cache);
+ } else {
+ djstest.done();
+ }
+ };
+ };
+
+ var validateFilterResultsAndRequests = function (feed, cache, index, count, predicate, finished, backwards, session, cacheVerifier) {
+ /** Runs filter and validates the results and network requests
+ * @param {Object} feed - The feed being read from
+ * @param {Object} cache - The cache to perform the filter on
+ * @param {Integer} index - The index value
+ * @param {Integer} count - The count value
+ * @param {Object} predicate - Filter string to append to the feed to validate the predicate
+ * @param {Function} finished - Callback function called after data is verified
+ * @param {Object} session - Session object to validate the network requests
+ * @param {Object} cacheVerifier - CacheVerifier object to validate the network requests
+ */
+
+ if (count < 0) {
+ count = itemsInCollection;
+ }
+
+ if (index < 0) {
+ index = 0;
+ }
+
+ window.ODataVerifyReader.readJsonAcrossServerPages(feed, function (expectData) {
+ if (backwards) {
+ cache.filterBack(index, count, predicate).then(function (actualResults) {
+ var expectedResults = CacheVerifier.getExpectedFilterResults(expectData, index, count, predicate, backwards);
+ djstest.assertAreEqualDeep(actualResults, expectedResults, "results for " + "filterBack requests");
+
+ if (session && cacheVerifier) {
+ // If the count is not satisfied in the expected results, read to the beginning of the collection
+ // otherwise read to the first expected index
+ var firstIndex = 0;
+ if (expectedResults.value.length != 0) {
+ firstIndex = (expectedResults.value.length < count) ? 0 : expectedResults.value[0].index;
+ }
+ // The effective count is the number of items between the first and last index
+ var expectedCount = index - firstIndex + 1;
+ cacheVerifier.verifyRequests(session.requests, session.responses, firstIndex, expectedCount, "filterBack requests", backwards);
+ }
+ finished();
+ });
+ }
+ else {
+ cache.filterForward(index, count, predicate).then(function (actualResults) {
+ var expectedResults = CacheVerifier.getExpectedFilterResults(expectData, index, count, predicate, backwards)
+ djstest.assertAreEqualDeep(actualResults, expectedResults, "results for " + "filterForward requests");
+
+ if (session && cacheVerifier) {
+ if (expectedResults.value.length > 0) {
+ // If the count is not satisfied in the expected results, read to the end of the collection
+ // otherwise read to the last index
+ var lastIndex = (expectedResults.value.length < count) ? itemsInCollection : expectedResults.value[expectedResults.value.length - 1].index + 1;
+ // One request is made if the index is outside the range of the collection if the end of the collection has not yet been found
+ var expectedCount = (index < itemsInCollection) ? (lastIndex - index) : 1;
+ }
+ else {
+ var expectedCount = itemsInCollection;
+ }
+
+ cacheVerifier.verifyRequests(session.requests, session.responses, index, expectedCount, "filterForward requests", backwards);
+ }
+ finished();
+ });
+ }
+ });
+ };
+
+ var createMultipleFilterTestName = function (scenarioName, params) {
+ return "Testing " + scenarioName + (params.backwards ? "filterBack: " : "filterForward: ") + " of " + params.feed + " with predicate " + params.predicate + " [index " +
+ params.firstIndex + ", count " + params.firstCount + "] and [index " + params.secondIndex + ", count " + params.secondCount +
+ "] with pageSize " + params.pageSize + ", and prefetch " + params.prefetchSize;
+ };
+
+ var createSingleFilterTestName = function (scenarioName, params) {
+ return "Testing " + scenarioName + (params.backwards ? "filterBack: " : "filterForward: ") + " of " + params.feed + " with predicate " + params.predicate + " [index " +
+ params.index + ", count " + params.count + "] with pageSize " + params.pageSize + ", and prefetch " + params.prefetchSize;
+ };
+
+ var singleFilterTest = function (params) {
+ djstest.assertsExpected(2);
+ var options = { name: "cache" + new Date().valueOf(), source: params.feed, pageSize: params.pageSize, prefetchSize: params.prefetchSize };
+
+ var cache = odatajs.cache.createDataCache(options);
+ var cacheVerifier = new CacheVerifier(params.feed, params.pageSize, itemsInCollection);
+ var session = this.observableHttpClient.newSession();
+ validateFilterResultsAndRequests(params.feed, cache, params.index, params.count, params.predicate, function () { djstest.destroyCacheAndDone(cache) }, params.backwards, session, cacheVerifier);
+ };
+
+ var filterAfterReadRangeTest = function (params) {
+ djstest.assertsExpected(3);
+ var options = { name: "cache" + new Date().valueOf(), source: params.feed, pageSize: params.pageSize, prefetchSize: params.prefetchSize };
+
+ var cache = odatajs.cache.createDataCache(options);
+ var cacheVerifier = new CacheVerifier(params.feed, params.pageSize, itemsInCollection);
+ var session = this.observableHttpClient.newSession();
+
+ cache.readRange(params.skip, params.take).then(function (data) {
+ cacheVerifier.verifyRequests(session.requests, session.responses, params.skip, params.take, "readRange requests");
+ session.clear();
+ validateFilterResultsAndRequests(params.feed, cache, params.index, params.count, params.predicate, function () { djstest.destroyCacheAndDone(cache); }, params.backwards, session, cacheVerifier);
+ });
+ };
+
+ var parallelFilterTest = function (params) {
+ djstest.assertsExpected(2);
+ var options = { name: "cache" + new Date().valueOf(), source: params.feed, pageSize: params.pageSize, prefetchSize: params.prefetchSize };
+
+ var cache = odatajs.cache.createDataCache(options);
+
+ var firstfilter = function (finished) {
+ validateFilterResultsAndRequests(params.feed, cache, params.firstIndex, params.firstCount, params.predicate, finished, params.backwards);
+ };
+
+ var secondfilter = function (finished) {
+ validateFilterResultsAndRequests(params.feed, cache, params.secondIndex, params.secondCount, params.predicate, finished, params.backwards);
+ };
+
+ djstest.asyncDo([firstfilter, secondfilter], function () {
+ djstest.destroyCacheAndDone(cache);
+ });
+ };
+
+ var serialFilterTest = function (params) {
+ djstest.assertsExpected(4);
+ var options = { name: "cache" + new Date().valueOf(), source: params.feed, pageSize: params.pageSize, prefetchSize: params.prefetchSize };
+
+ var cache = odatajs.cache.createDataCache(options);
+ var cacheVerifier = new CacheVerifier(params.feed, params.pageSize, itemsInCollection);
+ var session = this.observableHttpClient.newSession();
+
+ var filterMethod = function (index, count, predicate, backwards) {
+ if (backwards) {
+ return cache.filterBack(index, count, predicate);
+ }
+ else {
+ return cache.filterForward(index, count, predicate)
+ }
+ }
+
+ filterMethod(params.firstIndex, params.firstCount, params.predicate, params.backwards).then(
+ function (results) {
+ validateFilterResultsAndRequests(params.feed, cache, params.firstIndex, params.firstCount, params.predicate,
+ function () {
+ session.clear();
+ validateFilterResultsAndRequests(params.feed, cache, params.secondIndex, params.secondCount, params.predicate, function () { djstest.destroyCacheAndDone(cache) }, params.backwards, session, cacheVerifier);
+ }, params.backwards, session, cacheVerifier);
+ });
+ };
+
+ module("Functional", {
+ setup: function () {
+ this.observableHttpClient = new ObservableHttpClient();
+ window.odatajs.oData.net.defaultHttpClient = this.observableHttpClient;
+ },
+
+ teardown: function () {
+ window.odatajs.oData.net.defaultHttpClient = this.observableHttpClient.provider;
+ }
+ });
+
+ $.each(filterPredicates, function (_, filterPredicate) {
+ $.each(feeds, function (_, feedObject) {
+ $.each(filterForwardAfterReadCounts, function (_, filterCount) {
+ $.each(filterForwardAfterReadIndices, function (_, filterIndex) {
+ var parameters = { index: filterIndex, count: filterCount, predicate: filterPredicate, feed: feedObject.feed, take: readRangeTake,
+ skip: readRangeStart, pageSize: pageSize, prefetchSize: 0, backwards: false
+ };
+ djstest.addTest(filterAfterReadRangeTest, createSingleFilterTestName("after readRange, ", parameters), parameters);
+ });
+ });
+
+ $.each(filterBackAfterReadCounts, function (_, filterCount) {
+ $.each(filterBackAfterReadIndices, function (_, filterIndex) {
+ var parameters = { index: filterIndex, count: filterCount, predicate: filterPredicate, feed: feedObject.feed, take: readRangeTake,
+ skip: readRangeStart, pageSize: pageSize, prefetchSize: 0, backwards: true
+ };
+ djstest.addTest(filterAfterReadRangeTest, createSingleFilterTestName("After readRange, ", parameters), parameters);
+ });
+ });
+ });
+
+ $.each(singleFilterForwardIndices, function (_, filterIndex) {
+ $.each(singleFilterForwardCounts, function (_, filterCount) {
+ var parameters = { index: filterIndex, count: filterCount, predicate: filterPredicate, feed: feeds[0].feed, pageSize: pageSize, prefetchSize: 0, backwards: false };
+ djstest.addTest(singleFilterTest, createSingleFilterTestName("single ", parameters), parameters);
+ });
+ });
+
+ $.each(singleFilterBackIndices, function (_, filterIndex) {
+ $.each(singleFilterBackCounts, function (_, filterCount) {
+ var parameters = { index: filterIndex, count: filterCount, predicate: filterPredicate, feed: feeds[0].feed, pageSize: pageSize, prefetchSize: 0, backwards: true };
+ djstest.addTest(singleFilterTest, createSingleFilterTestName("single ", parameters), parameters);
+ });
+ });
+
+ $.each(multipleFilterForwards, function (_, firstFilter) {
+ $.each(multipleFilterForwards, function (_, secondFilter) {
+ var serialParameters = { firstIndex: firstFilter.index, firstCount: firstFilter.count, secondIndex: secondFilter.index, secondCount: secondFilter.count,
+ predicate: filterPredicate, feed: feeds[0].feed, pageSize: pageSize, prefetchSize: 0, backwards: false
+ };
+ djstest.addTest(serialFilterTest, createMultipleFilterTestName("serial ", serialParameters), serialParameters);
+ });
+ });
+
+ $.each(multipleFilterBacks, function (_, firstFilter) {
+ $.each(multipleFilterBacks, function (_, secondFilter) {
+ var serialParameters = { firstIndex: firstFilter.index, firstCount: firstFilter.count, secondIndex: secondFilter.index, secondCount: secondFilter.count,
+ predicate: filterPredicate, feed: feeds[0].feed, pageSize: pageSize, prefetchSize: 0, backwards: true
+ };
+ djstest.addTest(serialFilterTest, createMultipleFilterTestName("serial ", serialParameters), serialParameters);
+ });
+ });
+
+ $.each(multipleFilterForwards, function (_, firstFilter) {
+ $.each(multipleFilterForwards, function (_, secondFilter) {
+ var parallelParameters = { firstIndex: firstFilter.index, firstCount: firstFilter.count, secondIndex: secondFilter.index, secondCount: secondFilter.count,
+ predicate: filterPredicate, feed: feeds[0].feed, pageSize: pageSize, prefetchSize: 6, backwards: false
+ };
+ djstest.addTest(parallelFilterTest, createMultipleFilterTestName("parallel ", parallelParameters), parallelParameters);
+ });
+ });
+
+ $.each(multipleFilterBacks, function (_, firstFilter) {
+ $.each(multipleFilterBacks, function (_, secondFilter) {
+ var parallelParameters = { firstIndex: firstFilter.index, firstCount: firstFilter.count, secondIndex: secondFilter.index, secondCount: secondFilter.count,
+ predicate: filterPredicate, feed: feeds[0].feed, pageSize: pageSize, prefetchSize: 6, backwards: true
+ };
+ djstest.addTest(parallelFilterTest, createMultipleFilterTestName("parallel ", parallelParameters), parallelParameters);
+ });
+ });
+
+ $.each([true, false], function (_, isBackwards) {
+ var zeroCountParameters = { index: 0, count: 0, predicate: filterPredicate, feed: feeds[0].feed, take: readRangeTake,
+ skip: readRangeStart, pageSize: pageSize, prefetchSize: 0, backwards: isBackwards
+ };
+ djstest.addTest(singleFilterTest, createSingleFilterTestName("Count 0 ", zeroCountParameters), zeroCountParameters);
+ });
+ });
+
+ $.each([true, false], function (_, backwards) {
+ $.each(invalidIndices, function (_, invalidIndex) {
+ var invalidIndexParameters = { index: invalidIndex, count: -1, predicate: filterPredicates[0], feed: feeds[0].feed, pageSize: pageSize, prefetchSize: 0, backwards: backwards };
+
+ djstest.addTest(
+ function (params) {
+ djstest.assertsExpected(1);
+ var options = { name: "cache" + new Date().valueOf(), source: params.feed };
+ var cache = odatajs.cache.createDataCache(options);
+ try {
+ params.backwards ?
+ cache.filterForward(params.index, params.count, params.predicate).then(function (results) {
+ djstest.log(results);
+ }) :
+ cache.filterForward(params.index, params.count, params.predicate).then(function (results) {
+ djstest.log(results);
+ });
+ expectException(cache);
+ } catch (e) {
+ djstest.assertAreEqual(e.message, "'index' must be a valid number.", "Error message validation");
+ djstest.destroyCacheAndDone(cache);
+ }
+ }, createSingleFilterTestName("invalid index ", invalidIndexParameters), invalidIndexParameters);
+ });
+
+ $.each(invalidCounts, function (_, invalidCount) {
+ var invalidCountParameters = { index: 0, count: invalidCount, predicate: filterPredicates[0], feed: feeds[0].feed, pageSize: pageSize, prefetchSize: 0, backwards: backwards };
+
+ djstest.addTest(
+ function (params) {
+ djstest.assertsExpected(1);
+ var options = { name: "cache" + new Date().valueOf(), source: params.feed };
+ var cache = odatajs.cache.createDataCache(options);
+ try {
+ params.backwards ?
+ cache.filterBack(params.index, params.count, params.predicate).then(function (results) {
+ djstest.log(results);
+ }) :
+ cache.filterForward(params.index, params.count, params.predicate).then(function (results) {
+ djstest.log(results);
+ });
+ expectException(cache);
+ } catch (e) {
+ djstest.assertAreEqual(e.message, "'count' must be a valid number.", "Error message validation");
+ djstest.destroyCacheAndDone(cache);
+ }
+ }, createSingleFilterTestName("invalid count ", invalidCountParameters), invalidCountParameters);
+ });
+ });
+})(this);
http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/503b4417/tests/odata-cache-fperf-tests.html
----------------------------------------------------------------------
diff --git a/tests/odata-cache-fperf-tests.html b/tests/odata-cache-fperf-tests.html
new file mode 100644
index 0000000..f0ecd21
--- /dev/null
+++ b/tests/odata-cache-fperf-tests.html
@@ -0,0 +1,50 @@
+<!--
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+ -->
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+ <title>datajs.cache functional perf tests</title>
+ <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+ <meta http-equiv="cache-control" content="no-cache"/>
+ <meta http-equiv="pragma" content="no-cache"/>
+ <meta http-equiv="expires" content="-1"/>
+
+ <link rel="stylesheet" href="http://code.jquery.com/qunit/qunit-1.10.0.css" type="text/css" />
+ <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/json2/20110223/json2.js"></script>
+ <script type="text/javascript" src="http://code.jquery.com/jquery-1.4.4.min.js"></script>
+ <script type="text/javascript" src="http://code.jquery.com/qunit/qunit-1.10.0.js"></script>
+ <script type="text/javascript" src="common/TestSynchronizerClient.js"></script>
+ <script type="text/javascript">
+ window.TestSynchronizer.init(QUnit);
+ </script>
+ <script type="text/javascript" src="../build/odatajs-4.0.0-beta-01.js"></script>
+ <script type="text/javascript" src="common/common.js"></script>
+ <script type="text/javascript" src="common/CacheVerifier.js"></script>
+ <script type="text/javascript" src="common/djstest.js"></script>
+ <script type="text/javascript" src="odata-cache-fperf-tests.js"></script>
+</head>
+<body>
+ <h1 id="qunit-header">datajs.cache functional perf tests</h1>
+ <h2 id="qunit-banner"></h2>
+ <h2 id="qunit-userAgent"></h2>
+ <ol id="qunit-tests"></ol>
+</body>
+</html>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/503b4417/tests/odata-cache-fperf-tests.js
----------------------------------------------------------------------
diff --git a/tests/odata-cache-fperf-tests.js b/tests/odata-cache-fperf-tests.js
new file mode 100644
index 0000000..31bb5f8
--- /dev/null
+++ b/tests/odata-cache-fperf-tests.js
@@ -0,0 +1,115 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+
+(function (window, undefined) {
+
+ var slowHttpClient = {
+ latency: 750,
+ provider: window.odatajs.oData.net.defaultHttpClient,
+ request: function (request, success, error) {
+ setTimeout(function () {
+ slowHttpClient.provider.request(request, success, error);
+ }, slowHttpClient.latency);
+ }
+ };
+
+ var feeds = [
+ { uri: "./endpoints/FoodStoreDataServiceV4.svc/Foods" }
+ ];
+
+ module("Functional", {
+ setup: function () {
+ window.odatajs.oData.net.defaultHttpClient = slowHttpClient;
+ },
+ teardown: function () {
+ window.odatajs.oData.net.defaultHttpClient = slowHttpClient.provider;
+ }
+ });
+
+ var cacheReadRangeWallClockTest = function (totalReads, interval, mechanism, source, pageSize, prefetchSize, generateRange, threshold) {
+ /** Cache readRange wall-clock test
+ * The average time computed by the wall-clock test does *not* include the initial readRange
+ * @param totalReads - Number of reads to collect data from
+ * @param interval - Interval (milliseconds) between reads
+ * @param mechanism - The cache store mechanism
+ * @param source - The feed source
+ * @param pageSize - The page size
+ * @param prefetchSize - The prefetch size
+ * @param generateRange - The range generator function: given the read index, returns the readRange index and count
+ * @param threshold - The average read time threshold for test to pass; if not specified, defaults to the slowHttpClient latency
+ * @returns The test function
+ */
+ return function () {
+ var cache = odatajs.cache.createDataCache({ name: "cache" + new Date().valueOf(), source: source, pageSize: pageSize, prefetchSize: prefetchSize });
+ var totalTime = 0;
+ var readCount = 0;
+
+ var callReadRange = function () {
+ var range = generateRange(readCount);
+ var startTime = new Date().valueOf();
+ cache.readRange(range.index, range.count).then(function (data) {
+ var duration = (new Date().valueOf()) - startTime;
+ djstest.log("readRange " + readCount + " [" + range.index + ", " + range.count + "]: " + duration + "ms");
+
+ // The first readRange is not counted
+ totalTime += (readCount > 0) ? duration : 0;
+ readCount += 1;
+
+ if (readCount < totalReads) {
+ setTimeout(callReadRange, interval);
+ } else {
+ // The first readRange is not counted
+ var averageTime = totalTime / (totalReads - 1);
+ var actualThreshold = threshold === undefined ? slowHttpClient.latency : threshold;
+ djstest.assert(averageTime < actualThreshold, "Average: " + averageTime + "ms, Threshold: " + actualThreshold + "ms");
+ djstest.destroyCacheAndDone(cache);
+ }
+ }, function (err) {
+ djstest.fail("Unexpected call to error handler with error: " + djstest.toString(err));
+ djstest.destroyCacheAndDone(cache);
+ });
+ };
+
+ callReadRange();
+ };
+ };
+
+ $.each(CacheVerifier.mechanisms, function (_, mechanism) {
+ if (mechanism !== "best" && CacheVerifier.isMechanismAvailable(mechanism)) {
+ $.each(feeds, function (_, feed) {
+ djstest.addTest(cacheReadRangeWallClockTest(2, 1000, mechanism, feed.uri, 5, 0, function () {
+ return { index: 0, count: 5 };
+ }), "Cache small single-page wall-clock test with " + mechanism + " on " + feed.uri);
+
+ djstest.addTest(cacheReadRangeWallClockTest(5, 1000, mechanism, feed.uri, 3, -1, function (readCount) {
+ return { index: readCount * 3, count: 3 };
+ }), "Cache page-by-page wall-clock test with " + mechanism + " on " + feed.uri);
+
+ djstest.addTest(cacheReadRangeWallClockTest(5, 1000, mechanism, feed.uri, 3, -1, function (readCount) {
+ return { index: readCount, count: 3 };
+ }), "Cache line-by-line wall-clock test with " + mechanism + " on " + feed.uri);
+ });
+
+ var largeFeedUri = "./endpoints/LargeCollectionService.svc/Customers";
+ djstest.addTest(cacheReadRangeWallClockTest(2, 1000, mechanism, largeFeedUri, 100, 0, function () {
+ return { index: 0, count: 500 };
+ }), "Cache large single-page wall-clock test with " + mechanism + " on " + largeFeedUri, undefined, 60000);
+ }
+ });
+})(this);
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/503b4417/tests/odata-cache-functional-tests.html
----------------------------------------------------------------------
diff --git a/tests/odata-cache-functional-tests.html b/tests/odata-cache-functional-tests.html
new file mode 100644
index 0000000..ad328ab
--- /dev/null
+++ b/tests/odata-cache-functional-tests.html
@@ -0,0 +1,52 @@
+<!--
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+ -->
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+ <title>OData tests against local service</title>
+ <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+ <meta http-equiv="cache-control" content="no-cache"/>
+ <meta http-equiv="pragma" content="no-cache"/>
+ <meta http-equiv="expires" content="-1"/>
+
+ <link rel="stylesheet" href="http://code.jquery.com/qunit/qunit-1.10.0.css" type="text/css" />
+ <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/json2/20110223/json2.js"></script>
+ <script type="text/javascript" src="http://code.jquery.com/jquery-1.4.4.min.js"></script>
+ <script type="text/javascript" src="http://code.jquery.com/qunit/qunit-1.10.0.js"></script>
+ <script type="text/javascript" src="common/TestSynchronizerClient.js"></script>
+ <script type="text/javascript">
+ window.TestSynchronizer.init(QUnit);
+ </script>
+ <script type="text/javascript" src="../build/odatajs-4.0.0-beta-01.js"></script>
+ <script type="text/javascript" src="common/common.js"></script>
+ <script type="text/javascript" src="common/djstest.js"></script>
+ <script type="text/javascript" src="common/CacheVerifier.js"></script>
+ <script type="text/javascript" src="common/ObservableHttpClient.js"></script>
+ <script type="text/javascript" src="common/odataVerifyReader.js"></script>
+ <script type="text/javascript" src="odata-cache-functional-tests.js"></script>
+</head>
+<body>
+ <h1 id="qunit-header">datajs.cache tests against local in-memory service</h1>
+ <h2 id="qunit-banner"></h2>
+ <h2 id="qunit-userAgent"></h2>
+ <ol id="qunit-tests"></ol>
+</body>
+</html>
http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/503b4417/tests/odata-cache-functional-tests.js
----------------------------------------------------------------------
diff --git a/tests/odata-cache-functional-tests.js b/tests/odata-cache-functional-tests.js
new file mode 100644
index 0000000..c787bbf
--- /dev/null
+++ b/tests/odata-cache-functional-tests.js
@@ -0,0 +1,631 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+
+(function (window, undefined) {
+ OData.defaultHandler.accept = "application/json;q=0.9, */*;q=0.1";
+ var CustomDataSource = function (baseUri) {
+ this.baseUri = baseUri;
+ };
+
+ CustomDataSource.prototype.read = function (index, count, success, error) {
+ var that = this;
+ var url = this.baseUri + "?$skip=" + index + "&$top=" + count;
+ $(this).triggerHandler("request", { requestUri: url });
+ $.ajax({
+ url: url,
+ dataType: "json",
+ success: function (results) {
+ $(that).triggerHandler("success", { data: results });
+ success(results);
+ },
+ error: error
+ });
+ };
+
+ CustomDataSource.prototype.count = function (success, error) {
+ $.ajax({
+ url: "./endpoints/CustomDataService.svc/Count",
+ dataType: "json",
+ success: success,
+ error: error
+ });
+ },
+ CustomDataSource.prototype.toString = function () {
+ return this.baseUri;
+ };
+
+ var sources = [
+ { source: "./endpoints/FoodStoreDataServiceV4.svc/Foods", countSupported: true },
+ { source: new CustomDataSource("./endpoints/CustomDataService.svc/ReadRange"), countSupported: true }
+ ];
+
+ var itemsInCollection = 16;
+
+ // Cache config variations for single readRange with fixed skip/take that spans the entire collection
+ var pageSizes = [
+ 1,
+ 4, // factor of total, <= server page size
+ 5, // non-factor of total, <= server page size
+ 6, // non-factor of total, > server page size
+ 8, // factor of total, > server page size
+ itemsInCollection,
+ itemsInCollection + 1
+ ];
+
+ var cacheSizes = [
+ -5, // All you can store
+ 0, // Store nothing
+ 1024, // 1 KB
+ 2.5 * 1024, // 2.5 KB
+ 100 * 1024, // 10 KB
+ 512 * 1024, // 512 KB
+ 100 * 1024 * 1024, // 100 MB
+ undefined // Default to 1 MB
+ ];
+
+ // Skip/take variations for single readRange with fixed cache config
+ var fixedPageSize = 6;
+
+ var skipValues = [
+ 0,
+ fixedPageSize - 1,
+ fixedPageSize,
+ fixedPageSize + 1,
+ fixedPageSize * 2,
+ itemsInCollection + 1,
+ itemsInCollection + fixedPageSize + 1
+ ];
+
+ var takeValues = [
+ 0,
+ fixedPageSize - 1,
+ fixedPageSize,
+ fixedPageSize + 1,
+ fixedPageSize * 2,
+ itemsInCollection + 1
+ ];
+
+ // Skip/take variations for multiple readRanges with fixed cache config
+ var multipleReads = [
+ { skip: 1, take: 2 }, // page 1
+ {skip: 2, take: 7 }, // page 1, 2
+ {skip: 3, take: 10 }, // page 1, 2, 3
+ {skip: 6, take: 2} // page 2
+ ];
+
+ var invalidSkipValues = [-5, NaN, undefined, Infinity, "not a valid value"];
+ var invalidTakeValues = [-5, NaN, undefined, Infinity, "not a valid value"];
+ var invalidPageSizes = [-5, NaN, Infinity, 0, "not a valid value"];
+
+ // Prefetchsize variations for a single readRange
+ var prefetchSizes = [
+ -5,
+ 1,
+ 5,
+ itemsInCollection,
+ itemsInCollection + 1
+ ];
+
+ var expectException = function (cache) {
+ djstest.assert(false, "We should not get here because the an exception is expected.");
+ djstest.destroyCacheAndDone(cache);
+ };
+
+ var makeUnexpectedErrorHandler = function (cache) {
+ return function (err) {
+ djstest.assert(false, "Unexpected call to error handler with error: " + djstest.toString(err));
+ if (cache) {
+ djstest.destroyCacheAndDone(cache);
+ } else {
+ djstest.done();
+ }
+ };
+ };
+
+ var validateExpectedRange = function (cache, data, source, skipValue, takeValue, finished) {
+ /** Validates the data returned by readRange
+ * @param {Object} cache - The cache object
+ * @param {Object} data - The data returned by the cache
+ * @param {Object} source - The base URI of the feed, or the custom data source
+ * @param {Integer} skipValue - The skip value
+ * @param {Integer} takeValue - The take value
+ * @param {Function} finished - Callback function called after data is verified
+ */
+ var assertData = function (expectedData) {
+ djstest.assertAreEqualDeep(data, expectedData, "Verify response data");
+ finished();
+ };
+
+ if (typeof source === "string") {
+ var expectedRangeUrl = source + "?$skip=" + skipValue + "&$top=" + takeValue;
+ window.ODataVerifyReader.readJsonAcrossServerPages(expectedRangeUrl, assertData);
+ } else {
+ source.read(skipValue, takeValue, assertData);
+ }
+ };
+
+ var onidleValidation = function () {
+ djstest.assert(true, "expected call to onidle");
+ djstest.done();
+ };
+
+ var createSingleReadTestName = function (params) {
+ return "Testing readRange of " + params.source + " [skip " + params.skip + " take " + params.take + "] with pageSize " +
+ params.pageSize + ", prefetch " + params.prefetchSize + " and cacheSize " + params.cacheSize;
+ };
+
+ var createMultipleReadTestName = function (params) {
+ return "Testing readRange of " + params.source + " [skip " + params.firstSkip + " take " + params.firstTake + ", " +
+ (params.destroyCacheBetweenReads ? "cache.destroy(), " : "") +
+ "skip " + params.secondSkip + " take " + params.secondTake + "] with pageSize " +
+ params.pageSize + ", prefetch " + params.prefetchSize + " and cacheSize " + params.cacheSize;
+ };
+
+ var dataCacheSingleReadRangeTest = function (params) {
+ djstest.assertsExpected(2);
+ var options = { name: "cache" + new Date().valueOf(), source: params.source, pageSize: params.pageSize, prefetchSize: params.prefetchSize, cacheSize: params.cacheSize };
+
+ if (params.mechanism) {
+ options.mechanism = params.mechanism;
+ }
+
+ var cache = this.createAndAddCache(options);
+ var session = typeof params.source === "string" ? this.observableHttpClient.newSession() : new Session(params.source);
+ var cacheVerifier = new CacheVerifier(params.source, params.pageSize, itemsInCollection, params.cacheSize);
+ cache.readRange(params.skip, params.take).then(function (data) {
+ cacheVerifier.verifyRequests(session.requests, session.responses, params.skip, params.take, "readRange requests");
+ validateExpectedRange(cache, data, params.source, params.skip, params.take, function () {
+ djstest.destroyCacheAndDone(cache);
+ });
+ }, makeUnexpectedErrorHandler(cache));
+ };
+
+ var dataCacheParallelReadRangeTest = function (params) {
+ djstest.assertsExpected(2);
+ var options = { name: "cache" + new Date().valueOf(), source: params.source, pageSize: params.pageSize, prefetchSize: params.prefetchSize, cacheSize: params.cacheSize };
+
+ var cache = this.createAndAddCache(options);
+
+ var firstReadRange = function (finished) {
+ cache.readRange(params.firstSkip, params.firstTake).then(function (data) {
+ validateExpectedRange(cache, data, params.source, params.firstSkip, params.firstTake, finished);
+ }, makeUnexpectedErrorHandler(cache));
+ };
+
+ var secondReadRange = function (finished) {
+ cache.readRange(params.secondSkip, params.secondTake).then(function (data) {
+ validateExpectedRange(cache, data, params.source, params.secondSkip, params.secondTake, finished);
+ }, makeUnexpectedErrorHandler(cache));
+ };
+
+ djstest.asyncDo([firstReadRange, secondReadRange], function () {
+ djstest.destroyCacheAndDone(cache);
+ });
+ };
+
+ var dataCacheSerialReadRangeTest = function (params) {
+ djstest.assertsExpected(4);
+ var options = { name: "cache" + new Date().valueOf(), source: params.source, pageSize: params.pageSize, prefetchSize: params.prefetchSize, cacheSize: params.cacheSize };
+
+ var cacheVerifier = new CacheVerifier(params.source, params.pageSize, itemsInCollection, params.cacheSize);
+ var secondRead = function () {
+ session.clear();
+ cache.readRange(params.secondSkip, params.secondTake).then(function (data) {
+ cacheVerifier.verifyRequests(session.requests, session.responses, params.secondSkip, params.secondTake, "Second readRange requests");
+ validateExpectedRange(cache, data, params.source, params.secondSkip, params.secondTake, djstest.done);
+ }, makeUnexpectedErrorHandler(cache));
+ };
+
+ var cache = this.createAndAddCache(options);
+ var session = typeof params.source === "string" ? this.observableHttpClient.newSession() : new Session(params.source);
+ cache.readRange(params.firstSkip, params.firstTake).then(function (data) {
+ cacheVerifier.verifyRequests(session.requests, session.responses, params.firstSkip, params.firstTake, "First readRange requests");
+ validateExpectedRange(cache, data, params.source, params.firstSkip, params.firstTake, function () {
+ if (params.destroyCacheBetweenReads === true) {
+ cache.clear().then(function () {
+ cacheVerifier.clear();
+ secondRead();
+ }, function (err) {
+ djstest.fail("Error destroying the cache: " + djstest.toString(err));
+ });
+ } else {
+ secondRead();
+ }
+ });
+ }, makeUnexpectedErrorHandler(cache));
+ };
+
+ var dataCachePrefetchTest = function (params) {
+ djstest.assertsExpected(2);
+ var options = {
+ name: "cache" + new Date().valueOf(),
+ source: params.source,
+ pageSize: params.pageSize,
+ prefetchSize: params.prefetchSize,
+ cacheSize: params.cacheSize,
+ user: params.user,
+ password: params.password
+ };
+
+ var cache = this.createAndAddCache(options);
+ var session = typeof params.source === "string" ? this.observableHttpClient.newSession() : new Session(params.source);
+ var cacheVerifier = new CacheVerifier(params.source, params.pageSize, itemsInCollection, params.cacheSize);
+
+ cache.readRange(params.skip, params.take).then(function (data) {
+ cacheVerifier.verifyRequests(session.requests, session.responses, params.skip, params.take, "readRange requests");
+ session.clear();
+ }, makeUnexpectedErrorHandler(cache));
+
+ cache.onidle = function () {
+ var prefetchSize = params.prefetchSize < 0 ? itemsInCollection : params.prefetchSize;
+ cacheVerifier.verifyRequests(session.requests, session.responses, params.skip + params.take, prefetchSize, "prefetch requests", false, true);
+ cache.onidle = false;
+ djstest.destroyCacheAndDone(cache);
+ };
+ };
+
+ var cleanDomStorage = function (done) {
+ /** Cleans all the data saved in the browser's DOM Storage. Needs to be called asynchronously in the
+ * setup and teardown methods to be consistent with indexedDb's cleanup method.
+ * @param {Function} done - Function to be called after DOM storage is cleared.
+ */
+ if (window.localStorage) {
+ window.localStorage.clear();
+ }
+ done();
+ };
+
+ var cleanIndexedDb = function (done) {
+ /** Cleans all the data saved in the browser's IndexedDb Storage.
+ * @param {Function} done - Function to be called after indexedDb is cleared.
+ */
+ var caches = this.caches;
+
+ djstest.cleanStoreOnIndexedDb(caches, done);
+ };
+
+ var cleanupAllStorage = function (done) {
+ /** Cleans up all available storage mechanisms in the browser.
+ * @param {Function} done - Function to be called by each cleanup function after storage is cleared.
+ */
+ var that = this;
+ var storeCleanup = [];
+
+ $.each(CacheVerifier.mechanisms, function (_, mechanism) {
+ if (CacheVerifier.isMechanismAvailable(mechanism)) {
+ storeCleanup.push(function (done) {
+ if (storageMechanisms[mechanism]) {
+ storageMechanisms[mechanism].cleanup.call(that, done);
+ } else {
+ done();
+ }
+ });
+ }
+ });
+
+ djstest.asyncDo(storeCleanup, done);
+ };
+
+ var storageMechanisms = {
+ indexeddb: { cleanup: cleanIndexedDb },
+ dom: { cleanup: cleanDomStorage },
+ memory: { cleanup: function (done) { done(); } },
+ best: { cleanup: function (done) { done(); } }
+ };
+
+ module("Functional", {
+ setup: function () {
+ this.createAndAddCache = function (options) {
+ /** Returns a cache created from the options object and
+ * @param {Object} options - Object to create a cache from.
+ */
+ var cache = odatajs.cache.createDataCache(options);
+ this.caches.push({ name: options.name, cache: cache });
+ return cache;
+ };
+
+ this.observableHttpClient = new ObservableHttpClient();
+ window.odatajs.oData.net.defaultHttpClient = this.observableHttpClient;
+ this.caches = [];
+ var that = this;
+
+ djstest.wait(function (done) {
+ cleanupAllStorage.call(that, done);
+ });
+ },
+
+ teardown: function () {
+ window.odatajs.oData.net.defaultHttpClient = this.observableHttpClient.provider;
+ var clearActions = [];
+ var that = this;
+
+ $.each(this.caches, function (_, cacheObject) {
+ cacheObject.cache.onidle = undefined;
+
+ clearActions.push(function (done) {
+ cacheObject.cache.clear().then(function () {
+ done();
+ },
+ function (err) {
+ djstest.assert(false, "Unexpected call to error handler while attempting to clear with error: " + djstest.toString(err));
+ })
+ });
+ });
+
+ djstest.wait(function (done) {
+ djstest.asyncDo(clearActions, function () {
+ cleanupAllStorage.call(that, function () {
+ that.caches = [];
+ done();
+ });
+ });
+ });
+ }
+ });
+
+ $.each(CacheVerifier.mechanisms, function (_, mechanism) {
+ var parameters = { mechanism: mechanism, source: sources[1].source, take: 5, skip: 0, pageSize: 5, prefetchSize: 5 };
+ if (CacheVerifier.isMechanismAvailable(mechanism)) {
+ djstest.addTest(dataCacheSingleReadRangeTest, "Specified mechanism: " + parameters.mechanism + createSingleReadTestName(parameters), parameters);
+ }
+ else {
+ djstest.addTest(function (params) {
+ djstest.assertsExpected(1);
+ var options = { name: "cache" + new Date().valueOf(), mechanism: params.mechanism, source: params.source };
+ try {
+ var cache = this.createAndAddCache(options);
+ expectException(cache);
+ }
+ catch (e) {
+ if (mechanism === "indexeddb") {
+ djstest.assertAreEqual(e.message, "IndexedDB is not supported on this browser", "Validating expected error");
+ } else if (mechanism === "dom") {
+ djstest.assertAreEqual(e.message, "Web Storage not supported by the browser", "Validating expected error");
+ } else {
+ djstest.fail("Creating cache with mechanism " + mechanism + " should not fail: " + djstest.toString(e));
+ }
+
+ djstest.done();
+ }
+ }, "Invalid mechanism for browser: " + parameters.mechanism + createSingleReadTestName(parameters), parameters);
+ }
+ });
+
+ $.each(sources, function (_, sourceObject) {
+ $.each(pageSizes, function (_, pageSizeValue) {
+ $.each(cacheSizes, function (_, cacheSizeValue) {
+ var parameters = { source: sourceObject.source, skip: 0, take: itemsInCollection, pageSize: pageSizeValue, prefetchSize: 0, cacheSize: cacheSizeValue };
+ djstest.addTest(dataCacheSingleReadRangeTest, createSingleReadTestName(parameters), parameters);
+ });
+ });
+
+ $.each(skipValues, function (_, skipValue) {
+ $.each(takeValues, function (_, takeValue) {
+ var parameters = { source: sourceObject.source, take: takeValue, skip: skipValue, pageSize: 4, prefetchSize: 0, cacheSize: 0 };
+ djstest.addTest(dataCacheSingleReadRangeTest, createSingleReadTestName(parameters), parameters);
+ });
+ });
+
+ $.each(multipleReads, function (_, firstRange) {
+ $.each(multipleReads, function (_, secondRange) {
+ var parallelReadParams = { source: sourceObject.source, firstTake: firstRange.take, firstSkip: firstRange.skip, secondTake: secondRange.take, secondSkip: secondRange.skip, pageSize: 5, prefetchSize: 0, cacheSize: 0 };
+ djstest.addTest(dataCacheParallelReadRangeTest, "Parallel: " + createMultipleReadTestName(parallelReadParams), parallelReadParams);
+
+ $.each([false, true], function (_, destroyCacheBetweenReads) {
+ var serialReadParams = $.extend({}, parallelReadParams, { destroyCacheBetweenReads: destroyCacheBetweenReads });
+ djstest.addTest(dataCacheSerialReadRangeTest, "Serial: " + createMultipleReadTestName(serialReadParams), serialReadParams);
+ });
+ });
+ });
+
+ var getInvalidValueErrorMessage = function (invalidValue, parameterName) {
+ /** Returns the expected error message for the specified invalid value.
+ * @param {Object} invalidValue - invalid value (anything other than zero or positive integer) to determine the error message from.
+ * @param {String} parameterName - The name of the parameter being verified.
+ * @returns {String} Error message expected.
+ */
+ return (invalidValue === undefined || typeof invalidValue !== "number") ?
+ "'" + parameterName + "' must be a number." :
+ "'" + parameterName + "' must be greater than or equal to zero.";
+ };
+
+ $.each(invalidSkipValues, function (_, invalidSkipValue) {
+ var parameters = { source: sourceObject.source, skip: invalidSkipValue, take: 1 };
+ djstest.addTest(function (params) {
+ djstest.assertsExpected(1);
+ var options = { name: "cache" + new Date().valueOf(), source: params.source };
+ var cache = this.createAndAddCache(options);
+ try {
+ cache.readRange(params.skip, params.take);
+ expectException(cache);
+ } catch (e) {
+ djstest.assertAreEqual(e.message, getInvalidValueErrorMessage(invalidSkipValue, "index"), "Error message validation");
+ djstest.destroyCacheAndDone(cache);
+ }
+ }, "Invalid skip: " + createSingleReadTestName(parameters), parameters);
+ });
+
+ $.each(invalidTakeValues, function (_, invalidTakeValue) {
+ var parameters = { source: sourceObject.source, skip: 0, take: invalidTakeValue };
+ djstest.addTest(function (params) {
+ djstest.assertsExpected(1);
+ var options = { name: "cache" + new Date().valueOf(), source: params.source };
+ var cache = this.createAndAddCache(options);
+ try {
+ cache.readRange(params.skip, params.take);
+ expectException(cache);
+ } catch (e) {
+ djstest.assertAreEqual(e.message, getInvalidValueErrorMessage(invalidTakeValue, "count"), "Error message validation");
+ djstest.destroyCacheAndDone(cache);
+ }
+ }, "Invalid take: " + createSingleReadTestName(parameters), parameters);
+ });
+
+ $.each(invalidPageSizes, function (_, invalidPageSize) {
+ var parameters = { source: sourceObject.source, skip: 0, take: 5, pageSize: invalidPageSize };
+ djstest.addTest(function (params) {
+ var options = { name: "cache", source: params.source, pageSize: params.pageSize };
+ try {
+ var cache = this.createAndAddCache(options);
+ expectException(cache);
+ } catch (e) {
+ var expectedError = typeof invalidPageSize === "number" ? "'pageSize' must be greater than zero." : getInvalidValueErrorMessage(invalidPageSize, "pageSize");
+ djstest.assertAreEqual(e.message, expectedError, "Error message validation");
+ }
+ djstest.done();
+ }, "Invalid pageSize: " + createSingleReadTestName(parameters), parameters);
+ });
+
+ $.each(pageSizes, function (_, pageSize) {
+ $.each(cacheSizes, function (_, cacheSize) {
+ var parameters = { source: sourceObject.source, skip: 0, take: pageSize, pageSize: pageSize, prefetchSize: -1, cacheSize: cacheSize };
+ djstest.addTest(dataCachePrefetchTest, "Prefetch: " + createSingleReadTestName(parameters), parameters);
+ });
+ });
+
+ $.each(skipValues, function (_, skipValue) {
+ var parameters = { source: sourceObject.source, skip: skipValue, take: fixedPageSize, pageSize: fixedPageSize, prefetchSize: -1, cacheSize: -1 };
+ djstest.addTest(dataCachePrefetchTest, "Prefetch: " + createSingleReadTestName(parameters), parameters);
+ });
+
+ $.each(takeValues, function (_, takeValue) {
+ var parameters = { source: sourceObject.source, skip: 0, take: takeValue, pageSize: fixedPageSize, prefetchSize: -1, cacheSize: -1 };
+ djstest.addTest(dataCachePrefetchTest, "Prefetch: " + createSingleReadTestName(parameters), parameters);
+ });
+
+ $.each(prefetchSizes, function (_, prefetchSize) {
+ var parameters = { source: sourceObject.source, skip: 0, take: fixedPageSize, pageSize: fixedPageSize, prefetchSize: prefetchSize, cacheSize: -1 };
+ djstest.addTest(dataCachePrefetchTest, "Prefetch: " + createSingleReadTestName(parameters), parameters);
+ });
+
+ var fixedPrefetchSize = 5;
+
+ djstest.addTest(function (params) {
+ djstest.assertsExpected(1);
+ var cache = this.createAndAddCache({
+ name: "cache" + new Date().valueOf(),
+ source: params.source,
+ prefetchSize: fixedPrefetchSize,
+ idle: onidleValidation,
+ pageSize: 2,
+ mechanism: "memory"
+ });
+ cache.readRange(0, 5);
+
+ }, "onidle in constructor, prefetch size = " + fixedPrefetchSize + " on " + sourceObject.source, { source: sourceObject.source });
+
+ djstest.addTest(function (params) {
+ djstest.assertsExpected(1);
+ var cache = this.createAndAddCache({
+ name: "cache" + new Date().valueOf(),
+ source: params.source,
+ prefetchSize: fixedPrefetchSize,
+ pageSize: 2,
+ mechanism: "memory"
+ });
+ cache.onidle = onidleValidation;
+ cache.readRange(0, 5);
+ }, "onidle, prefetch size = " + fixedPrefetchSize + " on " + sourceObject.source, { source: sourceObject.source });
+
+ djstest.addTest(function (params) {
+ djstest.assertsExpected(1);
+ var cache = this.createAndAddCache({
+ name: "cache" + new Date().valueOf(),
+ source: params.source,
+ prefetchSize: fixedPrefetchSize,
+ idle: function () { djstest.assert(false, "unexpected onidle call") },
+ pageSize: 2,
+ mechanism: "memory"
+ });
+ cache.onidle = onidleValidation;
+ cache.readRange(0, 5);
+ }, "onidle override, prefetch size = " + fixedPrefetchSize + " on " + sourceObject.source, { source: sourceObject.source });
+
+ djstest.addTest(function (params) {
+ var cache = this.createAndAddCache({ name: "cache" + new Date().valueOf(), source: params.source, pageSize: 1, prefetchSize: -1 });
+ var observableSource = typeof params.source === "string" ? this.observableHttpClient : params.source;
+ cache.readRange(0, 1).then(function (data) {
+ // Let one prefetch request go out, to make sure the prefetcher is started, and then destroy the cache
+ $(observableSource).one("success", function () {
+ var session = new Session(observableSource);
+ cache.clear().then(function () {
+ setTimeout(function () {
+ djstest.assertAreEqualDeep(session.requests, [], "Verify no prefetch requests are sent out after cache.clear() callback");
+ djstest.done();
+ }, 1000);
+ }, function (err) {
+ djstest.fail("Error destroying the cache: " + djstest.toString(err));
+ });
+ });
+ });
+ }, "Testing cache.clear() halts the prefetcher" + sourceObject.source, { source: sourceObject.source });
+
+ djstest.addTest(function (params) {
+ var cache = this.createAndAddCache({ name: "cache" + new Date().valueOf(), source: params.source });
+ if (params.countSupported) {
+ cache.count().then(function (count) {
+ djstest.assertAreEqual(count, itemsInCollection, "All items accounted for");
+ djstest.destroyCacheAndDone(cache);
+ }, makeUnexpectedErrorHandler(cache));
+ }
+ else {
+ cache.count().then(function (count) {
+ djstest.assert(false, "Success should not be called, count not supported");
+ djstest.destroyCacheAndDone(cache);
+ }, function (err) {
+ djstest.assertAreEqual(err.message, "HTTP request failed", "Validating expected error");
+ djstest.destroyCacheAndDone(cache);
+ });
+ }
+ }, "Testing cache.count() on " + sourceObject.source, { source: sourceObject.source, countSupported: sourceObject.countSupported });
+
+ djstest.addTest(function (params) {
+ var cache = this.createAndAddCache({ name: "cache" + new Date().valueOf(), source: params.source, pageSize: 1, prefetchSize: 0 });
+ var session = typeof params.source === "string" ? this.observableHttpClient.newSession() : new Session(params.source);
+ cache.readRange(0, 1).cancel();
+ setTimeout(function () {
+ djstest.assertAreEqualDeep(session.requests, [], "Verify no requests are sent out after readRange is cancelled");
+ djstest.done();
+ }, 1000);
+ }, "Testing cancel()" + sourceObject.source, { source: sourceObject.source });
+
+ djstest.addTest(function (params) {
+ djstest.assertsExpected(1);
+ var cache = this.createAndAddCache({ name: "cache" + new Date().valueOf(), source: params.source, pageSize: 1, prefetchSize: 0 });
+ cache.clear().then(function () {
+ cache.clear().then(function () {
+ djstest.pass("Second clear succeeded");
+ djstest.done();
+ }, makeUnexpectedErrorHandler(cache));
+ }, makeUnexpectedErrorHandler(cache));
+ }, "Testing .clear().then(cache.clear())" + sourceObject.source, { source: sourceObject.source });
+ });
+
+ var params = {
+ source: "./endpoints/BasicAuthDataService.svc/Customers",
+ skip: 0,
+ take: 5,
+ pageSize: 5,
+ prefetchSize: -1,
+ cacheSize: -1,
+ user: "djsUser",
+ password: "djsPassword"
+ };
+ djstest.addTest(dataCachePrefetchTest, createSingleReadTestName(params), params);
+})(this);
http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/503b4417/tests/odata-cache-rx-functional-tests.html
----------------------------------------------------------------------
diff --git a/tests/odata-cache-rx-functional-tests.html b/tests/odata-cache-rx-functional-tests.html
new file mode 100644
index 0000000..728e833
--- /dev/null
+++ b/tests/odata-cache-rx-functional-tests.html
@@ -0,0 +1,50 @@
+<!--
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+ -->
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+ <title>>datajs.cache toObservable() tests</title>
+ <meta http-equiv="cache-control" content="no-cache"/>
+ <meta http-equiv="pragma" content="no-cache"/>
+ <meta http-equiv="expires" content="-1"/>
+
+ <link rel="stylesheet" href="http://code.jquery.com/qunit/qunit-1.10.0.css" type="text/css" />
+ <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/json2/20110223/json2.js"></script>
+ <script type="text/javascript" src="http://code.jquery.com/jquery-1.4.4.min.js"></script>
+ <script type="text/javascript" src="http://code.jquery.com/qunit/qunit-1.10.0.js"></script>
+ <script type="text/javascript" src="common/TestSynchronizerClient.js"></script>
+ <script type="text/javascript">
+ window.TestSynchronizer.init(QUnit);
+ </script>
+ <script type="text/javascript" src="../build/odatajs-4.0.0-beta-01.js"></script>
+ <script type="text/javascript" src="common/common.js"></script>
+ <script type="text/javascript" src="common/djstest.js"></script>
+ <script type="text/javascript" src="common/ODataVerifyReader.js"></script>
+ <script type="text/javascript" src="common/rx.js"></script>
+ <script type="text/javascript" src="odata-cache-rx-functional-tests.js"></script>
+</head>
+<body>
+ <h1 id="qunit-header">datajs.cache toObservable() tests</h1>
+ <h2 id="qunit-banner"></h2>
+ <h2 id="qunit-userAgent"></h2>
+ <ol id="qunit-tests"></ol>
+</body>
+</html>
http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/503b4417/tests/odata-cache-rx-functional-tests.js
----------------------------------------------------------------------
diff --git a/tests/odata-cache-rx-functional-tests.js b/tests/odata-cache-rx-functional-tests.js
new file mode 100644
index 0000000..714cccb
--- /dev/null
+++ b/tests/odata-cache-rx-functional-tests.js
@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+
+(function (window, undefined) {
+ OData.defaultHandler.accept = "application/json;q=0.9, */*;q=0.1";
+ var feeds = [
+ { uri: "./endpoints/FoodStoreDataServiceV4.svc/Foods" }
+ ];
+
+ var itemsInCollection = 16;
+ var pageSizes = [
+ 1,
+ 4, // factor of total, <= server page size
+ 5, // non-factor of total, <= server page size
+ 6, // non-factor of total, > server page size
+ 8, // factor of total, > server page size
+ itemsInCollection,
+ itemsInCollection + 1
+ ];
+
+ var operatorTests = [
+ function (observable) { return observable.Take(0); },
+ function (observable) { return observable.Take(1); },
+ function (observable) { return observable.Skip(1); },
+ function (observable) { return observable.Skip(2).Take(4); },
+ function (observable) { return observable.Select(function (item) { return item.Name; }); },
+ function (observable) { return observable.Where(function (item) { return item.FoodID % 2 === 1; }); }
+ ];
+
+ var assertObservables = function (actual, expected, done) {
+ /** Asserts two finite observables generate the same sequence
+ * @param {IObservable} actual - The actual observable
+ * @param {IObservable} expected - The expected observable
+ * @param {Function} done - The callback function when asserts are done
+ */
+ var toArray = function (observable, callback) {
+ var arr = [];
+ observable.Subscribe(
+ function (item) { arr.push(item); },
+ function (err) { arr.push({ "__error__": err }); },
+ function () { callback(arr); });
+ };
+
+ toArray(actual, function (actualSequence) {
+ toArray(expected, function (expectedSequence) {
+ djstest.assertAreEqualDeep(actualSequence, expectedSequence, "Verify observable sequence");
+ done();
+ });
+ });
+ };
+
+ module("Functional");
+ $.each(feeds, function (_, feed) {
+ $.each(pageSizes, function (_, pageSize) {
+ $.each(operatorTests, function (_, operator) {
+ var params = { feedUri: feed.uri, pageSize: pageSize, operator: operator };
+ djstest.addTest(function (params) {
+ djstest.assertsExpected(1);
+ var options = { name: "cache" + new Date().valueOf(), source: params.feedUri, pageSize: params.pageSize, prefetchSize: 0 };
+ var cache = odatajs.cache.createDataCache(options);
+
+ ODataVerifyReader.readJsonAcrossServerPages(params.feedUri, function (collection) {
+ assertObservables(params.operator(cache.toObservable()), params.operator(window.Rx.Observable.FromArray(collection.value)), function () {
+ djstest.destroyCacheAndDone(cache);
+ });
+ });
+ }, "feed: " + params.feedUri + ", pageSize: " + params.pageSize + ", operator: " + params.operator.toString(), params);
+ });
+ });
+ });
+})(this);