nghttp2/src/http2_test.cc

295 lines
8.7 KiB
C++

/*
* nghttp2 - HTTP/2 C Library
*
* Copyright (c) 2013 Tatsuhiro Tsujikawa
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "http2_test.h"
#include <cassert>
#include <cstring>
#include <iostream>
#include <CUnit/CUnit.h>
#include "http-parser/http_parser.h"
#include "http2.h"
#include "util.h"
using namespace nghttp2;
#define MAKE_NV(K, V) {(uint8_t*)K, (uint8_t*)V, \
sizeof(K) - 1, sizeof(V) - 1, \
NGHTTP2_NV_FLAG_NONE}
namespace shrpx {
namespace {
void check_nv(const Header& a, const nghttp2_nv *b)
{
CU_ASSERT(a.name.size() == b->namelen);
CU_ASSERT(a.value.size() == b->valuelen);
CU_ASSERT(memcmp(a.name.c_str(), b->name, b->namelen) == 0);
CU_ASSERT(memcmp(a.value.c_str(), b->value, b->valuelen) == 0);
}
} // namespace
void test_http2_add_header(void)
{
auto nva = Headers();
http2::add_header(nva, (const uint8_t*)"alpha", 5,
(const uint8_t*)"123", 3, false);
CU_ASSERT(Headers::value_type("alpha", "123") == nva[0]);
CU_ASSERT(!nva[0].no_index);
nva.clear();
http2::add_header(nva, (const uint8_t*)"alpha", 5,
(const uint8_t*)"", 0, true);
CU_ASSERT(Headers::value_type("alpha", "") == nva[0]);
CU_ASSERT(nva[0].no_index);
}
void test_http2_check_http2_headers(void)
{
auto nva1 = Headers{
{ "alpha", "1" },
{ "bravo", "2" },
{ "upgrade", "http2" }
};
CU_ASSERT(!http2::check_http2_headers(nva1));
auto nva2 = Headers{
{ "connection", "1" },
{ "delta", "2" },
{ "echo", "3" }
};
CU_ASSERT(!http2::check_http2_headers(nva2));
auto nva3 = Headers{
{ "alpha", "1" },
{ "bravo", "2" },
{ "te2", "3" }
};
CU_ASSERT(http2::check_http2_headers(nva3));
auto n1 = ":authority";
auto n1u8 = reinterpret_cast<const uint8_t*>(n1);
CU_ASSERT(http2::check_http2_request_pseudo_header(n1u8, strlen(n1)));
CU_ASSERT(!http2::check_http2_response_pseudo_header(n1u8, strlen(n1)));
auto n2 = ":status";
auto n2u8 = reinterpret_cast<const uint8_t*>(n2);
CU_ASSERT(!http2::check_http2_request_pseudo_header(n2u8, strlen(n2)));
CU_ASSERT(http2::check_http2_response_pseudo_header(n2u8, strlen(n2)));
}
void test_http2_get_unique_header(void)
{
auto nva = Headers{
{ "alpha", "1" },
{ "bravo", "2" },
{ "bravo", "3" },
{ "charlie", "4" },
{ "delta", "5" },
{ "echo", "6" }
};
const Headers::value_type *rv;
rv = http2::get_unique_header(nva, "delta");
CU_ASSERT(rv != nullptr);
CU_ASSERT("delta" == rv->name);
rv = http2::get_unique_header(nva, "bravo");
CU_ASSERT(rv == nullptr);
rv = http2::get_unique_header(nva, "foxtrot");
CU_ASSERT(rv == nullptr);
}
void test_http2_get_header(void)
{
auto nva = Headers{
{ "alpha", "1" },
{ "bravo", "2" },
{ "bravo", "3" },
{ "charlie", "4" },
{ "delta", "5" },
{ "echo", "6" }
};
const Headers::value_type *rv;
rv = http2::get_header(nva, "delta");
CU_ASSERT(rv != nullptr);
CU_ASSERT("delta" == rv->name);
rv = http2::get_header(nva, "bravo");
CU_ASSERT(rv != nullptr);
CU_ASSERT("bravo" == rv->name);
rv = http2::get_header(nva, "foxtrot");
CU_ASSERT(rv == nullptr);
}
void test_http2_value_lws(void)
{
auto nva = Headers{
{ "0", "alpha" },
{ "1", " alpha" },
{ "2", "" },
{" 3", " " },
{" 4", " a "}
};
CU_ASSERT(!http2::value_lws(&nva[0]));
CU_ASSERT(!http2::value_lws(&nva[1]));
CU_ASSERT(http2::value_lws(&nva[2]));
CU_ASSERT(http2::value_lws(&nva[3]));
CU_ASSERT(!http2::value_lws(&nva[4]));
}
namespace {
auto headers = Headers
{{"alpha", "0", true},
{"bravo", "1"},
{"connection", "2"},
{"connection", "3"},
{"delta", "4"},
{"expect", "5"},
{"foxtrot", "6"},
{"tango", "7"},
{"te", "8"},
{"te", "9"},
{"x-forwarded-proto", "10"},
{"x-forwarded-proto", "11"},
{"zulu", "12"}};
} // namespace
void test_http2_copy_norm_headers_to_nva(void)
{
std::vector<nghttp2_nv> nva;
http2::copy_norm_headers_to_nva(nva, headers);
CU_ASSERT(7 == nva.size());
auto ans = std::vector<int>{0, 1, 4, 5, 6, 7, 12};
for(size_t i = 0; i < ans.size(); ++i) {
check_nv(headers[ans[i]], &nva[i]);
if(ans[i] == 0) {
CU_ASSERT(nva[i].flags & NGHTTP2_NV_FLAG_NO_INDEX);
} else {
CU_ASSERT(NGHTTP2_NV_FLAG_NONE == nva[i].flags);
}
}
}
void test_http2_build_http1_headers_from_norm_headers(void)
{
std::string hdrs;
http2::build_http1_headers_from_norm_headers(hdrs, headers);
CU_ASSERT(hdrs ==
"Alpha: 0\r\n"
"Bravo: 1\r\n"
"Delta: 4\r\n"
"Expect: 5\r\n"
"Foxtrot: 6\r\n"
"Tango: 7\r\n"
"Te: 8\r\n"
"Te: 9\r\n"
"Zulu: 12\r\n");
hdrs.clear();
// Both nghttp2 and spdylay do not allow \r and \n in header value
// now.
// auto hd2 = std::vector<std::pair<std::string, std::string>>
// {{"alpha", "bravo\r\ncharlie\r\n"}};
// http2::build_http1_headers_from_norm_headers(hdrs, hd2);
// CU_ASSERT(hdrs == "Alpha: bravo charlie \r\n");
}
void test_http2_lws(void)
{
CU_ASSERT(!http2::lws("alpha"));
CU_ASSERT(http2::lws(" "));
CU_ASSERT(http2::lws(""));
}
namespace {
void check_rewrite_location_uri(const std::string& new_uri,
const std::string& uri,
const std::string& req_host,
const std::string& upstream_scheme,
uint16_t upstream_port)
{
http_parser_url u;
memset(&u, 0, sizeof(u));
CU_ASSERT(0 == http_parser_parse_url(uri.c_str(), uri.size(), 0, &u));
CU_ASSERT(new_uri ==
http2::rewrite_location_uri(uri, u, req_host,
upstream_scheme, upstream_port));
}
} // namespace
void test_http2_rewrite_location_uri(void)
{
check_rewrite_location_uri("https://localhost:3000/alpha?bravo#charlie",
"http://localhost:3001/alpha?bravo#charlie",
"localhost:3001", "https", 3000);
check_rewrite_location_uri("https://localhost/",
"http://localhost:3001/",
"localhost:3001", "https", 443);
check_rewrite_location_uri("http://localhost/",
"http://localhost:3001/",
"localhost:3001", "http", 80);
check_rewrite_location_uri("http://localhost:443/",
"http://localhost:3001/",
"localhost:3001", "http", 443);
check_rewrite_location_uri("https://localhost:80/",
"http://localhost:3001/",
"localhost:3001", "https", 80);
check_rewrite_location_uri("",
"http://localhost:3001/",
"127.0.0.1", "https", 3000);
check_rewrite_location_uri("https://localhost:3000/",
"http://localhost:3001/",
"localhost", "https", 3000);
check_rewrite_location_uri("",
"https://localhost:3001/",
"localhost", "https", 3000);
check_rewrite_location_uri("https://localhost:3000/",
"http://localhost/",
"localhost", "https", 3000);
}
void test_http2_parse_http_status_code(void)
{
CU_ASSERT(200 == http2::parse_http_status_code("200"));
CU_ASSERT(102 == http2::parse_http_status_code("102"));
CU_ASSERT(-1 == http2::parse_http_status_code("099"));
CU_ASSERT(-1 == http2::parse_http_status_code("99"));
CU_ASSERT(-1 == http2::parse_http_status_code("-1"));
CU_ASSERT(-1 == http2::parse_http_status_code("20a"));
CU_ASSERT(-1 == http2::parse_http_status_code(""));
}
} // namespace shrpx