chef 18.8.11 → 18.8.54

data/spec/unit/http/simple_spec.rb

@@ -1,32 +0,0 @@
-#
-# Author:: Serdar Sutay (<serdar@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-
-describe Chef::HTTP::Simple do
-  it "should have content length validation middleware after compressor middleware" do
-    client = Chef::HTTP::Simple.new("dummy.com")
-    middlewares = client.instance_variable_get(:@middlewares)
-    content_length = middlewares.find_index { |e| e.is_a? Chef::HTTP::ValidateContentLength }
-    decompressor = middlewares.find_index { |e| e.is_a? Chef::HTTP::Decompressor }
-
-    expect(content_length).not_to be_nil
-    expect(decompressor).not_to be_nil
-    expect(decompressor < content_length).to be_truthy
-  end
-end

data/spec/unit/http/socketless_chef_zero_client_spec.rb

@@ -1,174 +0,0 @@
-#--
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "chef/http/socketless_chef_zero_client"
-
-describe Chef::HTTP::SocketlessChefZeroClient do
-
-  let(:relative_url) { "" }
-  let(:uri_str) { "chefzero://localhost:1/#{relative_url}" }
-  let(:uri) { URI(uri_str) }
-
-  subject(:zero_client) { Chef::HTTP::SocketlessChefZeroClient.new(uri) }
-
-  it "has a host" do
-    expect(zero_client.host).to eq("localhost")
-  end
-
-  it "has a port" do
-    expect(zero_client.port).to eq(1)
-  end
-
-  describe "converting requests to rack format" do
-
-    let(:expected_rack_req) do
-      {
-        "SCRIPT_NAME" => "",
-        "SERVER_NAME" => "localhost",
-        "REQUEST_METHOD" => method.to_s.upcase,
-        "PATH_INFO" => uri.path,
-        "QUERY_STRING" => uri.query,
-        "SERVER_PORT" => uri.port,
-        "HTTP_HOST" => "localhost:#{uri.port}",
-        "rack.url_scheme" => "chefzero",
-      }
-    end
-
-    context "when the request has no body" do
-
-      let(:method) { :GET }
-      let(:relative_url) { "clients" }
-      let(:headers) { { "Accept" => "application/json" } }
-      let(:body) { false }
-      let(:expected_body_str) { "" }
-
-      let(:rack_req) { zero_client.req_to_rack(method, uri, body, headers) }
-
-      it "creates a rack request env" do
-        # StringIO doesn't implement == in a way that we can compare, so we
-        # check rack.input individually and then iterate over everything else
-        expect(rack_req["rack.input"].string).to eq(expected_body_str)
-        expected_rack_req.each do |key, value|
-          expect(rack_req[key]).to eq(value)
-        end
-      end
-
-    end
-
-    context "when the request has a body" do
-
-      let(:method) { :PUT }
-      let(:relative_url) { "clients/foo" }
-      let(:headers) { { "Accept" => "application/json" } }
-      let(:body) { "bunch o' JSON" }
-      let(:expected_body_str) { "bunch o' JSON" }
-
-      let(:rack_req) { zero_client.req_to_rack(method, uri, body, headers) }
-
-      it "creates a rack request env" do
-        # StringIO doesn't implement == in a way that we can compare, so we
-        # check rack.input individually and then iterate over everything else
-        expect(rack_req["rack.input"].string).to eq(expected_body_str)
-        expected_rack_req.each do |key, value|
-          expect(rack_req[key]).to eq(value)
-        end
-      end
-
-    end
-
-  end
-
-  describe "converting responses to Net::HTTP objects" do
-
-    let(:net_http_response) { zero_client.to_net_http(code, headers, body) }
-
-    context "when the request was successful (2XX)" do
-
-      let(:code) { 200 }
-      let(:headers) { { "Content-Type" => "Application/JSON" } }
-      let(:body) { [ "bunch o' JSON" ] }
-
-      it "creates a Net::HTTP success response object" do
-        expect(net_http_response).to be_a_kind_of(Net::HTTPOK)
-        expect(net_http_response.read_body).to eq("bunch o' JSON")
-        expect(net_http_response["content-type"]).to eq("Application/JSON")
-      end
-
-      it "does not fail when calling read_body with a block" do
-        expect(net_http_response.read_body { |chunk| chunk }).to eq("bunch o' JSON")
-      end
-
-    end
-
-    context "when the requested object doesn't exist (404)" do
-
-      let(:code) { 404 }
-      let(:headers) { { "Content-Type" => "Application/JSON" } }
-      let(:body) { [ "nope" ] }
-
-      it "creates a Net::HTTPNotFound response object" do
-        expect(net_http_response).to be_a_kind_of(Net::HTTPNotFound)
-      end
-    end
-
-  end
-
-  describe "request-response round trip" do
-
-    let(:method) { :GET }
-    let(:relative_url) { "clients" }
-    let(:headers) { { "Accept" => "application/json", "X-Ops-Server-API-Version" => "2" } }
-    let(:body) { false }
-
-    let(:expected_rack_req) do
-      {
-        "SCRIPT_NAME" => "",
-        "SERVER_NAME" => "localhost",
-        "REQUEST_METHOD" => method.to_s.upcase,
-        "PATH_INFO" => uri.path,
-        "QUERY_STRING" => uri.query,
-        "SERVER_PORT" => uri.port,
-        "HTTP_HOST" => "localhost:#{uri.port}",
-        "HTTP_X_OPS_SERVER_API_VERSION" => "2",
-        "rack.url_scheme" => "chefzero",
-        "rack.input" => an_instance_of(StringIO),
-      }
-    end
-
-    let(:response_code) { 200 }
-    let(:response_headers) { { "Content-Type" => "Application/JSON" } }
-    let(:response_body) { [ "bunch o' JSON" ] }
-
-    let(:rack_response) { [ response_code, response_headers, response_body ] }
-
-    let(:response) { zero_client.request(method, uri, body, headers) }
-
-    before do
-      expect(ChefZero::SocketlessServerMap).to receive(:request).with(1, expected_rack_req).and_return(rack_response)
-    end
-
-    it "makes a rack request to Chef Zero and returns the response as a Net::HTTP object" do
-      _client, net_http_response = response
-      expect(net_http_response).to be_a_kind_of(Net::HTTPOK)
-      expect(net_http_response.code).to eq("200")
-      expect(net_http_response.body).to eq("bunch o' JSON")
-    end
-
-  end
-
-end

data/spec/unit/http/ssl_policies_spec.rb

@@ -1,228 +0,0 @@
-#--
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "chef/http/ssl_policies"
-
-describe "HTTP SSL Policy" do
-
-  before do
-    Chef::Config[:ssl_client_cert] = nil
-    Chef::Config[:ssl_client_key]  = nil
-    Chef::Config[:ssl_ca_path]     = nil
-    Chef::Config[:ssl_ca_file]     = nil
-    ENV["SSL_CERT_FILE"]           = nil
-  end
-
-  let(:http_client) do
-    ssl_policy_class.apply_to(Net::HTTP.new("example.com"))
-  end
-
-  describe Chef::HTTP::DefaultSSLPolicy do
-
-    let(:ssl_policy_class) { Chef::HTTP::DefaultSSLPolicy }
-
-    it "raises a ConfigurationError if :ssl_ca_path is set to a path that doesn't exist" do
-      Chef::Config[:ssl_ca_path] = "/dev/null/nothing_here"
-      expect { http_client }.to raise_error(Chef::Exceptions::ConfigurationError)
-    end
-
-    it "should set the CA path if that is set in the configuration" do
-      Chef::Config[:ssl_ca_path] = File.join(CHEF_SPEC_DATA, "ssl")
-      expect(http_client.ca_path).to eq(File.join(CHEF_SPEC_DATA, "ssl"))
-    end
-
-    it "raises a ConfigurationError if :ssl_ca_file is set to a file that does not exist" do
-      Chef::Config[:ssl_ca_file] = "/dev/null/nothing_here"
-      expect { http_client }.to raise_error(Chef::Exceptions::ConfigurationError)
-    end
-
-    it "should set the CA file if that is set in the configuration" do
-      Chef::Config[:ssl_ca_file] = CHEF_SPEC_DATA + "/ssl/5e707473.0"
-      expect(http_client.ca_file).to eq(CHEF_SPEC_DATA + "/ssl/5e707473.0")
-    end
-
-    it "should set the custom CA file if SSL_CERT_FILE environment variable is set" do
-      ENV["SSL_CERT_FILE"] = CHEF_SPEC_DATA + "/trusted_certs/intermediate.pem"
-      expect(http_client.ca_file).to eq(CHEF_SPEC_DATA + "/trusted_certs/intermediate.pem")
-    end
-
-    it "raises a ConfigurationError if SSL_CERT_FILE environment variable is set to a file that does not exist" do
-      ENV["SSL_CERT_FILE"] = "/dev/null/nothing_here"
-      expect { http_client }.to raise_error(Chef::Exceptions::ConfigurationError)
-    end
-
-    it "sets the OpenSSL verify mode to verify_peer when configured with :ssl_verify_mode set to :verify_peer" do
-      Chef::Config[:ssl_verify_mode] = :verify_peer
-      expect(http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
-    end
-
-    it "sets the OpenSSL verify mode to :verify_none when configured with :ssl_verify_mode set to :verify_none" do
-      Chef::Config[:ssl_verify_mode] = :verify_none
-      expect(http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
-    end
-
-    describe "when configured with a client certificate" do
-      it "raises ConfigurationError if the certificate file doesn't exist" do
-        Chef::Config[:ssl_client_cert] = "/dev/null/nothing_here"
-        Chef::Config[:ssl_client_key]  = CHEF_SPEC_DATA + "/ssl/chef-rspec.key"
-        expect { http_client }.to raise_error(Chef::Exceptions::ConfigurationError, /ssl_client_cert .* does not exist/)
-      end
-
-      it "raises ConfigurationError if the private key file doesn't exist" do
-        Chef::Config[:ssl_client_cert] = CHEF_SPEC_DATA + "/ssl/chef-rspec.cert"
-        Chef::Config[:ssl_client_key]  = "/dev/null/nothing_here"
-        expect { http_client }.to raise_error(Chef::Exceptions::ConfigurationError, /ssl_client_key .* does not exist/)
-      end
-
-      it "raises a ConfigurationError if one of :ssl_client_cert and :ssl_client_key is set but not both" do
-        Chef::Config[:ssl_client_cert] = "/dev/null/nothing_here"
-        Chef::Config[:ssl_client_key]  = nil
-        expect { http_client }.to raise_error(Chef::Exceptions::ConfigurationError, /configure ssl_client_cert and ssl_client_key together/)
-      end
-
-      it "raises a ConfigurationError with a bad cert file" do
-        Chef::Config[:ssl_client_cert] = __FILE__
-        Chef::Config[:ssl_client_key]  = CHEF_SPEC_DATA + "/ssl/chef-rspec.key"
-        expect { http_client }.to raise_error(Chef::Exceptions::ConfigurationError, /Error reading cert file '#{__FILE__}'/)
-      end
-
-      it "raises a ConfigurationError with a bad key file" do
-        Chef::Config[:ssl_client_cert] = CHEF_SPEC_DATA + "/ssl/chef-rspec.cert"
-        Chef::Config[:ssl_client_key]  = __FILE__
-        expect { http_client }.to raise_error(Chef::Exceptions::ConfigurationError, /Error reading key file '#{__FILE__}'/)
-      end
-
-      it "configures the HTTP client's cert and private key" do
-        Chef::Config[:ssl_client_cert] = CHEF_SPEC_DATA + "/ssl/chef-rspec.cert"
-        Chef::Config[:ssl_client_key]  = CHEF_SPEC_DATA + "/ssl/chef-rspec.key"
-        expect(http_client.cert.to_s).to eq(OpenSSL::X509::Certificate.new(IO.read(CHEF_SPEC_DATA + "/ssl/chef-rspec.cert")).to_s)
-        expect(http_client.key.to_s).to eq(OpenSSL::PKey::RSA.new(IO.read(CHEF_SPEC_DATA + "/ssl/chef-rspec.key")).to_s)
-      end
-
-      it "configures the HTTP client's cert and private key with a DER encoded cert" do
-        Chef::Config[:ssl_client_cert] = CHEF_SPEC_DATA + "/ssl/binary/chef-rspec-der.cert"
-        Chef::Config[:ssl_client_key]  = CHEF_SPEC_DATA + "/ssl/chef-rspec.key"
-        expect(http_client.cert.to_s).to eq(OpenSSL::X509::Certificate.new(IO.read(CHEF_SPEC_DATA + "/ssl/chef-rspec.cert")).to_s)
-        expect(http_client.key.to_s).to eq(OpenSSL::PKey::RSA.new(IO.read(CHEF_SPEC_DATA + "/ssl/chef-rspec.key")).to_s)
-      end
-
-      it "configures the HTTP client's cert and private key with a DER encoded key" do
-        Chef::Config[:ssl_client_cert] = CHEF_SPEC_DATA + "/ssl/chef-rspec.cert"
-        Chef::Config[:ssl_client_key]  = CHEF_SPEC_DATA + "/ssl/binary/chef-rspec-der.key"
-        expect(http_client.cert.to_s).to eq(OpenSSL::X509::Certificate.new(IO.read(CHEF_SPEC_DATA + "/ssl/chef-rspec.cert")).to_s)
-        expect(http_client.key.to_s).to eq(OpenSSL::PKey::RSA.new(IO.read(CHEF_SPEC_DATA + "/ssl/chef-rspec.key")).to_s)
-      end
-    end
-
-    context "when additional certs are located in the trusted_certs dir" do
-      before do
-        Chef::Config.trusted_certs_dir = File.join(CHEF_SPEC_DATA, "trusted_certs")
-      end
-
-      it "enables verification of self-signed certificates" do
-        path = File.join(CHEF_SPEC_DATA, "trusted_certs", "example.crt")
-        self_signed_crt = OpenSSL::X509::Certificate.new(File.binread(path))
-
-        expect(http_client.cert_store.verify(self_signed_crt)).to be_truthy
-      end
-
-      it "enables verification of cert chains" do
-        # This cert is signed by DigiCert so it would be valid in normal SSL usage.
-        # The chain goes:
-        # trusted root -> intermediate -> opscode.pem
-        # In this test, the intermediate has to be loaded and trusted in order
-        # for verification to work correctly.
-        # If the machine running the test doesn't have ruby SSL configured correctly,
-        # then the root cert also has to be loaded for the test to succeed.
-        # The system under test **SHOULD** do both of these things.
-        path = File.join(CHEF_SPEC_DATA, "trusted_certs", "opscode.pem")
-        additional_pem = OpenSSL::X509::Certificate.new(File.binread(path))
-
-        expect(http_client.cert_store.verify(additional_pem)).to be_truthy
-      end
-
-      it "skips duplicate certs" do
-        # For whatever reason, OpenSSL errors out when adding a
-        # cert you already have to the certificate store.
-        ssl_policy = ssl_policy_class.new(Net::HTTP.new("example.com"))
-        ssl_policy.set_custom_certs
-        ssl_policy.set_custom_certs # should not raise an error
-      end
-
-      it "raises ConfigurationError with a bad cert file in the trusted_certs dir" do
-        ssl_policy = ssl_policy_class.new(Net::HTTP.new("example.com"))
-
-        Dir.mktmpdir do |dir|
-          bad_cert_file = File.join(dir, "bad_cert_file.crt")
-          File.write(bad_cert_file, File.read(__FILE__))
-
-          Chef::Config.trusted_certs_dir = dir
-          expect { ssl_policy.set_custom_certs }.to raise_error(Chef::Exceptions::ConfigurationError, /Error reading cert file/)
-        end
-      end
-
-      it "works with binary certs" do
-        Chef::Config.trusted_certs_dir = File.join(CHEF_SPEC_DATA, "ssl", "binary")
-
-        ssl_policy = ssl_policy_class.new(Net::HTTP.new("example.com"))
-        ssl_policy.set_custom_certs
-      end
-    end
-  end
-
-  describe Chef::HTTP::APISSLPolicy do
-
-    let(:ssl_policy_class) { Chef::HTTP::APISSLPolicy }
-
-    it "sets the OpenSSL verify mode to verify_peer when configured with :ssl_verify_mode set to :verify_peer" do
-      Chef::Config[:ssl_verify_mode] = :verify_peer
-      expect(http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
-    end
-
-    it "sets the OpenSSL verify mode to :verify_none when configured with :ssl_verify_mode set to :verify_none" do
-      Chef::Config[:ssl_verify_mode] = :verify_none
-      expect(http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
-    end
-
-    it "sets the OpenSSL verify mode to verify_peer when verify_api_cert is set" do
-      Chef::Config[:verify_api_cert] = true
-      expect(http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
-    end
-  end
-
-  describe Chef::HTTP::VerifyPeerSSLPolicy do
-
-    let(:ssl_policy_class) { Chef::HTTP::VerifyPeerSSLPolicy }
-
-    it "sets the OpenSSL verify mode to verify_peer" do
-      expect(http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
-    end
-
-  end
-
-  describe Chef::HTTP::VerifyNoneSSLPolicy do
-
-    let(:ssl_policy_class) { Chef::HTTP::VerifyNoneSSLPolicy }
-
-    it "sets the OpenSSL verify mode to verify_peer" do
-      expect(http_client.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
-    end
-
-  end
-end

data/spec/unit/http/validate_content_length_spec.rb

@@ -1,207 +0,0 @@
-#
-# Author:: Serdar Sutay (<serdar@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "stringio"
-
-describe Chef::HTTP::ValidateContentLength do
-  class TestClient < Chef::HTTP
-    use Chef::HTTP::ValidateContentLength
-  end
-
-  let(:method) { "GET" }
-  let(:url) { "http://dummy.com" }
-  let(:headers) { {} }
-  let(:data) { false }
-
-  let(:request) {}
-  let(:return_value) { "200" }
-
-  # Test Variables
-  let(:request_type) { :streaming }
-  let(:content_length_value) { 23 }
-  let(:streaming_length) { 23 }
-  let(:response_body) { "Thanks for checking in." }
-  let(:response_headers) do
-    {
-      "content-length" => content_length_value,
-    }
-  end
-
-  let(:response) do
-    m = double("HttpResponse", body: response_body)
-    allow(m).to receive(:[]) do |key|
-      response_headers[key]
-    end
-
-    m
-  end
-
-  let(:middleware) do
-    client = TestClient.new(url)
-    client.middlewares[0]
-  end
-
-  def run_content_length_validation
-    stream_handler = middleware.stream_response_handler(response)
-    middleware.handle_request(method, url, headers, data)
-
-    case request_type
-    when :streaming
-      # First stream the data
-      data_length = streaming_length
-      while data_length > 0
-        chunk_size = data_length > 10 ? 10 : data_length
-        stream_handler.handle_chunk(double("Chunk", bytesize: chunk_size))
-        data_length -= chunk_size
-      end
-
-      # Finally call stream complete
-      middleware.handle_stream_complete(response, request, return_value)
-    when :direct
-      middleware.handle_response(response, request, return_value)
-    else
-      raise "Unknown request_type: #{request_type}"
-    end
-  end
-
-  let(:debug_stream) { StringIO.new }
-  let(:debug_output) { debug_stream.string }
-
-  before(:each) do
-    @original_log_level = Chef::Log.level
-    Chef::Log.level = :trace
-    allow(Chef::Log).to receive(:trace) do |message|
-      debug_stream.puts message
-    end
-  end
-
-  after(:each) do
-    Chef::Log.level = @original_log_level
-  end
-
-  describe "without response body" do
-    let(:request_type) { :direct }
-    let(:response_body) { "Thanks for checking in." }
-
-    it "shouldn't raise error" do
-      expect { run_content_length_validation }.not_to raise_error
-    end
-  end
-
-  describe "without Content-Length header" do
-    let(:response_headers) { {} }
-
-    %w{direct streaming}.each do |req_type|
-      describe "when running #{req_type} request" do
-        let(:request_type) { req_type.to_sym }
-
-        it "should skip validation and log for trace" do
-          run_content_length_validation
-          expect(debug_output).to include("HTTP server did not include a Content-Length header in response")
-        end
-      end
-    end
-  end
-
-  describe "with negative Content-Length header" do
-    let(:content_length_value) { "-1" }
-
-    %w{direct streaming}.each do |req_type|
-      describe "when running #{req_type} request" do
-        let(:request_type) { req_type.to_sym }
-
-        it "should skip validation and log for trace" do
-          run_content_length_validation
-          expect(debug_output).to include("HTTP server responded with a negative Content-Length header (-1), cannot identify truncated downloads.")
-        end
-      end
-    end
-  end
-
-  describe "with correct Content-Length header" do
-    %w{direct streaming}.each do |req_type|
-      describe "when running #{req_type} request" do
-        let(:request_type) { req_type.to_sym }
-
-        it "should validate correctly" do
-          run_content_length_validation
-          expect(debug_output).to include("Content-Length validated correctly.")
-        end
-      end
-    end
-  end
-
-  describe "with wrong Content-Length header" do
-    let(:content_length_value) { 25 }
-    %w{direct streaming}.each do |req_type|
-      describe "when running #{req_type} request" do
-        let(:request_type) { req_type.to_sym }
-
-        it "should raise ContentLengthMismatch error" do
-          expect { run_content_length_validation }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
-        end
-      end
-    end
-  end
-
-  describe "when download is interrupted" do
-    let(:streaming_length) { 12 }
-
-    it "should raise ContentLengthMismatch error" do
-      expect { run_content_length_validation }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
-    end
-  end
-
-  describe "when Transfer-Encoding & Content-Length is set" do
-    let(:response_headers) do
-      {
-        "content-length" => content_length_value,
-        "transfer-encoding" => "chunked",
-      }
-    end
-
-    %w{direct streaming}.each do |req_type|
-      describe "when running #{req_type} request" do
-        let(:request_type) { req_type.to_sym }
-
-        it "should skip validation and log for trace" do
-          run_content_length_validation
-          expect(debug_output).to include("Transfer-Encoding header is set, skipping Content-Length check.")
-        end
-      end
-    end
-  end
-
-  describe "when client is being reused" do
-    before do
-      run_content_length_validation
-      expect(debug_output).to include("Content-Length validated correctly.")
-    end
-
-    it "should reset internal counter" do
-      expect(middleware.instance_variable_get(:@content_length_counter)).to be_nil
-    end
-
-    it "should validate correctly second time" do
-      run_content_length_validation
-      expect(debug_output).to include("Content-Length validated correctly.")
-    end
-  end
-
-end