Source/modules/serviceworkers/CacheTest.cpp - platform/external/chromium_org/third_party/WebKit - Git at Google

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "config.h"
 #include "modules/serviceworkers/Cache.h"

 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/modules/v8/V8Request.h"
 #include "bindings/modules/v8/V8Response.h"
 #include "core/dom/Document.h"
 #include "core/frame/Frame.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/serviceworkers/Request.h"
 #include "modules/serviceworkers/Response.h"
 #include "public/platform/WebServiceWorkerCache.h"
 #include "wtf/OwnPtr.h"

 #include <algorithm>
 #include <gtest/gtest.h>
 #include <string>

 namespace blink {

 namespace {

 const char kNotImplementedString[] = "NotSupportedError: Method is not implemented.";

 // A test implementation of the WebServiceWorkerCache interface which returns a (provided) error for every operation, and optionally checks arguments
 // to methods against provided arguments. Also used as a base class for test specific caches.
 class ErrorWebCacheForTests : public WebServiceWorkerCache {
 public:
     ErrorWebCacheForTests(const WebServiceWorkerCacheError error)
         : m_error(error)
         , m_expectedUrl(0)
         , m_expectedQueryParams(0)
         , m_expectedBatchOperations(0) { }

     std::string getAndClearLastErrorWebCacheMethodCalled()
     {
         std::string old = m_lastErrorWebCacheMethodCalled;
         m_lastErrorWebCacheMethodCalled.clear();
         return old;
     }

     // These methods do not take ownership of their parameter. They provide an optional sample object to check parameters against.
     void setExpectedUrl(const String* expectedUrl) { m_expectedUrl = expectedUrl; }
     void setExpectedQueryParams(const QueryParams* expectedQueryParams) { m_expectedQueryParams = expectedQueryParams; }
     void setExpectedBatchOperations(const WebVector<BatchOperation>* expectedBatchOperations) { m_expectedBatchOperations = expectedBatchOperations; }

     // From WebServiceWorkerCache:
     virtual void dispatchMatch(CacheMatchCallbacks* callbacks, const WebServiceWorkerRequest& webRequest, const QueryParams& queryParams) override
     {
         m_lastErrorWebCacheMethodCalled = "dispatchMatch";
         checkUrlIfProvided(webRequest.url());
         checkQueryParamsIfProvided(queryParams);

         OwnPtr<CacheMatchCallbacks> ownedCallbacks(adoptPtr(callbacks));
         WebServiceWorkerCacheError error = m_error;
         return callbacks->onError(&error);
     }

     virtual void dispatchMatchAll(CacheWithResponsesCallbacks* callbacks, const WebServiceWorkerRequest& webRequest, const QueryParams& queryParams) override
     {
         m_lastErrorWebCacheMethodCalled = "dispatchMatchAll";
         checkUrlIfProvided(webRequest.url());
         checkQueryParamsIfProvided(queryParams);

         OwnPtr<CacheWithResponsesCallbacks> ownedCallbacks(adoptPtr(callbacks));
         WebServiceWorkerCacheError error = m_error;
         return callbacks->onError(&error);
     }

     virtual void dispatchKeys(CacheWithRequestsCallbacks* callbacks, const WebServiceWorkerRequest* webRequest, const QueryParams& queryParams) override
     {
         m_lastErrorWebCacheMethodCalled = "dispatchKeys";
         if (webRequest) {
             checkUrlIfProvided(webRequest->url());
             checkQueryParamsIfProvided(queryParams);
         }

         OwnPtr<CacheWithRequestsCallbacks> ownedCallbacks(adoptPtr(callbacks));
         WebServiceWorkerCacheError error = m_error;
         return callbacks->onError(&error);
     }

     virtual void dispatchBatch(CacheWithResponsesCallbacks* callbacks, const WebVector<BatchOperation>& batchOperations) override
     {
         m_lastErrorWebCacheMethodCalled = "dispatchBatch";
         checkBatchOperationsIfProvided(batchOperations);

         OwnPtr<CacheWithResponsesCallbacks> ownedCallbacks(adoptPtr(callbacks));
         WebServiceWorkerCacheError error = m_error;
         return callbacks->onError(&error);
     }

 protected:
     void checkUrlIfProvided(const KURL& url)
     {
         if (!m_expectedUrl)
             return;
         EXPECT_EQ(*m_expectedUrl, url);
     }

     void checkQueryParamsIfProvided(const QueryParams& queryParams)
     {
         if (!m_expectedQueryParams)
             return;
         CompareQueryParamsForTest(*m_expectedQueryParams, queryParams);
     }

     void checkBatchOperationsIfProvided(const WebVector<BatchOperation>& batchOperations)
     {
         if (!m_expectedBatchOperations)
             return;
         const WebVector<BatchOperation> expectedBatchOperations = *m_expectedBatchOperations;
         EXPECT_EQ(expectedBatchOperations.size(), batchOperations.size());
         for (int i = 0, minsize = std::min(expectedBatchOperations.size(), batchOperations.size()); i < minsize; ++i) {
             EXPECT_EQ(expectedBatchOperations[i].operationType, batchOperations[i].operationType);
             const String expectedRequestUrl = KURL(expectedBatchOperations[i].request.url());
             EXPECT_EQ(expectedRequestUrl, KURL(batchOperations[i].request.url()));
             const String expectedResponseUrl = KURL(expectedBatchOperations[i].response.url());
             EXPECT_EQ(expectedResponseUrl, KURL(batchOperations[i].response.url()));
             CompareQueryParamsForTest(expectedBatchOperations[i].matchParams, batchOperations[i].matchParams);
         }
     }

 private:
     static void CompareQueryParamsForTest(const QueryParams& expectedQueryParams, const QueryParams& queryParams)
     {
         EXPECT_EQ(expectedQueryParams.ignoreSearch, queryParams.ignoreSearch);
         EXPECT_EQ(expectedQueryParams.ignoreMethod, queryParams.ignoreMethod);
         EXPECT_EQ(expectedQueryParams.ignoreVary, queryParams.ignoreVary);
         EXPECT_EQ(expectedQueryParams.prefixMatch, queryParams.prefixMatch);
         EXPECT_EQ(expectedQueryParams.cacheName, queryParams.cacheName);
     }

     const WebServiceWorkerCacheError m_error;

     const String* m_expectedUrl;
     const QueryParams* m_expectedQueryParams;
     const WebVector<BatchOperation>* m_expectedBatchOperations;

     std::string m_lastErrorWebCacheMethodCalled;
 };

 class NotImplementedErrorCache : public ErrorWebCacheForTests {
 public:
     NotImplementedErrorCache() : ErrorWebCacheForTests(WebServiceWorkerCacheErrorNotImplemented) { }
 };

 class ServiceWorkerCacheTest : public ::testing::Test {
 public:
     ServiceWorkerCacheTest()
         : m_page(DummyPageHolder::create(IntSize(1, 1))) { }

     ScriptState* scriptState() { return ScriptState::forMainWorld(m_page->document().frame()); }
     ExecutionContext* executionContext() { return scriptState()->executionContext(); }
     v8::Isolate* isolate() { return scriptState()->isolate(); }

     Request* newRequestFromUrl(const String& url)
     {
         TrackExceptionState exceptionState;
         Request* request = Request::create(executionContext(), url, exceptionState);
         EXPECT_FALSE(exceptionState.hadException());
         return exceptionState.hadException() ? 0 : request;
     }

     // Convenience methods for testing the returned promises.
     ScriptValue getRejectValue(ScriptPromise& promise)
     {
         ScriptValue onReject;
         promise.then(UnreachableFunction::create(scriptState()), TestFunction::create(scriptState(), &onReject));
         isolate()->RunMicrotasks();
         return onReject;
     }

     std::string getRejectString(ScriptPromise& promise)
     {
         ScriptValue onReject = getRejectValue(promise);
         return toCoreString(onReject.v8Value()->ToString()).ascii().data();
     }

     ScriptValue getResolveValue(ScriptPromise& promise)
     {
         ScriptValue onResolve;
         promise.then(TestFunction::create(scriptState(), &onResolve), UnreachableFunction::create(scriptState()));
         isolate()->RunMicrotasks();
         return onResolve;
     }

     std::string getResolveString(ScriptPromise& promise)
     {
         ScriptValue onResolve = getResolveValue(promise);
         return toCoreString(onResolve.v8Value()->ToString()).ascii().data();
     }

     ExceptionState& exceptionState()
     {
         return m_exceptionState;
     }

 private:
     // A ScriptFunction that creates a test failure if it is ever called.
     class UnreachableFunction : public ScriptFunction {
     public:
         static v8::Handle<v8::Function> create(ScriptState* scriptState)
         {
             UnreachableFunction* self = new UnreachableFunction(scriptState);
             return self->bindToV8Function();
         }

         virtual ScriptValue call(ScriptValue value) override
         {
             ADD_FAILURE() << "Unexpected call to a null ScriptFunction.";
             return value;
         }
     private:
         UnreachableFunction(ScriptState* scriptState) : ScriptFunction(scriptState) { }
     };

     // A ScriptFunction that saves its parameter; used by tests to assert on correct
     // values being passed.
     class TestFunction : public ScriptFunction {
     public:
         static v8::Handle<v8::Function> create(ScriptState* scriptState, ScriptValue* outValue)
         {
             TestFunction* self = new TestFunction(scriptState, outValue);
             return self->bindToV8Function();
         }

         virtual ScriptValue call(ScriptValue value) override
         {
             ASSERT(!value.isEmpty());
             *m_value = value;
             return value;
         }

     private:
         TestFunction(ScriptState* scriptState, ScriptValue* outValue) : ScriptFunction(scriptState), m_value(outValue) { }

         ScriptValue* m_value;
     };

     // From ::testing::Test:
     virtual void SetUp() override
     {
         EXPECT_FALSE(m_scriptScope);
         m_scriptScope = adoptPtr(new ScriptState::Scope(scriptState()));
     }

     virtual void TearDown() override
     {
         m_scriptScope = 0;
     }

     // Lifetime is that of the text fixture.
     OwnPtr<DummyPageHolder> m_page;

     // Lifetime is per test instance.
     OwnPtr<ScriptState::Scope> m_scriptScope;

     NonThrowableExceptionState m_exceptionState;
 };

 TEST_F(ServiceWorkerCacheTest, Basics)
 {
     ErrorWebCacheForTests* testCache;
     Cache* cache = Cache::create(testCache = new NotImplementedErrorCache());
     ASSERT(cache);

     const String url = "http://www.cachetest.org/";

     CacheQueryOptions options;
     ScriptPromise matchPromise = cache->match(scriptState(), url, options, exceptionState());
     EXPECT_EQ(kNotImplementedString, getRejectString(matchPromise));

     cache = Cache::create(testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorNotFound));
     matchPromise = cache->match(scriptState(), url, options, exceptionState());
     ScriptValue scriptValue = getResolveValue(matchPromise);
     EXPECT_TRUE(scriptValue.isUndefined());

     cache = Cache::create(testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorExists));
     matchPromise = cache->match(scriptState(), url, options, exceptionState());
     EXPECT_EQ("InvalidAccessError: Entry already exists.", getRejectString(matchPromise));
 }

 // Tests that arguments are faithfully passed on calls to Cache methods, except for methods which use batch operations,
 // which are tested later.
 TEST_F(ServiceWorkerCacheTest, BasicArguments)
 {
     ErrorWebCacheForTests* testCache;
     Cache* cache = Cache::create(testCache = new NotImplementedErrorCache());
     ASSERT(cache);

     const String url = "http://www.cache.arguments.test/";
     testCache->setExpectedUrl(&url);

     WebServiceWorkerCache::QueryParams expectedQueryParams;
     expectedQueryParams.ignoreVary = true;
     expectedQueryParams.cacheName = "this is a cache name";
     testCache->setExpectedQueryParams(&expectedQueryParams);

     CacheQueryOptions options;
     options.setIgnoreVary(1);
     options.setCacheName(expectedQueryParams.cacheName);

     Request* request = newRequestFromUrl(url);
     ASSERT(request);
     ScriptPromise matchResult = cache->match(scriptState(), request, options);
     EXPECT_EQ("dispatchMatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(matchResult));

     ScriptPromise stringMatchResult = cache->match(scriptState(), url, options, exceptionState());
     EXPECT_EQ("dispatchMatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(stringMatchResult));

     request = newRequestFromUrl(url);
     ASSERT(request);
     ScriptPromise matchAllResult = cache->matchAll(scriptState(), request, options);
     EXPECT_EQ("dispatchMatchAll", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(matchAllResult));

     ScriptPromise stringMatchAllResult = cache->matchAll(scriptState(), url, options, exceptionState());
     EXPECT_EQ("dispatchMatchAll", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(stringMatchAllResult));

     ScriptPromise keysResult1 = cache->keys(scriptState());
     EXPECT_EQ("dispatchKeys", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(keysResult1));

     request = newRequestFromUrl(url);
     ASSERT(request);
     ScriptPromise keysResult2 = cache->keys(scriptState(), request, options);
     EXPECT_EQ("dispatchKeys", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(keysResult2));

     ScriptPromise stringKeysResult2 = cache->keys(scriptState(), url, options, exceptionState());
     EXPECT_EQ("dispatchKeys", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(stringKeysResult2));
 }

 // Tests that arguments are faithfully passed to API calls that degrade to batch operations.
 TEST_F(ServiceWorkerCacheTest, BatchOperationArguments)
 {
     ErrorWebCacheForTests* testCache;
     Cache* cache = Cache::create(testCache = new NotImplementedErrorCache());
     ASSERT(cache);

     WebServiceWorkerCache::QueryParams expectedQueryParams;
     expectedQueryParams.prefixMatch = true;
     expectedQueryParams.cacheName = "this is another cache name";
     testCache->setExpectedQueryParams(&expectedQueryParams);

     CacheQueryOptions options;
     options.setPrefixMatch(1);
     options.setCacheName(expectedQueryParams.cacheName);

     const String url = "http://batch.operations.test/";
     Request* request = newRequestFromUrl(url);
     ASSERT(request);

     WebServiceWorkerResponse webResponse;
     webResponse.setURL(KURL(ParsedURLString, url));
     Response* response = Response::create(executionContext(), webResponse);

     WebVector<WebServiceWorkerCache::BatchOperation> expectedDeleteOperations(size_t(1));
     {
         WebServiceWorkerCache::BatchOperation deleteOperation;
         deleteOperation.operationType = WebServiceWorkerCache::OperationTypeDelete;
         request->populateWebServiceWorkerRequest(deleteOperation.request);
         deleteOperation.matchParams = expectedQueryParams;
         expectedDeleteOperations[0] = deleteOperation;
     }
     testCache->setExpectedBatchOperations(&expectedDeleteOperations);

     ScriptPromise deleteResult = cache->deleteFunction(scriptState(), request, options);
     EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(deleteResult));

     ScriptPromise stringDeleteResult = cache->deleteFunction(scriptState(), url, options, exceptionState());
     EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(stringDeleteResult));

     WebVector<WebServiceWorkerCache::BatchOperation> expectedPutOperations(size_t(1));
     {
         WebServiceWorkerCache::BatchOperation putOperation;
         putOperation.operationType = WebServiceWorkerCache::OperationTypePut;
         request->populateWebServiceWorkerRequest(putOperation.request);
         response->populateWebServiceWorkerResponse(putOperation.response);
         expectedPutOperations[0] = putOperation;
     }
     testCache->setExpectedBatchOperations(&expectedPutOperations);

     request = newRequestFromUrl(url);
     ASSERT(request);
     ScriptPromise putResult = cache->put(scriptState(), request, response->clone());
     EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(putResult));

     ScriptPromise stringPutResult = cache->put(scriptState(), url, response, exceptionState());
     EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(stringPutResult));

     // FIXME: test add & addAll.
 }

 class MatchTestCache : public NotImplementedErrorCache {
 public:
     MatchTestCache(WebServiceWorkerResponse& response)
         : m_response(response) { }

     // From WebServiceWorkerCache:
     virtual void dispatchMatch(CacheMatchCallbacks* callbacks, const WebServiceWorkerRequest& webRequest, const QueryParams& queryParams) override
     {
         OwnPtr<CacheMatchCallbacks> ownedCallbacks(adoptPtr(callbacks));
         return callbacks->onSuccess(&m_response);
     }

 private:
     WebServiceWorkerResponse& m_response;
 };

 TEST_F(ServiceWorkerCacheTest, MatchResponseTest)
 {
     const String requestUrl = "http://request.url/";
     const String responseUrl = "http://match.response.test/";

     WebServiceWorkerResponse webResponse;
     webResponse.setURL(KURL(ParsedURLString, responseUrl));
     webResponse.setResponseType(WebServiceWorkerResponseTypeDefault);

     Cache* cache = Cache::create(new MatchTestCache(webResponse));
     CacheQueryOptions options;

     ScriptPromise result = cache->match(scriptState(), requestUrl, options, exceptionState());
     ScriptValue scriptValue = getResolveValue(result);
     Response* response = V8Response::toImplWithTypeCheck(isolate(), scriptValue.v8Value());
     ASSERT_TRUE(response);
     EXPECT_EQ(responseUrl, response->url());
 }

 class KeysTestCache : public NotImplementedErrorCache {
 public:
     KeysTestCache(WebVector<WebServiceWorkerRequest>& requests)
         : m_requests(requests) { }

     virtual void dispatchKeys(CacheWithRequestsCallbacks* callbacks, const WebServiceWorkerRequest* webRequest, const QueryParams& queryParams) override
     {
         OwnPtr<CacheWithRequestsCallbacks> ownedCallbacks(adoptPtr(callbacks));
         return callbacks->onSuccess(&m_requests);
     }

 private:
     WebVector<WebServiceWorkerRequest>& m_requests;
 };

 TEST_F(ServiceWorkerCacheTest, KeysResponseTest)
 {
     const String url1 = "http://first.request/";
     const String url2 = "http://second.request/";

     Vector<String> expectedUrls(size_t(2));
     expectedUrls[0] = url1;
     expectedUrls[1] = url2;

     WebVector<WebServiceWorkerRequest> webRequests(size_t(2));
     webRequests[0].setURL(KURL(ParsedURLString, url1));
     webRequests[1].setURL(KURL(ParsedURLString, url2));

     Cache* cache = Cache::create(new KeysTestCache(webRequests));

     ScriptPromise result = cache->keys(scriptState());
     ScriptValue scriptValue = getResolveValue(result);

     Vector<v8::Handle<v8::Value> > requests = toImplArray<v8::Handle<v8::Value> >(scriptValue.v8Value(), 0, isolate(), exceptionState());
     EXPECT_EQ(expectedUrls.size(), requests.size());
     for (int i = 0, minsize = std::min(expectedUrls.size(), requests.size()); i < minsize; ++i) {
         Request* request = V8Request::toImplWithTypeCheck(isolate(), requests[i]);
         EXPECT_TRUE(request);
         if (request)
             EXPECT_EQ(expectedUrls[i], request->url());
     }
 }

 class MatchAllAndBatchTestCache : public NotImplementedErrorCache {
 public:
     MatchAllAndBatchTestCache(WebVector<WebServiceWorkerResponse>& responses)
         : m_responses(responses) { }

     virtual void dispatchMatchAll(CacheWithResponsesCallbacks* callbacks, const WebServiceWorkerRequest& webRequest, const QueryParams& queryParams) override
     {
         OwnPtr<CacheWithResponsesCallbacks> ownedCallbacks(adoptPtr(callbacks));
         return callbacks->onSuccess(&m_responses);
     }

     virtual void dispatchBatch(CacheWithResponsesCallbacks* callbacks, const WebVector<BatchOperation>& batchOperations) override
     {
         OwnPtr<CacheWithResponsesCallbacks> ownedCallbacks(adoptPtr(callbacks));
         return callbacks->onSuccess(&m_responses);
     }

 private:
     WebVector<WebServiceWorkerResponse>& m_responses;
 };

 TEST_F(ServiceWorkerCacheTest, MatchAllAndBatchResponseTest)
 {
     const String url1 = "http://first.response/";
     const String url2 = "http://second.response/";

     Vector<String> expectedUrls(size_t(2));
     expectedUrls[0] = url1;
     expectedUrls[1] = url2;

     WebVector<WebServiceWorkerResponse> webResponses(size_t(2));
     webResponses[0].setURL(KURL(ParsedURLString, url1));
     webResponses[0].setResponseType(WebServiceWorkerResponseTypeDefault);
     webResponses[1].setURL(KURL(ParsedURLString, url2));
     webResponses[1].setResponseType(WebServiceWorkerResponseTypeDefault);

     Cache* cache = Cache::create(new MatchAllAndBatchTestCache(webResponses));

     CacheQueryOptions options;
     ScriptPromise result = cache->matchAll(scriptState(), "http://some.url/", options, exceptionState());
     ScriptValue scriptValue = getResolveValue(result);

     Vector<v8::Handle<v8::Value> > responses = toImplArray<v8::Handle<v8::Value> >(scriptValue.v8Value(), 0, isolate(), exceptionState());
     EXPECT_EQ(expectedUrls.size(), responses.size());
     for (int i = 0, minsize = std::min(expectedUrls.size(), responses.size()); i < minsize; ++i) {
         Response* response = V8Response::toImplWithTypeCheck(isolate(), responses[i]);
         EXPECT_TRUE(response);
         if (response)
             EXPECT_EQ(expectedUrls[i], response->url());
     }

     result = cache->deleteFunction(scriptState(), "http://some.url/", options, exceptionState());
     scriptValue = getResolveValue(result);
     EXPECT_TRUE(scriptValue.v8Value()->IsBoolean());
     EXPECT_EQ(true, scriptValue.v8Value()->BooleanValue());
 }

 } // namespace
 } // namespace blink
	// Copyright 2014 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "config.h"
	#include "modules/serviceworkers/Cache.h"

	#include "bindings/core/v8/ExceptionState.h"
	#include "bindings/core/v8/ScriptFunction.h"
	#include "bindings/core/v8/ScriptPromise.h"
	#include "bindings/core/v8/ScriptValue.h"
	#include "bindings/core/v8/V8Binding.h"
	#include "bindings/modules/v8/V8Request.h"
	#include "bindings/modules/v8/V8Response.h"
	#include "core/dom/Document.h"
	#include "core/frame/Frame.h"
	#include "core/testing/DummyPageHolder.h"
	#include "modules/serviceworkers/Request.h"
	#include "modules/serviceworkers/Response.h"
	#include "public/platform/WebServiceWorkerCache.h"
	#include "wtf/OwnPtr.h"

	#include <algorithm>
	#include <gtest/gtest.h>
	#include <string>

	namespace blink {

	namespace {

	const char kNotImplementedString[] = "NotSupportedError: Method is not implemented.";

	// A test implementation of the WebServiceWorkerCache interface which returns a (provided) error for every operation, and optionally checks arguments
	// to methods against provided arguments. Also used as a base class for test specific caches.
	class ErrorWebCacheForTests : public WebServiceWorkerCache {
	public:
	ErrorWebCacheForTests(const WebServiceWorkerCacheError error)
	: m_error(error)
	, m_expectedUrl(0)
	, m_expectedQueryParams(0)
	, m_expectedBatchOperations(0) { }

	std::string getAndClearLastErrorWebCacheMethodCalled()
	{
	std::string old = m_lastErrorWebCacheMethodCalled;
	m_lastErrorWebCacheMethodCalled.clear();
	return old;
	}

	// These methods do not take ownership of their parameter. They provide an optional sample object to check parameters against.
	void setExpectedUrl(const String* expectedUrl) { m_expectedUrl = expectedUrl; }
	void setExpectedQueryParams(const QueryParams* expectedQueryParams) { m_expectedQueryParams = expectedQueryParams; }
	void setExpectedBatchOperations(const WebVector<BatchOperation>* expectedBatchOperations) { m_expectedBatchOperations = expectedBatchOperations; }

	// From WebServiceWorkerCache:
	virtual void dispatchMatch(CacheMatchCallbacks* callbacks, const WebServiceWorkerRequest& webRequest, const QueryParams& queryParams) override
	{
	m_lastErrorWebCacheMethodCalled = "dispatchMatch";
	checkUrlIfProvided(webRequest.url());
	checkQueryParamsIfProvided(queryParams);

	OwnPtr<CacheMatchCallbacks> ownedCallbacks(adoptPtr(callbacks));
	WebServiceWorkerCacheError error = m_error;
	return callbacks->onError(&error);
	}

	virtual void dispatchMatchAll(CacheWithResponsesCallbacks* callbacks, const WebServiceWorkerRequest& webRequest, const QueryParams& queryParams) override
	{
	m_lastErrorWebCacheMethodCalled = "dispatchMatchAll";
	checkUrlIfProvided(webRequest.url());
	checkQueryParamsIfProvided(queryParams);

	OwnPtr<CacheWithResponsesCallbacks> ownedCallbacks(adoptPtr(callbacks));
	WebServiceWorkerCacheError error = m_error;
	return callbacks->onError(&error);
	}

	virtual void dispatchKeys(CacheWithRequestsCallbacks* callbacks, const WebServiceWorkerRequest* webRequest, const QueryParams& queryParams) override
	{
	m_lastErrorWebCacheMethodCalled = "dispatchKeys";
	if (webRequest) {
	checkUrlIfProvided(webRequest->url());
	checkQueryParamsIfProvided(queryParams);
	}

	OwnPtr<CacheWithRequestsCallbacks> ownedCallbacks(adoptPtr(callbacks));
	WebServiceWorkerCacheError error = m_error;
	return callbacks->onError(&error);
	}

	virtual void dispatchBatch(CacheWithResponsesCallbacks* callbacks, const WebVector<BatchOperation>& batchOperations) override
	{
	m_lastErrorWebCacheMethodCalled = "dispatchBatch";
	checkBatchOperationsIfProvided(batchOperations);

	OwnPtr<CacheWithResponsesCallbacks> ownedCallbacks(adoptPtr(callbacks));
	WebServiceWorkerCacheError error = m_error;
	return callbacks->onError(&error);
	}

	protected:
	void checkUrlIfProvided(const KURL& url)
	{
	if (!m_expectedUrl)
	return;
	EXPECT_EQ(*m_expectedUrl, url);
	}

	void checkQueryParamsIfProvided(const QueryParams& queryParams)
	{
	if (!m_expectedQueryParams)
	return;
	CompareQueryParamsForTest(*m_expectedQueryParams, queryParams);
	}

	void checkBatchOperationsIfProvided(const WebVector<BatchOperation>& batchOperations)
	{
	if (!m_expectedBatchOperations)
	return;
	const WebVector<BatchOperation> expectedBatchOperations = *m_expectedBatchOperations;
	EXPECT_EQ(expectedBatchOperations.size(), batchOperations.size());
	for (int i = 0, minsize = std::min(expectedBatchOperations.size(), batchOperations.size()); i < minsize; ++i) {
	EXPECT_EQ(expectedBatchOperations[i].operationType, batchOperations[i].operationType);
	const String expectedRequestUrl = KURL(expectedBatchOperations[i].request.url());
	EXPECT_EQ(expectedRequestUrl, KURL(batchOperations[i].request.url()));
	const String expectedResponseUrl = KURL(expectedBatchOperations[i].response.url());
	EXPECT_EQ(expectedResponseUrl, KURL(batchOperations[i].response.url()));
	CompareQueryParamsForTest(expectedBatchOperations[i].matchParams, batchOperations[i].matchParams);
	}
	}

	private:
	static void CompareQueryParamsForTest(const QueryParams& expectedQueryParams, const QueryParams& queryParams)
	{
	EXPECT_EQ(expectedQueryParams.ignoreSearch, queryParams.ignoreSearch);
	EXPECT_EQ(expectedQueryParams.ignoreMethod, queryParams.ignoreMethod);
	EXPECT_EQ(expectedQueryParams.ignoreVary, queryParams.ignoreVary);
	EXPECT_EQ(expectedQueryParams.prefixMatch, queryParams.prefixMatch);
	EXPECT_EQ(expectedQueryParams.cacheName, queryParams.cacheName);
	}

	const WebServiceWorkerCacheError m_error;

	const String* m_expectedUrl;
	const QueryParams* m_expectedQueryParams;
	const WebVector<BatchOperation>* m_expectedBatchOperations;

	std::string m_lastErrorWebCacheMethodCalled;
	};

	class NotImplementedErrorCache : public ErrorWebCacheForTests {
	public:
	NotImplementedErrorCache() : ErrorWebCacheForTests(WebServiceWorkerCacheErrorNotImplemented) { }
	};

	class ServiceWorkerCacheTest : public ::testing::Test {
	public:
	ServiceWorkerCacheTest()
	: m_page(DummyPageHolder::create(IntSize(1, 1))) { }

	ScriptState* scriptState() { return ScriptState::forMainWorld(m_page->document().frame()); }
	ExecutionContext* executionContext() { return scriptState()->executionContext(); }
	v8::Isolate* isolate() { return scriptState()->isolate(); }

	Request* newRequestFromUrl(const String& url)
	{
	TrackExceptionState exceptionState;
	Request* request = Request::create(executionContext(), url, exceptionState);
	EXPECT_FALSE(exceptionState.hadException());
	return exceptionState.hadException() ? 0 : request;
	}

	// Convenience methods for testing the returned promises.
	ScriptValue getRejectValue(ScriptPromise& promise)
	{
	ScriptValue onReject;
	promise.then(UnreachableFunction::create(scriptState()), TestFunction::create(scriptState(), &onReject));
	isolate()->RunMicrotasks();
	return onReject;
	}

	std::string getRejectString(ScriptPromise& promise)
	{
	ScriptValue onReject = getRejectValue(promise);
	return toCoreString(onReject.v8Value()->ToString()).ascii().data();
	}

	ScriptValue getResolveValue(ScriptPromise& promise)
	{
	ScriptValue onResolve;
	promise.then(TestFunction::create(scriptState(), &onResolve), UnreachableFunction::create(scriptState()));
	isolate()->RunMicrotasks();
	return onResolve;
	}

	std::string getResolveString(ScriptPromise& promise)
	{
	ScriptValue onResolve = getResolveValue(promise);
	return toCoreString(onResolve.v8Value()->ToString()).ascii().data();
	}

	ExceptionState& exceptionState()
	{
	return m_exceptionState;
	}

	private:
	// A ScriptFunction that creates a test failure if it is ever called.
	class UnreachableFunction : public ScriptFunction {
	public:
	static v8::Handle<v8::Function> create(ScriptState* scriptState)
	{
	UnreachableFunction* self = new UnreachableFunction(scriptState);
	return self->bindToV8Function();
	}

	virtual ScriptValue call(ScriptValue value) override
	{
	ADD_FAILURE() << "Unexpected call to a null ScriptFunction.";
	return value;
	}
	private:
	UnreachableFunction(ScriptState* scriptState) : ScriptFunction(scriptState) { }
	};

	// A ScriptFunction that saves its parameter; used by tests to assert on correct
	// values being passed.
	class TestFunction : public ScriptFunction {
	public:
	static v8::Handle<v8::Function> create(ScriptState* scriptState, ScriptValue* outValue)
	{
	TestFunction* self = new TestFunction(scriptState, outValue);
	return self->bindToV8Function();
	}

	virtual ScriptValue call(ScriptValue value) override
	{
	ASSERT(!value.isEmpty());
	*m_value = value;
	return value;
	}

	private:
	TestFunction(ScriptState* scriptState, ScriptValue* outValue) : ScriptFunction(scriptState), m_value(outValue) { }

	ScriptValue* m_value;
	};

	// From ::testing::Test:
	virtual void SetUp() override
	{
	EXPECT_FALSE(m_scriptScope);
	m_scriptScope = adoptPtr(new ScriptState::Scope(scriptState()));
	}

	virtual void TearDown() override
	{
	m_scriptScope = 0;
	}

	// Lifetime is that of the text fixture.
	OwnPtr<DummyPageHolder> m_page;

	// Lifetime is per test instance.
	OwnPtr<ScriptState::Scope> m_scriptScope;

	NonThrowableExceptionState m_exceptionState;
	};

	TEST_F(ServiceWorkerCacheTest, Basics)
	{
	ErrorWebCacheForTests* testCache;
	Cache* cache = Cache::create(testCache = new NotImplementedErrorCache());
	ASSERT(cache);

	const String url = "http://www.cachetest.org/";

	CacheQueryOptions options;
	ScriptPromise matchPromise = cache->match(scriptState(), url, options, exceptionState());
	EXPECT_EQ(kNotImplementedString, getRejectString(matchPromise));

	cache = Cache::create(testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorNotFound));
	matchPromise = cache->match(scriptState(), url, options, exceptionState());
	ScriptValue scriptValue = getResolveValue(matchPromise);
	EXPECT_TRUE(scriptValue.isUndefined());

	cache = Cache::create(testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorExists));
	matchPromise = cache->match(scriptState(), url, options, exceptionState());
	EXPECT_EQ("InvalidAccessError: Entry already exists.", getRejectString(matchPromise));
	}

	// Tests that arguments are faithfully passed on calls to Cache methods, except for methods which use batch operations,
	// which are tested later.
	TEST_F(ServiceWorkerCacheTest, BasicArguments)
	{
	ErrorWebCacheForTests* testCache;
	Cache* cache = Cache::create(testCache = new NotImplementedErrorCache());
	ASSERT(cache);

	const String url = "http://www.cache.arguments.test/";
	testCache->setExpectedUrl(&url);

	WebServiceWorkerCache::QueryParams expectedQueryParams;
	expectedQueryParams.ignoreVary = true;
	expectedQueryParams.cacheName = "this is a cache name";
	testCache->setExpectedQueryParams(&expectedQueryParams);

	CacheQueryOptions options;
	options.setIgnoreVary(1);
	options.setCacheName(expectedQueryParams.cacheName);

	Request* request = newRequestFromUrl(url);
	ASSERT(request);
	ScriptPromise matchResult = cache->match(scriptState(), request, options);
	EXPECT_EQ("dispatchMatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
	EXPECT_EQ(kNotImplementedString, getRejectString(matchResult));

	ScriptPromise stringMatchResult = cache->match(scriptState(), url, options, exceptionState());
	EXPECT_EQ("dispatchMatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
	EXPECT_EQ(kNotImplementedString, getRejectString(stringMatchResult));

	request = newRequestFromUrl(url);
	ASSERT(request);
	ScriptPromise matchAllResult = cache->matchAll(scriptState(), request, options);
	EXPECT_EQ("dispatchMatchAll", testCache->getAndClearLastErrorWebCacheMethodCalled());
	EXPECT_EQ(kNotImplementedString, getRejectString(matchAllResult));

	ScriptPromise stringMatchAllResult = cache->matchAll(scriptState(), url, options, exceptionState());
	EXPECT_EQ("dispatchMatchAll", testCache->getAndClearLastErrorWebCacheMethodCalled());
	EXPECT_EQ(kNotImplementedString, getRejectString(stringMatchAllResult));

	ScriptPromise keysResult1 = cache->keys(scriptState());
	EXPECT_EQ("dispatchKeys", testCache->getAndClearLastErrorWebCacheMethodCalled());
	EXPECT_EQ(kNotImplementedString, getRejectString(keysResult1));

	request = newRequestFromUrl(url);
	ASSERT(request);
	ScriptPromise keysResult2 = cache->keys(scriptState(), request, options);
	EXPECT_EQ("dispatchKeys", testCache->getAndClearLastErrorWebCacheMethodCalled());
	EXPECT_EQ(kNotImplementedString, getRejectString(keysResult2));

	ScriptPromise stringKeysResult2 = cache->keys(scriptState(), url, options, exceptionState());
	EXPECT_EQ("dispatchKeys", testCache->getAndClearLastErrorWebCacheMethodCalled());
	EXPECT_EQ(kNotImplementedString, getRejectString(stringKeysResult2));
	}

	// Tests that arguments are faithfully passed to API calls that degrade to batch operations.
	TEST_F(ServiceWorkerCacheTest, BatchOperationArguments)
	{
	ErrorWebCacheForTests* testCache;
	Cache* cache = Cache::create(testCache = new NotImplementedErrorCache());
	ASSERT(cache);

	WebServiceWorkerCache::QueryParams expectedQueryParams;
	expectedQueryParams.prefixMatch = true;
	expectedQueryParams.cacheName = "this is another cache name";
	testCache->setExpectedQueryParams(&expectedQueryParams);

	CacheQueryOptions options;
	options.setPrefixMatch(1);
	options.setCacheName(expectedQueryParams.cacheName);

	const String url = "http://batch.operations.test/";
	Request* request = newRequestFromUrl(url);
	ASSERT(request);

	WebServiceWorkerResponse webResponse;
	webResponse.setURL(KURL(ParsedURLString, url));
	Response* response = Response::create(executionContext(), webResponse);

	WebVector<WebServiceWorkerCache::BatchOperation> expectedDeleteOperations(size_t(1));
	{
	WebServiceWorkerCache::BatchOperation deleteOperation;
	deleteOperation.operationType = WebServiceWorkerCache::OperationTypeDelete;
	request->populateWebServiceWorkerRequest(deleteOperation.request);
	deleteOperation.matchParams = expectedQueryParams;
	expectedDeleteOperations[0] = deleteOperation;
	}
	testCache->setExpectedBatchOperations(&expectedDeleteOperations);

	ScriptPromise deleteResult = cache->deleteFunction(scriptState(), request, options);
	EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
	EXPECT_EQ(kNotImplementedString, getRejectString(deleteResult));

	ScriptPromise stringDeleteResult = cache->deleteFunction(scriptState(), url, options, exceptionState());
	EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
	EXPECT_EQ(kNotImplementedString, getRejectString(stringDeleteResult));

	WebVector<WebServiceWorkerCache::BatchOperation> expectedPutOperations(size_t(1));
	{
	WebServiceWorkerCache::BatchOperation putOperation;
	putOperation.operationType = WebServiceWorkerCache::OperationTypePut;
	request->populateWebServiceWorkerRequest(putOperation.request);
	response->populateWebServiceWorkerResponse(putOperation.response);
	expectedPutOperations[0] = putOperation;
	}
	testCache->setExpectedBatchOperations(&expectedPutOperations);

	request = newRequestFromUrl(url);
	ASSERT(request);
	ScriptPromise putResult = cache->put(scriptState(), request, response->clone());
	EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
	EXPECT_EQ(kNotImplementedString, getRejectString(putResult));

	ScriptPromise stringPutResult = cache->put(scriptState(), url, response, exceptionState());
	EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
	EXPECT_EQ(kNotImplementedString, getRejectString(stringPutResult));

	// FIXME: test add & addAll.
	}

	class MatchTestCache : public NotImplementedErrorCache {
	public:
	MatchTestCache(WebServiceWorkerResponse& response)
	: m_response(response) { }

	// From WebServiceWorkerCache:
	virtual void dispatchMatch(CacheMatchCallbacks* callbacks, const WebServiceWorkerRequest& webRequest, const QueryParams& queryParams) override
	{
	OwnPtr<CacheMatchCallbacks> ownedCallbacks(adoptPtr(callbacks));
	return callbacks->onSuccess(&m_response);
	}

	private:
	WebServiceWorkerResponse& m_response;
	};

	TEST_F(ServiceWorkerCacheTest, MatchResponseTest)
	{
	const String requestUrl = "http://request.url/";
	const String responseUrl = "http://match.response.test/";

	WebServiceWorkerResponse webResponse;
	webResponse.setURL(KURL(ParsedURLString, responseUrl));
	webResponse.setResponseType(WebServiceWorkerResponseTypeDefault);

	Cache* cache = Cache::create(new MatchTestCache(webResponse));
	CacheQueryOptions options;

	ScriptPromise result = cache->match(scriptState(), requestUrl, options, exceptionState());
	ScriptValue scriptValue = getResolveValue(result);
	Response* response = V8Response::toImplWithTypeCheck(isolate(), scriptValue.v8Value());
	ASSERT_TRUE(response);
	EXPECT_EQ(responseUrl, response->url());
	}

	class KeysTestCache : public NotImplementedErrorCache {
	public:
	KeysTestCache(WebVector<WebServiceWorkerRequest>& requests)
	: m_requests(requests) { }

	virtual void dispatchKeys(CacheWithRequestsCallbacks* callbacks, const WebServiceWorkerRequest* webRequest, const QueryParams& queryParams) override
	{
	OwnPtr<CacheWithRequestsCallbacks> ownedCallbacks(adoptPtr(callbacks));
	return callbacks->onSuccess(&m_requests);
	}

	private:
	WebVector<WebServiceWorkerRequest>& m_requests;
	};

	TEST_F(ServiceWorkerCacheTest, KeysResponseTest)
	{
	const String url1 = "http://first.request/";
	const String url2 = "http://second.request/";

	Vector<String> expectedUrls(size_t(2));
	expectedUrls[0] = url1;
	expectedUrls[1] = url2;

	WebVector<WebServiceWorkerRequest> webRequests(size_t(2));
	webRequests[0].setURL(KURL(ParsedURLString, url1));
	webRequests[1].setURL(KURL(ParsedURLString, url2));

	Cache* cache = Cache::create(new KeysTestCache(webRequests));

	ScriptPromise result = cache->keys(scriptState());
	ScriptValue scriptValue = getResolveValue(result);

	Vector<v8::Handle<v8::Value> > requests = toImplArray<v8::Handle<v8::Value> >(scriptValue.v8Value(), 0, isolate(), exceptionState());
	EXPECT_EQ(expectedUrls.size(), requests.size());
	for (int i = 0, minsize = std::min(expectedUrls.size(), requests.size()); i < minsize; ++i) {
	Request* request = V8Request::toImplWithTypeCheck(isolate(), requests[i]);
	EXPECT_TRUE(request);
	if (request)
	EXPECT_EQ(expectedUrls[i], request->url());
	}
	}

	class MatchAllAndBatchTestCache : public NotImplementedErrorCache {
	public:
	MatchAllAndBatchTestCache(WebVector<WebServiceWorkerResponse>& responses)
	: m_responses(responses) { }

	virtual void dispatchMatchAll(CacheWithResponsesCallbacks* callbacks, const WebServiceWorkerRequest& webRequest, const QueryParams& queryParams) override
	{
	OwnPtr<CacheWithResponsesCallbacks> ownedCallbacks(adoptPtr(callbacks));
	return callbacks->onSuccess(&m_responses);
	}

	virtual void dispatchBatch(CacheWithResponsesCallbacks* callbacks, const WebVector<BatchOperation>& batchOperations) override
	{
	OwnPtr<CacheWithResponsesCallbacks> ownedCallbacks(adoptPtr(callbacks));
	return callbacks->onSuccess(&m_responses);
	}

	private:
	WebVector<WebServiceWorkerResponse>& m_responses;
	};

	TEST_F(ServiceWorkerCacheTest, MatchAllAndBatchResponseTest)
	{
	const String url1 = "http://first.response/";
	const String url2 = "http://second.response/";

	Vector<String> expectedUrls(size_t(2));
	expectedUrls[0] = url1;
	expectedUrls[1] = url2;

	WebVector<WebServiceWorkerResponse> webResponses(size_t(2));
	webResponses[0].setURL(KURL(ParsedURLString, url1));
	webResponses[0].setResponseType(WebServiceWorkerResponseTypeDefault);
	webResponses[1].setURL(KURL(ParsedURLString, url2));
	webResponses[1].setResponseType(WebServiceWorkerResponseTypeDefault);

	Cache* cache = Cache::create(new MatchAllAndBatchTestCache(webResponses));

	CacheQueryOptions options;
	ScriptPromise result = cache->matchAll(scriptState(), "http://some.url/", options, exceptionState());
	ScriptValue scriptValue = getResolveValue(result);

	Vector<v8::Handle<v8::Value> > responses = toImplArray<v8::Handle<v8::Value> >(scriptValue.v8Value(), 0, isolate(), exceptionState());
	EXPECT_EQ(expectedUrls.size(), responses.size());
	for (int i = 0, minsize = std::min(expectedUrls.size(), responses.size()); i < minsize; ++i) {
	Response* response = V8Response::toImplWithTypeCheck(isolate(), responses[i]);
	EXPECT_TRUE(response);
	if (response)
	EXPECT_EQ(expectedUrls[i], response->url());
	}

	result = cache->deleteFunction(scriptState(), "http://some.url/", options, exceptionState());
	scriptValue = getResolveValue(result);
	EXPECT_TRUE(scriptValue.v8Value()->IsBoolean());
	EXPECT_EQ(true, scriptValue.v8Value()->BooleanValue());
	}

	} // namespace
	} // namespace blink