Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(787)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: Source/modules/serviceworkers/ResponseTest.cpp

Issue 795323003: Move Fetch API releted code to modules/fetch. (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: Created 6 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « Source/modules/serviceworkers/ResponseInit.h ('k') | Source/modules/serviceworkers/ServiceWorkerGlobalScope.cpp » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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 "config.h"
6 #include "modules/serviceworkers/Response.h"
7
8 #include "bindings/core/v8/ExceptionState.h"
9 #include "bindings/core/v8/ScriptState.h"
10 #include "core/dom/Document.h"
11 #include "core/frame/Frame.h"
12 #include "core/testing/DummyPageHolder.h"
13 #include "modules/serviceworkers/BodyStreamBuffer.h"
14 #include "modules/serviceworkers/FetchResponseData.h"
15 #include "platform/blob/BlobData.h"
16 #include "public/platform/WebServiceWorkerResponse.h"
17 #include <gtest/gtest.h>
18
19 namespace blink {
20 namespace {
21
22 const char kTestData[] = "Here is sample text for the blob.";
23
24 PassOwnPtr<WebServiceWorkerResponse> createTestWebServiceWorkerResponse()
25 {
26 const KURL url(ParsedURLString, "http://www.webresponse.com/");
27 const unsigned short status = 200;
28 const String statusText = "the best status text";
29 struct {
30 const char* key;
31 const char* value;
32 } headers[] = { { "cache-control", "no-cache" }, { "set-cookie", "foop" }, { "foo", "bar" }, { 0, 0 } };
33
34 OwnPtr<WebServiceWorkerResponse> webResponse = adoptPtr(new WebServiceWorker Response());
35 webResponse->setURL(url);
36 webResponse->setStatus(status);
37 webResponse->setStatusText(statusText);
38 webResponse->setResponseType(WebServiceWorkerResponseTypeDefault);
39 for (int i = 0; headers[i].key; ++i)
40 webResponse->setHeader(WebString::fromUTF8(headers[i].key), WebString::f romUTF8(headers[i].value));
41 return webResponse.release();
42 }
43
44 class BlobHandleCreatorClient final : public BodyStreamBuffer::BlobHandleCreator Client {
45 public:
46 BlobHandleCreatorClient()
47 {
48 }
49 ~BlobHandleCreatorClient() override { }
50 void trace(Visitor* visitor) override
51 {
52 visitor->trace(m_exception);
53 BodyStreamBuffer::BlobHandleCreatorClient::trace(visitor);
54 }
55 void didCreateBlobHandle(PassRefPtr<BlobDataHandle> blobHandle) override
56 {
57 m_blobHandle = blobHandle;
58 }
59 void didFail(PassRefPtrWillBeRawPtr<DOMException> exception) override
60 {
61 m_exception = exception;
62 }
63 PassRefPtr<BlobDataHandle> blobHandle()
64 {
65 return m_blobHandle;
66 }
67 PassRefPtrWillBeRawPtr<DOMException> exception()
68 {
69 return m_exception;
70 }
71
72 private:
73 RefPtr<BlobDataHandle> m_blobHandle;
74 RefPtrWillBeMember<DOMException> m_exception;
75 };
76
77
78 class ServiceWorkerResponseTest : public ::testing::Test {
79 public:
80 ServiceWorkerResponseTest()
81 : m_page(DummyPageHolder::create(IntSize(1, 1))) { }
82
83 ScriptState* scriptState() { return ScriptState::forMainWorld(m_page->docume nt().frame()); }
84 ExecutionContext* executionContext() { return scriptState()->executionContex t(); }
85
86 private:
87 OwnPtr<DummyPageHolder> m_page;
88 };
89
90
91 TEST_F(ServiceWorkerResponseTest, FromFetchResponseData)
92 {
93 const KURL url(ParsedURLString, "http://www.response.com");
94
95 FetchResponseData* fetchResponseData = FetchResponseData::create();
96 fetchResponseData->setURL(url);
97
98 Response* response = Response::create(executionContext(), fetchResponseData) ;
99 ASSERT(response);
100 EXPECT_EQ(url, response->url());
101 }
102
103 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponse)
104 {
105 OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerRes ponse();
106 Response* response = Response::create(executionContext(), *webResponse);
107 ASSERT(response);
108 EXPECT_EQ(webResponse->url(), response->url());
109 EXPECT_EQ(webResponse->status(), response->status());
110 EXPECT_STREQ(webResponse->statusText().utf8().c_str(), response->statusText( ).utf8().data());
111
112 Headers* responseHeaders = response->headers();
113
114 WebVector<WebString> keys = webResponse->getHeaderKeys();
115 EXPECT_EQ(keys.size(), responseHeaders->headerList()->size());
116 for (size_t i = 0, max = keys.size(); i < max; ++i) {
117 WebString key = keys[i];
118 TrackExceptionState exceptionState;
119 EXPECT_STREQ(webResponse->getHeader(key).utf8().c_str(), responseHeaders ->get(key, exceptionState).utf8().data());
120 EXPECT_FALSE(exceptionState.hadException());
121 }
122 }
123
124 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseDefault)
125 {
126 OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerRes ponse();
127 webResponse->setResponseType(WebServiceWorkerResponseTypeDefault);
128 Response* response = Response::create(executionContext(), *webResponse);
129
130 Headers* responseHeaders = response->headers();
131 TrackExceptionState exceptionState;
132 EXPECT_STREQ("foop", responseHeaders->get("set-cookie", exceptionState).utf8 ().data());
133 EXPECT_STREQ("bar", responseHeaders->get("foo", exceptionState).utf8().data( ));
134 EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionStat e).utf8().data());
135 EXPECT_FALSE(exceptionState.hadException());
136 }
137
138 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseBasic)
139 {
140 OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerRes ponse();
141 webResponse->setResponseType(WebServiceWorkerResponseTypeBasic);
142 Response* response = Response::create(executionContext(), *webResponse);
143
144 Headers* responseHeaders = response->headers();
145 TrackExceptionState exceptionState;
146 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d ata());
147 EXPECT_STREQ("bar", responseHeaders->get("foo", exceptionState).utf8().data( ));
148 EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionStat e).utf8().data());
149 EXPECT_FALSE(exceptionState.hadException());
150 }
151
152 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseCORS)
153 {
154 OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerRes ponse();
155 webResponse->setResponseType(WebServiceWorkerResponseTypeCORS);
156 Response* response = Response::create(executionContext(), *webResponse);
157
158 Headers* responseHeaders = response->headers();
159 TrackExceptionState exceptionState;
160 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d ata());
161 EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data());
162 EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionStat e).utf8().data());
163 EXPECT_FALSE(exceptionState.hadException());
164 }
165
166 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseOpaque)
167 {
168 OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerRes ponse();
169 webResponse->setResponseType(WebServiceWorkerResponseTypeOpaque);
170 Response* response = Response::create(executionContext(), *webResponse);
171
172 Headers* responseHeaders = response->headers();
173 TrackExceptionState exceptionState;
174 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d ata());
175 EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data());
176 EXPECT_STREQ("", responseHeaders->get("cache-control", exceptionState).utf8( ).data());
177 EXPECT_FALSE(exceptionState.hadException());
178 }
179
180 void checkResponseBlobHandle(Response* response, bool hasNonInternalBlobHandle, const unsigned long long blobSize)
181 {
182 EXPECT_TRUE(response->internalBlobDataHandle());
183 EXPECT_EQ(blobSize, response->internalBlobDataHandle()->size());
184 EXPECT_FALSE(response->internalBuffer());
185 if (hasNonInternalBlobHandle) {
186 EXPECT_TRUE(response->blobDataHandle());
187 EXPECT_EQ(response->blobDataHandle(), response->internalBlobDataHandle() );
188 EXPECT_EQ(blobSize, response->blobDataHandle()->size());
189 } else {
190 EXPECT_FALSE(response->blobDataHandle());
191 }
192 EXPECT_FALSE(response->buffer());
193
194 TrackExceptionState exceptionState;
195 Response* clonedResponse = response->clone(exceptionState);
196 EXPECT_FALSE(exceptionState.hadException());
197
198 EXPECT_TRUE(response->internalBlobDataHandle());
199 EXPECT_EQ(blobSize, clonedResponse->internalBlobDataHandle()->size());
200 EXPECT_EQ(response->internalBlobDataHandle(), clonedResponse->internalBlobDa taHandle());
201 EXPECT_FALSE(response->internalBuffer());
202 EXPECT_FALSE(clonedResponse->internalBuffer());
203 if (hasNonInternalBlobHandle) {
204 EXPECT_EQ(response->internalBlobDataHandle(), response->blobDataHandle() );
205 EXPECT_EQ(clonedResponse->internalBlobDataHandle(), clonedResponse->blob DataHandle());
206 } else {
207 EXPECT_FALSE(response->blobDataHandle());
208 EXPECT_FALSE(clonedResponse->blobDataHandle());
209 }
210 EXPECT_FALSE(response->buffer());
211 EXPECT_FALSE(clonedResponse->buffer());
212 }
213
214 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneDefault)
215 {
216 FetchResponseData* fetchResponseData = FetchResponseData::create();
217 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
218 OwnPtr<BlobData> blobData(BlobData::create());
219 blobData->appendBytes(kTestData, sizeof(kTestData) - 1);
220 const unsigned long long size = blobData->length();
221 fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release (), size));
222 checkResponseBlobHandle(Response::create(executionContext(), fetchResponseDa ta), true, size);
223 }
224
225 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneBasic)
226 {
227 FetchResponseData* fetchResponseData = FetchResponseData::create();
228 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
229 OwnPtr<BlobData> blobData(BlobData::create());
230 blobData->appendBytes(kTestData, sizeof(kTestData) - 1);
231 const unsigned long long size = blobData->length();
232 fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release (), size));
233 fetchResponseData = fetchResponseData->createBasicFilteredResponse();
234 checkResponseBlobHandle(Response::create(executionContext(), fetchResponseDa ta), true, size);
235 }
236
237 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneCORS)
238 {
239 FetchResponseData* fetchResponseData = FetchResponseData::create();
240 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
241 OwnPtr<BlobData> blobData(BlobData::create());
242 blobData->appendBytes(kTestData, sizeof(kTestData) - 1);
243 const unsigned long long size = blobData->length();
244 fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release (), size));
245 fetchResponseData = fetchResponseData->createCORSFilteredResponse();
246 checkResponseBlobHandle(Response::create(executionContext(), fetchResponseDa ta), true, size);
247 }
248
249 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneOpaque)
250 {
251 FetchResponseData* fetchResponseData = FetchResponseData::create();
252 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
253 OwnPtr<BlobData> blobData(BlobData::create());
254 blobData->appendBytes(kTestData, sizeof(kTestData) - 1);
255 const unsigned long long size = blobData->length();
256 fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release (), size));
257 fetchResponseData = fetchResponseData->createOpaqueFilteredResponse();
258 checkResponseBlobHandle(Response::create(executionContext(), fetchResponseDa ta), false, size);
259 }
260
261 void checkResponseStream(Response* response, bool checkResponseBodyStreamBuffer)
262 {
263 BodyStreamBuffer* buffer = response->internalBuffer();
264 EXPECT_FALSE(response->internalBlobDataHandle());
265 EXPECT_FALSE(response->blobDataHandle());
266 if (checkResponseBodyStreamBuffer) {
267 EXPECT_EQ(response->buffer(), buffer);
268 } else {
269 EXPECT_FALSE(response->buffer());
270 }
271
272 TrackExceptionState exceptionState;
273 Response* clonedResponse = response->clone(exceptionState);
274 EXPECT_FALSE(exceptionState.hadException());
275 EXPECT_FALSE(response->internalBlobDataHandle());
276 EXPECT_FALSE(response->blobDataHandle());
277 EXPECT_FALSE(clonedResponse->internalBlobDataHandle());
278 EXPECT_FALSE(clonedResponse->blobDataHandle());
279
280 EXPECT_TRUE(response->internalBuffer());
281 EXPECT_TRUE(clonedResponse->internalBuffer());
282 EXPECT_NE(response->internalBuffer(), buffer);
283 EXPECT_NE(clonedResponse->internalBuffer(), buffer);
284 EXPECT_NE(response->internalBuffer(), clonedResponse->internalBuffer());
285 if (checkResponseBodyStreamBuffer) {
286 EXPECT_EQ(response->buffer(), response->internalBuffer());
287 EXPECT_EQ(clonedResponse->buffer(), clonedResponse->internalBuffer());
288 } else {
289 EXPECT_FALSE(response->buffer());
290 EXPECT_FALSE(clonedResponse->buffer());
291 }
292 BlobHandleCreatorClient* client1 = new BlobHandleCreatorClient();
293 BlobHandleCreatorClient* client2 = new BlobHandleCreatorClient();
294 EXPECT_TRUE(response->internalBuffer()->readAllAndCreateBlobHandle(response- >internalContentTypeForBuffer(), client1));
295 EXPECT_TRUE(clonedResponse->internalBuffer()->readAllAndCreateBlobHandle(clo nedResponse->internalContentTypeForBuffer(), client2));
296 buffer->write(DOMArrayBuffer::create("foobar", 6));
297 buffer->write(DOMArrayBuffer::create("piyo", 4));
298 EXPECT_FALSE(client1->blobHandle());
299 EXPECT_FALSE(client2->blobHandle());
300 buffer->close();
301 EXPECT_TRUE(client1->blobHandle());
302 EXPECT_TRUE(client2->blobHandle());
303 EXPECT_EQ(10u, client1->blobHandle()->size());
304 EXPECT_EQ(10u, client2->blobHandle()->size());
305 }
306
307 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneDefault)
308 {
309 BodyStreamBuffer* buffer = new BodyStreamBuffer();
310 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b uffer);
311 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
312 Response* response = Response::create(executionContext(), fetchResponseData) ;
313 EXPECT_EQ(response->internalBuffer(), buffer);
314 checkResponseStream(response, true);
315 }
316
317 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneBasic)
318 {
319 BodyStreamBuffer* buffer = new BodyStreamBuffer();
320 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b uffer);
321 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
322 fetchResponseData = fetchResponseData->createBasicFilteredResponse();
323 Response* response = Response::create(executionContext(), fetchResponseData) ;
324 EXPECT_EQ(response->internalBuffer(), buffer);
325 checkResponseStream(response, true);
326 }
327
328 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneCORS)
329 {
330 BodyStreamBuffer* buffer = new BodyStreamBuffer();
331 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b uffer);
332 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
333 fetchResponseData = fetchResponseData->createCORSFilteredResponse();
334 Response* response = Response::create(executionContext(), fetchResponseData) ;
335 EXPECT_EQ(response->internalBuffer(), buffer);
336 checkResponseStream(response, true);
337 }
338
339 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneOpaque)
340 {
341 BodyStreamBuffer* buffer = new BodyStreamBuffer();
342 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b uffer);
343 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
344 fetchResponseData = fetchResponseData->createOpaqueFilteredResponse();
345 Response* response = Response::create(executionContext(), fetchResponseData) ;
346 EXPECT_EQ(response->internalBuffer(), buffer);
347 checkResponseStream(response, false);
348 }
349
350 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneError)
351 {
352 BodyStreamBuffer* buffer = new BodyStreamBuffer();
353 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b uffer);
354 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
355 Response* response = Response::create(executionContext(), fetchResponseData) ;
356 TrackExceptionState exceptionState;
357 Response* clonedResponse = response->clone(exceptionState);
358 EXPECT_FALSE(exceptionState.hadException());
359 BlobHandleCreatorClient* client1 = new BlobHandleCreatorClient();
360 BlobHandleCreatorClient* client2 = new BlobHandleCreatorClient();
361 EXPECT_TRUE(response->internalBuffer()->readAllAndCreateBlobHandle(response- >internalContentTypeForBuffer(), client1));
362 EXPECT_TRUE(clonedResponse->internalBuffer()->readAllAndCreateBlobHandle(clo nedResponse->internalContentTypeForBuffer(), client2));
363 buffer->write(DOMArrayBuffer::create("foobar", 6));
364 buffer->write(DOMArrayBuffer::create("piyo", 4));
365 EXPECT_FALSE(client1->blobHandle());
366 EXPECT_FALSE(client2->blobHandle());
367 buffer->error(DOMException::create(NetworkError, "Error Message"));
368 EXPECT_EQ("NetworkError", client1->exception()->name());
369 EXPECT_EQ("Error Message", client1->exception()->message());
370 EXPECT_EQ("NetworkError", client2->exception()->name());
371 EXPECT_EQ("Error Message", client2->exception()->message());
372 }
373
374 } // namespace
375 } // namespace blink
OLDNEW
« no previous file with comments | « Source/modules/serviceworkers/ResponseInit.h ('k') | Source/modules/serviceworkers/ServiceWorkerGlobalScope.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698