1/*
2 *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#include <string>
12#include "webrtc/base/asynchttprequest.h"
13#include "webrtc/base/gunit.h"
14#include "webrtc/base/httpserver.h"
15#include "webrtc/base/socketstream.h"
16#include "webrtc/base/thread.h"
17#include "webrtc/test/testsupport/gtest_disable.h"
18
19namespace rtc {
20
21static const SocketAddress kServerAddr("127.0.0.1", 0);
22static const SocketAddress kServerHostnameAddr("localhost", 0);
23static const char kServerGetPath[] = "/get";
24static const char kServerPostPath[] = "/post";
25static const char kServerResponse[] = "This is a test";
26
27class TestHttpServer : public HttpServer, public sigslot::has_slots<> {
28 public:
29  TestHttpServer(Thread* thread, const SocketAddress& addr) :
30      socket_(thread->socketserver()->CreateAsyncSocket(addr.family(),
31                                                        SOCK_STREAM)) {
32    socket_->Bind(addr);
33    socket_->Listen(5);
34    socket_->SignalReadEvent.connect(this, &TestHttpServer::OnAccept);
35  }
36
37  SocketAddress address() const { return socket_->GetLocalAddress(); }
38  void Close() const { socket_->Close(); }
39
40 private:
41  void OnAccept(AsyncSocket* socket) {
42    AsyncSocket* new_socket = socket_->Accept(NULL);
43    if (new_socket) {
44      HandleConnection(new SocketStream(new_socket));
45    }
46  }
47  rtc::scoped_ptr<AsyncSocket> socket_;
48};
49
50class AsyncHttpRequestTest : public testing::Test,
51                             public sigslot::has_slots<> {
52 public:
53  AsyncHttpRequestTest()
54      : started_(false),
55        done_(false),
56        server_(Thread::Current(), kServerAddr) {
57    server_.SignalHttpRequest.connect(this, &AsyncHttpRequestTest::OnRequest);
58  }
59
60  bool started() const { return started_; }
61  bool done() const { return done_; }
62
63  AsyncHttpRequest* CreateGetRequest(const std::string& host, int port,
64                                     const std::string& path) {
65    rtc::AsyncHttpRequest* request =
66        new rtc::AsyncHttpRequest("unittest");
67    request->SignalWorkDone.connect(this,
68        &AsyncHttpRequestTest::OnRequestDone);
69    request->request().verb = rtc::HV_GET;
70    request->set_host(host);
71    request->set_port(port);
72    request->request().path = path;
73    request->response().document.reset(new MemoryStream());
74    return request;
75  }
76  AsyncHttpRequest* CreatePostRequest(const std::string& host, int port,
77                                      const std::string& path,
78                                      const std::string content_type,
79                                      StreamInterface* content) {
80    rtc::AsyncHttpRequest* request =
81        new rtc::AsyncHttpRequest("unittest");
82    request->SignalWorkDone.connect(this,
83        &AsyncHttpRequestTest::OnRequestDone);
84    request->request().verb = rtc::HV_POST;
85    request->set_host(host);
86    request->set_port(port);
87    request->request().path = path;
88    request->request().setContent(content_type, content);
89    request->response().document.reset(new MemoryStream());
90    return request;
91  }
92
93  const TestHttpServer& server() const { return server_; }
94
95 protected:
96  void OnRequest(HttpServer* server, HttpServerTransaction* t) {
97    started_ = true;
98
99    if (t->request.path == kServerGetPath) {
100      t->response.set_success("text/plain", new MemoryStream(kServerResponse));
101    } else if (t->request.path == kServerPostPath) {
102      // reverse the data and reply
103      size_t size;
104      StreamInterface* in = t->request.document.get();
105      StreamInterface* out = new MemoryStream();
106      in->GetSize(&size);
107      for (size_t i = 0; i < size; ++i) {
108        char ch;
109        in->SetPosition(size - i - 1);
110        in->Read(&ch, 1, NULL, NULL);
111        out->Write(&ch, 1, NULL, NULL);
112      }
113      out->Rewind();
114      t->response.set_success("text/plain", out);
115    } else {
116      t->response.set_error(404);
117    }
118    server_.Respond(t);
119  }
120  void OnRequestDone(SignalThread* thread) {
121    done_ = true;
122  }
123
124 private:
125  bool started_;
126  bool done_;
127  TestHttpServer server_;
128};
129
130TEST_F(AsyncHttpRequestTest, DISABLED_ON_MAC(TestGetSuccess)) {
131  AsyncHttpRequest* req = CreateGetRequest(
132      kServerHostnameAddr.hostname(), server().address().port(),
133      kServerGetPath);
134  EXPECT_FALSE(started());
135  req->Start();
136  EXPECT_TRUE_WAIT(started(), 5000);  // Should have started by now.
137  EXPECT_TRUE_WAIT(done(), 5000);
138  std::string response;
139  EXPECT_EQ(200U, req->response().scode);
140  ASSERT_TRUE(req->response().document);
141  req->response().document->Rewind();
142  req->response().document->ReadLine(&response);
143  EXPECT_EQ(kServerResponse, response);
144  req->Release();
145}
146
147TEST_F(AsyncHttpRequestTest, DISABLED_ON_MAC(TestGetNotFound)) {
148  AsyncHttpRequest* req = CreateGetRequest(
149      kServerHostnameAddr.hostname(), server().address().port(),
150      "/bad");
151  req->Start();
152  EXPECT_TRUE_WAIT(done(), 5000);
153  size_t size;
154  EXPECT_EQ(404U, req->response().scode);
155  ASSERT_TRUE(req->response().document);
156  req->response().document->GetSize(&size);
157  EXPECT_EQ(0U, size);
158  req->Release();
159}
160
161TEST_F(AsyncHttpRequestTest, DISABLED_ON_MAC(TestGetToNonServer)) {
162  AsyncHttpRequest* req = CreateGetRequest(
163      "127.0.0.1", server().address().port(),
164      kServerGetPath);
165  // Stop the server before we send the request.
166  server().Close();
167  req->Start();
168  EXPECT_TRUE_WAIT(done(), 10000);
169  size_t size;
170  EXPECT_EQ(500U, req->response().scode);
171  ASSERT_TRUE(req->response().document);
172  req->response().document->GetSize(&size);
173  EXPECT_EQ(0U, size);
174  req->Release();
175}
176
177TEST_F(AsyncHttpRequestTest, DISABLED_TestGetToInvalidHostname) {
178  AsyncHttpRequest* req = CreateGetRequest(
179      "invalid", server().address().port(),
180      kServerGetPath);
181  req->Start();
182  EXPECT_TRUE_WAIT(done(), 5000);
183  size_t size;
184  EXPECT_EQ(500U, req->response().scode);
185  ASSERT_TRUE(req->response().document);
186  req->response().document->GetSize(&size);
187  EXPECT_EQ(0U, size);
188  req->Release();
189}
190
191TEST_F(AsyncHttpRequestTest, DISABLED_ON_MAC(TestPostSuccess)) {
192  AsyncHttpRequest* req = CreatePostRequest(
193      kServerHostnameAddr.hostname(), server().address().port(),
194      kServerPostPath, "text/plain", new MemoryStream("abcd1234"));
195  req->Start();
196  EXPECT_TRUE_WAIT(done(), 5000);
197  std::string response;
198  EXPECT_EQ(200U, req->response().scode);
199  ASSERT_TRUE(req->response().document);
200  req->response().document->Rewind();
201  req->response().document->ReadLine(&response);
202  EXPECT_EQ("4321dcba", response);
203  req->Release();
204}
205
206// Ensure that we shut down properly even if work is outstanding.
207TEST_F(AsyncHttpRequestTest, DISABLED_ON_MAC(TestCancel)) {
208  AsyncHttpRequest* req = CreateGetRequest(
209      kServerHostnameAddr.hostname(), server().address().port(),
210      kServerGetPath);
211  req->Start();
212  req->Destroy(true);
213}
214
215TEST_F(AsyncHttpRequestTest, DISABLED_ON_MAC(TestGetSuccessDelay)) {
216  AsyncHttpRequest* req = CreateGetRequest(
217      kServerHostnameAddr.hostname(), server().address().port(),
218      kServerGetPath);
219  req->set_start_delay(10);  // Delay 10ms.
220  req->Start();
221  Thread::SleepMs(5);
222  EXPECT_FALSE(started());  // Should not have started immediately.
223  EXPECT_TRUE_WAIT(started(), 5000);  // Should have started by now.
224  EXPECT_TRUE_WAIT(done(), 5000);
225  std::string response;
226  EXPECT_EQ(200U, req->response().scode);
227  ASSERT_TRUE(req->response().document);
228  req->response().document->Rewind();
229  req->response().document->ReadLine(&response);
230  EXPECT_EQ(kServerResponse, response);
231  req->Release();
232}
233
234}  // namespace rtc
235