OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 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/at_exit.h" |
| 6 #include "base/auto_reset.h" |
| 7 #include "base/bind.h" |
| 8 #include "base/logging.h" |
| 9 #include "base/macros.h" |
| 10 #include "base/memory/scoped_ptr.h" |
| 11 #include "base/message_loop/message_loop.h" |
| 12 #include "base/run_loop.h" |
| 13 #include "mojo/fetcher/network_fetcher.h" |
| 14 #include "mojo/public/cpp/bindings/strong_binding.h" |
| 15 #include "mojo/runner/context.h" |
| 16 #include "mojo/services/network/public/interfaces/url_loader.mojom.h" |
| 17 #include "mojo/services/network/public/interfaces/url_loader_factory.mojom.h" |
| 18 #include "testing/gtest/include/gtest/gtest.h" |
| 19 |
| 20 namespace mojo { |
| 21 namespace fetcher { |
| 22 namespace { |
| 23 |
| 24 const char k200Request[] = "http://request_expect_200"; |
| 25 const char k404Request[] = "http://request_expect_404"; |
| 26 const char k504Request[] = "http://request_expect_504"; |
| 27 const char kErrorRequest[] = "http://request_expect_error"; |
| 28 |
| 29 class TestURLLoaderImpl : public URLLoader { |
| 30 public: |
| 31 explicit TestURLLoaderImpl(InterfaceRequest<URLLoader> request) |
| 32 : binding_(this, request.Pass()) {} |
| 33 ~TestURLLoaderImpl() override {} |
| 34 |
| 35 private: |
| 36 // URLLoader implementation. |
| 37 void Start(URLRequestPtr request, |
| 38 const Callback<void(URLResponsePtr)>& callback) override { |
| 39 URLResponsePtr response(URLResponse::New()); |
| 40 response->url = request->url; |
| 41 if (request->url == std::string(k200Request)) { |
| 42 response->mime_type = "text/html"; |
| 43 response->status_code = 200; |
| 44 } else if (request->url == std::string(k404Request)) { |
| 45 response->mime_type = "text/html"; |
| 46 response->status_code = 404; |
| 47 } else if (request->url == std::string(k504Request)) { |
| 48 response->mime_type = "text/html"; |
| 49 response->status_code = 504; |
| 50 } else { |
| 51 response->error = NetworkError::New(); |
| 52 response->error->code = -2; |
| 53 } |
| 54 callback.Run(response.Pass()); |
| 55 } |
| 56 void FollowRedirect(const Callback<void(URLResponsePtr)>& callback) override { |
| 57 NOTREACHED(); |
| 58 } |
| 59 void QueryStatus( |
| 60 const Callback<void(URLLoaderStatusPtr)>& callback) override { |
| 61 NOTREACHED(); |
| 62 } |
| 63 |
| 64 StrongBinding<URLLoader> binding_; |
| 65 DISALLOW_COPY_AND_ASSIGN(TestURLLoaderImpl); |
| 66 }; |
| 67 |
| 68 class TestURLLoaderFactoryImpl : public URLLoaderFactory { |
| 69 public: |
| 70 explicit TestURLLoaderFactoryImpl(InterfaceRequest<URLLoaderFactory> request) |
| 71 : binding_(this, request.Pass()) {} |
| 72 ~TestURLLoaderFactoryImpl() override {} |
| 73 |
| 74 private: |
| 75 // URLLoaderFactory implementation. |
| 76 void CreateURLLoader(InterfaceRequest<URLLoader> loader) override { |
| 77 new TestURLLoaderImpl(loader.Pass()); |
| 78 } |
| 79 |
| 80 StrongBinding<URLLoaderFactory> binding_; |
| 81 DISALLOW_COPY_AND_ASSIGN(TestURLLoaderFactoryImpl); |
| 82 }; |
| 83 |
| 84 class FetchCallbackHelper { |
| 85 public: |
| 86 FetchCallbackHelper() : run_loop_(nullptr) {} |
| 87 ~FetchCallbackHelper() {} |
| 88 |
| 89 shell::Fetcher::FetchCallback GetCallback() { |
| 90 return base::Bind(&FetchCallbackHelper::CallbackHandler, |
| 91 base::Unretained(this)); |
| 92 } |
| 93 |
| 94 void WaitForCallback() { |
| 95 base::RunLoop run_loop; |
| 96 base::AutoReset<base::RunLoop*> auto_reset(&run_loop_, &run_loop); |
| 97 run_loop.Run(); |
| 98 } |
| 99 |
| 100 shell::Fetcher* fetcher() const { return fetcher_.get(); } |
| 101 |
| 102 private: |
| 103 void CallbackHandler(scoped_ptr<shell::Fetcher> fetcher) { |
| 104 fetcher_ = fetcher.Pass(); |
| 105 if (run_loop_) |
| 106 run_loop_->Quit(); |
| 107 } |
| 108 |
| 109 // If it is not null, it points to a stack-allocated base::RunLoop instance in |
| 110 // WaitForCallback(). |
| 111 base::RunLoop* run_loop_; |
| 112 scoped_ptr<shell::Fetcher> fetcher_; |
| 113 DISALLOW_COPY_AND_ASSIGN(FetchCallbackHelper); |
| 114 }; |
| 115 |
| 116 class NetworkFetcherTest : public testing::Test { |
| 117 public: |
| 118 NetworkFetcherTest() {} |
| 119 ~NetworkFetcherTest() override {} |
| 120 |
| 121 protected: |
| 122 // Overridden from testing::Test: |
| 123 void SetUp() override { |
| 124 runner::Context::EnsureEmbedderIsInitialized(); |
| 125 // Automatically destroyed when |url_loader_factory_| is closed. |
| 126 new TestURLLoaderFactoryImpl(GetProxy(&url_loader_factory_)); |
| 127 } |
| 128 |
| 129 // When |expect_fetch_success| is false, |expected_status_code| is ignored. |
| 130 void TestFetchURL(const std::string& url, |
| 131 bool expect_fetch_success, |
| 132 uint32_t expected_status_code) { |
| 133 FetchCallbackHelper helper; |
| 134 |
| 135 URLRequestPtr request(URLRequest::New()); |
| 136 request->url = url; |
| 137 new NetworkFetcher(true, request.Pass(), url_loader_factory_.get(), |
| 138 helper.GetCallback()); |
| 139 helper.WaitForCallback(); |
| 140 |
| 141 if (!expect_fetch_success) { |
| 142 ASSERT_FALSE(helper.fetcher()); |
| 143 } else { |
| 144 ASSERT_TRUE(helper.fetcher()); |
| 145 URLResponsePtr response = helper.fetcher()->AsURLResponse(nullptr, 0); |
| 146 ASSERT_TRUE(response); |
| 147 EXPECT_EQ(url, response->url); |
| 148 EXPECT_EQ(expected_status_code, response->status_code); |
| 149 } |
| 150 } |
| 151 |
| 152 private: |
| 153 base::ShadowingAtExitManager at_exit_; |
| 154 base::MessageLoop loop_; |
| 155 URLLoaderFactoryPtr url_loader_factory_; |
| 156 |
| 157 DISALLOW_COPY_AND_ASSIGN(NetworkFetcherTest); |
| 158 }; |
| 159 |
| 160 TEST_F(NetworkFetcherTest, FetchSucceeded200) { |
| 161 TestFetchURL(k200Request, true, 200u); |
| 162 } |
| 163 |
| 164 TEST_F(NetworkFetcherTest, FetchSucceeded404) { |
| 165 TestFetchURL(k404Request, true, 404u); |
| 166 } |
| 167 |
| 168 TEST_F(NetworkFetcherTest, FetchSucceeded504) { |
| 169 TestFetchURL(k504Request, true, 504u); |
| 170 } |
| 171 |
| 172 TEST_F(NetworkFetcherTest, FetchFailed) { |
| 173 TestFetchURL(kErrorRequest, false, 0u); |
| 174 } |
| 175 |
| 176 } // namespace |
| 177 } // namespace fetcher |
| 178 } // namespace mojo |
OLD | NEW |