puppet 7.28.0 → 7.29.1

data/spec/unit/certificate_factory_spec.rb

@@ -1,170 +0,0 @@
-require 'spec_helper'
-require 'puppet/test_ca'
-
-require 'puppet/certificate_factory'
-
-describe Puppet::CertificateFactory, :unless => RUBY_PLATFORM == 'java' do
-  let :serial    do OpenSSL::BN.new('12') end
-  let :name      do "example.local" end
-  let :x509_name do OpenSSL::X509::Name.new([['CN', name]]) end
-  let :key       do OpenSSL::PKey::RSA.new(Puppet[:keylength]) end
-  let :csr       do
-    csr = Puppet::SSL::CertificateRequest.new(name)
-    csr.generate(key)
-    csr
-  end
-  let(:issuer) { Puppet::TestCa.new.ca_cert }
-
-  describe "when generating the certificate" do
-    it "should return a new X509 certificate" do
-      a = subject.build(:server, csr, issuer, serial)
-      b = subject.build(:server, csr, issuer, serial)
-      # The two instances are equal in every aspect except that they are
-      # different instances - they are `==`, but not hash `eql?`
-      expect(a).not_to eql(b)
-    end
-
-    it "should set the certificate's version to 2" do
-      expect(subject.build(:server, csr, issuer, serial).version).to eq(2)
-    end
-
-    it "should set the certificate's subject to the CSR's subject" do
-      cert = subject.build(:server, csr, issuer, serial)
-      expect(cert.subject).to eq x509_name
-    end
-
-    it "should set the certificate's issuer to the Issuer's subject" do
-      cert = subject.build(:server, csr, issuer, serial)
-      expect(cert.issuer).to eq issuer.subject
-    end
-
-    it "should set the certificate's public key to the CSR's public key" do
-      cert = subject.build(:server, csr, issuer, serial)
-      expect(cert.public_key).to be_public
-      expect(cert.public_key.to_s).to eq(csr.content.public_key.to_s)
-    end
-
-    it "should set the certificate's serial number to the provided serial number" do
-      cert = subject.build(:server, csr, issuer, serial)
-      expect(cert.serial).to eq(serial)
-    end
-
-    it "should have 24 hours grace on the start of the cert" do
-      cert = subject.build(:server, csr, issuer, serial)
-      expect(cert.not_before).to be_within(30).of(Time.now - 24*60*60)
-    end
-
-    it "should not allow a non-integer TTL" do
-      [ 'foo', 1.2, Time.now, true ].each do |ttl|
-        expect { subject.build(:server, csr, issuer, serial, ttl) }.to raise_error(ArgumentError)
-      end
-    end
-
-    it "should respect a custom TTL for the CA" do
-      now = Time.now.utc
-      expect(Time).to receive(:now).at_least(:once).and_return(now)
-      cert = subject.build(:server, csr, issuer, serial, 12)
-      expect(cert.not_after.to_i).to eq(now.to_i + 12)
-    end
-
-    it "should adds an extension for the nsComment" do
-      cert = subject.build(:server, csr, issuer, serial)
-      expect(cert.extensions.map {|x| x.to_h }.find {|x| x["oid"] == "nsComment" }).to eq(
-        { "oid"      => "nsComment",
-          # Note that this output is due to a bug in OpenSSL::X509::Extensions
-          # where the values of some extensions are not properly decoded
-          "value"    => ".(Puppet Ruby/OpenSSL Internal Certificate",
-          "critical" => false }
-      )
-    end
-
-    it "should add an extension for the subjectKeyIdentifer" do
-      cert = subject.build(:server, csr, issuer, serial)
-      ef = OpenSSL::X509::ExtensionFactory.new(issuer, cert)
-      expect(cert.extensions.map { |x| x.to_h }.find {|x| x["oid"] == "subjectKeyIdentifier" }).to eq(
-        ef.create_extension("subjectKeyIdentifier", "hash", false).to_h
-      )
-    end
-
-    it "should add an extension for the authorityKeyIdentifer" do
-      cert = subject.build(:server, csr, issuer, serial)
-      ef = OpenSSL::X509::ExtensionFactory.new(issuer, cert)
-      expect(cert.extensions.map { |x| x.to_h }.find {|x| x["oid"] == "authorityKeyIdentifier" }).to eq(
-        ef.create_extension("authorityKeyIdentifier", "keyid:always", false).to_h
-      )
-    end
-
-    # See #2848 for why we are doing this: we need to make sure that
-    # subjectAltName is set if the CSR has it, but *not* if it is set when the
-    # certificate is built!
-    it "should not add subjectAltNames from dns_alt_names" do
-      Puppet[:dns_alt_names] = 'one, two'
-      # Verify the CSR still has no extReq, just in case...
-      expect(csr.request_extensions).to eq([])
-      cert = subject.build(:server, csr, issuer, serial)
-
-      expect(cert.extensions.find {|x| x.oid == 'subjectAltName' }).to be_nil
-    end
-
-    it "should add subjectAltName when the CSR requests them" do
-      Puppet[:dns_alt_names] = ''
-
-      expect = %w{one two} + [name]
-
-      csr = Puppet::SSL::CertificateRequest.new(name)
-      csr.generate(key, :dns_alt_names => expect.join(', '))
-
-      expect(csr.request_extensions).not_to be_nil
-      expect(csr.subject_alt_names).to match_array(expect.map{|x| "DNS:#{x}"})
-
-      cert = subject.build(:server, csr, issuer, serial)
-      san = cert.extensions.find {|x| x.oid == 'subjectAltName' }
-      expect(san).not_to be_nil
-      expect.each do |name|
-        expect(san.value).to match(/DNS:#{name}\b/i)
-      end
-    end
-
-    it "can add custom extension requests" do
-      csr = Puppet::SSL::CertificateRequest.new(name)
-      csr.generate(key)
-
-      allow(csr).to receive(:request_extensions).and_return([
-        {'oid' => '1.3.6.1.4.1.34380.1.2.1', 'value' => 'some-value'},
-        {'oid' => 'pp_uuid', 'value' => 'some-uuid'},
-      ])
-
-      cert = subject.build(:client, csr, issuer, serial)
-
-      # The cert must be signed before being later DER-decoding
-      signer = Puppet::SSL::CertificateSigner.new
-      signer.sign(cert, key)
-      wrapped_cert = Puppet::SSL::Certificate.from_instance cert
-
-      priv_ext = wrapped_cert.custom_extensions.find {|ext| ext['oid'] == '1.3.6.1.4.1.34380.1.2.1'}
-      uuid_ext = wrapped_cert.custom_extensions.find {|ext| ext['oid'] == 'pp_uuid'}
-
-      # The expected results should be DER encoded, the Puppet cert wrapper will turn
-      # these into normal strings.
-      expect(priv_ext['value']).to eq 'some-value'
-      expect(uuid_ext['value']).to eq 'some-uuid'
-    end
-
-    # Can't check the CA here, since that requires way more infrastructure
-    # that I want to build up at this time.  We can verify the critical
-    # values, though, which are non-CA certs. --daniel 2011-10-11
-    { :ca            => 'CA:TRUE',
-      :terminalsubca => ['CA:TRUE', 'pathlen:0'],
-      :server        => 'CA:FALSE',
-      :ocsp          => 'CA:FALSE',
-      :client        => 'CA:FALSE',
-    }.each do |name, value|
-      it "should set basicConstraints for #{name} #{value.inspect}" do
-        cert = subject.build(name, csr, issuer, serial)
-        bc = cert.extensions.find {|x| x.oid == 'basicConstraints' }
-        expect(bc).to be
-        expect(bc.value.split(/\s*,\s*/)).to match_array(Array(value))
-      end
-    end
-  end
-end

data/spec/unit/concurrent/lock_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-require 'puppet/concurrent/lock'
-
-describe Puppet::Concurrent::Lock do
-  if Puppet::Util::Platform.jruby?
-    context 'on jruby' do
-      it 'synchronizes a block on itself' do
-        iterations = 100
-        value = 0
-
-        lock = Puppet::Concurrent::Lock.new
-        threads = iterations.times.collect do
-          Thread.new do
-            lock.synchronize do
-              tmp = (value += 1)
-              sleep(0.001)
-              # This update using tmp is designed to lose increments if threads overlap
-              value = tmp + 1
-            end
-          end
-        end
-        threads.each(&:join)
-
-        # In my testing this always fails by quite a lot when not synchronized (ie on mri)
-        expect(value).to eq(iterations * 2)
-      end
-    end
-  end
-end

data/spec/unit/concurrent/thread_local_singleton_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-require 'puppet/concurrent/thread_local_singleton'
-
-class PuppetSpec::Singleton
-  extend Puppet::Concurrent::ThreadLocalSingleton
-end
-
-# Use the `equal?` matcher to ensure we get the same object
-describe Puppet::Concurrent::ThreadLocalSingleton do
-  it 'returns the same object for a single thread' do
-    expect(PuppetSpec::Singleton.singleton).to equal(PuppetSpec::Singleton.singleton)
-  end
-
-  it 'is not inherited for a newly created thread' do
-    main_thread_local = PuppetSpec::Singleton.singleton
-    Thread.new do
-      expect(main_thread_local).to_not equal(PuppetSpec::Singleton.singleton)
-    end.join
-  end
-
-  it 'does not leak outside a thread' do
-    thread_local = nil
-    Thread.new do
-      thread_local = PuppetSpec::Singleton.singleton
-    end.join
-    expect(thread_local).to_not equal(PuppetSpec::Singleton.singleton)
-  end
-
-  it 'is different for each thread' do
-    locals = []
-    Thread.new do
-      locals << PuppetSpec::Singleton.singleton
-    end.join
-    Thread.new do
-      locals << PuppetSpec::Singleton.singleton
-    end.join
-    expect(locals.first).to_not equal(locals.last)
-  end
-end

data/spec/unit/configurer/downloader_spec.rb

@@ -1,252 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/configurer/downloader'
-
-describe Puppet::Configurer::Downloader do
-  require 'puppet_spec/files'
-  include PuppetSpec::Files
-
-  let(:path)   { Puppet[:plugindest] }
-  let(:source) { 'puppet://puppet/plugins' }
-
-  it "should require a name" do
-    expect { Puppet::Configurer::Downloader.new }.to raise_error(ArgumentError)
-  end
-
-  it "should require a path and a source at initialization" do
-    expect { Puppet::Configurer::Downloader.new("name") }.to raise_error(ArgumentError)
-  end
-
-  it "should set the name, path and source appropriately" do
-    dler = Puppet::Configurer::Downloader.new("facts", "path", "source")
-    expect(dler.name).to eq("facts")
-    expect(dler.path).to eq("path")
-    expect(dler.source).to eq("source")
-  end
-
-  def downloader(options = {})
-    options[:name] ||= "facts"
-    options[:path] ||= path
-    options[:source_permissions] ||= :ignore
-    Puppet::Configurer::Downloader.new(options[:name], options[:path], source, options[:ignore], options[:environment], options[:source_permissions])
-  end
-
-  def generate_file_resource(options = {})
-    dler = downloader(options)
-    dler.file
-  end
-
-  describe "when creating the file that does the downloading" do
-    it "should create a file instance with the right path and source" do
-      file = generate_file_resource(:path => path, :source => source)
-
-      expect(file[:path]).to eq(path)
-      expect(file[:source]).to eq([source])
-    end
-
-    it "should tag the file with the downloader name" do
-      name = "mydownloader"
-      file = generate_file_resource(:name => name)
-
-      expect(file[:tag]).to eq([name])
-    end
-
-    it "should always recurse" do
-      file = generate_file_resource
-
-      expect(file[:recurse]).to be_truthy
-    end
-
-    it "should follow links by default" do
-      file = generate_file_resource
-
-      expect(file[:links]).to eq(:follow)
-    end
-
-    it "should always purge" do
-      file = generate_file_resource
-
-      expect(file[:purge]).to be_truthy
-    end
-
-    it "should never be in noop" do
-      file = generate_file_resource
-
-      expect(file[:noop]).to be_falsey
-    end
-
-    it "should set source_permissions to ignore by default" do
-      file = generate_file_resource
-
-      expect(file[:source_permissions]).to eq(:ignore)
-    end
-
-    it "should ignore the max file limit" do
-      file = generate_file_resource
-
-      expect(file[:max_files]).to eq(-1)
-    end
-
-    describe "on POSIX", :if => Puppet.features.posix? do
-      it "should allow source_permissions to be overridden" do
-        file = generate_file_resource(:source_permissions => :use)
-
-        expect(file[:source_permissions]).to eq(:use)
-      end
-
-      it "should always set the owner to the current UID" do
-        expect(Process).to receive(:uid).and_return(51)
-
-        file = generate_file_resource(:path => '/path')
-        expect(file[:owner]).to eq(51)
-      end
-
-      it "should always set the group to the current GID" do
-        expect(Process).to receive(:gid).and_return(61)
-
-        file = generate_file_resource(:path => '/path')
-        expect(file[:group]).to eq(61)
-      end
-    end
-
-    describe "on Windows", :if => Puppet::Util::Platform.windows? do
-      it "should omit the owner" do
-        file = generate_file_resource(:path => 'C:/path')
-
-        expect(file[:owner]).to be_nil
-      end
-
-      it "should omit the group" do
-        file = generate_file_resource(:path => 'C:/path')
-
-        expect(file[:group]).to be_nil
-      end
-    end
-
-    it "should always force the download" do
-      file = generate_file_resource
-
-      expect(file[:force]).to be_truthy
-    end
-
-    it "should never back up when downloading" do
-      file = generate_file_resource
-
-      expect(file[:backup]).to be_falsey
-    end
-
-    it "should support providing an 'ignore' parameter" do
-      file = generate_file_resource(:ignore => '.svn')
-
-      expect(file[:ignore]).to eq(['.svn'])
-    end
-
-    it "should split the 'ignore' parameter on whitespace" do
-      file = generate_file_resource(:ignore => '.svn CVS')
-
-      expect(file[:ignore]).to eq(['.svn', 'CVS'])
-    end
-  end
-
-  describe "when creating the catalog to do the downloading" do
-    before do
-      @path = make_absolute("/download/path")
-      @dler = Puppet::Configurer::Downloader.new("foo", @path, make_absolute("source"))
-    end
-
-    it "should create a catalog and add the file to it" do
-      catalog = @dler.catalog
-      expect(catalog.resources.size).to eq(1)
-      expect(catalog.resources.first.class).to eq(Puppet::Type::File)
-      expect(catalog.resources.first.name).to eq(@path)
-    end
-
-    it "should specify that it is not managing a host catalog" do
-      expect(@dler.catalog.host_config).to eq(false)
-    end
-
-    it "should not issue a deprecation warning for source_permissions" do
-      expect(Puppet).not_to receive(:puppet_deprecation_warning)
-      catalog = @dler.catalog
-      expect(catalog.resources.size).to eq(1) # Must consume catalog to fix warnings
-    end
-  end
-
-  describe "when downloading" do
-    before do
-      @dl_name = tmpfile("downloadpath")
-      source_name = tmpfile("source")
-      File.open(source_name, 'w') {|f| f.write('hola mundo') }
-      env = Puppet::Node::Environment.remote('foo')
-      @dler = Puppet::Configurer::Downloader.new("foo", @dl_name, source_name, Puppet[:pluginsignore], env)
-    end
-
-    it "should not skip downloaded resources when filtering on tags" do
-      Puppet[:tags] = 'maytag'
-      @dler.evaluate
-
-      expect(Puppet::FileSystem.exist?(@dl_name)).to be_truthy
-    end
-
-    it "should log that it is downloading" do
-      expect(Puppet).to receive(:info)
-
-      @dler.evaluate
-    end
-
-    it "should return all changed file paths" do
-      Puppet[:ignore_plugin_errors] = true
-
-      trans = double('transaction')
-
-      catalog = double('catalog')
-      expect(@dler).to receive(:catalog).and_return(catalog)
-      expect(catalog).to receive(:apply).and_yield(trans)
-
-      resource = double('resource')
-      expect(resource).to receive(:[]).with(:path).and_return("/changed/file")
-
-      expect(trans).to receive(:changed?).and_return([resource])
-
-      expect(@dler.evaluate).to eq(%w{/changed/file})
-    end
-
-    it "should yield the resources if a block is given" do
-      Puppet[:ignore_plugin_errors] = true
-
-      trans = double('transaction')
-
-      catalog = double('catalog')
-      expect(@dler).to receive(:catalog).and_return(catalog)
-      expect(catalog).to receive(:apply).and_yield(trans)
-
-      resource = double('resource')
-      expect(resource).to receive(:[]).with(:path).and_return("/changed/file")
-
-      expect(trans).to receive(:changed?).and_return([resource])
-
-      yielded = nil
-      @dler.evaluate { |r| yielded = r }
-      expect(yielded).to eq(resource)
-    end
-
-    it "should catch and log exceptions" do
-      Puppet[:ignore_plugin_errors] = true
-
-      expect(Puppet).to receive(:log_exception)
-      # The downloader creates a new catalog for each apply, and really the only object
-      # that it is possible to stub for the purpose of generating a puppet error
-      allow_any_instance_of(Puppet::Resource::Catalog).to receive(:apply).and_raise(Puppet::Error, "testing")
-
-      expect { @dler.evaluate }.not_to raise_error
-    end
-
-    it "raises an exception if catalog application fails" do
-      expect(@dler.file).to receive(:retrieve).and_raise(Puppet::Error, "testing")
-
-      expect {
-        @dler.evaluate
-      }.to raise_error(Puppet::Error, /testing/)
-    end
-  end
-end

data/spec/unit/configurer/fact_handler_spec.rb

@@ -1,147 +0,0 @@
-require 'spec_helper'
-require 'puppet/configurer'
-require 'puppet/configurer/fact_handler'
-require 'matchers/json'
-
-class FactHandlerTester
-  include Puppet::Configurer::FactHandler
-
-  attr_accessor :environment
-
-  def initialize(environment)
-    self.environment = environment
-  end
-
-  def reload_facter
-    # don't want to do this in tests
-  end
-end
-
-describe Puppet::Configurer::FactHandler do
-  include JSONMatchers
-
-  let(:facthandler) { FactHandlerTester.new('production') }
-
-  describe "when finding facts" do
-    it "should use the node name value to retrieve the facts" do
-      foo_facts = Puppet::Node::Facts.new('foo')
-      bar_facts = Puppet::Node::Facts.new('bar')
-      Puppet::Node::Facts.indirection.save(foo_facts)
-      Puppet::Node::Facts.indirection.save(bar_facts)
-      Puppet[:certname] = 'foo'
-      Puppet[:node_name_value] = 'bar'
-
-      expect(facthandler.find_facts).to eq(bar_facts)
-    end
-
-    it "should set the facts name based on the node_name_fact" do
-      facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
-      Puppet::Node::Facts.indirection.save(facts)
-      Puppet[:node_name_fact] = 'my_name_fact'
-
-      expect(facthandler.find_facts.name).to eq('other_node_name')
-    end
-
-    it "should set the node_name_value based on the node_name_fact" do
-      facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
-      Puppet::Node::Facts.indirection.save(facts)
-      Puppet[:node_name_fact] = 'my_name_fact'
-
-      facthandler.find_facts
-
-      expect(Puppet[:node_name_value]).to eq('other_node_name')
-    end
-
-    it "should fail if finding facts fails" do
-      expect(Puppet::Node::Facts.indirection).to receive(:find).and_raise(RuntimeError)
-
-      expect { facthandler.find_facts }.to raise_error(Puppet::Error, /Could not retrieve local facts/)
-    end
-
-    it "should only load fact plugins once" do
-      expect(Puppet::Node::Facts.indirection).to receive(:find).once
-      facthandler.find_facts
-    end
-  end
-
-  context "when serializing" do
-    facts_with_special_characters = [
-      { :hash => { 'afact' => 'a+b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%2Bb' + '%22%7D' },
-      { :hash => { 'afact' => 'a b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%20b' + '%22%7D' },
-      { :hash => { 'afact' => 'a&b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%26b' + '%22%7D' },
-      { :hash => { 'afact' => 'a*b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%2Ab' + '%22%7D' },
-      { :hash => { 'afact' => 'a=b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%3Db' + '%22%7D' },
-      # different UTF-8 widths
-      # 1-byte A
-      # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
-      # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
-      # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
-      { :hash => { 'afact' => "A\u06FF\u16A0\u{2070E}" }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'A%DB%BF%E1%9A%A0%F0%A0%9C%8E' + '%22%7D' },
-    ]
-
-    context "as pson" do
-      before :each do
-        Puppet[:preferred_serialization_format] = 'pson'
-      end
-
-      it "should serialize and CGI escape the fact values for uploading" do
-        facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
-        Puppet::Node::Facts.indirection.save(facts)
-        text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:pson))
-
-        expect(text).to include('%22values%22%3A%7B%22my_name_fact%22%3A%22other_node_name%22%7D')
-        expect(facthandler.facts_for_uploading).to eq({:facts_format => :pson, :facts => text})
-      end
-
-      facts_with_special_characters.each do |test_fact|
-        it "should properly accept the fact #{test_fact[:hash]}" do
-          facts = Puppet::Node::Facts.new(Puppet[:node_name_value], test_fact[:hash])
-          Puppet::Node::Facts.indirection.save(facts)
-          text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:pson))
-
-          to_upload = facthandler.facts_for_uploading
-          expect(to_upload).to eq({:facts_format => :pson, :facts => text})
-          expect(text).to include(test_fact[:encoded])
-
-          # this is not sufficient to test whether these values are sent via HTTP GET or HTTP POST in actual catalog request
-          expect(JSON.parse(Puppet::Util.uri_unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
-        end
-      end
-    end
-
-    context "as json" do
-      it "should serialize and CGI escape the fact values for uploading" do
-        facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
-        Puppet::Node::Facts.indirection.save(facts)
-        text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:json))
-
-        expect(text).to include('%22values%22%3A%7B%22my_name_fact%22%3A%22other_node_name%22%7D')
-        expect(facthandler.facts_for_uploading).to eq({:facts_format => 'application/json', :facts => text})
-      end
-
-      facts_with_special_characters.each do |test_fact|
-        it "should properly accept the fact #{test_fact[:hash]}" do
-          facts = Puppet::Node::Facts.new(Puppet[:node_name_value], test_fact[:hash])
-          Puppet::Node::Facts.indirection.save(facts)
-          text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:json))
-
-          to_upload = facthandler.facts_for_uploading
-          expect(to_upload).to eq({:facts_format => 'application/json', :facts => text})
-          expect(text).to include(test_fact[:encoded])
-
-          expect(JSON.parse(Puppet::Util.uri_unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
-        end
-      end
-    end
-
-    it "should generate valid facts data against the facts schema" do
-      facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
-      Puppet::Node::Facts.indirection.save(facts)
-
-      # prefer Puppet::Util.uri_unescape but validate CGI also works
-      encoded_facts = facthandler.facts_for_uploading[:facts]
-      expect(Puppet::Util.uri_unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
-      expect(CGI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
-    end
-  end
-end