puppet 7.27.0 → 7.29.0

data/spec/unit/network/http/handler_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/handler'
-require 'puppet/indirector_testing'
-require 'puppet/network/http'
-
-describe Puppet::Network::HTTP::Handler do
-  before :each do
-    Puppet::IndirectorTesting.indirection.terminus_class = :memory
-  end
-
-  let(:indirection) { Puppet::IndirectorTesting.indirection }
-
-  def a_request(method = "HEAD", path = "/production/#{indirection.name}/unknown")
-    {
-      :accept_header => "application/json",
-      :content_type_header => "application/json",
-      :method => method,
-      :path => path,
-      :params => {},
-      :client_cert => nil,
-      :headers => {},
-      :body => nil
-    }
-  end
-
-  let(:handler) { PuppetSpec::Handler.new() }
-
-  describe "the HTTP Handler" do
-    def respond(text)
-      lambda { |req, res| res.respond_with(200, "text/plain", text) }
-    end
-
-    it "hands the request to the first route that matches the request path" do
-      handler = PuppetSpec::Handler.new(
-        Puppet::Network::HTTP::Route.path(%r{^/foo}).get(respond("skipped")),
-        Puppet::Network::HTTP::Route.path(%r{^/vtest}).get(respond("used")),
-        Puppet::Network::HTTP::Route.path(%r{^/vtest/foo}).get(respond("ignored")))
-
-      req = a_request("GET", "/vtest/foo")
-      res = {}
-
-      handler.process(req, res)
-
-      expect(res[:body]).to eq("used")
-    end
-
-    it "raises an error if multiple routes with the same path regex are registered" do
-      expect do
-        PuppetSpec::Handler.new(
-          Puppet::Network::HTTP::Route.path(%r{^/foo}).get(respond("ignored")),
-          Puppet::Network::HTTP::Route.path(%r{^/foo}).post(respond("also ignored"))
-        )
-      end.to raise_error(ArgumentError)
-    end
-
-    it "raises an HTTP not found error if no routes match" do
-      handler = PuppetSpec::Handler.new
-
-      req = a_request("GET", "/vtest/foo")
-      res = {}
-
-      handler.process(req, res)
-
-      res_body = JSON(res[:body])
-
-      expect(res[:content_type_header]).to eq("application/json; charset=utf-8")
-      expect(res_body["issue_kind"]).to eq("HANDLER_NOT_FOUND")
-      expect(res_body["message"]).to eq("Not Found: No route for GET /vtest/foo")
-      expect(res[:status]).to eq(404)
-    end
-
-    it "returns a structured error response when the server encounters an internal error" do
-      error = StandardError.new("the sky is falling!")
-      original_stacktrace = ['a.rb', 'b.rb']
-      error.set_backtrace(original_stacktrace)
-
-      handler = PuppetSpec::Handler.new(
-        Puppet::Network::HTTP::Route.path(/.*/).get(lambda { |_, _| raise error}))
-
-      # Stacktraces should be included in logs
-      expect(Puppet).to receive(:err).with("Server Error: the sky is falling!\na.rb\nb.rb")
-
-      req = a_request("GET", "/vtest/foo")
-      res = {}
-
-      handler.process(req, res)
-
-      res_body = JSON(res[:body])
-
-      expect(res[:content_type_header]).to eq("application/json; charset=utf-8")
-      expect(res_body["issue_kind"]).to eq(Puppet::Network::HTTP::Issues::RUNTIME_ERROR.to_s)
-      expect(res_body["message"]).to eq("Server Error: the sky is falling!")
-      expect(res[:status]).to eq(500)
-    end
-
-  end
-
-  describe "when processing a request" do
-    let(:response) do
-      { :status => 200 }
-    end
-
-    it "should setup a profiler when the puppet-profiling header exists" do
-      request = a_request
-      request[:headers][Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase] = "true"
-
-      p = PuppetSpec::HandlerProfiler.new
-
-      expect(Puppet::Util::Profiler).to receive(:add_profiler).with(be_a(Puppet::Util::Profiler::WallClock)).and_return(p)
-      expect(Puppet::Util::Profiler).to receive(:remove_profiler).with(p)
-
-      handler.process(request, response)
-    end
-
-    it "should not setup profiler when the profile parameter is missing" do
-      request = a_request
-      request[:params] = { }
-
-      expect(Puppet::Util::Profiler).not_to receive(:add_profiler)
-
-      handler.process(request, response)
-    end
-
-    it "should still find the correct format if content type contains charset information" do
-      request = Puppet::Network::HTTP::Request.new({ 'content-type' => "text/plain; charset=UTF-8" },
-                                                   {}, 'GET', '/', nil)
-      expect(request.formatter.name).to eq(:s)
-    end
-
-    # PUP-3272
-    # This used to be for YAML, and doing a to_yaml on an array.
-    # The result with to_json is something different, the result is a string
-    # Which seems correct. Looks like this was some kind of nesting option "yaml inside yaml" ?
-    # Removing the test
-#    it "should deserialize JSON parameters" do
-#      params = {'my_param' => [1,2,3].to_json}
-#
-#      decoded_params = handler.send(:decode_params, params)
-#
-#      decoded_params.should == {:my_param => [1,2,3]}
-#    end
-  end
-
-  describe "when resolving node" do
-    it "should use a look-up from the ip address" do
-      expect(Resolv).to receive(:getname).with("1.2.3.4").and_return("host.domain.com")
-
-      handler.resolve_node(:ip => "1.2.3.4")
-    end
-
-    it "should return the look-up result" do
-      allow(Resolv).to receive(:getname).with("1.2.3.4").and_return("host.domain.com")
-
-      expect(handler.resolve_node(:ip => "1.2.3.4")).to eq("host.domain.com")
-    end
-
-    it "should return the ip address if resolving fails" do
-      allow(Resolv).to receive(:getname).with("1.2.3.4").and_raise(RuntimeError, "no such host")
-
-      expect(handler.resolve_node(:ip => "1.2.3.4")).to eq("1.2.3.4")
-    end
-  end
-end

data/spec/unit/network/http/request_spec.rb

@@ -1,108 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/network'
-require 'puppet/network/http'
-
-describe Puppet::Network::HTTP::Request do
-  include PuppetSpec::Network
-
-  let(:json_formatter) { Puppet::Network::FormatHandler.format(:json) }
-  let(:pson_formatter) { Puppet::Network::FormatHandler.format(:pson) }
-
-  def headers
-    {
-      'accept' => 'application/json',
-      'content-type' => 'application/json'
-    }
-  end
-
-  def a_request(headers, body = "")
-    described_class.from_hash(
-      :method => "PUT",
-      :path   => "/path/to/endpoint",
-      :body   => body,
-      :headers => headers
-    )
-  end
-
-  context "when resolving the formatter for the request body" do
-    it "returns the formatter for that Content-Type" do
-      request = a_request(headers.merge("content-type" => "application/json"))
-      expect(request.formatter).to eq(json_formatter)
-    end
-
-    it "raises HTTP 400 if Content-Type is missing" do
-      request = a_request({})
-      expect {
-        request.formatter
-      }.to raise_error(bad_request_error, /No Content-Type header was received, it isn't possible to unserialize the request/)
-    end
-
-    it "raises HTTP 415 if Content-Type is unsupported" do
-      request = a_request(headers.merge('content-type' => 'application/ogg'))
-      expect {
-        request.formatter
-      }.to raise_error(unsupported_media_type_error, /Unsupported Media Type: Client sent a mime-type \(application\/ogg\) that doesn't correspond to a format we support/)
-    end
-
-    it "raises HTTP 415 if Content-Type is unsafe yaml" do
-      request = a_request(headers.merge('content-type' => 'yaml'))
-      expect {
-        request.formatter
-      }.to raise_error(unsupported_media_type_error, /Unsupported Media Type: Client sent a mime-type \(yaml\) that doesn't correspond to a format we support/)
-    end
-
-    it "raises HTTP 415 if Content-Type is unsafe b64_zlib_yaml" do
-      request = a_request(headers.merge('content-type' => 'b64_zlib_yaml'))
-      expect {
-        request.formatter
-      }.to raise_error(unsupported_media_type_error, /Unsupported Media Type: Client sent a mime-type \(b64_zlib_yaml\) that doesn't correspond to a format we support/)
-    end
-  end
-
-  context "when resolving the formatter for the response body" do
-    context "when the client doesn't specify an Accept header" do
-      it "raises HTTP 400 if the server doesn't specify a default" do
-        request = a_request({})
-        expect {
-          request.response_formatters_for([:json])
-        }.to raise_error(bad_request_error, /Missing required Accept header/)
-      end
-
-      it "uses the server default" do
-        request = a_request({})
-        expect(request.response_formatters_for([:json], 'application/json')).to eq([json_formatter])
-      end
-    end
-
-    it "returns accepted and supported formats, in the accepted order" do
-      request = a_request(headers.merge('accept' => 'application/json, application/x-msgpack, text/pson'))
-      expect(request.response_formatters_for([:pson, :json])).to eq([json_formatter, pson_formatter])
-    end
-
-    it "selects the second format if the first one isn't supported by the server" do
-      request = a_request(headers.merge('accept' => 'application/json, text/pson'))
-      expect(request.response_formatters_for([:pson])).to eq([pson_formatter])
-    end
-
-    it "raises HTTP 406 if Accept doesn't include any server-supported formats" do
-      request = a_request(headers.merge('accept' => 'application/ogg'))
-      expect {
-        request.response_formatters_for([:json])
-      }.to raise_error(not_acceptable_error, /No supported formats are acceptable \(Accept: application\/ogg\)/)
-    end
-
-    it "raises HTTP 406 if Accept resolves to unsafe yaml" do
-      request = a_request(headers.merge('accept' => 'yaml'))
-      expect {
-        request.response_formatters_for([:json])
-      }.to raise_error(not_acceptable_error, /No supported formats are acceptable \(Accept: yaml\)/)
-    end
-
-    it "raises HTTP 406 if Accept resolves to unsafe b64_zlib_yaml" do
-      request = a_request(headers.merge('accept' => 'b64_zlib_yaml'))
-      expect {
-        request.response_formatters_for([:json])
-      }.to raise_error(not_acceptable_error, /No supported formats are acceptable \(Accept: b64_zlib_yaml\)/)
-    end
-  end
-end

data/spec/unit/network/http/response_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require 'puppet_spec/handler'
-require 'puppet/network/http'
-
-describe Puppet::Network::HTTP::Response do
-  include PuppetSpec::Files
-
-  let(:handler) { PuppetSpec::Handler.new }
-  let(:response) { {} }
-  let(:subject) { described_class.new(handler, response) }
-  let(:body_utf8) { JSON.dump({ "foo" => "bar"}).encode('UTF-8') }
-  let(:body_shift_jis) { [130, 174].pack('C*').force_encoding(Encoding::Shift_JIS) }
-  let(:invalid_shift_jis) { "\xC0\xFF".force_encoding(Encoding::Shift_JIS) }
-
-  context "when passed a response body" do
-    it "passes the status code and body to the handler" do
-      expect(handler).to receive(:set_response).with(response, body_utf8, 200)
-
-      subject.respond_with(200, 'application/json', body_utf8)
-    end
-
-    it "accepts a File body" do
-      file = tmpfile('response_spec')
-      expect(handler).to receive(:set_response).with(response, file, 200)
-
-      subject.respond_with(200, 'application/octet-stream', file)
-    end
-  end
-
-  context "when passed a content type" do
-    it "accepts a mime string" do
-      expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
-
-      subject.respond_with(200, 'application/json', body_utf8)
-    end
-
-    it "accepts a format object" do
-      formatter = Puppet::Network::FormatHandler.format(:json)
-      expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
-
-      subject.respond_with(200, formatter, body_utf8)
-    end
-  end
-
-  context "when resolving charset" do
-    context "with binary content" do
-      it "omits the charset" do
-        body_binary = [0xDEADCAFE].pack('L')
-
-        formatter = Puppet::Network::FormatHandler.format(:binary)
-        expect(handler).to receive(:set_content_type).with(response, 'application/octet-stream')
-
-        subject.respond_with(200, formatter, body_binary)
-      end
-    end
-
-    context "with text/plain content" do
-      let(:formatter) { Puppet::Network::FormatHandler.format(:s) }
-
-      it "sets the charset to UTF-8 for content already in that format" do
-        body_pem = "BEGIN CERTIFICATE".encode('UTF-8')
-
-        expect(handler).to receive(:set_content_type).with(response, 'text/plain; charset=utf-8')
-
-        subject.respond_with(200, formatter, body_pem)
-      end
-
-      it "encodes the content to UTF-8 for content not already in UTF-8" do
-        expect(handler).to receive(:set_content_type).with(response, 'text/plain; charset=utf-8')
-        expect(handler).to receive(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
-
-        subject.respond_with(200, formatter, body_shift_jis)
-      end
-
-      it "raises an exception if transcoding fails" do
-        expect {
-          subject.respond_with(200, formatter, invalid_shift_jis)
-        }.to raise_error(EncodingError, /"\\xFF" on Shift_JIS/)
-      end
-    end
-
-    context "with application/json content" do
-      let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
-
-      it "sets the charset to UTF-8 for content already in that format" do
-        expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
-
-        subject.respond_with(200, formatter, body_utf8)
-      end
-
-      it "encodes the content to UTF-8 for content not already in UTF-8" do
-        expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
-        expect(handler).to receive(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
-
-        subject.respond_with(200, formatter, body_shift_jis)
-      end
-
-      it "raises an exception if transcoding fails" do
-        expect {
-          subject.respond_with(200, formatter, invalid_shift_jis)
-        }.to raise_error(EncodingError, /"\\xFF" on Shift_JIS/)
-      end
-    end
-  end
-end

data/spec/unit/network/http/route_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-require 'puppet/indirector_testing'
-
-require 'puppet/network/http'
-
-describe Puppet::Network::HTTP::Route do
-  def request(method, path)
-    Puppet::Network::HTTP::Request.from_hash({
-      :method => method,
-      :path => path,
-      :routing_path => path })
-  end
-
-  def respond(text)
-    lambda { |req, res| res.respond_with(200, "text/plain", text) }
-  end
-
-  let(:req) { request("GET", "/vtest/foo") }
-  let(:res) { Puppet::Network::HTTP::MemoryResponse.new }
-
-  describe "an HTTP Route" do
-    it "can match a request" do
-      route = Puppet::Network::HTTP::Route.path(%r{^/vtest})
-      expect(route.matches?(req)).to be_truthy
-    end
-
-    it "will raise a Method Not Allowed error when no handler for the request's method is given" do
-      route = Puppet::Network::HTTP::Route.path(%r{^/vtest}).post(respond("ignored"))
-      expect do
-        route.process(req, res)
-      end.to raise_error(Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError)
-    end
-
-    it "can match any HTTP method" do
-      route = Puppet::Network::HTTP::Route.path(%r{^/vtest/foo}).any(respond("used"))
-      expect(route.matches?(req)).to be_truthy
-
-      route.process(req, res)
-
-      expect(res.body).to eq("used")
-    end
-
-    it "processes DELETE requests" do
-      route = Puppet::Network::HTTP::Route.path(%r{^/vtest/foo}).delete(respond("used"))
-
-      route.process(request("DELETE", "/vtest/foo"), res)
-
-      expect(res.body).to eq("used")
-    end
-
-    it "does something when it doesn't know the verb" do
-      route = Puppet::Network::HTTP::Route.path(%r{^/vtest/foo})
-
-      expect do
-        route.process(request("UNKNOWN", "/vtest/foo"), res)
-      end.to raise_error(Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError, /UNKNOWN/)
-    end
-
-    it "calls the method handlers in turn" do
-      call_count = 0
-      handler = lambda { |request, response| call_count += 1 }
-      route = Puppet::Network::HTTP::Route.path(%r{^/vtest/foo}).get(handler, handler)
-
-      route.process(req, res)
-      expect(call_count).to eq(2)
-    end
-
-    it "stops calling handlers if one of them raises an error" do
-      ignored_called = false
-      ignored = lambda { |req, res| ignored_called = true }
-      raise_error = lambda { |req, res| raise Puppet::Network::HTTP::Error::HTTPNotAuthorizedError, "go away" }
-      route = Puppet::Network::HTTP::Route.path(%r{^/vtest/foo}).get(raise_error, ignored)
-
-      expect do
-        route.process(req, res)
-      end.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAuthorizedError)
-      expect(ignored_called).to be_falsey
-    end
-
-    it "chains to other routes after calling its handlers" do
-      inner_route = Puppet::Network::HTTP::Route.path(%r{^/inner}).any(respond("inner"))
-      unused_inner_route = Puppet::Network::HTTP::Route.path(%r{^/unused_inner}).any(respond("unused"))
-
-      top_route = Puppet::Network::HTTP::Route.path(%r{^/vtest}).any(respond("top")).chain(unused_inner_route, inner_route)
-      top_route.process(request("GET", "/vtest/inner"), res)
-
-      expect(res.body).to eq("topinner")
-    end
-  end
-end

data/spec/unit/network/http_pool_spec.rb

@@ -1,145 +0,0 @@
-require 'spec_helper'
-require 'puppet/network/http_pool'
-
-class Puppet::Network::HttpPool::FooClient
-  def initialize(host, port, options = {})
-    @host = host
-    @port = port
-  end
-  attr_reader :host, :port
-end
-
-describe Puppet::Network::HttpPool do
-  include PuppetSpec::Files
-
-  describe "when registering an http client class" do
-    let(:http_impl) { Puppet::Network::HttpPool::FooClient }
-
-    around :each do |example|
-      orig_class = Puppet::Network::HttpPool.http_client_class
-      begin
-        example.run
-      ensure
-        Puppet::Network::HttpPool.http_client_class = orig_class
-      end
-    end
-
-    it "returns instances of the http client class" do
-      Puppet::Network::HttpPool.http_client_class = http_impl
-      http = Puppet::Network::HttpPool.http_instance("me", 54321)
-      expect(http).to be_an_instance_of(http_impl)
-      expect(http.host).to eq('me')
-      expect(http.port).to eq(54321)
-    end
-
-    it "uses the default http client" do
-      expect(Puppet.runtime[:http]).to be_an_instance_of(Puppet::HTTP::Client)
-    end
-
-    it "switches to the external client implementation" do
-      Puppet::Network::HttpPool.http_client_class = http_impl
-
-      expect(Puppet.runtime[:http]).to be_an_instance_of(Puppet::HTTP::ExternalClient)
-    end
-
-    it "always uses an explicitly registered http implementation" do
-      Puppet::Network::HttpPool.http_client_class = http_impl
-
-      new_impl = double('new_http_impl')
-      Puppet.initialize_settings([], true, true, http: new_impl)
-
-      expect(Puppet.runtime[:http]).to eq(new_impl)
-    end
-  end
-
-  describe "when managing http instances" do
-    it "should return an http instance created with the passed host and port" do
-      http = Puppet::Network::HttpPool.http_instance("me", 54321)
-      expect(http).to be_a_kind_of Puppet::Network::HTTP::Connection
-      expect(http.address).to eq('me')
-      expect(http.port).to    eq(54321)
-    end
-
-    it "should enable ssl on the http instance by default" do
-      expect(Puppet::Network::HttpPool.http_instance("me", 54321)).to be_use_ssl
-    end
-
-    it "can set ssl using an option" do
-      expect(Puppet::Network::HttpPool.http_instance("me", 54321, false)).not_to be_use_ssl
-      expect(Puppet::Network::HttpPool.http_instance("me", 54321, true)).to be_use_ssl
-    end
-
-    context "when calling 'connection'" do
-      it 'requires an ssl_context' do
-        expect {
-          Puppet::Network::HttpPool.connection('me', 8140)
-        }.to raise_error(ArgumentError, "An ssl_context is required when connecting to 'https://me:8140'")
-      end
-
-      it 'creates a verifier from the context' do
-        ssl_context = Puppet::SSL::SSLContext.new
-        expect(
-          Puppet::Network::HttpPool.connection('me', 8140, ssl_context: ssl_context).verifier
-        ).to be_a_kind_of(Puppet::SSL::Verifier)
-      end
-
-      it 'does not use SSL when specified' do
-        expect(Puppet::Network::HttpPool.connection('me', 8140, use_ssl: false)).to_not be_use_ssl
-      end
-
-      it 'defaults to SSL' do
-        ssl_context = Puppet::SSL::SSLContext.new
-        conn = Puppet::Network::HttpPool.connection('me', 8140, ssl_context: ssl_context)
-        expect(conn).to be_use_ssl
-      end
-
-      it 'warns if an ssl_context is used for an http connection' do
-        expect(Puppet).to receive(:warning).with("An ssl_context is unnecessary when connecting to 'http://me:8140' and will be ignored")
-
-        ssl_context = Puppet::SSL::SSLContext.new
-        Puppet::Network::HttpPool.connection('me', 8140, use_ssl: false, ssl_context: ssl_context)
-      end
-    end
-
-    describe 'peer verification' do
-
-      before(:each) do
-        Puppet[:ssldir] = tmpdir('ssl')
-        Puppet.settings.use(:main)
-
-        Puppet[:certname] = 'signed'
-        File.write(Puppet[:localcacert], cert_fixture('ca.pem'))
-        File.write(Puppet[:hostcrl], crl_fixture('crl.pem'))
-        File.write(Puppet[:hostcert], cert_fixture('signed.pem'))
-        File.write(Puppet[:hostprivkey], key_fixture('signed-key.pem'))
-      end
-
-      it 'enables peer verification by default' do
-        stub_request(:get, "https://me:54321")
-
-        conn = Puppet::Network::HttpPool.http_instance("me", 54321, true)
-        expect_any_instance_of(Net::HTTP).to receive(:start) do |http|
-          expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
-        end
-
-        conn.get('/')
-      end
-
-      it 'can disable peer verification' do
-        stub_request(:get, "https://me:54321")
-
-        conn = Puppet::Network::HttpPool.http_instance("me", 54321, true, false)
-        expect_any_instance_of(Net::HTTP).to receive(:start) do |http|
-          expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
-        end
-
-        conn.get('/')
-      end
-    end
-
-    it "should not cache http instances" do
-      expect(Puppet::Network::HttpPool.http_instance("me", 54321)).
-        not_to equal(Puppet::Network::HttpPool.http_instance("me", 54321))
-    end
-  end
-end

data/spec/unit/network/uri_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-require 'puppet/network/uri'
-
-describe Puppet::Network::Uri do
-  include Puppet::Network::Uri
-  describe '.mask_credentials' do
-    let(:address_with_passwd) { 'https://admin:S3cr3T@puppetforge.acmecorp.com/' }
-    let(:masked) { 'https://admin:***@puppetforge.acmecorp.com/' }
-    let(:address) { 'https://puppetforge.acmecorp.com/' }
-
-    subject do
-      input = to_be_masked.dup
-      result = mask_credentials(input)
-      raise 'illegal unexpected modification' if input != to_be_masked
-      result
-    end
-
-    describe 'if password was given in URI' do
-      describe 'as a String' do
-        let(:to_be_masked) { address_with_passwd }
-        it 'should mask out password' do
-          is_expected.to eq(masked)
-        end
-      end
-      describe 'as an URI' do
-        let(:to_be_masked) { URI.parse(address_with_passwd) }
-        it 'should mask out password' do
-          is_expected.to eq(masked)
-        end
-      end
-    end
-    describe "if password wasn't given in URI" do
-      describe 'as a String' do
-        let(:to_be_masked) { address }
-        it "shouldn't add mask to URI" do
-          is_expected.to eq(address)
-        end
-      end
-      describe 'as an URI' do
-        let(:to_be_masked) { URI.parse(address) }
-        it "shouldn't add mask to URI" do
-          is_expected.to eq(address)
-        end
-      end
-    end
-  end
-end