puppet 5.4.0-universal-darwin → 5.5.0-universal-darwin

data/spec/unit/indirector/rest_spec.rb

@@ -1,6 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-require 'json'
+require 'puppet/util/json'
 require 'puppet/indirector'
 require 'puppet/indirector/errors'
 require 'puppet/indirector/rest'
@@ -52,7 +52,7 @@ shared_examples_for "a REST terminus method" do |terminus_method|
     describe "when the response code is #{code}" do
       let(:message) { 'error messaged!!!' }
       let(:body) do
-        JSON.generate({
+        Puppet::Util::Json.dump({
           :issue_kind => 'server-error',
           :message    => message
         })

data/spec/unit/indirector_spec.rb

@@ -113,7 +113,6 @@ describe Puppet::Indirector, "when registering an indirection" do
   end
 
   it "should pass any provided options to the indirection during initialization" do
-    klass = mock 'terminus class'
     Puppet::Indirector::Indirection.expects(:new).with(@thingie, :first, {:some => :options, :indirected_class => 'Thingie'})
     @indirection = @thingie.indirects :first, :some => :options
   end

data/spec/unit/info_service_spec.rb

@@ -20,7 +20,7 @@ describe "Puppet::InfoService" do
     context 'tasks_per_environment method' do
       it "returns task data for the tasks in an environment" do
         Puppet.override(:environments => env_loader) do
-          mod = PuppetSpec::Modules.create(mod_name, modpath, {:environment => env, :tasks => [['thingtask']]})
+          PuppetSpec::Modules.create(mod_name, modpath, {:environment => env, :tasks => [['thingtask']]})
           expect(Puppet::InfoService.tasks_per_environment(env_name)).to eq([{:name => task_name, :module => {:name => mod_name}}])
         end
       end

data/spec/unit/interface/action_manager_spec.rb

@@ -232,7 +232,7 @@ describe Puppet::Interface::ActionManager do
           when_invoked do |options| true end
           default
         }
-      }.to raise_error /cannot both be default/
+      }.to raise_error(/cannot both be default/)
     end
   end
 

data/spec/unit/interface/action_spec.rb

@@ -246,7 +246,7 @@ describe Puppet::Interface::Action do
         face = Puppet::Interface.new(:with_options, '0.0.1') do
           action(:foo) do
             when_invoked do |options| true end
-            self.instance_eval &block
+            self.instance_eval(&block)
           end
         end
         face.get_action(:foo)

data/spec/unit/module_spec.rb

@@ -169,7 +169,6 @@ describe Puppet::Module do
     end
 
     it "should list modules that are missing" do
-      metadata_file = "#{@modpath}/needy/metadata.json"
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
@@ -194,7 +193,6 @@ describe Puppet::Module do
     end
 
     it "should list modules that are missing and have invalid names" do
-      metadata_file = "#{@modpath}/needy/metadata.json"
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
@@ -224,8 +222,6 @@ describe Puppet::Module do
       ['test_gte_req', 'test_specific_req', 'foobar'].each do |mod_name|
         mod_dir = "#{@modpath}/#{mod_name}"
         metadata_file = "#{mod_dir}/metadata.json"
-        tasks_dir = "#{mod_dir}/tasks"
-        locale_dir = "#{mod_dir}/locales"
         Puppet::FileSystem.stubs(:exist?).with(metadata_file).returns true
       end
       mod = PuppetSpec::Modules.create(
@@ -305,7 +301,6 @@ describe Puppet::Module do
     it "should consider a dependency without a semantic version to be unmet" do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
-      metadata_file = "#{@modpath}/foobar/metadata.json"
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,

data/spec/unit/module_tool/applications/builder_spec.rb

@@ -27,7 +27,7 @@ describe Puppet::ModuleTool::Applications::Builder do
       builder.run
     end
 
-      def create_regular_files
+    def create_regular_files
       Puppet::FileSystem.touch(File.join(path, '.dotfile'))
       Puppet::FileSystem.touch(File.join(path, 'file.foo'))
       Puppet::FileSystem.touch(File.join(path, 'REVISION'))

data/spec/unit/module_tool/applications/unpacker_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'json'
+require 'puppet/util/json'
 
 require 'puppet/module_tool/applications'
 require 'puppet/file_system'
@@ -23,7 +23,7 @@ describe Puppet::ModuleTool::Applications::Unpacker do
     untar.expects(:unpack).with(filename, anything()) do |src, dest, _|
       FileUtils.mkdir(File.join(dest, 'extractedmodule'))
       File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
-        file.puts JSON.generate('name' => module_name, 'version' => '1.0.0')
+        file.puts Puppet::Util::Json.dump('name' => module_name, 'version' => '1.0.0')
       end
       true
     end
@@ -39,7 +39,7 @@ describe Puppet::ModuleTool::Applications::Unpacker do
     untar.expects(:unpack).with(filename, anything()) do |src, dest, _|
       FileUtils.mkdir(File.join(dest, 'extractedmodule'))
       File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
-        file.puts JSON.generate('name' => module_name, 'version' => '1.0.0')
+        file.puts Puppet::Util::Json.dump('name' => module_name, 'version' => '1.0.0')
       end
       FileUtils.touch(File.join(dest, 'extractedmodule/tempfile'))
       Puppet::FileSystem.symlink(File.join(dest, 'extractedmodule/tempfile'), File.join(dest, 'extractedmodule/tempfile2'))
@@ -58,7 +58,7 @@ describe Puppet::ModuleTool::Applications::Unpacker do
     untar.expects(:unpack).with(filename, anything()) do |src, dest, _|
       FileUtils.mkdir(File.join(dest, 'extractedmodule'))
       File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
-        file.puts JSON.generate('name' => module_name, 'version' => '1.0.0')
+        file.puts Puppet::Util::Json.dump('name' => module_name, 'version' => '1.0.0')
       end
       FileUtils.mkdir(File.join(dest, 'extractedmodule/manifests'))
       FileUtils.touch(File.join(dest, 'extractedmodule/manifests/tempfile'))

data/spec/unit/network/formats_spec.rb

@@ -333,14 +333,6 @@ describe "Puppet Network Format" do
       expect(json.weight).to eq(15)
     end
 
-    it "should use a native parser implementation" do
-      expect(JSON.parser.name).to eq("JSON::Ext::Parser")
-    end
-
-    it "should use a native generator implementation" do
-      expect(JSON.generator.name).to eq("JSON::Ext::Generator")
-    end
-
     it "should render an instance as JSON" do
       instance = FormatsTest.new("foo")
       expect(json.render(instance)).to eq({"string" => "foo"}.to_json)
@@ -352,20 +344,20 @@ describe "Puppet Network Format" do
     end
 
     it "should intern an instance from a JSON hash" do
-      text = JSON.dump({"string" => "parsed_json"})
+      text = Puppet::Util::Json.dump({"string" => "parsed_json"})
       instance = json.intern(FormatsTest, text)
       expect(instance.string).to eq("parsed_json")
     end
 
     it "should skip data_to_hash if data is already an instance of the specified class" do
       # The rest terminus for the report indirected type relies on this behavior
-      data = JSON.dump([1, 2])
+      data = Puppet::Util::Json.dump([1, 2])
       instance = json.intern(Array, data)
       expect(instance).to eq([1, 2])
     end
 
     it "should intern multiple instances from a JSON array of hashes" do
-      text = JSON.dump(
+      text = Puppet::Util::Json.dump(
         [
           {
             "string" => "BAR"
@@ -379,7 +371,7 @@ describe "Puppet Network Format" do
     end
 
     it "should reject wrapped data from legacy clients as they've never supported JSON" do
-      text = JSON.dump(
+      text = Puppet::Util::Json.dump(
         {
           "type" => "FormatsTest",
           "data" => {
@@ -394,7 +386,7 @@ describe "Puppet Network Format" do
     it "fails intelligibly when given invalid data" do
       expect do
         json.intern(Puppet::Node, '')
-      end.to raise_error(JSON::ParserError, /A JSON text must at least contain two octets|unexpected token at ''/)
+      end.to raise_error(Puppet::Util::Json::ParseError)
     end
   end
 

data/spec/unit/network/http/api/indirected_routes_spec.rb

@@ -106,6 +106,10 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(handler.uri2indirection("GET", "#{master_url_prefix}/nodes/bar", params)[1]).to eq(:search)
     end
 
+    it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is facts" do
+      expect(handler.uri2indirection("PUT", "#{master_url_prefix}/facts/puppet.node.test", params)[0].name).to eq(:facts)
+    end
+
     it "should change indirection name to 'status' if the http method is a GET and the indirection name is statuses" do
       expect(handler.uri2indirection("GET", "#{master_url_prefix}/statuses/bar", params)[0].name).to eq(:status)
     end
@@ -128,7 +132,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
     it "should not URI unescape the indirection key" do
       escaped = Puppet::Util.uri_encode("foo bar")
-      indirection, _, key, _ = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
+      _, _, key, _ = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
       expect(key).to eq(escaped)
     end
 
@@ -136,7 +140,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       key_escaped = Puppet::Util.uri_encode("foo bar")
       uri_escaped = "#{master_url_prefix}/node/#{key_escaped}"
       handler.expects(:check_authorization).with(anything, uri_escaped, anything)
-      indirection, _, _, _ = handler.uri2indirection("GET", uri_escaped, params)
+      _, _, _, _ = handler.uri2indirection("GET", uri_escaped, params)
     end
 
     it "should not pass through an environment to check_authorization and fail if the environment is unknown" do

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

@@ -344,7 +344,7 @@ describe Puppet::Network::HTTP::Connection do
 
       ::Kernel.expects(:sleep).with(30)
 
-      result = subject.get('/foo')
+      subject.get('/foo')
     end
   end
 

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

@@ -52,9 +52,10 @@ describe Puppet::Network::HTTP::Handler do
 
     it "raises an error if multiple routes with the same path regex are registered" do
       expect do
-        handler = PuppetSpec::Handler.new(
+        PuppetSpec::Handler.new(
           Puppet::Network::HTTP::Route.path(%r{^/foo}).get(respond("ignored")),
-          Puppet::Network::HTTP::Route.path(%r{^/foo}).post(respond("also ignored")))
+          Puppet::Network::HTTP::Route.path(%r{^/foo}).post(respond("also ignored"))
+        )
       end.to raise_error(ArgumentError)
     end
 

data/spec/unit/node/environment_spec.rb

@@ -353,7 +353,7 @@ describe Puppet::Node::Environment do
           end
 
           it "does not find modules with same name by the wrong author" do
-            mod = PuppetSpec::Modules.create(
+            PuppetSpec::Modules.create(
               'baz',
               first_modulepath,
               :metadata => {:author => 'sneakylabs'},

data/spec/unit/node_spec.rb

@@ -58,7 +58,7 @@ describe Puppet::Node do
     end
 
     it "can round-trip through json" do
-      facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+      Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
       node = Puppet::Node.new("hello",
                               :environment => 'bar',
                               :classes => ['erth', 'aiu'],
@@ -72,7 +72,7 @@ describe Puppet::Node do
     end
 
     it "validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
-      facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+      Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
       node = Puppet::Node.new("hello",
                               :environment => 'bar',
                               :classes => ['erth', 'aiu'],
@@ -82,7 +82,7 @@ describe Puppet::Node do
     end
 
     it "when missing optional parameters validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
-      facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+      Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
       node = Puppet::Node.new("hello",
                               :environment => 'bar'
                              )

data/spec/unit/parser/compiler_spec.rb

@@ -235,7 +235,6 @@ describe Puppet::Parser::Compiler do
     end
 
     it "should set the parent scope of the new scope to its topscope if the parent passed in is nil" do
-      scope = mock 'scope'
       newscope = @compiler.newscope(nil)
 
       expect(newscope.parent).to equal(@compiler.topscope)
@@ -279,6 +278,14 @@ describe Puppet::Parser::Compiler do
       expect(@compiler.topscope['wat']).to eq('this is how the sausage is made')
     end
 
+    it "sets the environment based on node.environment instead of the parameters" do
+      compile_stub(:set_node_parameters)
+      @node.parameters['environment'] = "Not actually #{@node.environment.name}"
+
+      @compiler.compile
+      expect(@compiler.topscope['environment']).to eq('testing')
+    end
+
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       @node.stubs(:parameters).returns(params)
@@ -725,7 +732,7 @@ describe Puppet::Parser::Compiler do
     end
 
     it "should ensure class is in catalog without params" do
-      @node.classes = klasses = {'foo'=>nil}
+      @node.classes = {'foo'=>nil}
       foo = Puppet::Resource::Type.new(:hostclass, 'foo')
       @compiler.environment.known_resource_types.add foo
       catalog = @compiler.compile

data/spec/unit/parser/environment_compiler_spec.rb

@@ -490,19 +490,19 @@ EOS
   describe "in the environment catalog" do
     it "does not fail if there is no site expression" do
       expect {
-      catalog = compile_to_env_catalog(<<-EOC).to_resource
-        notify { 'ignore me':}
-      EOC
+        compile_to_env_catalog(<<-EOC).to_resource
+          notify { 'ignore me':}
+        EOC
       }.to_not raise_error()
     end
 
     it "ignores usage of hiera_include() at topscope for classification" do
-      Puppet.expects(:debug).with(regexp_matches /Ignoring hiera_include/)
+      Puppet.expects(:debug).with(regexp_matches(/Ignoring hiera_include/))
 
       expect {
-        catalog = compile_to_env_catalog(<<-EOC).to_resource
-        hiera_include('classes')
-        site { }
+        compile_to_env_catalog(<<-EOC).to_resource
+          hiera_include('classes')
+          site { }
         EOC
       }.to_not raise_error()
 
@@ -598,7 +598,7 @@ EOS
 
       it "fails if there are non component resources in the site" do
         expect {
-        catalog = compile_to_env_catalog(MANIFEST_WITH_ILLEGAL_RESOURCE).to_resource
+          compile_to_env_catalog(MANIFEST_WITH_ILLEGAL_RESOURCE).to_resource
         }.to raise_error(/Only application components can appear inside a site - Notify\[fail me\] is not allowed \(line: 20\)/)
       end
     end

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -328,7 +328,7 @@ describe 'function for dynamically creating resources' do
     it 'is not available when --tasks is on' do
       Puppet[:tasks] = true
       expect do
-        catalog = compile_to_catalog(<<-MANIFEST)
+        compile_to_catalog(<<-MANIFEST)
           create_resources('class', {'bar'=>{}}, {'one' => 'two'})
         MANIFEST
       end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)

data/spec/unit/parser/functions/fail_spec.rb

@@ -23,6 +23,6 @@ describe "the 'fail' parser function" do
   end
 
   it "should join arguments into a string in the error" do
-    expect { scope.function_fail(["hello", "world"]) }.to raise_error /hello world/
+    expect { scope.function_fail(["hello", "world"]) }.to raise_error(/hello world/)
   end
 end

data/spec/unit/parser/functions/fqdn_rand_spec.rb

@@ -38,6 +38,30 @@ describe "the fqdn_rand function" do
     expect(val1).not_to eql(val2)
   end
 
+  it "should return a specific value with given set of inputs on non-fips enabled host" do
+    Puppet::Util::Platform.stubs(:fips_enabled?).returns false
+
+    expect(fqdn_rand(3000, :host => 'dummy.fqdn.net')).to eql(338)
+  end
+
+  it "should return a specific value with given set of inputs on fips enabled host" do
+    Puppet::Util::Platform.stubs(:fips_enabled?).returns true
+
+    expect(fqdn_rand(3000, :host => 'dummy.fqdn.net')).to eql(278)
+  end
+
+  it "should return a specific value with given seed on a non-fips enabled host" do
+    Puppet::Util::Platform.stubs(:fips_enabled?).returns false
+
+    expect(fqdn_rand(5000, :extra_identifier => ['expensive job 33'])).to eql(3374)
+  end
+
+  it "should return a specific value with given seed on a fips enabled host" do
+    Puppet::Util::Platform.stubs(:fips_enabled?).returns true
+
+    expect(fqdn_rand(5000, :extra_identifier => ['expensive job 33'])).to eql(2389)
+  end
+
   def fqdn_rand(max, args = {})
     host = args[:host] || '127.0.0.1'
     extra = args[:extra_identifier] || []

data/spec/unit/parser/functions/realize_spec.rb

@@ -62,7 +62,7 @@ describe "the realize function" do
   it 'is not available when --tasks is on' do
     Puppet[:tasks] = true
     expect do
-      catalog = compile_to_catalog(<<-MANIFEST)
+      compile_to_catalog(<<-MANIFEST)
         realize([])
       MANIFEST
     end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)

data/spec/unit/parser/resource_spec.rb

@@ -177,7 +177,6 @@ describe Puppet::Parser::Resource do
     end
 
     it "should add edges from the class resources to the parent's stage if no stage is specified" do
-      main      = @compiler.catalog.resource(:stage, :main)
       foo_stage = Puppet::Parser::Resource.new(:stage, :foo_stage, :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, foo_stage)
       @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})

data/spec/unit/parser/scope_spec.rb

@@ -294,13 +294,13 @@ describe Puppet::Parser::Scope do
       end
 
       it "should return nil for qualified variables that cannot be found in other classes" do
-        other_scope = create_class_scope("other::deep::klass")
+        create_class_scope("other::deep::klass")
 
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should warn and return nil for qualified variables whose classes have not been evaluated" do
-        klass = newclass("other::deep::klass")
+        newclass("other::deep::klass")
         Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
@@ -316,7 +316,7 @@ describe Puppet::Parser::Scope do
 
       it "should return nil when asked for a non-string qualified variable from a class that has not been evaluated" do
         @scope.stubs(:warning)
-        klass = newclass("other::deep::klass")
+        newclass("other::deep::klass")
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
     end

data/spec/unit/parser/type_loader_spec.rb

@@ -161,7 +161,7 @@ describe Puppet::Parser::TypeLoader do
     end
 
     it "should skip modules that don't have manifests" do
-      module1 = mk_module(modulebase1, "one")
+      mk_module(modulebase1, "one")
       module2 = mk_module(modulebase2, "two")
       mk_manifests(modulebase2, module2, %w{c d})