From 655c26075c8194bdb6ffcbef3180dfb15dba551b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Manuel=20Oll=C3=A9?= Date: Tue, 1 Oct 2024 16:43:34 -0300 Subject: [PATCH 1/5] wasm: Add data buffering for chunks MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Juan Manuel Ollé --- changelogs/current.yaml | 4 + source/extensions/common/wasm/context.cc | 8 +- .../http/wasm/test_data/test_body_cpp.cc | 9 ++ .../http/wasm/wasm_filter_integration_test.cc | 90 +++++++++++++++---- 4 files changed, 91 insertions(+), 20 deletions(-) diff --git a/changelogs/current.yaml b/changelogs/current.yaml index b773fb76f626e..15d69156dc137 100644 --- a/changelogs/current.yaml +++ b/changelogs/current.yaml @@ -203,6 +203,10 @@ bug_fixes: - area: tracing change: | Fixed a bug where the OpenTelemetry tracer exports the OTLP request even when no spans are present. +- area: wasm + change: | + Fixed a bug where a body received in chunks is not correctly dumped, resulting in + an incomplete dump and loss of the last chunk. This issue is manifested in HTTP/2. removed_config_or_runtime: # *Normally occurs at the end of the* :ref:`deprecation period ` diff --git a/source/extensions/common/wasm/context.cc b/source/extensions/common/wasm/context.cc index 8d717c38d23ef..64c34a6f20bd0 100644 --- a/source/extensions/common/wasm/context.cc +++ b/source/extensions/common/wasm/context.cc @@ -1723,6 +1723,9 @@ Http::FilterDataStatus Context::decodeData(::Envoy::Buffer::Instance& data, bool if (!in_vm_context_created_) { return Http::FilterDataStatus::Continue; } + if (buffering_request_body_) { + decoder_callbacks_->addDecodedData(data, false); + } request_body_buffer_ = &data; end_of_stream_ = end_stream; const auto buffer = getBuffer(WasmBufferType::HttpRequestBody); @@ -1793,6 +1796,9 @@ Http::FilterDataStatus Context::encodeData(::Envoy::Buffer::Instance& data, bool if (!in_vm_context_created_) { return Http::FilterDataStatus::Continue; } + if (buffering_response_body_) { + encoder_callbacks_->addEncodedData(data, false); + } response_body_buffer_ = &data; end_of_stream_ = end_stream; const auto buffer = getBuffer(WasmBufferType::HttpResponseBody); @@ -1801,7 +1807,7 @@ Http::FilterDataStatus Context::encodeData(::Envoy::Buffer::Instance& data, bool buffering_response_body_ = false; switch (result) { case Http::FilterDataStatus::Continue: - request_body_buffer_ = nullptr; + response_body_buffer_ = nullptr; break; case Http::FilterDataStatus::StopIterationAndBuffer: buffering_response_body_ = true; diff --git a/test/extensions/filters/http/wasm/test_data/test_body_cpp.cc b/test/extensions/filters/http/wasm/test_data/test_body_cpp.cc index 1b8ebb28ed053..acc88745f8ec3 100644 --- a/test/extensions/filters/http/wasm/test_data/test_body_cpp.cc +++ b/test/extensions/filters/http/wasm/test_data/test_body_cpp.cc @@ -118,6 +118,15 @@ FilterDataStatus BodyContext::onBody(WasmBufferType type, size_t buffer_length, } return FilterDataStatus::StopIterationAndBuffer; + } else if (body_op_ == "SetEndOfBodies") { + logBody(type); + if (end_of_stream) { + getBufferStatus(type, &size, &flags); + setBuffer(type, size, 0, ".0"); + return FilterDataStatus::Continue; + } + return FilterDataStatus::StopIterationAndBuffer; + } else { // This is a test and the test was configured incorrectly. logError("Invalid body test op " + body_op_); diff --git a/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc b/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc index 455bde64393fc..75d0370d877ed 100644 --- a/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc +++ b/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc @@ -12,13 +12,21 @@ namespace { class WasmFilterIntegrationTest : public HttpIntegrationTest, - public testing::TestWithParam> { + public testing::TestWithParam< + std::tuple, Http::CodecType>> { public: WasmFilterIntegrationTest() - : HttpIntegrationTest(Http::CodecType::HTTP1, Network::Address::IpVersion::v4) {} + : HttpIntegrationTest(std::get<1>(GetParam()), Network::Address::IpVersion::v4) {} void SetUp() override { - setUpstreamProtocol(Http::CodecType::HTTP1); + setUpstreamProtocol(std::get<1>(GetParam())); + if (std::get<1>(GetParam()) == Http::CodecType::HTTP2) { + config_helper_.setClientCodec(envoy::extensions::filters::network::http_connection_manager:: + v3::HttpConnectionManager::HTTP2); + } else { + config_helper_.setClientCodec(envoy::extensions::filters::network::http_connection_manager:: + v3::HttpConnectionManager::HTTP1); + } // Wasm filters are expensive to setup and sometime default is not enough, // It needs to increase timeout to avoid flaky tests setListenersBoundTimeout(10 * TestUtility::DefaultTimeout); @@ -27,7 +35,7 @@ class WasmFilterIntegrationTest void TearDown() override { fake_upstream_connection_.reset(); } void setupWasmFilter(const std::string& config, const std::string& root_id = "") { - bool downstream = std::get<2>(GetParam()); + bool downstream = std::get<2>(std::get<0>(GetParam())); const std::string yaml = TestEnvironment::substitute(absl::StrCat( R"EOF( name: envoy.filters.http.wasm @@ -40,7 +48,7 @@ class WasmFilterIntegrationTest vm_config: vm_id: "vm_id" runtime: envoy.wasm.runtime.)EOF", - std::get<0>(GetParam()), R"EOF( + std::get<0>(std::get<0>(GetParam())), R"EOF( configuration: "@type": type.googleapis.com/google.protobuf.StringValue value: )EOF", @@ -68,11 +76,12 @@ class WasmFilterIntegrationTest }); } - void runTest(const Http::RequestHeaderMap& request_headers, const std::string& request_body, + void runTest(const Http::RequestHeaderMap& request_headers, + const std::vector& request_body, const Http::RequestHeaderMap& expected_request_headers, const std::string& expected_request_body, const Http::ResponseHeaderMap& upstream_response_headers, - const std::string& upstream_response_body, + const std::vector& upstream_response_body, const Http::ResponseHeaderMap& expected_response_headers, const std::string& expected_response_body) { @@ -84,8 +93,11 @@ class WasmFilterIntegrationTest auto encoder_decoder = codec_client_->startRequest(request_headers); request_encoder_ = &encoder_decoder.first; response = std::move(encoder_decoder.second); - Buffer::OwnedImpl buffer(request_body); - codec_client_->sendData(*request_encoder_, buffer, true); + const auto request_body_size = request_body.size(); + for (size_t n = 0; n < request_body_size; n++) { + Buffer::OwnedImpl buffer(request_body[n]); + codec_client_->sendData(*request_encoder_, buffer, n == request_body_size - 1); + } } ASSERT_TRUE(fake_upstreams_[0]->waitForHttpConnection(*dispatcher_, fake_upstream_connection_)); @@ -99,8 +111,11 @@ class WasmFilterIntegrationTest upstream_request_->encodeHeaders(upstream_response_headers, true /*end_stream*/); } else { upstream_request_->encodeHeaders(upstream_response_headers, false /*end_stream*/); - Buffer::OwnedImpl buffer(upstream_response_body); - upstream_request_->encodeData(buffer, true); + const auto upstream_response_body_size = upstream_response_body.size(); + for (size_t n = 0; n < upstream_response_body_size; n++) { + Buffer::OwnedImpl buffer(upstream_response_body[n]); + upstream_request_->encodeData(buffer, n == upstream_response_body_size - 1); + } } ASSERT_TRUE(response->waitForEndStream()); @@ -114,12 +129,21 @@ class WasmFilterIntegrationTest ASSERT_TRUE(fake_upstream_connection_->close()); ASSERT_TRUE(fake_upstream_connection_->waitForDisconnect()); } + + static std::string + testParamsToString(const ::testing::TestParamInfo< + std::tuple, Http::CodecType>>& p) { + return fmt::format("{}_{}_{}_{}", std::get<2>(std::get<0>(p.param)) ? "downstream" : "upstream", + std::get<0>(std::get<0>(p.param)), std::get<1>(std::get<0>(p.param)), + std::get<1>(p.param) == Http::CodecType::HTTP2 ? "Http2" : "Http"); + } }; -INSTANTIATE_TEST_SUITE_P( - Runtimes, WasmFilterIntegrationTest, - Envoy::Extensions::Common::Wasm::dual_filter_sandbox_runtime_and_cpp_values, - Envoy::Extensions::Common::Wasm::wasmDualFilterTestParamsToString); +INSTANTIATE_TEST_SUITE_P(Runtimes, WasmFilterIntegrationTest, + testing::Combine(Common::Wasm::dual_filter_sandbox_runtime_and_cpp_values, + testing::Values(Http::CodecType::HTTP1, + Http::CodecType::HTTP2)), + WasmFilterIntegrationTest::testParamsToString); GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WasmFilterIntegrationTest); TEST_P(WasmFilterIntegrationTest, HeadersManipulation) { @@ -143,8 +167,10 @@ TEST_P(WasmFilterIntegrationTest, HeadersManipulation) { Http::TestResponseHeaderMapImpl expected_response_headers{ {":status", "200"}, {"content-type", "application/json"}, {"test-status", "OK"}}; - runTest(request_headers, "", expected_request_headers, "", upstream_response_headers, "", - expected_response_headers, ""); + auto request_body = std::vector{}; + auto upstream_response_body = std::vector{}; + runTest(request_headers, request_body, expected_request_headers, "", upstream_response_headers, + upstream_response_body, expected_response_headers, ""); } TEST_P(WasmFilterIntegrationTest, BodyManipulation) { @@ -164,8 +190,34 @@ TEST_P(WasmFilterIntegrationTest, BodyManipulation) { Http::TestResponseHeaderMapImpl expected_response_headers{{":status", "200"}}; - runTest(request_headers, "request_body", expected_request_headers, "replace", - upstream_response_headers, "response_body", expected_response_headers, "replace"); + auto request_body = std::vector{{"request_body"}}; + auto upstream_response_body = std::vector{{"upstream_body"}}; + runTest(request_headers, request_body, expected_request_headers, "replace", + upstream_response_headers, upstream_response_body, expected_response_headers, "replace"); +} + +TEST_P(WasmFilterIntegrationTest, BodyBufferedManipulation) { + setupWasmFilter("", "body"); + HttpIntegrationTest::initialize(); + + Http::TestRequestHeaderMapImpl request_headers{{":scheme", "http"}, + {":method", "GET"}, + {":path", "/"}, + {":authority", "host"}, + {"x-test-operation", "SetEndOfBodies"}}; + + Http::TestRequestHeaderMapImpl expected_request_headers{{":path", "/"}}; + + Http::TestResponseHeaderMapImpl upstream_response_headers{{":status", "200"}, + {"x-test-operation", "SetEndOfBodies"}}; + + Http::TestResponseHeaderMapImpl expected_response_headers{{":status", "200"}}; + + auto request_body = std::vector{{"request_"}, {"body"}}; + auto upstream_response_body = std::vector{{"upstream_"}, {"body"}}; + runTest(request_headers, request_body, expected_request_headers, "request_body.0", + upstream_response_headers, upstream_response_body, expected_response_headers, + "upstream_body.0"); } } // namespace From 04b008aec229d5476b5c81d35bae0adae1fef0d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Manuel=20Oll=C3=A9?= Date: Thu, 10 Oct 2024 11:58:57 -0300 Subject: [PATCH 2/5] Add extra test MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Juan Manuel Ollé --- .../http/wasm/wasm_filter_integration_test.cc | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc b/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc index 75d0370d877ed..417560bc7e052 100644 --- a/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc +++ b/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc @@ -220,6 +220,31 @@ TEST_P(WasmFilterIntegrationTest, BodyBufferedManipulation) { "upstream_body.0"); } +TEST_P(WasmFilterIntegrationTest, BodyBufferedMultipleChunksManipulation) { + setupWasmFilter("", "body"); + HttpIntegrationTest::initialize(); + + Http::TestRequestHeaderMapImpl request_headers{{":scheme", "http"}, + {":method", "GET"}, + {":path", "/"}, + {":authority", "host"}, + {"x-test-operation", "SetEndOfBodies"}}; + + Http::TestRequestHeaderMapImpl expected_request_headers{{":path", "/"}}; + + Http::TestResponseHeaderMapImpl upstream_response_headers{{":status", "200"}, + {"x-test-operation", "SetEndOfBodies"}}; + + Http::TestResponseHeaderMapImpl expected_response_headers{{":status", "200"}}; + + auto request_body = std::vector{{"request_"}, {"very_"}, {"long_"}, {"body"}}; + auto upstream_response_body = + std::vector{{"upstream_"}, {"very_"}, {"long_"}, {"body"}}; + runTest(request_headers, request_body, expected_request_headers, "request_very_long_body.0", + upstream_response_headers, upstream_response_body, expected_response_headers, + "upstream_very_long_body.0"); +} + } // namespace } // namespace Wasm } // namespace Extensions From 13cbc23aef3aabe8454df41930fabef964420b0b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Manuel=20Oll=C3=A9?= Date: Mon, 14 Oct 2024 11:21:09 -0300 Subject: [PATCH 3/5] some rework MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Juan Manuel Ollé --- test/extensions/common/wasm/BUILD | 1 + test/extensions/common/wasm/wasm_runtime.cc | 36 ++++++++++++++++++ test/extensions/common/wasm/wasm_runtime.h | 11 ++++++ .../http/wasm/test_data/test_body_cpp.cc | 2 +- .../http/wasm/wasm_filter_integration_test.cc | 38 +++++++------------ 5 files changed, 63 insertions(+), 25 deletions(-) diff --git a/test/extensions/common/wasm/BUILD b/test/extensions/common/wasm/BUILD index 8335f4a557337..66d0664ffb3c9 100644 --- a/test/extensions/common/wasm/BUILD +++ b/test/extensions/common/wasm/BUILD @@ -98,6 +98,7 @@ envoy_cc_test_library( hdrs = ["wasm_runtime.h"], tags = ["skip_on_windows"], deps = [ + "//envoy/http:codec_interface", "//source/extensions/wasm_runtime/null:config", "//source/extensions/wasm_runtime/v8:config", "//source/extensions/wasm_runtime/wamr:config", diff --git a/test/extensions/common/wasm/wasm_runtime.cc b/test/extensions/common/wasm/wasm_runtime.cc index 498812b0896eb..f04b202ab535a 100644 --- a/test/extensions/common/wasm/wasm_runtime.cc +++ b/test/extensions/common/wasm/wasm_runtime.cc @@ -55,6 +55,20 @@ wasmDualFilterTestMatrix(bool include_nullvm, bool cpp_only) { return values; } +std::vector> +wasmDualFilterWithCodecsTestMatrix(bool include_nullvm, bool cpp_only, + std::vector codecs_type) { + std::vector> values; + for (const auto& codec_type : codecs_type) { + for (const auto& p : + Envoy::Extensions::Common::Wasm::wasmTestMatrix(include_nullvm, cpp_only)) { + values.push_back(std::make_tuple(std::get<0>(p), std::get<1>(p), true, codec_type)); + values.push_back(std::make_tuple(std::get<0>(p), std::get<1>(p), false, codec_type)); + } + } + return values; +} + std::string wasmTestParamsToString(const ::testing::TestParamInfo>& p) { return std::get<0>(p.param) + "_" + std::get<1>(p.param); @@ -66,6 +80,28 @@ std::string wasmDualFilterTestParamsToString( std::get<1>(p.param); } +static std::string codecToString(const Http::CodecType& e) { + switch (e) { + case Http::CodecType::HTTP1: + return "http1"; + case Http::CodecType::HTTP2: + return "http2"; + case Http::CodecType::HTTP3: + return "http3"; + default: + break; + } + return "Unknown"; +} + +std::string wasmDualFilterWithCodecsTestParamsToString( + const ::testing::TestParamInfo>& + p) { + auto [runtime, language, direction, codec_type] = p.param; + return fmt::format("{}_{}_{}_{}", direction ? "downstream" : "upstream", runtime, language, + codecToString(codec_type)); +} + } // namespace Wasm } // namespace Common } // namespace Extensions diff --git a/test/extensions/common/wasm/wasm_runtime.h b/test/extensions/common/wasm/wasm_runtime.h index e2df8362a99e3..c5d36e84d9e7f 100644 --- a/test/extensions/common/wasm/wasm_runtime.h +++ b/test/extensions/common/wasm/wasm_runtime.h @@ -1,5 +1,7 @@ #pragma once +#include "envoy/http/codec.h" + #include "gtest/gtest.h" namespace Envoy { @@ -14,10 +16,17 @@ std::vector> wasmTestMatrix(bool include_nu std::vector> wasmDualFilterTestMatrix(bool include_nullvm, bool cpp_only); +std::vector> +wasmDualFilterWithCodecsTestMatrix(bool include_nullvm, bool cpp_only, + std::vector codecs_type); + inline auto runtime_and_cpp_values = testing::ValuesIn(wasmTestMatrix(true, true)); inline auto sandbox_runtime_and_cpp_values = testing::ValuesIn(wasmTestMatrix(false, true)); inline auto dual_filter_sandbox_runtime_and_cpp_values = testing::ValuesIn(wasmDualFilterTestMatrix(false, true)); +inline auto dual_filter_with_codecs_sandbox_runtime_and_cpp_values = + testing::ValuesIn(wasmDualFilterWithCodecsTestMatrix( + false, true, {Envoy::Http::CodecType::HTTP1, Envoy::Http::CodecType::HTTP2})); inline auto runtime_and_language_values = testing::ValuesIn(wasmTestMatrix(true, false)); inline auto sandbox_runtime_and_language_values = testing::ValuesIn(wasmTestMatrix(false, false)); @@ -25,6 +34,8 @@ std::string wasmTestParamsToString(const ::testing::TestParamInfo>& p); std::string wasmDualFilterTestParamsToString( const ::testing::TestParamInfo>& p); +std::string wasmDualFilterWithCodecsTestParamsToString( + const ::testing::TestParamInfo>& p); } // namespace Wasm } // namespace Common diff --git a/test/extensions/filters/http/wasm/test_data/test_body_cpp.cc b/test/extensions/filters/http/wasm/test_data/test_body_cpp.cc index acc88745f8ec3..9a9feff01b05d 100644 --- a/test/extensions/filters/http/wasm/test_data/test_body_cpp.cc +++ b/test/extensions/filters/http/wasm/test_data/test_body_cpp.cc @@ -122,7 +122,7 @@ FilterDataStatus BodyContext::onBody(WasmBufferType type, size_t buffer_length, logBody(type); if (end_of_stream) { getBufferStatus(type, &size, &flags); - setBuffer(type, size, 0, ".0"); + setBuffer(type, size, 0, ".end"); return FilterDataStatus::Continue; } return FilterDataStatus::StopIterationAndBuffer; diff --git a/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc b/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc index 417560bc7e052..584a9ce959477 100644 --- a/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc +++ b/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc @@ -12,15 +12,14 @@ namespace { class WasmFilterIntegrationTest : public HttpIntegrationTest, - public testing::TestWithParam< - std::tuple, Http::CodecType>> { + public testing::TestWithParam> { public: WasmFilterIntegrationTest() - : HttpIntegrationTest(std::get<1>(GetParam()), Network::Address::IpVersion::v4) {} + : HttpIntegrationTest(std::get<3>(GetParam()), Network::Address::IpVersion::v4) {} void SetUp() override { - setUpstreamProtocol(std::get<1>(GetParam())); - if (std::get<1>(GetParam()) == Http::CodecType::HTTP2) { + setUpstreamProtocol(std::get<3>(GetParam())); + if (std::get<3>(GetParam()) == Http::CodecType::HTTP2) { config_helper_.setClientCodec(envoy::extensions::filters::network::http_connection_manager:: v3::HttpConnectionManager::HTTP2); } else { @@ -35,7 +34,7 @@ class WasmFilterIntegrationTest void TearDown() override { fake_upstream_connection_.reset(); } void setupWasmFilter(const std::string& config, const std::string& root_id = "") { - bool downstream = std::get<2>(std::get<0>(GetParam())); + bool downstream = std::get<2>(GetParam()); const std::string yaml = TestEnvironment::substitute(absl::StrCat( R"EOF( name: envoy.filters.http.wasm @@ -48,14 +47,15 @@ class WasmFilterIntegrationTest vm_config: vm_id: "vm_id" runtime: envoy.wasm.runtime.)EOF", - std::get<0>(std::get<0>(GetParam())), R"EOF( + std::get<0>(GetParam()), R"EOF( configuration: "@type": type.googleapis.com/google.protobuf.StringValue value: )EOF", config, R"EOF( code: local: - filename: "{{ test_rundir }}/test/extensions/filters/http/wasm/test_data/test_cpp.wasm" + filename: "/Users/jolle/repos/envoy-jmo/test_cpp_append2.wasm" + #filename: "{{ test_rundir }}/test/extensions/filters/http/wasm/test_data/test_cpp.wasm" )EOF")); config_helper_.prependFilter(yaml, downstream); } @@ -129,21 +129,11 @@ class WasmFilterIntegrationTest ASSERT_TRUE(fake_upstream_connection_->close()); ASSERT_TRUE(fake_upstream_connection_->waitForDisconnect()); } - - static std::string - testParamsToString(const ::testing::TestParamInfo< - std::tuple, Http::CodecType>>& p) { - return fmt::format("{}_{}_{}_{}", std::get<2>(std::get<0>(p.param)) ? "downstream" : "upstream", - std::get<0>(std::get<0>(p.param)), std::get<1>(std::get<0>(p.param)), - std::get<1>(p.param) == Http::CodecType::HTTP2 ? "Http2" : "Http"); - } }; INSTANTIATE_TEST_SUITE_P(Runtimes, WasmFilterIntegrationTest, - testing::Combine(Common::Wasm::dual_filter_sandbox_runtime_and_cpp_values, - testing::Values(Http::CodecType::HTTP1, - Http::CodecType::HTTP2)), - WasmFilterIntegrationTest::testParamsToString); + Common::Wasm::dual_filter_with_codecs_sandbox_runtime_and_cpp_values, + Common::Wasm::wasmDualFilterWithCodecsTestParamsToString); GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WasmFilterIntegrationTest); TEST_P(WasmFilterIntegrationTest, HeadersManipulation) { @@ -215,9 +205,9 @@ TEST_P(WasmFilterIntegrationTest, BodyBufferedManipulation) { auto request_body = std::vector{{"request_"}, {"body"}}; auto upstream_response_body = std::vector{{"upstream_"}, {"body"}}; - runTest(request_headers, request_body, expected_request_headers, "request_body.0", + runTest(request_headers, request_body, expected_request_headers, "request_body.end", upstream_response_headers, upstream_response_body, expected_response_headers, - "upstream_body.0"); + "upstream_body.end"); } TEST_P(WasmFilterIntegrationTest, BodyBufferedMultipleChunksManipulation) { @@ -240,9 +230,9 @@ TEST_P(WasmFilterIntegrationTest, BodyBufferedMultipleChunksManipulation) { auto request_body = std::vector{{"request_"}, {"very_"}, {"long_"}, {"body"}}; auto upstream_response_body = std::vector{{"upstream_"}, {"very_"}, {"long_"}, {"body"}}; - runTest(request_headers, request_body, expected_request_headers, "request_very_long_body.0", + runTest(request_headers, request_body, expected_request_headers, "request_very_long_body.end", upstream_response_headers, upstream_response_body, expected_response_headers, - "upstream_very_long_body.0"); + "upstream_very_long_body.end"); } } // namespace From d20b21e9d32969450556178f17693aa91428cfa2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Manuel=20Oll=C3=A9?= Date: Mon, 14 Oct 2024 11:58:15 -0300 Subject: [PATCH 4/5] use correct path MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Juan Manuel Ollé --- .../filters/http/wasm/wasm_filter_integration_test.cc | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc b/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc index 584a9ce959477..c3f956a6ed78a 100644 --- a/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc +++ b/test/extensions/filters/http/wasm/wasm_filter_integration_test.cc @@ -54,8 +54,7 @@ class WasmFilterIntegrationTest config, R"EOF( code: local: - filename: "/Users/jolle/repos/envoy-jmo/test_cpp_append2.wasm" - #filename: "{{ test_rundir }}/test/extensions/filters/http/wasm/test_data/test_cpp.wasm" + filename: "{{ test_rundir }}/test/extensions/filters/http/wasm/test_data/test_cpp.wasm" )EOF")); config_helper_.prependFilter(yaml, downstream); } From dee70d1c4085529d3bdbf002fa653be6ebc93dda Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Manuel=20Oll=C3=A9?= Date: Mon, 14 Oct 2024 14:40:39 -0300 Subject: [PATCH 5/5] some rework MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Juan Manuel Ollé --- test/extensions/common/wasm/wasm_runtime.cc | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/test/extensions/common/wasm/wasm_runtime.cc b/test/extensions/common/wasm/wasm_runtime.cc index f04b202ab535a..3981eff89f751 100644 --- a/test/extensions/common/wasm/wasm_runtime.cc +++ b/test/extensions/common/wasm/wasm_runtime.cc @@ -59,11 +59,11 @@ std::vector> wasmDualFilterWithCodecsTestMatrix(bool include_nullvm, bool cpp_only, std::vector codecs_type) { std::vector> values; - for (const auto& codec_type : codecs_type) { - for (const auto& p : + for (const Http::CodecType codec_type : codecs_type) { + for (const auto& [runtime, language] : Envoy::Extensions::Common::Wasm::wasmTestMatrix(include_nullvm, cpp_only)) { - values.push_back(std::make_tuple(std::get<0>(p), std::get<1>(p), true, codec_type)); - values.push_back(std::make_tuple(std::get<0>(p), std::get<1>(p), false, codec_type)); + values.push_back(std::make_tuple(runtime, language, true, codec_type)); + values.push_back(std::make_tuple(runtime, language, false, codec_type)); } } return values; @@ -76,8 +76,8 @@ wasmTestParamsToString(const ::testing::TestParamInfo>& p) { - return (std::get<2>(p.param) ? "downstream_" : "upstream_") + std::get<0>(p.param) + "_" + - std::get<1>(p.param); + auto [runtime, language, direction] = p.param; + return fmt::format("{}_{}_{}", direction ? "downstream" : "upstream", runtime, language); } static std::string codecToString(const Http::CodecType& e) {