HTTPMessageTest.cpp File Reference

#include <fcntl.h>
#include <folly/portability/GTest.h>
#include <proxygen/lib/http/HTTPMessage.h>
#include <proxygen/lib/utils/TestUtils.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>

Go to the source code of this file.

Functions
	TEST (HTTPMessage, TestParseCookiesSimple)
	TEST (HTTPMessage, TestParseCookiesSpaces)
	TEST (HTTPMessage, TestParseCookiesSingleCookie)
	TEST (HTTPMessage, TestParseCookiesMultipleCookies)
	TEST (HTTPMessage, TestParseQueryParamsSimple)
	TEST (HTTPMessage, TestParseQueryParamsComplex)
	TEST (HTTPMessage, TestHeaderPreservation)
	TEST (HTTPMessage, TestHeaderRemove)
	TEST (HTTPMessage, TestSetHeader)
	TEST (HTTPMessage, TestCombine)
	TEST (HTTPMessage, TestProxification)
	TEST (HTTPMessage, TestKeepaliveCheck)
	TEST (HTTPMessage, TestHeaderStripPerHop)
	TEST (HTTPMessage, TestEmptyName)
	TEST (HTTPMessage, TestMethod)
void	testPathAndQuery (const string &url, const string &expectedPath, const string &expectedQuery)
	TEST (GetPathAndQuery, ParseURL)
	TEST (HTTPHeaders, AddStringPiece)
	TEST (HTTPHeaders, InitializerList)
	TEST (HTTPHeaders, InitializerListStringPiece)
void	testRemoveQueryParam (const string &url, const string &queryParam, const string &expectedUrl, const string &expectedQuery)
	TEST (HTTPMessage, RemoveQueryParamTests)
void	testSetQueryParam (const string &url, const string &queryParam, const string &paramValue, const string &expectedUrl, const string &expectedQuery)
	TEST (HTTPMessage, SetQueryParamTests)
	TEST (HTTPMessage, TestCheckForHeaderToken)
	TEST (HttpMessage, TestProtocolStringHTTPVersion)
	TEST (HttpMessage, TestProtocolStringAdvancedProtocol)

Function Documentation

TEST	(	HTTPMessage	,
		TestParseCookiesSimple
	)

Definition at line 22 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPMessage::getCookie(), and proxygen::HTTPMessage::getHeaders().

                                          {
  HTTPMessage msg;

  msg.getHeaders().add("Cookie", "id=1256679245; data=0:1234567");
  EXPECT_EQ(msg.getCookie("id"), "1256679245");
  EXPECT_EQ(msg.getCookie("data"), "0:1234567");
  EXPECT_EQ(msg.getCookie("mising"), "");
}

TEST	(	HTTPMessage	,
		TestParseCookiesSpaces
	)

Definition at line 31 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPMessage::getCookie(), and proxygen::HTTPMessage::getHeaders().

                                          {
  HTTPMessage msg;

  msg.getHeaders().add("Cookie", " id=1256679245 ;   data=0:1234567  ;");
  EXPECT_EQ(msg.getCookie("id"), "1256679245");
  EXPECT_EQ(msg.getCookie("data"), "0:1234567");
}

TEST	(	HTTPMessage	,
		TestParseCookiesSingleCookie
	)

Definition at line 39 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPMessage::getCookie(), and proxygen::HTTPMessage::getHeaders().

                                                {
  HTTPMessage msg;

  msg.getHeaders().add("Cookie", "   user_id=1256679245  ");
  EXPECT_EQ(msg.getCookie("user_id"), "1256679245");
}

TEST	(	HTTPMessage	,
		TestParseCookiesMultipleCookies
	)

Definition at line 46 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPMessage::getCookie(), and proxygen::HTTPMessage::getHeaders().

                                                   {
  HTTPMessage msg;

  msg.getHeaders().add(
    "Cookie", "id=1256679245; data=0:1234567; same=Always; Name");
  msg.getHeaders().add(
    "Cookie", "id2=1256679245; data2=0:1234567; same=Always; ");
  EXPECT_EQ(msg.getCookie("id"), "1256679245");
  EXPECT_EQ(msg.getCookie("id2"), "1256679245");
  EXPECT_EQ(msg.getCookie("data"), "0:1234567");
  EXPECT_EQ(msg.getCookie("data2"), "0:1234567");
  EXPECT_EQ(msg.getCookie("same"), "Always");
  EXPECT_EQ(msg.getCookie("Name"), "");
}

TEST	(	HTTPMessage	,
		TestParseQueryParamsSimple
	)

Definition at line 61 of file HTTPMessageTest.cpp.

References EXPECT_ANY_THROW, EXPECT_EQ, proxygen::HTTPMessage::getDecodedQueryParam(), proxygen::HTTPMessage::getIntQueryParam(), proxygen::HTTPMessage::getQueryParam(), proxygen::HTTPMessage::hasQueryParam(), and proxygen::HTTPMessage::setURL().

                                              {
  HTTPMessage msg;
  string url = "/test?seq=123456&userid=1256679245&dup=1&dup=2&helloWorld"
               "&second=was+it+clear+%28already%29%3F";

  msg.setURL(url);
  EXPECT_EQ(msg.getQueryParam("seq"), "123456");
  EXPECT_EQ(msg.getQueryParam("userid"), "1256679245");
  EXPECT_EQ(msg.getQueryParam("dup"), "2");
  EXPECT_EQ(msg.getQueryParam("helloWorld"), "");
  EXPECT_EQ(msg.getIntQueryParam("dup", 5), 2);
  EXPECT_EQ(msg.getIntQueryParam("abc", 5), 5);
  EXPECT_EQ(msg.getDecodedQueryParam("second"), "was it clear (already)?");
  EXPECT_EQ(msg.getDecodedQueryParam("seq"), "123456");
  EXPECT_EQ(msg.hasQueryParam("seq"), true);
  EXPECT_EQ(msg.hasQueryParam("seq1"), false);
  EXPECT_EQ(msg.getIntQueryParam("dup"), 2);
  EXPECT_ANY_THROW(msg.getIntQueryParam("abc"));
  EXPECT_ANY_THROW(msg.getIntQueryParam("second"));
}

TEST	(	HTTPMessage	,
		TestParseQueryParamsComplex
	)

Definition at line 82 of file HTTPMessageTest.cpp.

References folly::empty(), EXPECT_EQ, folly::gen::first, proxygen::HTTPMessage::getQueryParam(), i, proxygen::HTTPMessage::setURL(), string, folly::gen::sub(), and val.

                                               {
  HTTPMessage msg;
  std::vector<std::vector<std::string>> input = {
    {"", "", ""},
    {"key_and_equal_but_no_value", "=", ""},
    {"only_key", "", ""},
    {"key_and_value", "=", "value"},
    {"key_and_value_2", "=", "value2"},
    {"key_and_value_3", "=", "value3"}
  };

  for (int i = 0; i < (1 << input.size()); ++i) {
    std::vector<std::vector<std::string>> sub;
    for (size_t j = 0; j < input.size(); ++j) {
      if ((i & (1 << j))) {
        sub.push_back(input[j]);
      }
    }

    sort(sub.begin(), sub.end());
    do {
      bool first = true;
      std::string url = "/test?";
      for (const auto& val: sub) {
        if (first) {
          first = false;
        } else {
          url += "&";
        }

        url += val[0] + val[1] + val[2];
      }

      msg.setURL(url);
      for (const auto& val: sub) {
        if (val[0].empty()) {
          continue;
        }

        EXPECT_EQ(val[2], msg.getQueryParam(val[0]));
      }

    } while (next_permutation(sub.begin(), sub.end()));
  }
}

TEST	(	HTTPMessage	,
		TestHeaderPreservation
	)

Definition at line 128 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), proxygen::HTTPHeaders::getNumberOfValues(), and proxygen::HTTPHeaders::size().

                                          {
  HTTPMessage msg;
  HTTPHeaders& hdrs = msg.getHeaders();

  hdrs.add("Jojo", "1");
  hdrs.add("Binky", "2");
  hdrs.add("jOJo", "3");
  hdrs.add("bINKy", "4");

  EXPECT_EQ(hdrs.size(), 4);
  EXPECT_EQ(hdrs.getNumberOfValues("jojo"), 2);
  EXPECT_EQ(hdrs.getNumberOfValues("binky"), 2);
}

TEST	(	HTTPMessage	,
		TestHeaderRemove
	)

Definition at line 142 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), proxygen::HTTPHeaders::getNumberOfValues(), proxygen::HTTPHeaders::remove(), and proxygen::HTTPHeaders::size().

                                    {
  HTTPMessage msg;
  HTTPHeaders& hdrs = msg.getHeaders();

  hdrs.add("Jojo", "1");
  hdrs.add("Binky", "2");
  hdrs.add("jOJo", "3");
  hdrs.add("bINKy", "4");
  hdrs.remove("jojo");

  EXPECT_EQ(hdrs.size(), 2);
  EXPECT_EQ(hdrs.getNumberOfValues("binky"), 2);
}

TEST	(	HTTPMessage	,
		TestSetHeader
	)

Definition at line 156 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), proxygen::HTTPHeaders::getNumberOfValues(), proxygen::HTTPHeaders::set(), and proxygen::HTTPHeaders::size().

                                 {
  HTTPMessage msg;
  HTTPHeaders& hdrs = msg.getHeaders();

  hdrs.set("Jojo", "1");
  EXPECT_EQ(hdrs.size(), 1);
  EXPECT_EQ(hdrs.getNumberOfValues("Jojo"), 1);

  hdrs.add("jojo", "2");
  hdrs.add("jojo", "3");
  hdrs.add("bar", "4");
  EXPECT_EQ(hdrs.size(), 4);
  EXPECT_EQ(hdrs.getNumberOfValues("Jojo"), 3);

  hdrs.set("joJO", "5");
  EXPECT_EQ(hdrs.size(), 2);
  EXPECT_EQ(hdrs.getNumberOfValues("Jojo"), 1);
}

TEST	(	HTTPMessage	,
		TestCombine
	)

Definition at line 175 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), proxygen::HTTPHeaders::combine(), EXPECT_EQ, and proxygen::HTTPMessage::getHeaders().

                               {
  HTTPMessage msg;
  HTTPHeaders& headers = msg.getHeaders();

  EXPECT_EQ(headers.combine("Combine"), "");

  headers.add("Combine", "first value");
  EXPECT_EQ(headers.combine("Combine"), "first value");

  headers.add("Combine", "second value");
  EXPECT_EQ(headers.combine("Combine"), "first value, second value");

  headers.add("Combine", "third value");
  EXPECT_EQ(headers.combine("Combine"),
            "first value, second value, third value");
  VLOG(4) << msg;
}

TEST	(	HTTPMessage	,
		TestProxification
	)

Definition at line 193 of file HTTPMessageTest.cpp.

References proxygen::HTTPMessage::ensureHostHeader(), EXPECT_EQ, EXPECT_FALSE, proxygen::HTTPMessage::getHeaders(), proxygen::HTTPHeaders::getSingleOrEmpty(), proxygen::HTTP_HEADER_HOST, proxygen::HTTPMessage::setDstAddress(), proxygen::HTTPMessage::setLocalIp(), proxygen::HTTPMessage::setWantsKeepalive(), and proxygen::HTTPMessage::wantsKeepalive().

                                     {
  HTTPMessage msg;

  folly::SocketAddress dstAddr("192.168.1.1", 1887);
  folly::SocketAddress clientAddr("74.125.127.9", 1987);
  msg.setDstAddress(dstAddr);
  msg.setLocalIp("10.0.0.1");
  msg.ensureHostHeader();
  msg.setWantsKeepalive(false);

  HTTPHeaders& hdrs = msg.getHeaders();
  EXPECT_EQ("192.168.1.1", hdrs.getSingleOrEmpty(HTTP_HEADER_HOST));
  EXPECT_FALSE(msg.wantsKeepalive());
}

TEST	(	HTTPMessage	,
		TestKeepaliveCheck
	)

Definition at line 208 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), proxygen::HTTPMessage::computeKeepalive(), EXPECT_FALSE, EXPECT_TRUE, proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_CONNECTION, proxygen::HTTPMessage::setHTTPVersion(), and proxygen::HTTPMessage::stripPerHopHeaders().

                                      {
  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 0);
    EXPECT_FALSE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 1);
    EXPECT_TRUE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 1);
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "close");
    EXPECT_FALSE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 1);
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "ClOsE");
    EXPECT_FALSE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 1);
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "foo,bar");
    EXPECT_TRUE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 1);
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "foo,bar");
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "abc,CLOSE,def");
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "xyz");
    EXPECT_FALSE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 1);
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "foo,bar");
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "abc ,  CLOSE , def");
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "xyz");
    EXPECT_FALSE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 1);
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "  close ");
    EXPECT_FALSE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 1);
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, ",  close ");
    EXPECT_FALSE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 1);
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "  close , ");
    EXPECT_FALSE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 0);
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "Keep-Alive");
    EXPECT_TRUE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 0);
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "keep-alive");
    EXPECT_TRUE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 0);
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "keep-alive");
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "close");
    EXPECT_FALSE(msg.computeKeepalive());
  }

  {
    HTTPMessage msg;
    msg.setHTTPVersion(1, 0);
    msg.getHeaders().add(HTTP_HEADER_CONNECTION, "keep-alive");
    msg.stripPerHopHeaders();
    EXPECT_TRUE(msg.computeKeepalive());
  }
}

TEST	(	HTTPMessage	,
		TestHeaderStripPerHop
	)

Definition at line 312 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), proxygen::HTTPMessage::getStrippedPerHopHeaders(), proxygen::HTTP_HEADER_CONNECTION, proxygen::HTTPHeaders::size(), and proxygen::HTTPMessage::stripPerHopHeaders().

                                         {
  HTTPMessage msg;

  msg.getHeaders().add(HTTP_HEADER_CONNECTION, "a, b, c");
  msg.getHeaders().add(HTTP_HEADER_CONNECTION, "d");
  msg.getHeaders().add(HTTP_HEADER_CONNECTION, ",,,,");
  msg.getHeaders().add(HTTP_HEADER_CONNECTION, " , , , ,");
  msg.getHeaders().add(HTTP_HEADER_CONNECTION, ", e");
  msg.getHeaders().add(HTTP_HEADER_CONNECTION, " f ,\tg\t, \r\n\th ");
  msg.getHeaders().add("Keep-Alive", "true");

  msg.getHeaders().add("a", "1");
  msg.getHeaders().add("b", "2");
  msg.getHeaders().add("c", "3");
  msg.getHeaders().add("d", "4");
  msg.getHeaders().add("e", "5");
  msg.getHeaders().add("f", "6");
  msg.getHeaders().add("g", "7");
  msg.getHeaders().add("h", "8");

  EXPECT_EQ(msg.getHeaders().size(), 15);
  msg.stripPerHopHeaders();
  EXPECT_EQ(msg.getHeaders().size(), 0);
  EXPECT_EQ(msg.getStrippedPerHopHeaders().size(), 15);
}

TEST	(	HTTPMessage	,
		TestEmptyName
	)

Definition at line 338 of file HTTPMessageTest.cpp.

References EXPECT_DEATH_NO_CORE, proxygen::HTTPMessage::getHeaders(), and proxygen::HTTPHeaders::set().

                                 {
  HTTPMessage msg;
  EXPECT_DEATH_NO_CORE(msg.getHeaders().set("", "empty name?!"), ".*");
}

TEST	(	HTTPMessage	,
		TestMethod
	)

Definition at line 343 of file HTTPMessageTest.cpp.

References proxygen::CONNECT, EXPECT_EQ, proxygen::GET, proxygen::HTTPMessage::getMethod(), proxygen::HTTPMessage::getMethodString(), folly::none, and proxygen::HTTPMessage::setMethod().

                              {
  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(folly::none, msg.getMethod());

  msg.setMethod(HTTPMethod::CONNECT);
  EXPECT_EQ("CONNECT", msg.getMethodString());
  EXPECT_EQ(HTTPMethod::CONNECT == msg.getMethod(), true);
}

TEST	(	GetPathAndQuery	,
		ParseURL
	)

Definition at line 370 of file HTTPMessageTest.cpp.

References testPathAndQuery().

                                {
  testPathAndQuery("http://localhost:80/foo?bar#qqq", "/foo", "bar");
  testPathAndQuery("localhost:80/foo?bar#qqq", "/foo", "bar");
  testPathAndQuery("localhost", "", "");
  testPathAndQuery("/f/o/o?bar#qqq", "/f/o/o", "bar");
  testPathAndQuery("#?hello", "", "");
}

TEST	(	HTTPHeaders	,
		AddStringPiece
	)

Definition at line 378 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPHeaders::getSingleOrEmpty(), name, and folly::Range< Iter >::split_step().

                                  {
  const char foo[] = "name:value";
  HTTPHeaders headers;

  folly::StringPiece str(foo);
  folly::StringPiece name = str.split_step(':');
  headers.add(name, str);
  EXPECT_EQ("value", headers.getSingleOrEmpty("name"));
}

TEST	(	HTTPHeaders	,
		InitializerList
	)

Definition at line 388 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), proxygen::HTTPHeaders::combine(), EXPECT_EQ, proxygen::HTTPHeaders::getSingleOrEmpty(), proxygen::HTTP_HEADER_CONNECTION, and proxygen::HTTP_HEADER_SERVER.

                                   {
  HTTPHeaders hdrs;

  hdrs.add({{"name", "value"}});
  hdrs.add({{HTTP_HEADER_CONNECTION, "close"}});
  hdrs.add({{"a", "b"},
            {HTTP_HEADER_CONNECTION, "foo"},
            {HTTP_HEADER_SERVER, "x"}});

  EXPECT_EQ("value", hdrs.getSingleOrEmpty("name"));
  EXPECT_EQ("close, foo", hdrs.combine(HTTP_HEADER_CONNECTION));
  EXPECT_EQ("x", hdrs.getSingleOrEmpty(HTTP_HEADER_SERVER));
}

TEST	(	HTTPHeaders	,
		InitializerListStringPiece
	)

Definition at line 402 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPHeaders::getSingleOrEmpty(), proxygen::HTTP_HEADER_CONNECTION, name, and folly::Range< Iter >::split_step().

                                              {
  HTTPHeaders hdrs;

  const char* foo = "name:value";
  folly::StringPiece str(foo);
  folly::StringPiece name = str.split_step(':');
  hdrs.add({{name, str}, {HTTP_HEADER_CONNECTION, str}});

  EXPECT_EQ("value", hdrs.getSingleOrEmpty("name"));
  EXPECT_EQ("value", hdrs.getSingleOrEmpty(HTTP_HEADER_CONNECTION));
}

TEST	(	HTTPMessage	,
		RemoveQueryParamTests
	)

Definition at line 427 of file HTTPMessageTest.cpp.

References testRemoveQueryParam().

                                         {
  // Query param present
  testRemoveQueryParam("http://localhost:80/foo?param1=a&param2=b#qqq",
                       "param2",
                       "http://localhost:80/foo?param1=a#qqq",
                       "param1=a");
  // Query param not present
  testRemoveQueryParam("http://localhost/foo?param1=a&param2=b#qqq",
                       "param3",
                       "http://localhost/foo?param1=a&param2=b#qqq",
                       "param1=a&param2=b");
  // No scheme
  testRemoveQueryParam("localhost:80/foo?param1=a&param2=b#qqq",
                       "param2",
                       "localhost:80/foo?param1=a#qqq",
                       "param1=a");
  // Just hostname as URL and empty query param
  testRemoveQueryParam("localhost", "param2", "localhost", "");
  testRemoveQueryParam("localhost", "", "localhost", "");
  // Just path as URL
  testRemoveQueryParam("/f/o/o?bar#qqq", "bar", "/f/o/o#qqq", "");
}

TEST	(	HTTPMessage	,
		SetQueryParamTests
	)

Definition at line 464 of file HTTPMessageTest.cpp.

References testSetQueryParam().

                                      {
  // Overwrite existing parameter
  testSetQueryParam("http://localhost:80/foo?param1=a&param2=b#qqq",
                    "param2",
                    "true",
                    "http://localhost:80/foo?param1=a&param2=true#qqq",
                    "param1=a&param2=true");
  // Add a query parameter
  testSetQueryParam("http://localhost/foo?param1=a&param2=b#qqq",
                    "param3",
                    "true",
                    "http://localhost/foo?param1=a&param2=b&param3=true#qqq",
                    "param1=a&param2=b&param3=true");
  // Add a query parameter, should be alphabetical order
  testSetQueryParam("localhost:80/foo?param1=a&param3=c#qqq",
                    "param2",
                    "b",
                    "localhost:80/foo?param1=a&param2=b&param3=c#qqq",
                    "param1=a&param2=b&param3=c");
  // Add a query parameter when no query parameters exist
  testSetQueryParam("localhost:80/foo#qqq",
                    "param2",
                    "b",
                    "localhost:80/foo?param2=b#qqq",
                    "param2=b");
}

TEST	(	HTTPMessage	,
		TestCheckForHeaderToken
	)

Definition at line 491 of file HTTPMessageTest.cpp.

References proxygen::HTTPHeaders::add(), proxygen::HTTPMessage::checkForHeaderToken(), EXPECT_FALSE, EXPECT_TRUE, proxygen::HTTPMessage::getHeaders(), and proxygen::HTTP_HEADER_CONNECTION.

                                           {
  HTTPMessage msg;
  HTTPHeaders& headers = msg.getHeaders();

  headers.add(HTTP_HEADER_CONNECTION, "HTTP2-Settings");
  EXPECT_TRUE(msg.checkForHeaderToken(HTTP_HEADER_CONNECTION, "HTTP2-Settings",
                                      false));
  EXPECT_FALSE(msg.checkForHeaderToken(HTTP_HEADER_CONNECTION, "http2-settings",
                                       true));
}

TEST	(	HttpMessage	,
		TestProtocolStringHTTPVersion
	)

Definition at line 502 of file HTTPMessageTest.cpp.

References EXPECT_EQ, proxygen::HTTPMessage::getProtocolString(), and proxygen::HTTPMessage::setHTTPVersion().

                                                 {
  HTTPMessage msg;
  msg.setHTTPVersion(1, 1);

  EXPECT_EQ(msg.getProtocolString(), "1.1");
}

TEST	(	HttpMessage	,
		TestProtocolStringAdvancedProtocol
	)

Definition at line 509 of file HTTPMessageTest.cpp.

References EXPECT_EQ, proxygen::HTTPMessage::getProtocolString(), proxygen::HTTPMessage::setAdvancedProtocolString(), and string.

                                                      {
  HTTPMessage msg;
  std::string advancedProtocol = "h2";
  msg.setAdvancedProtocolString(advancedProtocol);
  EXPECT_EQ(msg.getProtocolString(), advancedProtocol);
}

void testPathAndQuery	(	const string &	url,
		const string &	expectedPath,
		const string &	expectedQuery
	)

Definition at line 359 of file HTTPMessageTest.cpp.

References EXPECT_EQ, proxygen::HTTPMessage::getPath(), proxygen::HTTPMessage::getQueryString(), proxygen::HTTPMessage::getURL(), and proxygen::HTTPMessage::setURL().

Referenced by TEST().

                                                   {
  HTTPMessage msg;
  msg.setURL(url);

  EXPECT_EQ(msg.getURL(), url);
  EXPECT_EQ(msg.getPath(), expectedPath);
  EXPECT_EQ(msg.getQueryString(), expectedQuery);
}

void testRemoveQueryParam	(	const string &	url,
		const string &	queryParam,
		const string &	expectedUrl,
		const string &	expectedQuery
	)

Definition at line 414 of file HTTPMessageTest.cpp.

References EXPECT_EQ, proxygen::HTTPMessage::getQueryString(), proxygen::HTTPMessage::getURL(), proxygen::HTTPMessage::removeQueryParam(), and proxygen::HTTPMessage::setURL().

Referenced by TEST().

                                                       {
  HTTPMessage msg;
  msg.setURL(url);
  bool expectedChange = (url != expectedUrl);
  EXPECT_EQ(msg.removeQueryParam(queryParam), expectedChange);

  EXPECT_EQ(msg.getURL(), expectedUrl);
  EXPECT_EQ(msg.getQueryString(), expectedQuery);
}

void testSetQueryParam	(	const string &	url,
		const string &	queryParam,
		const string &	paramValue,
		const string &	expectedUrl,
		const string &	expectedQuery
	)

Definition at line 450 of file HTTPMessageTest.cpp.

References EXPECT_EQ, proxygen::HTTPMessage::getQueryString(), proxygen::HTTPMessage::getURL(), proxygen::HTTPMessage::setQueryParam(), and proxygen::HTTPMessage::setURL().

Referenced by TEST().

                                                    {
  HTTPMessage msg;
  msg.setURL(url);
  bool expectedChange = (url != expectedUrl);
  EXPECT_EQ(msg.setQueryParam(queryParam, paramValue), expectedChange);

  EXPECT_EQ(msg.getURL(), expectedUrl);
  EXPECT_EQ(msg.getQueryString(), expectedQuery);
}