TEST(HTTPMessage, TestMethod) {
HTTPMessage msg;
msg.setMethod(HTTPMethod::GET);
EXPECT_EQ("GET", msg.getMethodString());
EXPECT_EQ(HTTPMethod::GET == msg.getMethod(), true);
msg.setMethod("FOO");
EXPECT_EQ("FOO", msg.getMethodString());
EXPECT_EQ(boost::none == msg.getMethod(), true);
msg.setMethod(HTTPMethod::CONNECT);
EXPECT_EQ("CONNECT", msg.getMethodString());
EXPECT_EQ(HTTPMethod::CONNECT == msg.getMethod(), true);
}
// Test serializing and deserializing a header that has many values
TEST(SPDYCodecTest, HeaderWithManyValues) {
const std::string kMultiValued = "X-Multi-Valued";
const unsigned kNumValues = 1000;
FakeHTTPCodecCallback callbacks;
SPDYCodec egressCodec(TransportDirection::UPSTREAM,
SPDYVersion::SPDY3);
SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
SPDYVersion::SPDY3);
ingressCodec.setCallback(&callbacks);
HTTPMessage req;
req.setMethod("GET");
req.getHeaders().set("HOST", "www.foo.com");
req.setURL("https://www.foo.com");
for (unsigned i = 0; i < kNumValues; ++i) {
req.getHeaders().add(kMultiValued, folly::to<string>("Value", i));
}
auto syn = getSynStream(egressCodec, 1, req);
ingressCodec.onIngress(*syn);
EXPECT_EQ(callbacks.messageBegin, 1);
EXPECT_EQ(callbacks.headersComplete, 1);
EXPECT_EQ(callbacks.messageComplete, 0);
EXPECT_EQ(callbacks.streamErrors, 0);
EXPECT_EQ(callbacks.sessionErrors, 0);
CHECK_NOTNULL(callbacks.msg.get());
EXPECT_EQ(callbacks.msg->getHeaders().getNumberOfValues(kMultiValued),
kNumValues);
}
void doEmptyHeaderValueTest(Codec1& ingressCodec, Codec2& egressCodec) {
uint8_t version = ingressCodec.getVersion();
bool emptyAllowed = version != 2;
FakeHTTPCodecCallback callbacks;
ingressCodec.setCallback(&callbacks);
HTTPMessage toSend;
toSend.setMethod("GET");
toSend.setURL("http://www.foo.com");
auto& headers = toSend.getHeaders();
headers.set("Host", "www.foo.com");
headers.set("Pragma", "");
headers.set("X-Test1", "yup");
HTTPHeaderSize size;
auto toParse = getSynStream(egressCodec, 1, toSend, 0, false, &size);
ingressCodec.onIngress(*toParse);
EXPECT_EQ(callbacks.sessionErrors, 0);
EXPECT_EQ(callbacks.streamErrors, 0);
ASSERT_NE(callbacks.msg.get(), nullptr);
const auto& parsed = callbacks.msg->getHeaders();
EXPECT_EQ(parsed.exists("Pragma"), emptyAllowed);
EXPECT_EQ(parsed.exists("pragma"), emptyAllowed);
EXPECT_EQ(parsed.getSingleOrEmpty("X-Test1"), "yup");
// All codecs add the accept-encoding header
EXPECT_EQ(parsed.exists("accept-encoding"), true);
// SPDY/2 subtracts the Host header, but it should infer it from the host:port
// portion of the requested url and present it in the headers
EXPECT_EQ(parsed.exists("host"), true);
EXPECT_EQ(callbacks.msg->getURL(), "http://www.foo.com");
EXPECT_EQ(parsed.size(), emptyAllowed ? 4 : 3);
EXPECT_TRUE(size.uncompressed > 0);
EXPECT_TRUE(size.compressed > 0);
}
unique_ptr<folly::IOBuf> getSynStream(Codec& egressCodec,
uint32_t streamID) {
HTTPMessage msg;
msg.setMethod("GET");
msg.getHeaders().set("HOST", "www.foo.com");
msg.setURL("https://www.foo.com");
return getSynStream(egressCodec, streamID, msg);
}
HTTPMessage getGetRequest(const std::string& url) {
HTTPMessage req;
req.setMethod("GET");
req.setURL(url);
req.setHTTPVersion(1, 1);
req.getHeaders().set(HTTP_HEADER_HOST, "www.foo.com");
return req;
}
HTTPMessage getPostRequest() {
HTTPMessage req;
req.setMethod("POST");
req.setURL<string>("/");
req.setHTTPVersion(1, 1);
req.getHeaders().set(HTTP_HEADER_HOST, "www.foo.com");
req.getHeaders().set(HTTP_HEADER_CONTENT_LENGTH, "200");
return req;
}
HTTPMessage getChunkedPostRequest() {
HTTPMessage req;
req.setMethod("POST");
req.setURL<string>("/");
req.setHTTPVersion(1, 1);
req.setIsChunked(true);
req.getHeaders().set(HTTP_HEADER_HOST, "www.foo.com");
req.getHeaders().set(HTTP_HEADER_TRANSFER_ENCODING, "chunked");
return req;
}
HTTPMessage getPostRequest(uint32_t contentLength) {
HTTPMessage req;
req.setMethod("POST");
req.setURL<string>("/");
req.setHTTPVersion(1, 1);
req.getHeaders().set(HTTP_HEADER_HOST, "www.foo.com");
req.getHeaders().set(HTTP_HEADER_CONTENT_LENGTH,
folly::to<string>(contentLength));
return req;
}
HTTPMessage getUpgradeRequest(const std::string& upgradeHeader,
HTTPMethod method, uint32_t bodyLen) {
HTTPMessage req = getGetRequest();
req.setMethod(method);
req.getHeaders().set(HTTP_HEADER_UPGRADE, upgradeHeader);
if (bodyLen > 0) {
req.getHeaders().set(HTTP_HEADER_CONTENT_LENGTH,
folly::to<std::string>(bodyLen));
}
return req;
}
HTTPMessage getBigGetRequest(const std::string& url) {
HTTPMessage req;
req.setMethod("GET");
req.setURL(url);
req.setHTTPVersion(1, 1);
req.getHeaders().set(HTTP_HEADER_HOST, "www.foo.com");
req.getHeaders().add(HTTP_HEADER_USER_AGENT, "coolio");
req.getHeaders().add(
"x-huge-header",
std::string(http2::kMaxFramePayloadLengthMin, '!'));
return req;
}
TEST(SPDYCodecTest, SegmentedHeaderBlock) {
SPDYCodec egressCodec(TransportDirection::UPSTREAM,
SPDYVersion::SPDY3_1_HPACK);
SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
SPDYVersion::SPDY3_1_HPACK);
// generate huge string to use as a header value
string huge;
uint32_t size = 20000;
char ch = 'a';
for (uint32_t i = 0; i < size; i++) {
huge.push_back(ch);
if (ch == 'z') {
ch = 'a';
} else {
ch++;
}
}
HTTPMessage req;
req.setMethod("GET");
req.setURL("http://www.facebook.com");
auto& reqHeaders = req.getHeaders();
reqHeaders.set("HOST", "www.facebook.com");
// setting this huge header value will cause allocation of a separate IOBuf
reqHeaders.set("X-FB-Huge", huge);
auto buf = getSynStream(egressCodec, 1, req);
FakeHTTPCodecCallback callbacks;
ingressCodec.setCallback(&callbacks);
ingressCodec.onIngress(*buf);
EXPECT_EQ(callbacks.streamErrors, 0);
EXPECT_EQ(callbacks.sessionErrors, 0);
EXPECT_EQ(callbacks.headersComplete, 1);
EXPECT_EQ(callbacks.msg->getHeaders().getSingleOrEmpty("x-fb-huge").size(),
size);
// do it for responses
HTTPMessage resp;
resp.setStatusCode(200);
resp.setStatusMessage("OK");
auto& respHeaders = resp.getHeaders();
respHeaders.set("X-FB-Huge", huge);
auto buf2 = getSynStream(ingressCodec, 1, resp);
callbacks.reset();
egressCodec.setCallback(&callbacks);
egressCodec.onIngress(*buf2);
EXPECT_EQ(callbacks.streamErrors, 0);
EXPECT_EQ(callbacks.sessionErrors, 0);
EXPECT_EQ(callbacks.headersComplete, 1);
EXPECT_EQ(callbacks.msg->getHeaders().getSingleOrEmpty("x-fb-huge").size(),
size);
}
TEST_P(ConnectionHeaderTest, TestConnectionHeaders) {
HTTP1xCodec upstream(TransportDirection::UPSTREAM);
HTTP1xCodec downstream(TransportDirection::DOWNSTREAM);
HTTP1xCodecCallback callbacks;
downstream.setCallback(&callbacks);
HTTPMessage req;
req.setMethod(HTTPMethod::GET);
req.setURL("/");
auto val = GetParam();
for (auto header: val.first) {
req.getHeaders().add(HTTP_HEADER_CONNECTION, header);
}
folly::IOBufQueue writeBuf(folly::IOBufQueue::cacheChainLength());
upstream.generateHeader(writeBuf, upstream.createStream(), req);
downstream.onIngress(*writeBuf.front());
EXPECT_EQ(callbacks.headersComplete, 1);
auto& headers = callbacks.msg_->getHeaders();
EXPECT_EQ(headers.getSingleOrEmpty(HTTP_HEADER_CONNECTION),
val.second);
}
TEST(HTTP1xCodecTest, Test09Resp) {
HTTP1xCodec codec(TransportDirection::UPSTREAM);
HTTP1xCodecCallback callbacks;
HTTPMessage req;
auto id = codec.createStream();
req.setHTTPVersion(0, 9);
req.setMethod(HTTPMethod::GET);
req.setURL("/");
codec.setCallback(&callbacks);
folly::IOBufQueue buf;
codec.generateHeader(buf, id, req, 0, true);
auto buffer = folly::IOBuf::copyBuffer(
string("iamtheverymodelofamodernmajorgeneral"));
codec.onIngress(*buffer);
EXPECT_EQ(callbacks.headersComplete, 1);
EXPECT_EQ(callbacks.bodyLen, buffer->computeChainDataLength());
EXPECT_EQ(callbacks.messageComplete, 0);
codec.onIngressEOF();
EXPECT_EQ(callbacks.messageComplete, 1);
}
TEST(SPDYCodecTest, HeaderWithFin) {
FakeHTTPCodecCallback callbacks;
SPDYCodec egressCodec(TransportDirection::UPSTREAM,
SPDYVersion::SPDY3);
SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
SPDYVersion::SPDY3);
ingressCodec.setCallback(&callbacks);
HTTPMessage req;
req.setMethod("GET");
req.getHeaders().set("HOST", "www.foo.com");
req.setURL("https://www.foo.com/");
auto syn = getSynStream(egressCodec, 1, req, 0, true /* eom */);
ingressCodec.onIngress(*syn);
EXPECT_EQ(callbacks.messageBegin, 1);
EXPECT_EQ(callbacks.headersComplete, 1);
EXPECT_EQ(callbacks.messageComplete, 1);
EXPECT_EQ(callbacks.streamErrors, 0);
EXPECT_EQ(callbacks.sessionErrors, 0);
EXPECT_EQ(callbacks.assocStreamId, 0);
}
