1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
// Copyright 2007 Google Inc.
// All Rights Reserved.
#include "talk/base/gunit.h"
#include "talk/base/httpserver.h"
#include "talk/base/testutils.h"
using namespace testing;
namespace talk_base {
namespace {
const char* const kRequest =
"GET /index.html HTTP/1.1\r\n"
"Host: localhost\r\n"
"\r\n";
const char* const kResponse =
"HTTP/1.1 200\r\n"
"Connection: Close\r\n"
"Content-Length: 0\r\n"
"\r\n";
struct HttpServerMonitor : public sigslot::has_slots<> {
HttpServerTransaction* transaction;
bool server_closed, connection_closed;
HttpServerMonitor(HttpServer* server)
: transaction(NULL), server_closed(false), connection_closed(false) {
server->SignalCloseAllComplete.connect(this,
&HttpServerMonitor::OnClosed);
server->SignalHttpRequest.connect(this, &HttpServerMonitor::OnRequest);
server->SignalHttpRequestComplete.connect(this,
&HttpServerMonitor::OnRequestComplete);
server->SignalConnectionClosed.connect(this,
&HttpServerMonitor::OnConnectionClosed);
}
void OnRequest(HttpServer*, HttpServerTransaction* t) {
ASSERT_FALSE(transaction);
transaction = t;
transaction->response.set_success();
transaction->response.setHeader(HH_CONNECTION, "Close");
}
void OnRequestComplete(HttpServer*, HttpServerTransaction* t, int) {
ASSERT_EQ(transaction, t);
transaction = NULL;
}
void OnClosed(HttpServer*) {
server_closed = true;
}
void OnConnectionClosed(HttpServer*, int, StreamInterface* stream) {
connection_closed = true;
delete stream;
}
};
void CreateClientConnection(HttpServer& server,
HttpServerMonitor& monitor,
bool send_request) {
StreamSource* client = new StreamSource;
client->SetState(SS_OPEN);
server.HandleConnection(client);
EXPECT_FALSE(monitor.server_closed);
EXPECT_FALSE(monitor.transaction);
if (send_request) {
// Simulate a request
client->QueueString(kRequest);
EXPECT_FALSE(monitor.server_closed);
}
}
} // anonymous namespace
TEST(HttpServer, DoesNotSignalCloseUnlessCloseAllIsCalled) {
HttpServer server;
HttpServerMonitor monitor(&server);
// Add an active client connection
CreateClientConnection(server, monitor, true);
// Simulate a response
ASSERT_TRUE(NULL != monitor.transaction);
server.Respond(monitor.transaction);
EXPECT_FALSE(monitor.transaction);
// Connection has closed, but no server close signal
EXPECT_FALSE(monitor.server_closed);
EXPECT_TRUE(monitor.connection_closed);
}
TEST(HttpServer, SignalsCloseWhenNoConnectionsAreActive) {
HttpServer server;
HttpServerMonitor monitor(&server);
// Add an idle client connection
CreateClientConnection(server, monitor, false);
// Perform graceful close
server.CloseAll(false);
// Connections have all closed
EXPECT_TRUE(monitor.server_closed);
EXPECT_TRUE(monitor.connection_closed);
}
TEST(HttpServer, SignalsCloseAfterGracefulCloseAll) {
HttpServer server;
HttpServerMonitor monitor(&server);
// Add an active client connection
CreateClientConnection(server, monitor, true);
// Initiate a graceful close
server.CloseAll(false);
EXPECT_FALSE(monitor.server_closed);
// Simulate a response
ASSERT_TRUE(NULL != monitor.transaction);
server.Respond(monitor.transaction);
EXPECT_FALSE(monitor.transaction);
// Connections have all closed
EXPECT_TRUE(monitor.server_closed);
EXPECT_TRUE(monitor.connection_closed);
}
TEST(HttpServer, SignalsCloseAfterForcedCloseAll) {
HttpServer server;
HttpServerMonitor monitor(&server);
// Add an active client connection
CreateClientConnection(server, monitor, true);
// Initiate a forceful close
server.CloseAll(true);
// Connections have all closed
EXPECT_TRUE(monitor.server_closed);
EXPECT_TRUE(monitor.connection_closed);
}
} // namespace talk_base
|