puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/spec/unit/node/environment_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'tmpdir'
@@ -111,7 +112,7 @@ describe Puppet::Node::Environment do
 
     describe "when managing known resource types" do
       before do
-        allow(env).to receive(:perform_initial_import).and_return(Puppet::Parser::AST::Hostclass.new(''))
+        env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
       end
 
       it "creates a resource type collection if none exists" do
@@ -123,13 +124,13 @@ describe Puppet::Node::Environment do
       end
 
       it "performs the initial import when creating a new collection" do
-        expect(env).to receive(:perform_initial_import).and_return(Puppet::Parser::AST::Hostclass.new(''))
+        env.expects(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
         env.known_resource_types
       end
 
       it "generates a new TypeCollection if the current one requires reparsing" do
         old_type_collection = env.known_resource_types
-        allow(old_type_collection).to receive(:parse_failed?).and_return(true)
+        old_type_collection.stubs(:parse_failed?).returns true
 
         env.check_for_reparse
 
@@ -170,7 +171,7 @@ describe Puppet::Node::Environment do
       end
 
       context "when disable_per_environment_manifest is true" do
-        let(:config) { double('config') }
+        let(:config) { mock('config') }
         let(:global_modulepath) { ["/global/modulepath"] }
         let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, global_modulepath) }
 
@@ -179,12 +180,12 @@ describe Puppet::Node::Environment do
         end
 
         def assert_manifest_conflict(expectation, envconf_manifest_value)
-          expect(config).to receive(:setting).with(:manifest).and_return(
-            double('setting', :value => envconf_manifest_value)
+          config.expects(:setting).with(:manifest).returns(
+            mock('setting', :value => envconf_manifest_value)
           )
           environment = Puppet::Node::Environment.create(:directory, [], '/default/manifests/site.pp')
           loader = Puppet::Environments::Static.new(environment)
-          allow(loader).to receive(:get_conf).and_return(envconf)
+          loader.stubs(:get_conf).returns(envconf)
 
           Puppet.override(:environments => loader) do
             if expectation
@@ -418,7 +419,7 @@ describe Puppet::Node::Environment do
               }
             )
 
-            expect(Puppet).to receive(:log_exception).with(be_a(Puppet::Module::MissingMetadata))
+            Puppet.expects(:log_exception).with(is_a(Puppet::Module::MissingMetadata))
 
             env.modules
           end
@@ -430,14 +431,12 @@ describe Puppet::Node::Environment do
       let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
       before(:each) do
-        allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
+        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+        Puppet.push_context({:loaders => loaders, :current_environment => env})
       end
 
-      around :each do |example|
-        Puppet.override(:loaders => loaders, :current_environment => env) do
-          example.run
-          Puppet::Pops::Loaders.clear
-        end
+      after(:each) do
+        Puppet.pop_context()
       end
 
       it "loads from Puppet[:code]" do
@@ -496,9 +495,9 @@ describe Puppet::Node::Environment do
 
   describe "managing module translations" do
     it "creates a new text domain the first time we try to use the text domain" do
-      expect(Puppet::GettextConfig).to receive(:reset_text_domain).with(env.name)
-      expect(Puppet::ModuleTranslations).to receive(:load_from_modulepath)
-      expect(Puppet::GettextConfig).to receive(:clear_text_domain)
+      Puppet::GettextConfig.expects(:reset_text_domain).with(env.name)
+      Puppet::ModuleTranslations.expects(:load_from_modulepath)
+      Puppet::GettextConfig.expects(:clear_text_domain)
 
       env.with_text_domain do; end
     end
@@ -506,7 +505,7 @@ describe Puppet::Node::Environment do
     it "uses the existing text domain once it has been created" do
       env.with_text_domain do; end
 
-      expect(Puppet::GettextConfig).to receive(:use_text_domain).with(env.name)
+      Puppet::GettextConfig.expects(:use_text_domain).with(env.name)
       env.with_text_domain do; end
     end
 

data/spec/unit/node/facts_spec.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 require 'puppet/node/facts'
 require 'matchers/json'
@@ -79,18 +81,30 @@ describe Puppet::Node::Facts, "when indirecting" do
       @facts.sanitize
       expect(@facts.values["test"]).to eq({"(?-mix:foo)" => ["bar", "(?-mix:baz)"]})
     end
+
+    it "should handle alien values having a to_s that returns ascii-8bit" do
+      class Alien
+      end
+      an_alien = Alien.new
+      @facts.values["test"] = an_alien
+      @facts.sanitize
+      fact_value = @facts.values['test']
+      expect(fact_value).to eq(an_alien.to_s)
+      expect(fact_value.encoding).to eq(Encoding::UTF_8)
+    end
+
   end
 
   describe "when indirecting" do
     before do
-      @indirection = double('indirection', :request => double('request'), :name => :facts)
+      @indirection = stub 'indirection', :request => mock('request'), :name => :facts
 
       @facts = Puppet::Node::Facts.new("me", "one" => "two")
     end
 
     it "should redirect to the specified fact store for storage" do
-      allow(Puppet::Node::Facts).to receive(:indirection).and_return(@indirection)
-      expect(@indirection).to receive(:save)
+      Puppet::Node::Facts.stubs(:indirection).returns(@indirection)
+      @indirection.expects(:save)
       Puppet::Node::Facts.indirection.save(@facts)
     end
 
@@ -127,8 +141,9 @@ describe Puppet::Node::Facts, "when indirecting" do
       end
 
       def deserialize_yaml_facts(facts)
+        facts.sanitize
         format = Puppet::Network::FormatHandler.format('yaml')
-        format.intern(Puppet::Node::Facts, facts.to_yaml)
+        format.intern(Puppet::Node::Facts, YAML.dump(facts.to_data_hash))
       end
 
       it 'preserves `_timestamp` value' do
@@ -175,7 +190,7 @@ describe Puppet::Node::Facts, "when indirecting" do
       end
 
       it "should generate properly formatted json" do
-        allow(Time).to receive(:now).and_return(@timestamp)
+        Time.stubs(:now).returns(@timestamp)
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
         result = JSON.parse(facts.to_json)
@@ -186,7 +201,7 @@ describe Puppet::Node::Facts, "when indirecting" do
       end
 
       it "should generate valid facts data against the facts schema" do
-        allow(Time).to receive(:now).and_return(@timestamp)
+        Time.stubs(:now).returns(@timestamp)
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
 

data/spec/unit/node_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'matchers/json'
 require 'puppet_spec/files'
@@ -10,6 +11,7 @@ describe Puppet::Node do
   let(:env_loader) { Puppet::Environments::Static.new(environment) }
 
   describe "when managing its environment" do
+
     it "provides an environment instance" do
       expect(Puppet::Node.new("foo", :environment => environment).environment.name).to eq(:bar)
     end
@@ -69,7 +71,7 @@ describe Puppet::Node do
       expect(new_node.name).to eq(node.name)
     end
 
-    it "validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
+    it "validates against the node json schema" do
       Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
       node = Puppet::Node.new("hello",
                               :environment => 'bar',
@@ -79,7 +81,7 @@ describe Puppet::Node do
       expect(node.to_json).to validate_against('api/schemas/node.json')
     end
 
-    it "when missing optional parameters validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
+    it "when missing optional parameters validates against the node json schema" do
       Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
       node = Puppet::Node.new("hello",
                               :environment => 'bar'
@@ -111,25 +113,29 @@ describe Puppet::Node do
     end
 
     it "a node can roundtrip" do
-      expect(YAML.load(@node.to_yaml).name).to eql("mynode")
+      expect(Puppet::Util::Yaml.safe_load(@node.to_yaml, [Puppet::Node]).name).to eql("mynode")
     end
 
     it "limits the serialization of environment to be just the name" do
       yaml_file = file_containing("temp_yaml", @node.to_yaml)
-      node_yaml = Puppet::Util::Yaml.load_file(yaml_file, false, true)
-      expect(node_yaml['environment']).to eq('production')
+      expect(File.read(yaml_file)).to eq(<<~NODE)
+        --- !ruby/object:Puppet::Node
+        name: mynode
+        environment: production
+      NODE
     end
   end
 
   describe "when serializing using yaml and values classes and parameters are missing in deserialized hash" do
     it "a node can roundtrip" do
       @node = Puppet::Node.from_data_hash({'name' => "mynode"})
-      expect(YAML.load(@node.to_yaml).name).to eql("mynode")
+      expect(Puppet::Util::Yaml.safe_load(@node.to_yaml, [Puppet::Node]).name).to eql("mynode")
     end
 
     it "errors if name is nil" do
       expect { Puppet::Node.from_data_hash({ })}.to raise_error(ArgumentError, /No name provided in serialized data/)
     end
+
   end
 
   describe "when converting to json" do
@@ -268,18 +274,18 @@ describe Puppet::Node, "when merging facts" do
     let(:facts) { Puppet::Node::Facts.new(@node.name, "foo" => "bar") }
 
     it "accepts facts to merge with the node" do
-      expect(@node).to receive(:merge).with({ 'foo' => 'bar' })
+      @node.expects(:merge).with({ 'foo' => 'bar' })
       @node.fact_merge(facts)
     end
 
     it "will not query the facts indirection if facts are supplied" do
-      expect(Puppet::Node::Facts.indirection).not_to receive(:find)
+      Puppet::Node::Facts.indirection.expects(:find).never
       @node.fact_merge(facts)
     end
   end
 
   it "recovers with a Puppet::Error if something is thrown from the facts indirection" do
-    expect(Puppet::Node::Facts.indirection).to receive(:find).and_raise("something bad happened in the indirector")
+    Puppet::Node::Facts.indirection.expects(:find).raises "something bad happened in the indirector"
     expect { @node.fact_merge }.to raise_error(Puppet::Error, /Could not retrieve facts for testnode: something bad happened in the indirector/)
   end
 
@@ -297,7 +303,7 @@ describe Puppet::Node, "when merging facts" do
 
   it "warns when a parameter value is not updated" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
-    expect(Puppet).to receive(:warning).with('The node parameter \'one\' for node \'testnode\' was already set to \'a\'. It could not be set to \'b\'')
+    Puppet.expects(:warning).with('The node parameter \'one\' for node \'testnode\' was already set to \'a\'. It could not be set to \'b\'')
     @node.merge "one" => "b"
   end
 
@@ -371,7 +377,9 @@ describe Puppet::Node, "when merging facts" do
     end
 
     context "when a node is initialized from new" do
+
       context "when a node is initialzed with an environment" do
+
         it "adds the environment to the list of parameters" do
           Puppet[:environment] = "one"
           @node = Puppet::Node.new("testnode", :environment => "one")
@@ -393,6 +401,7 @@ describe Puppet::Node, "when merging facts" do
       end
 
       context "when a node is initialized without an environment" do
+
         it "it perfers an environment name to an environment fact" do
           @node = Puppet::Node.new("testnode")
           @node.environment_name = "one"
@@ -414,9 +423,7 @@ end
 
 describe Puppet::Node, "when generating the list of names to search through" do
   before do
-    Puppet[:strict_hostname_checking] = false
-    @node = Puppet::Node.new("foo.domain.com",
-                             :parameters => {"hostname" => "yay", "domain" => "domain.com"})
+    @node = Puppet::Node.new("foo.domain.com", :parameters => {"hostname" => "yay", "domain" => "domain.com"})
   end
 
   it "returns an array of names" do
@@ -447,6 +454,7 @@ describe Puppet::Node, "when generating the list of names to search through" do
 
   describe "and :node_name is set to 'cert'" do
     before do
+      Puppet[:strict_hostname_checking] = false
       Puppet[:node_name] = "cert"
     end
 
@@ -455,11 +463,8 @@ describe Puppet::Node, "when generating the list of names to search through" do
     end
 
     describe "and strict hostname checking is enabled" do
-      before do
-        Puppet[:strict_hostname_checking] = true
-      end
-
       it "only uses the passed-in key" do
+        Puppet[:strict_hostname_checking] = true
         expect(@node.names).to eq(["foo.domain.com"])
       end
     end
@@ -467,6 +472,7 @@ describe Puppet::Node, "when generating the list of names to search through" do
 
   describe "and :node_name is set to 'facter'" do
     before do
+      Puppet[:strict_hostname_checking] = false
       Puppet[:node_name] = "facter"
     end
 

data/spec/unit/other/selinux_spec.rb

@@ -1,8 +1,6 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/type/selboolean'
-require 'puppet/type/selmodule'
-
 describe Puppet::Type.type(:file), " when manipulating file contexts" do
   include PuppetSpec::Files
 
@@ -28,71 +26,3 @@ describe Puppet::Type.type(:file), " when manipulating file contexts" do
     expect(@file[:seltype]).to eq("type_t")
   end
 end
-
-describe Puppet::Type.type(:selboolean), " when manipulating booleans" do
-  before :each do
-    provider_class = Puppet::Type::Selboolean.provider(Puppet::Type::Selboolean.providers[0])
-    allow(Puppet::Type::Selboolean).to receive(:defaultprovider).and_return(provider_class)
-
-    @bool = Puppet::Type::Selboolean.new(
-      :name => "foo",
-      :value => "on",
-      :persistent => true )
-  end
-
-  it "should be able to access :name" do
-    expect(@bool[:name]).to eq("foo")
-  end
-
-  it "should be able to access :value" do
-    expect(@bool.property(:value).should).to eq(:on)
-  end
-
-  it "should set :value to off" do
-    @bool[:value] = :off
-    expect(@bool.property(:value).should).to eq(:off)
-  end
-
-  it "should be able to access :persistent" do
-    expect(@bool[:persistent]).to eq(:true)
-  end
-
-  it "should set :persistent to false" do
-    @bool[:persistent] = false
-    expect(@bool[:persistent]).to eq(:false)
-  end
-end
-
-describe Puppet::Type.type(:selmodule), " when checking policy modules" do
-  before :each do
-    provider_class = Puppet::Type::Selmodule.provider(Puppet::Type::Selmodule.providers[0])
-    allow(Puppet::Type::Selmodule).to receive(:defaultprovider).and_return(provider_class)
-
-    @module = Puppet::Type::Selmodule.new(
-      :name => "foo",
-      :selmoduledir => "/some/path",
-      :selmodulepath => "/some/path/foo.pp",
-      :syncversion => true)
-  end
-
-  it "should be able to access :name" do
-    expect(@module[:name]).to eq("foo")
-  end
-
-  it "should be able to access :selmoduledir" do
-    expect(@module[:selmoduledir]).to eq("/some/path")
-  end
-
-  it "should be able to access :selmodulepath" do
-    expect(@module[:selmodulepath]).to eq("/some/path/foo.pp")
-  end
-
-  it "should be able to access :syncversion" do
-    expect(@module[:syncversion]).to eq(:true)
-  end
-
-  it "should set the syncversion value to false" do
-    @module[:syncversion] = :false
-    expect(@module[:syncversion]).to eq(:false)
-  end
-end

data/spec/unit/parameter/boolean_spec.rb

@@ -1,9 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet'
 require 'puppet/parameter/boolean'
 
 describe Puppet::Parameter::Boolean do
-  let (:resource) { double('resource') }
+  let (:resource) { mock('resource') }
   describe "after initvars" do
     before { described_class.initvars }
     it "should have the correct value_collection" do

data/spec/unit/parameter/package_options_spec.rb

@@ -1,9 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/parameter/package_options'
 
 describe Puppet::Parameter::PackageOptions do
-  let (:resource) { double('resource') }
+  let (:resource) { mock('resource') }
   let (:param)    { described_class.new(:resource => resource) }
   let (:arg)      { '/S' }
   let (:key)      { 'INSTALLDIR' }

data/spec/unit/parameter/path_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/parameter/path'

data/spec/unit/parameter/value_collection_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/parameter'

data/spec/unit/parameter/value_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/parameter'

data/spec/unit/parameter_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/parameter'
@@ -8,9 +9,8 @@ describe Puppet::Parameter do
       @name = :foo
     end
     @class.initvars
-    @resource = double('resource')
-    allow(@resource).to receive(:expects)
-    allow(@resource).to receive(:pathbuilder)
+    @resource = mock 'resource'
+    @resource.stub_everything
     @parameter = @class.new :resource => @resource
   end
 
@@ -27,13 +27,13 @@ describe Puppet::Parameter do
 
   [:line, :file, :version].each do |data|
     it "should return its resource's #{data} as its #{data}" do
-      expect(@resource).to receive(data).and_return("foo")
+      @resource.expects(data).returns "foo"
       expect(@parameter.send(data)).to eq("foo")
     end
   end
 
   it "should return the resource's tags plus its name as its tags" do
-    expect(@resource).to receive(:tags).and_return(%w{one two})
+    @resource.expects(:tags).returns %w{one two}
     expect(@parameter.tags).to eq(%w{one two foo})
   end
 
@@ -47,12 +47,12 @@ describe Puppet::Parameter do
     end
 
     it "should validate the value" do
-      expect(@parameter).to receive(:validate).with("foo")
+      @parameter.expects(:validate).with("foo")
       @parameter.value = "foo"
     end
 
     it "should munge the value and use any result as the actual value" do
-      expect(@parameter).to receive(:munge).with("foo").and_return("bar")
+      @parameter.expects(:munge).with("foo").returns "bar"
       @parameter.value = "foo"
       expect(@parameter.value).to eq("bar")
     end
@@ -149,8 +149,8 @@ describe Puppet::Parameter do
 
   describe "when logging" do
     it "should use its resource's log level and the provided message" do
-      expect(@resource).to receive(:[]).with(:loglevel).and_return(:notice)
-      expect(@parameter).to receive(:send_log).with(:notice, "mymessage")
+      @resource.expects(:[]).with(:loglevel).returns :notice
+      @parameter.expects(:send_log).with(:notice, "mymessage")
       @parameter.log "mymessage"
     end
   end