service_worker_url_request_job_unittest.cc revision 5c02ac1a9c1b504631c0a3d2b6e737b5d738bae1 
1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "base/basictypes.h"
6#include "base/callback.h"
7#include "base/memory/scoped_ptr.h"
8#include "base/run_loop.h"
9#include "content/browser/service_worker/embedded_worker_registry.h"
10#include "content/browser/service_worker/embedded_worker_test_helper.h"
11#include "content/browser/service_worker/service_worker_context_core.h"
12#include "content/browser/service_worker/service_worker_provider_host.h"
13#include "content/browser/service_worker/service_worker_registration.h"
14#include "content/browser/service_worker/service_worker_test_utils.h"
15#include "content/browser/service_worker/service_worker_url_request_job.h"
16#include "content/browser/service_worker/service_worker_version.h"
17#include "content/public/test/test_browser_thread_bundle.h"
18#include "net/base/io_buffer.h"
19#include "net/http/http_request_headers.h"
20#include "net/http/http_response_headers.h"
21#include "net/url_request/url_request.h"
22#include "net/url_request/url_request_context.h"
23#include "net/url_request/url_request_job_factory_impl.h"
24#include "testing/gtest/include/gtest/gtest.h"
25
26namespace content {
27
28namespace {
29
30const int kBufferSize = 1024;
31const int kProcessID = 1;
32const int kProviderID = 100;
33
34class MockURLRequestDelegate : public net::URLRequest::Delegate {
35 public:
36  MockURLRequestDelegate() : received_data_(new net::IOBuffer(kBufferSize)) {}
37  virtual ~MockURLRequestDelegate() {}
38  virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE {
39    if (request->status().is_success()) {
40      EXPECT_TRUE(request->response_headers());
41      Read(request);
42    }
43  }
44  virtual void OnReadCompleted(net::URLRequest* request,
45                               int bytes_read) OVERRIDE {
46    EXPECT_EQ(0, bytes_read);
47  }
48
49 private:
50  void Read(net::URLRequest* request) {
51    if (request->is_pending()) {
52      int bytes_read = 0;
53      request->Read(received_data_.get(), kBufferSize, &bytes_read);
54      // For now ServiceWorkerURLRequestJob wouldn't return
55      // any content data yet.
56      EXPECT_EQ(0, bytes_read);
57    }
58  }
59
60  scoped_refptr<net::IOBuffer> received_data_;
61  base::Closure on_complete_;
62};
63
64class MockProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler {
65 public:
66  MockProtocolHandler(base::WeakPtr<ServiceWorkerProviderHost> provider_host)
67      : provider_host_(provider_host) {}
68  virtual ~MockProtocolHandler() {}
69
70  virtual net::URLRequestJob* MaybeCreateJob(
71      net::URLRequest* request,
72      net::NetworkDelegate* network_delegate) const OVERRIDE {
73    ServiceWorkerURLRequestJob* job = new ServiceWorkerURLRequestJob(
74        request, network_delegate, provider_host_);
75    job->ForwardToServiceWorker();
76    return job;
77  }
78
79 private:
80  base::WeakPtr<ServiceWorkerProviderHost> provider_host_;
81};
82
83}  // namespace
84
85class ServiceWorkerURLRequestJobTest : public testing::Test {
86 protected:
87  ServiceWorkerURLRequestJobTest()
88      : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
89  virtual ~ServiceWorkerURLRequestJobTest() {}
90
91  virtual void SetUp() OVERRIDE {
92    helper_.reset(new EmbeddedWorkerTestHelper(kProcessID));
93
94    registration_ = new ServiceWorkerRegistration(
95        GURL("http://example.com/*"),
96        GURL("http://example.com/service_worker.js"),
97        1L,
98        helper_->context()->AsWeakPtr());
99    version_ = new ServiceWorkerVersion(
100        registration_, 1L, helper_->context()->AsWeakPtr());
101
102    scoped_ptr<ServiceWorkerProviderHost> provider_host(
103        new ServiceWorkerProviderHost(
104            kProcessID, kProviderID, helper_->context()->AsWeakPtr(), NULL));
105    provider_host->SetActiveVersion(version_.get());
106
107    url_request_job_factory_.SetProtocolHandler(
108        "http", new MockProtocolHandler(provider_host->AsWeakPtr()));
109    url_request_context_.set_job_factory(&url_request_job_factory_);
110
111    helper_->context()->AddProviderHost(provider_host.Pass());
112  }
113
114  virtual void TearDown() OVERRIDE {
115    version_ = NULL;
116    registration_ = NULL;
117    helper_.reset();
118  }
119
120  void TestRequest() {
121    request_ = url_request_context_.CreateRequest(
122        GURL("http://example.com/foo.html"),
123        net::DEFAULT_PRIORITY,
124        &url_request_delegate_,
125        NULL);
126
127    request_->set_method("GET");
128    request_->Start();
129    base::RunLoop().RunUntilIdle();
130
131    // Verify response.
132    EXPECT_TRUE(request_->status().is_success());
133    EXPECT_EQ(200, request_->response_headers()->response_code());
134  }
135
136  TestBrowserThreadBundle thread_bundle_;
137
138  scoped_ptr<EmbeddedWorkerTestHelper> helper_;
139  scoped_refptr<ServiceWorkerRegistration> registration_;
140  scoped_refptr<ServiceWorkerVersion> version_;
141
142  net::URLRequestJobFactoryImpl url_request_job_factory_;
143  net::URLRequestContext url_request_context_;
144  MockURLRequestDelegate url_request_delegate_;
145  scoped_ptr<net::URLRequest> request_;
146
147  DISALLOW_COPY_AND_ASSIGN(ServiceWorkerURLRequestJobTest);
148};
149
150TEST_F(ServiceWorkerURLRequestJobTest, Simple) {
151  version_->SetStatus(ServiceWorkerVersion::ACTIVE);
152  TestRequest();
153}
154
155TEST_F(ServiceWorkerURLRequestJobTest, WaitForActivation) {
156  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
157  version_->SetStatus(ServiceWorkerVersion::INSTALLED);
158  version_->DispatchActivateEvent(CreateReceiverOnCurrentThread(&status));
159
160  TestRequest();
161
162  EXPECT_EQ(SERVICE_WORKER_OK, status);
163}
164
165// TODO(kinuko): Add more tests with different response data and also for
166// FallbackToNetwork case.
167
168}  // namespace content
169