puppet 7.11.0-universal-darwin → 7.14.0-universal-darwin

data/spec/unit/resource_spec.rb

@@ -638,19 +638,68 @@ describe Puppet::Resource do
     it "should use the resource type's :new method to create the resource if the resource is of a builtin type" do
       resource = Puppet::Resource.new("file", basepath+"/my/file")
       result = resource.to_ral
+
       expect(result).to be_instance_of(Puppet::Type.type(:file))
       expect(result[:path]).to eq(basepath+"/my/file")
     end
 
-    it "should convert to a component instance if the resource type is not of a builtin type" do
+    it "should convert to a component instance if the resource is not a compilable_type" do
       resource = Puppet::Resource.new("foobar", "somename")
       result = resource.to_ral
 
       expect(result).to be_instance_of(Puppet::Type.type(:component))
       expect(result.title).to eq("Foobar[somename]")
     end
-  end
 
+    it "should convert to a component instance if the resource is a class" do
+      resource = Puppet::Resource.new("Class", "somename")
+      result = resource.to_ral
+
+      expect(result).to be_instance_of(Puppet::Type.type(:component))
+      expect(result.title).to eq("Class[Somename]")
+    end
+
+    it "should convert to component when the resource is a defined_type" do
+      resource = Puppet::Resource.new("Unknown", "type", :kind => 'defined_type')
+
+      result = resource.to_ral
+      expect(result).to be_instance_of(Puppet::Type.type(:component))
+    end
+
+    it "should raise if a resource type is a compilable_type and it wasn't found" do
+      resource = Puppet::Resource.new("Unknown", "type", :kind => 'compilable_type')
+
+      expect { resource.to_ral }.to raise_error(Puppet::Error, "Resource type 'Unknown' was not found")
+    end
+
+    it "should use the old behaviour when the catalog_format is equal to 1" do
+      resource = Puppet::Resource.new("Unknown", "type")
+      catalog = Puppet::Resource::Catalog.new("mynode")
+
+      resource.catalog = catalog
+      resource.catalog.catalog_format = 1
+
+      result = resource.to_ral
+      expect(result).to be_instance_of(Puppet::Type.type(:component))
+    end
+
+    it "should use the new behaviour and fail when the catalog_format is greater than 1" do
+      resource = Puppet::Resource.new("Unknown", "type", :kind => 'compilable_type')
+      catalog = Puppet::Resource::Catalog.new("mynode")
+
+      resource.catalog = catalog
+      resource.catalog.catalog_format = 2
+
+      expect { resource.to_ral }.to raise_error(Puppet::Error, "Resource type 'Unknown' was not found")
+    end
+
+    it "should use the resource type when the resource doesn't respond to kind and the resource type can be found" do
+      resource = Puppet::Resource.new("file", basepath+"/my/file")
+
+      result = resource.to_ral
+      expect(result).to be_instance_of(Puppet::Type.type(:file))
+    end
+  end
   describe "when converting to puppet code" do
     before do
       @resource = Puppet::Resource.new("one::two", "/my/file",
@@ -766,6 +815,13 @@ describe Puppet::Resource do
       expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).line).to eq(50)
     end
 
+    it "should include the kind if one is set" do
+      resource = Puppet::Resource.new("File", "/foo")
+      resource.kind = 'im_a_file'
+
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).kind).to eq('im_a_file')
+    end
+
     it "should include the 'exported' value if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.exported = true

data/spec/unit/transaction/persistence_spec.rb

@@ -138,6 +138,57 @@ describe Puppet::Transaction::Persistence do
         persistence = Puppet::Transaction::Persistence.new
         expect(persistence.load.dig("File[/tmp/audit]", "parameters", "mtime", "system_value")).to contain_exactly(be_a(Time))
       end
+
+      it 'should load Regexp' do
+        write_state_file(<<~END)
+          system_value:
+            - !ruby/regexp /regexp/
+        END
+
+        persistence = Puppet::Transaction::Persistence.new
+        expect(persistence.load.dig("system_value")).to contain_exactly(be_a(Regexp))
+      end
+
+      it 'should load semantic puppet version' do
+        write_state_file(<<~END)
+          system_value:
+            - !ruby/object:SemanticPuppet::Version
+              major: 1
+              minor: 0
+              patch: 0
+              prerelease: 
+              build: 
+        END
+
+        persistence = Puppet::Transaction::Persistence.new
+        expect(persistence.load.dig("system_value")).to contain_exactly(be_a(SemanticPuppet::Version))
+      end
+
+      it 'should load puppet time related objects' do
+        write_state_file(<<~END)
+          system_value:
+            - !ruby/object:Puppet::Pops::Time::Timestamp
+              nsecs: 1638316135955087259
+            - !ruby/object:Puppet::Pops::Time::TimeData
+              nsecs: 1495789430910161286
+            - !ruby/object:Puppet::Pops::Time::Timespan
+              nsecs: 1495789430910161286
+        END
+
+        persistence = Puppet::Transaction::Persistence.new
+        expect(persistence.load.dig("system_value")).to contain_exactly(be_a(Puppet::Pops::Time::Timestamp), be_a(Puppet::Pops::Time::TimeData), be_a(Puppet::Pops::Time::Timespan))
+      end
+
+      it 'should load binary objects' do
+        write_state_file(<<~END)
+          system_value:
+            - !ruby/object:Puppet::Pops::Types::PBinaryType::Binary
+              binary_buffer: ''
+        END
+
+        persistence = Puppet::Transaction::Persistence.new
+        expect(persistence.load.dig("system_value")).to contain_exactly(be_a(Puppet::Pops::Types::PBinaryType::Binary))
+      end
     end
   end
 

data/spec/unit/type/file/group_spec.rb

@@ -27,6 +27,13 @@ describe Puppet::Type.type(:file).attrclass(:group) do
       expect { group.insync?(5) }.to raise_error(/Could not find group foos/)
     end
 
+    it "should return false if a group's id can't be found by name in noop" do
+      Puppet[:noop] = true
+      allow(resource.provider).to receive(:name2gid).and_return(nil)
+
+      expect(group.insync?('notcreatedyet')).to eq(false)
+    end
+
     it "should use the id for comparisons, not the name" do
       expect(group.insync?('foos')).to be_falsey
     end

data/spec/unit/type/file/owner_spec.rb

@@ -25,6 +25,13 @@ describe Puppet::Type.type(:file).attrclass(:owner) do
       expect { owner.insync?(5) }.to raise_error(/Could not find user foo/)
     end
 
+    it "should return false if an owner's id can't be found by name in noop" do
+      Puppet[:noop] = true
+      allow(resource.provider).to receive(:name2uid).and_return(nil)
+
+      expect(owner.insync?('notcreatedyet')).to eq(false)
+    end
+
     it "should use the id for comparisons, not the name" do
       expect(owner.insync?('foo')).to be_falsey
     end

data/spec/unit/type/service_spec.rb

@@ -158,6 +158,33 @@ describe test_title, "when validating attribute values" do
         expect(srv[:timeout]).to eq(int)
       end
     end
+
+    it "should default :timeout to 10 when provider has no default value" do
+      srv = Puppet::Type.type(:service).new(:name => "yay")
+      expect(srv[:timeout]).to eq(10)
+    end
+
+    it "should default :timeout to provider given default time when it has one" do
+      provider_class_with_timeout = Puppet::Type.type(:service).provide(:simple) do
+        has_features :configurable_timeout
+        def default_timeout
+          30
+        end
+      end
+      allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class_with_timeout)
+
+      srv = Puppet::Type.type(:service).new(:name => "yay")
+      expect(srv[:timeout]).to eq(30)
+    end
+
+    it "should accept string as value" do
+      srv = Puppet::Type.type(:service).new(:name => "yay", :timeout => "25")
+      expect(srv[:timeout]).to eq(25)
+    end
+
+    it "should not support values that cannot be converted to Integer such as Array" do
+      expect { Puppet::Type.type(:service).new(:name => "yay", :timeout => [25]) }.to raise_error(Puppet::Error)
+    end
   end
 
   describe "the service logon credentials" do 

data/spec/unit/type/user_spec.rb

@@ -174,51 +174,6 @@ describe Puppet::Type.type(:user) do
     end
   end
 
-  describe "when managing the purge_ssh_keys property" do
-    context "with valid input" do
-      it "should support a :true value" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => :true) }.to_not raise_error
-      end
-
-      it "should support a :false value" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => :false) }.to_not raise_error
-      end
-
-      it "should support a String value" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => File.expand_path('home/foo/.ssh/authorized_keys')) }.to_not raise_error
-      end
-
-      it "should support an Array value" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => [File.expand_path('home/foo/.ssh/authorized_keys'),
-          File.expand_path('custom/authorized_keys')]) }.to_not raise_error
-      end
-    end
-
-    context "with faulty input" do
-      it "should raise error for relative path" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => 'home/foo/.ssh/authorized_keys') }.to raise_error(Puppet::ResourceError,
-          /Paths to keyfiles must be absolute/ )
-      end
-
-      it "should raise error for invalid type" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => :invalid) }.to raise_error(Puppet::ResourceError,
-          /purge_ssh_keys must be true, false, or an array of file names/ )
-      end
-
-      it "should raise error for array with relative path" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => ['home/foo/.ssh/authorized_keys',
-          File.expand_path('custom/authorized_keys')]) }.to raise_error(Puppet::ResourceError,
-          /Paths to keyfiles must be absolute/ )
-      end
-
-      it "should raise error for array with invalid type" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => [:invalid,
-          File.expand_path('custom/authorized_keys')]) }.to raise_error(Puppet::ResourceError,
-          /Each entry for purge_ssh_keys must be a string/ )
-      end
-    end
-  end
-
   describe "when managing the uid property" do
     it "should convert number-looking strings into actual numbers" do
       expect(described_class.new(:name => 'foo', :uid => '50')[:uid]).to eq(50)
@@ -334,6 +289,73 @@ describe Puppet::Type.type(:user) do
     end
   end
 
+  describe "when managing the purge_ssh_keys property" do
+    context "with valid input" do
+      ['true', :true, true].each do |input|
+        it "should support #{input} as value" do
+          expect { described_class.new(:name => 'foo', :purge_ssh_keys => input) }.to_not raise_error
+        end
+      end
+
+      ['false', :false, false].each do |input|
+        it "should support #{input} as value" do
+          expect { described_class.new(:name => 'foo', :purge_ssh_keys => input) }.to_not raise_error
+        end
+      end
+
+      it "should support a String value" do
+        expect { described_class.new(:name => 'foo', :purge_ssh_keys => File.expand_path('home/foo/.ssh/authorized_keys')) }.to_not raise_error
+      end
+
+      it "should support an Array value" do
+        expect { described_class.new(:name => 'foo', :purge_ssh_keys => [File.expand_path('home/foo/.ssh/authorized_keys'),
+          File.expand_path('custom/authorized_keys')]) }.to_not raise_error
+      end
+    end
+
+    context "with faulty input" do
+      it "should raise error for relative path" do
+        expect { described_class.new(:name => 'foo', :purge_ssh_keys => 'home/foo/.ssh/authorized_keys') }.to raise_error(Puppet::ResourceError,
+          /Paths to keyfiles must be absolute/ )
+      end
+
+      it "should raise error for invalid type" do
+        expect { described_class.new(:name => 'foo', :purge_ssh_keys => :invalid) }.to raise_error(Puppet::ResourceError,
+          /purge_ssh_keys must be true, false, or an array of file names/ )
+      end
+
+      it "should raise error for array with relative path" do
+        expect { described_class.new(:name => 'foo', :purge_ssh_keys => ['home/foo/.ssh/authorized_keys',
+          File.expand_path('custom/authorized_keys')]) }.to raise_error(Puppet::ResourceError,
+          /Paths to keyfiles must be absolute/ )
+      end
+
+      it "should raise error for array with invalid type" do
+        expect { described_class.new(:name => 'foo', :purge_ssh_keys => [:invalid,
+          File.expand_path('custom/authorized_keys')]) }.to raise_error(Puppet::ResourceError,
+          /Each entry for purge_ssh_keys must be a string/ )
+      end
+    end
+
+    context "homedir retrieval" do
+      it "should accept the home provided" do
+        expect(Puppet).not_to receive(:debug).with("User 'foo' does not exist")
+        described_class.new(:name => 'foo', :purge_ssh_keys => true, :home => '/my_home')
+      end
+
+      it "should accept the home provided" do
+        expect(Dir).to receive(:home).with('foo').and_return('/my_home')
+        expect(Puppet).not_to receive(:debug).with("User 'foo' does not exist")
+        described_class.new(:name => 'foo', :purge_ssh_keys => true)
+      end
+
+      it "should output debug message when home directory cannot be retrieved" do
+        allow(Dir).to receive(:home).with('foo').and_raise(ArgumentError)
+        expect(Puppet).to receive(:debug).with("User 'foo' does not exist")
+        described_class.new(:name => 'foo', :purge_ssh_keys => true)
+      end
+    end
+  end
 
   describe "when managing expiry" do
     it "should fail if given an invalid date" do

data/spec/unit/util/autoload_spec.rb

@@ -178,15 +178,14 @@ describe Puppet::Util::Autoload do
   end
 
   describe "when loading all files" do
+    let(:basedir) { tmpdir('autoloader') }
+    let(:path) { File.join(basedir, @autoload.path, 'file.rb') }
+
     before do
-      allow(@autoload.class).to receive(:search_directories).and_return([make_absolute("/a")])
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(Dir).to receive(:glob).and_return([make_absolute("/a/foo/file.rb")])
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      @time_a = Time.utc(2010, 'jan', 1, 6, 30)
-      allow(File).to receive(:mtime).and_return(@time_a)
+      FileUtils.mkdir_p(File.dirname(path))
+      FileUtils.touch(path)
 
-      allow(@autoload.class).to receive(:loaded?).and_return(false)
+      allow(@autoload.class).to receive(:search_directories).and_return([basedir])
     end
 
     [RuntimeError, LoadError, SyntaxError].each do |error|
@@ -198,7 +197,25 @@ describe Puppet::Util::Autoload do
     end
 
     it "should require the full path to the file" do
-      expect(Kernel).to receive(:load).with(make_absolute("/a/foo/file.rb"), any_args)
+      expect(Kernel).to receive(:load).with(path, any_args)
+
+      @autoload.loadall(env)
+    end
+
+    it "autoloads from a directory whose ancestor is Windows 8.3", if: Puppet::Util::Platform.windows? do
+      # File.expand_path will expand ~ in the last directory component only(!)
+      # so create an ancestor directory with a long path
+      dir = File.join(tmpdir('longpath'), 'short')
+      path = File.join(dir, @autoload.path, 'file.rb')
+
+      FileUtils.mkdir_p(File.dirname(path))
+      FileUtils.touch(path)
+
+      dir83 = File.join(File.dirname(basedir), 'longpa~1', 'short')
+      path83 = File.join(dir83, @autoload.path, 'file.rb')
+
+      allow(@autoload.class).to receive(:search_directories).and_return([dir83])
+      expect(Kernel).to receive(:load).with(path83, any_args)
 
       @autoload.loadall(env)
     end

data/spec/unit/util/json_spec.rb

@@ -0,0 +1,126 @@
+# coding: utf-8
+require 'spec_helper'
+require 'puppet/util/json'
+
+describe Puppet::Util::Json do
+  include PuppetSpec::Files
+
+  shared_examples_for 'json file loader' do |load_method|
+    it 'reads a JSON file from disk' do
+      file_path = file_containing('input', JSON.dump({ "my" => "data" }))
+
+      expect(load_method.call(file_path)).to eq({ "my" => "data" })
+    end
+
+    it 'reads JSON as UTF-8' do
+      file_path = file_containing('input', JSON.dump({ "my" => "𠜎" }))
+
+      expect(load_method.call(file_path)).to eq({ "my" => "𠜎" })
+    end
+  end
+
+  context "#load" do
+    it 'raises an error if JSON is invalid' do
+      expect {
+        Puppet::Util::Json.load('{ invalid')
+      }.to raise_error(Puppet::Util::Json::ParseError, /unexpected token at '{ invalid'/)
+    end
+
+    it 'raises an error if the content is empty' do
+      expect {
+        Puppet::Util::Json.load('')
+      }.to raise_error(Puppet::Util::Json::ParseError)
+    end
+
+    it 'loads true' do
+      expect(Puppet::Util::Json.load('true')).to eq(true)
+    end
+
+    it 'loads false' do
+      expect(Puppet::Util::Json.load('false')).to eq(false)
+    end
+
+    it 'loads a numeric' do
+      expect(Puppet::Util::Json.load('42')).to eq(42)
+    end
+
+    it 'loads a string' do
+      expect(Puppet::Util::Json.load('"puppet"')).to eq('puppet')
+    end
+
+    it 'loads an array' do
+      expect(Puppet::Util::Json.load(<<~JSON)).to eq([1, 2])
+        [1, 2]
+      JSON
+    end
+
+    it 'loads a hash' do
+      expect(Puppet::Util::Json.load(<<~JSON)).to eq('a' => 1, 'b' => 2)
+        {
+          "a": 1,
+          "b": 2
+        }
+      JSON
+    end
+  end
+
+  context "load_file_if_valid" do
+    before do
+      Puppet[:log_level] = 'debug'
+    end
+
+    it_should_behave_like 'json file loader', Puppet::Util::Json.method(:load_file_if_valid)
+
+    it 'returns nil when the file is invalid JSON and debug logs about it' do
+      file_path = file_containing('input', '{ invalid')
+      expect(Puppet).to receive(:debug)
+        .with(/Could not retrieve JSON content .+: unexpected token at '{ invalid'/).and_call_original
+
+      expect(Puppet::Util::Json.load_file_if_valid(file_path)).to eql(nil)
+    end
+
+    it 'returns nil when the filename is illegal and debug logs about it' do
+      expect(Puppet).to receive(:debug)
+        .with(/Could not retrieve JSON content .+: pathname contains null byte/).and_call_original
+
+      expect(Puppet::Util::Json.load_file_if_valid("not\0allowed")).to eql(nil)
+    end
+
+    it 'returns nil when the file does not exist and debug logs about it' do
+      expect(Puppet).to receive(:debug)
+        .with(/Could not retrieve JSON content .+: No such file or directory/).and_call_original
+
+      expect(Puppet::Util::Json.load_file_if_valid('does/not/exist.json')).to eql(nil)
+    end
+  end
+
+  context '#load_file' do
+    it_should_behave_like 'json file loader', Puppet::Util::Json.method(:load_file)
+
+    it 'raises an error when the file is invalid JSON' do
+      file_path = file_containing('input', '{ invalid')
+
+      expect {
+        Puppet::Util::Json.load_file(file_path)
+      }.to raise_error(Puppet::Util::Json::ParseError, /unexpected token at '{ invalid'/)
+    end
+
+    it 'raises an error when the filename is illegal' do
+      expect {
+        Puppet::Util::Json.load_file("not\0allowed")
+      }.to raise_error(ArgumentError, /null byte/)
+    end
+
+    it 'raises an error when the file does not exist' do
+      expect {
+        Puppet::Util::Json.load_file('does/not/exist.json')
+      }.to raise_error(Errno::ENOENT, /No such file or directory/)
+    end
+
+    it 'writes data formatted as JSON to disk' do
+      file_path = file_containing('input', Puppet::Util::Json.dump({ "my" => "data" }))
+
+      expect(Puppet::Util::Json.load_file(file_path)).to eq({ "my" => "data" })
+    end
+  end
+end

data/spec/unit/util/yaml_spec.rb

@@ -1,6 +1,5 @@
 # coding: utf-8
 require 'spec_helper'
-
 require 'puppet/util/yaml'
 
 describe Puppet::Util::Yaml do
@@ -10,21 +9,21 @@ describe Puppet::Util::Yaml do
 
   shared_examples_for 'yaml file loader' do |load_method|
     it 'returns false when the file is empty' do
-      Puppet::FileSystem.touch(filename)
+      file_path = file_containing('input', '')
 
-      expect(load_method.call(filename)).to eq(false)
+      expect(load_method.call(file_path)).to eq(false)
     end
 
     it 'reads a YAML file from disk' do
-      write_file(filename, YAML.dump({ "my" => "data" }))
+      file_path = file_containing('input', YAML.dump({ "my" => "data" }))
 
-      expect(load_method.call(filename)).to eq({ "my" => "data" })
+      expect(load_method.call(file_path)).to eq({ "my" => "data" })
     end
 
     it 'reads YAML as UTF-8' do
-      write_file(filename, YAML.dump({ "my" => "𠜎" }))
+      file_path = file_containing('input', YAML.dump({ "my" => "𠜎" }))
 
-      expect(load_method.call(filename)).to eq({ "my" => "𠜎" })
+      expect(load_method.call(file_path)).to eq({ "my" => "𠜎" })
     end
   end
 
@@ -119,11 +118,11 @@ FACTS
     it_should_behave_like 'yaml file loader', Puppet::Util::Yaml.method(:safe_load_file)
 
     it 'raises an error when the file is invalid YAML' do
-      write_file(filename, '{ invalid')
+      file_path = file_containing('input', '{ invalid')
 
       expect {
-        Puppet::Util::Yaml.safe_load_file(filename)
-      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, %r[\(#{filename}\): .* at line \d+ column \d+])
+        Puppet::Util::Yaml.safe_load_file(file_path)
+      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, %r[\(#{file_path}\): .* at line \d+ column \d+])
     end
 
     it 'raises an error when the filename is illegal' do
@@ -139,9 +138,34 @@ FACTS
     end
   end
 
-  def write_file(name, contents)
-    File.open(name, "w:UTF-8") do |fh|
-      fh.write(contents)
+  context "#safe_load_file_if_valid" do
+    before do
+      Puppet[:log_level] = 'debug'
+    end
+
+    it_should_behave_like 'yaml file loader', Puppet::Util::Yaml.method(:safe_load_file_if_valid)
+
+    it 'returns nil when the file is invalid YAML and debug logs about it' do
+      file_path = file_containing('input', '{ invalid')
+
+      expect(Puppet).to receive(:debug)
+        .with(/Could not retrieve YAML content .+ expected ',' or '}'/).and_call_original
+
+      expect(Puppet::Util::Yaml.safe_load_file_if_valid(file_path)).to eql(nil)
+    end
+
+    it 'returns nil when the filename is illegal and debug logs about it' do
+      expect(Puppet).to receive(:debug)
+        .with(/Could not retrieve YAML content .+: pathname contains null byte/).and_call_original
+
+      expect(Puppet::Util::Yaml.safe_load_file_if_valid("not\0allowed")).to eql(nil)
+    end
+
+    it 'returns nil when the file does not exist and debug logs about it' do
+      expect(Puppet).to receive(:debug)
+        .with(/Could not retrieve YAML content .+: No such file or directory/).and_call_original
+
+      expect(Puppet::Util::Yaml.safe_load_file_if_valid('does/not/exist.yaml')).to eql(nil)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet
 version: !ruby/object:Gem::Version
-  version: 7.11.0
+  version: 7.14.0
 platform: universal-darwin
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-13 00:00:00.000000000 Z
+date: 2022-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facter
@@ -68,16 +68,22 @@ dependencies:
   name: fast_gettext
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: locale
   requirement: !ruby/object:Gem::Requirement
@@ -1849,6 +1855,7 @@ files:
 - spec/unit/application_spec.rb
 - spec/unit/certificate_factory_spec.rb
 - spec/unit/concurrent/lock_spec.rb
+- spec/unit/concurrent/thread_local_singleton_spec.rb
 - spec/unit/configurer/downloader_spec.rb
 - spec/unit/configurer/fact_handler_spec.rb
 - spec/unit/configurer/plugin_handler_spec.rb
@@ -2445,6 +2452,7 @@ files:
 - spec/unit/util/filetype_spec.rb
 - spec/unit/util/inifile_spec.rb
 - spec/unit/util/json_lockfile_spec.rb
+- spec/unit/util/json_spec.rb
 - spec/unit/util/ldap/connection_spec.rb
 - spec/unit/util/ldap/generator_spec.rb
 - spec/unit/util/ldap/manager_spec.rb
@@ -2543,7 +2551,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Puppet, an automated configuration management tool
@@ -3106,6 +3114,7 @@ test_files:
 - spec/unit/application_spec.rb
 - spec/unit/certificate_factory_spec.rb
 - spec/unit/concurrent/lock_spec.rb
+- spec/unit/concurrent/thread_local_singleton_spec.rb
 - spec/unit/configurer/downloader_spec.rb
 - spec/unit/configurer/fact_handler_spec.rb
 - spec/unit/configurer/plugin_handler_spec.rb
@@ -3702,6 +3711,7 @@ test_files:
 - spec/unit/util/filetype_spec.rb
 - spec/unit/util/inifile_spec.rb
 - spec/unit/util/json_lockfile_spec.rb
+- spec/unit/util/json_spec.rb
 - spec/unit/util/ldap/connection_spec.rb
 - spec/unit/util/ldap/generator_spec.rb
 - spec/unit/util/ldap/manager_spec.rb