ZlibServerFilterTest.cpp File Reference

#include <folly/Conv.h>
#include <folly/ScopeGuard.h>
#include <folly/io/IOBuf.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
#include <proxygen/httpserver/filters/ZlibServerFilter.h>
#include <proxygen/lib/utils/ZlibStreamCompressor.h>
#include <proxygen/httpserver/Mocks.h>
#include <proxygen/httpserver/ResponseBuilder.h>

Go to the source code of this file.

Classes
class	ZlibServerFilterTest

Functions
	MATCHER_P (IOBufEquals, expected, folly::to< std::string >("IOBuf is ", negation?"not ":"","'", expected,"'"))
	TEST_F (ZlibServerFilterTest, NonchunkedCompression)
	TEST_F (ZlibServerFilterTest, ChunkedCompression)
	TEST_F (ZlibServerFilterTest, ParameterizedContenttype)
	TEST_F (ZlibServerFilterTest, MixedcaseContenttype)
	TEST_F (ZlibServerFilterTest, MultipleAcceptedEncodings)
	TEST_F (ZlibServerFilterTest, MultipleAcceptedEncodingsQvalues)
	TEST_F (ZlibServerFilterTest, NoCompressibleAcceptedEncodings)
	TEST_F (ZlibServerFilterTest, MissingAcceptedEncodings)
	TEST_F (ZlibServerFilterTest, UncompressibleContenttype)
	TEST_F (ZlibServerFilterTest, UncompressibleContenttypeParam)
	TEST_F (ZlibServerFilterTest, TooSmallToCompress)
	TEST_F (ZlibServerFilterTest, SmallChunksCompress)
	TEST_F (ZlibServerFilterTest, MinimumCompressSizeEqualToRequestSize)
	TEST_F (ZlibServerFilterTest, NoResponseBody)

Function Documentation

MATCHER_P	(	IOBufEquals	,
		expected	,
		folly::to< std::string >	"IOBuf is ", negation?"not ":"","'", expected,"'"
	)

Definition at line 24 of file ZlibServerFilterTest.cpp.

References string.

                                             : "", "'", expected, "'")) {
  auto iob = arg->clone();
  auto br = iob->coalesce();
  std::string actual(br.begin(), br.end());
  *result_listener << "'" << actual << "'";
  return actual == expected;
}

TEST_F	(	ZlibServerFilterTest	,
		NonchunkedCompression
	)

Definition at line 212 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, folly::IOBuf::copyBuffer(), and string.

                                                    {
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(true,
                         std::string("http://locahost/foo.compressme"),
                         std::string("gzip"),
                         std::string("gzip"),
                         std::string("Hello World"),
                         std::string("text/html"),
                         folly::IOBuf::copyBuffer("Hello World"));
  });
}

TEST_F	(	ZlibServerFilterTest	,
		ChunkedCompression
	)

Definition at line 224 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, chunks, and string.

                                                 {
  std::vector<std::string> chunks = {"Hello", " World"};
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(true,
                         std::string("http://locahost/foo.compressme"),
                         std::string("gzip"),
                         std::string("gzip"),
                         std::string("Hello World"),
                         std::string("text/html"),
                         createResponseChain(chunks));
  });
}

TEST_F	(	ZlibServerFilterTest	,
		ParameterizedContenttype
	)

Definition at line 237 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, folly::IOBuf::copyBuffer(), and string.

                                                       {
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(true,
                         std::string("http://locahost/foo.compressme"),
                         std::string("gzip"),
                         std::string("gzip"),
                         std::string("Hello World"),
                         std::string("text/html; param1"),
                         folly::IOBuf::copyBuffer("Hello World"));
  });
}

TEST_F	(	ZlibServerFilterTest	,
		MixedcaseContenttype
	)

Definition at line 249 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, folly::IOBuf::copyBuffer(), and string.

                                                   {
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(true,
                         std::string("http://locahost/foo.compressme"),
                         std::string("gzip"),
                         std::string("gzip"),
                         std::string("Hello World"),
                         std::string("Text/Html; param1"),
                         folly::IOBuf::copyBuffer("Hello World"));
  });
}

TEST_F	(	ZlibServerFilterTest	,
		MultipleAcceptedEncodings
	)

Definition at line 262 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, folly::IOBuf::copyBuffer(), and string.

                                                        {
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(true,
                         std::string("http://locahost/foo.compressme"),
                         std::string("gzip, identity, deflate"),
                         std::string("gzip"),
                         std::string("Hello World"),
                         std::string("text/html"),
                         folly::IOBuf::copyBuffer("Hello World"));
  });
}

TEST_F	(	ZlibServerFilterTest	,
		MultipleAcceptedEncodingsQvalues
	)

Definition at line 274 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, folly::IOBuf::copyBuffer(), and string.

                                                               {
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(true,
                         std::string("http://locahost/foo.compressme"),
                         std::string("gzip; q=.7;, identity"),
                         std::string("gzip"),
                         std::string("Hello World"),
                         std::string("text/html"),
                         folly::IOBuf::copyBuffer("Hello World"));
  });
}

TEST_F	(	ZlibServerFilterTest	,
		NoCompressibleAcceptedEncodings
	)

Definition at line 286 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, folly::IOBuf::copyBuffer(), and string.

                                                              {
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(false,
                         std::string("http://locahost/foo.compressme"),
                         std::string("identity; q=.7;"),
                         std::string(""),
                         std::string("Hello World"),
                         std::string("text/html"),
                         folly::IOBuf::copyBuffer("Hello World"));
  });
}

TEST_F	(	ZlibServerFilterTest	,
		MissingAcceptedEncodings
	)

Definition at line 298 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, folly::IOBuf::copyBuffer(), and string.

                                                       {
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(false,
                         std::string("http://locahost/foo.compressme"),
                         std::string(""),
                         std::string(""),
                         std::string("Hello World"),
                         std::string("text/html"),
                         folly::IOBuf::copyBuffer("Hello World"));
  });
}

TEST_F	(	ZlibServerFilterTest	,
		UncompressibleContenttype
	)

Definition at line 311 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, folly::IOBuf::copyBuffer(), and string.

                                                        {
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(false,
                         std::string("http://locahost/foo.nocompress"),
                         std::string("gzip"),
                         std::string(""),
                         std::string("Hello World"),
                         std::string("image/jpeg"),
                         folly::IOBuf::copyBuffer("Hello World"));
  });
}

TEST_F	(	ZlibServerFilterTest	,
		UncompressibleContenttypeParam
	)

Definition at line 323 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, folly::IOBuf::copyBuffer(), and string.

                                                             {
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(false,
                         std::string("http://locahost/foo.nocompress"),
                         std::string("gzip"),
                         std::string(""),
                         std::string("Hello World"),
                         std::string("application/jpeg; param1"),
                         folly::IOBuf::copyBuffer("Hello World"));
  });
}

TEST_F	(	ZlibServerFilterTest	,
		TooSmallToCompress
	)

Definition at line 336 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, folly::IOBuf::copyBuffer(), and string.

                                                 {
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(false,
                         std::string("http://locahost/foo.smallfry"),
                         std::string("gzip"),
                         std::string(""),
                         std::string("Hello World"),
                         std::string("text/html"),
                         folly::IOBuf::copyBuffer("Hello World"),
                         4,
                         1000);
  });
}

TEST_F	(	ZlibServerFilterTest	,
		SmallChunksCompress
	)

Definition at line 350 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, chunks, and string.

                                                  {
  // Expect this to compress despite being small because can't tell the content
  // length when we're chunked
  std::vector<std::string> chunks = {"Hello", " World"};
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(true,
                         std::string("http://locahost/foo.compressme"),
                         std::string("gzip"),
                         std::string("gzip"),
                         std::string("Hello World"),
                         std::string("text/html"),
                         createResponseChain(chunks),
                         4,
                         1000);
  });
}

TEST_F	(	ZlibServerFilterTest	,
		MinimumCompressSizeEqualToRequestSize
	)

Definition at line 367 of file ZlibServerFilterTest.cpp.

References ASSERT_NO_FATAL_FAILURE, folly::IOBuf::copyBuffer(), and string.

                                                                   {
  auto requestBody = std::string("Hello World");
  ASSERT_NO_FATAL_FAILURE({
    exercise_compression(true,
                         std::string("http://locahost/foo.compressme"),
                         std::string("gzip"),
                         std::string("gzip"),
                         requestBody,
                         std::string("text/html"),
                         folly::IOBuf::copyBuffer(requestBody),
                         4,
                         requestBody.length());
  });
}

TEST_F	(	ZlibServerFilterTest	,
		NoResponseBody
	)

Definition at line 382 of file ZlibServerFilterTest.cpp.

References testing::_, ASSERT_NO_FATAL_FAILURE, proxygen::HTTPMessage::checkForHeaderToken(), testing::DoAll(), EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, folly::pushmi::operators::filter, proxygen::HTTPMessage::getHeaders(), proxygen::HTTPMessage::getIsChunked(), proxygen::ResponseBuilder::header(), proxygen::HTTP_HEADER_ACCEPT_ENCODING, proxygen::HTTP_HEADER_CONTENT_ENCODING, proxygen::HTTP_HEADER_CONTENT_TYPE, int32_t, testing::Invoke(), testing::Return(), proxygen::ResponseBuilder::send(), proxygen::ResponseBuilder::sendWithEOM(), proxygen::HTTPHeaders::set(), proxygen::HTTPMessage::setURL(), proxygen::ResponseBuilder::status(), string, and uint32_t.

                                            {
  std::string acceptedEncoding = "gzip";
  std::string expectedEncoding = "gzip";
  std::string url = std::string("http://locahost/foo.compressme");
  std::string responseContentType = std::string("text/html");
  int32_t compressionLevel = 4;
  uint32_t minimumCompressionSize = 0;

  ASSERT_NO_FATAL_FAILURE({
    // Request Handler Expectations
    EXPECT_CALL(*requestHandler_, onEOM()).Times(1);

    // Need to capture whatever the filter is for ResponseBuilder later
    EXPECT_CALL(*requestHandler_, setResponseHandler(_))
        .WillOnce(DoAll(SaveArg<0>(&downstream_), Return()));

    // Response Handler Expectations
    // Headers are only sent once
    EXPECT_CALL(*responseHandler_, sendHeaders(_)).WillOnce(DoAll(
        Invoke([&](HTTPMessage& msg) {
          auto& headers = msg.getHeaders();
          EXPECT_TRUE(msg.checkForHeaderToken(
            HTTP_HEADER_CONTENT_ENCODING, expectedEncoding.c_str(), false));
          if (msg.getIsChunked()) {
            EXPECT_FALSE(headers.exists("Content-Length"));
          } else {
            //Content-Length is not set on chunked messages
            EXPECT_TRUE(headers.exists("Content-Length"));
          }
        }),
        Return()));

    EXPECT_CALL(*responseHandler_, sendEOM()).Times(1);

    /* Simulate Request/Response where no body message received */
    HTTPMessage msg;
    msg.setURL(url);
    msg.getHeaders().set(HTTP_HEADER_ACCEPT_ENCODING, acceptedEncoding);

    std::set<std::string> compressibleTypes = {"text/html"};
    auto filterFactory = std::make_unique<ZlibServerFilterFactory>(
        compressionLevel, minimumCompressionSize, compressibleTypes);

    auto filter = filterFactory->onRequest(requestHandler_, &msg);
    filter->setResponseHandler(responseHandler_.get());

    // Send fake request
    filter->onEOM();

    ResponseBuilder(downstream_)
      .status(200, "OK")
      .header(HTTP_HEADER_CONTENT_TYPE, responseContentType)
      .send();

    ResponseBuilder(downstream_).sendWithEOM();

    filter->requestComplete();
  });
}