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

data/spec/integration/network/formats_spec.rb

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

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

@@ -1,12 +1,12 @@
 require 'spec_helper'
 require 'puppet/network/http'
 require 'puppet/network/http/api/indirected_routes'
-require 'rack/mock' if Puppet.features.rack?
-require 'puppet/network/http/rack/rest'
 require 'puppet/indirector_proxy'
 require 'puppet_spec/files'
 require 'puppet_spec/network'
 require 'puppet/util/json'
+require 'puppet/file_serving/content'
+require 'puppet/file_serving/metadata'
 
 describe Puppet::Network::HTTP::API::IndirectedRoutes do
   include PuppetSpec::Files
@@ -15,7 +15,10 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
   describe "when running the master application" do
     before :each do
-      Puppet::Application[:master].setup_terminuses
+      Puppet::FileServing::Content.indirection.terminus_class = :file_server
+      Puppet::FileServing::Metadata.indirection.terminus_class = :file_server
+
+      Puppet::FileBucket::File.indirection.terminus_class = :file
     end
 
     describe "using Puppet API to request file metadata" do
@@ -53,36 +56,5 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
         end
       end
     end
-
-    describe "an error from IndirectedRoutes", :if => Puppet.features.rack? do
-      let(:handler) { Puppet::Network::HTTP::RackREST.new }
-
-      describe "returns json" do
-        it "when a standard error" do
-          response = Rack::Response.new
-          request = Rack::Request.new(
-            Rack::MockRequest.env_for("/puppet/v3/invalid-indirector"))
-
-          handler.process(request, response)
-
-          expect(response.header["Content-Type"]).to match(/json/)
-          resp = Puppet::Util::Json.load(response.body.first)
-          expect(resp["message"]).to match(/The indirection name must be purely alphanumeric/)
-          expect(resp["issue_kind"]).to be_a_kind_of(String)
-        end
-        it "when a server error" do
-          response = Rack::Response.new
-          request = Rack::Request.new(
-            Rack::MockRequest.env_for("/puppet/v3/unknown_indirector"))
-
-          handler.process(request, response)
-
-          expect(response.header["Content-Type"]).to match(/json/)
-          resp = Puppet::Util::Json.load(response.body.first)
-          expect(resp["message"]).to match(/Could not find indirection/)
-          expect(resp["issue_kind"]).to be_a_kind_of(String)
-        end
-      end
-    end
   end
 end

data/spec/integration/node/environment_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet_spec/files'
@@ -140,7 +141,7 @@ describe Puppet::Node::Environment do
       :strict_variables => true
   end
 
-  describe "#extralibs on Windows", :if => Puppet.features.microsoft_windows? do
+  describe "#extralibs on Windows", :if => Puppet::Util::Platform.windows? do
 
     describe "with UTF8 characters in PUPPETLIB" do
       let(:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }

data/spec/integration/node/facts_spec.rb

@@ -1,38 +1,39 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Node::Facts do
   describe "when using the indirector" do
     it "should expire any cached node instances when it is saved" do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:yaml)
+      Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :yaml
 
       expect(Puppet::Node::Facts.indirection.terminus(:yaml)).to equal(Puppet::Node::Facts.indirection.terminus(:yaml))
       terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
-      allow(terminus).to receive(:save)
+      terminus.stubs :save
 
-      expect(Puppet::Node.indirection).to receive(:expire).with("me", be_a(Hash).or(be_nil))
+      Puppet::Node.indirection.expects(:expire).with("me", optionally(instance_of(Hash)))
 
       facts = Puppet::Node::Facts.new("me")
       Puppet::Node::Facts.indirection.save(facts)
     end
 
     it "should be able to delegate to the :yaml terminus" do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:yaml)
+      Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :yaml
 
       # Load now, before we stub the exists? method.
       terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
 
-      expect(terminus).to receive(:path).with("me").and_return("/my/yaml/file")
-      expect(Puppet::FileSystem).to receive(:exist?).with("/my/yaml/file").and_return(false)
+      terminus.expects(:path).with("me").returns "/my/yaml/file"
+      Puppet::FileSystem.expects(:exist?).with("/my/yaml/file").returns false
 
       expect(Puppet::Node::Facts.indirection.find("me")).to be_nil
     end
 
     it "should be able to delegate to the :facter terminus" do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:facter)
+      Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :facter
 
-      expect(Facter).to receive(:to_hash).and_return("facter_hash")
+      Facter.expects(:to_hash).returns "facter_hash"
       facts = Puppet::Node::Facts.new("me")
-      expect(Puppet::Node::Facts).to receive(:new).with("me", "facter_hash").and_return(facts)
+      Puppet::Node::Facts.expects(:new).with("me", "facter_hash").returns facts
 
       expect(Puppet::Node::Facts.indirection.find("me")).to equal(facts)
     end

data/spec/integration/node_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/node'
@@ -13,28 +14,24 @@ describe Puppet::Node do
     end
 
     it "should be able to use the yaml terminus" do
-      allow(Puppet::Node.indirection).to receive(:terminus_class).and_return(:yaml)
+      Puppet::Node.indirection.stubs(:terminus_class).returns :yaml
 
       # Load now, before we stub the exists? method.
       terminus = Puppet::Node.indirection.terminus(:yaml)
 
-      expect(terminus).to receive(:path).with(@name).and_return("/my/yaml/file")
+      terminus.expects(:path).with(@name).returns "/my/yaml/file"
 
-      expect(Puppet::FileSystem).to receive(:exist?).with("/my/yaml/file").and_return(false)
+      Puppet::FileSystem.expects(:exist?).with("/my/yaml/file").returns false
       expect(Puppet::Node.indirection.find(@name)).to be_nil
     end
 
-    it "should have an ldap terminus" do
-      expect(Puppet::Node.indirection.terminus(:ldap)).not_to be_nil
-    end
-
     it "should be able to use the plain terminus" do
-      allow(Puppet::Node.indirection).to receive(:terminus_class).and_return(:plain)
+      Puppet::Node.indirection.stubs(:terminus_class).returns :plain
 
       # Load now, before we stub the exists? method.
       Puppet::Node.indirection.terminus(:plain)
 
-      expect(Puppet::Node).to receive(:new).with(@name).and_return(@node)
+      Puppet::Node.expects(:new).with(@name).returns @node
 
       expect(Puppet::Node.indirection.find(@name)).to equal(@node)
     end
@@ -43,7 +40,7 @@ describe Puppet::Node do
       before do
         @name = "me"
         @terminus = Puppet::Node.indirection.terminus(:memory)
-        allow(Puppet::Node.indirection).to receive(:terminus).and_return(@terminus)
+        Puppet::Node.indirection.stubs(:terminus).returns @terminus
         @node = Puppet::Node.new(@name)
       end
 

data/spec/integration/parser/catalog_spec.rb

@@ -12,17 +12,19 @@ describe "A catalog" 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.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
+
+    before(:each) do
+      Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
     end
 
     context "when transmitted to the agent" do
+
       it "preserves the order in which the resources are added to the catalog" do
         resources_in_declaration_order = ["Class[First]",
                                           "Second[position]",

data/spec/integration/parser/collection_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 
@@ -11,10 +12,6 @@ describe 'collectors' do
     expect(messages).to include(*expected_messages)
   end
 
-  def warnings
-    @logs.select { |log| log.level == :warning }.map { |log| log.message }
-  end
-
   context "virtual resource collection" do
     it "matches everything when no query given" do
       expect_the_message_to_be(["the other message", "the message"], <<-MANIFEST)
@@ -316,6 +313,8 @@ describe 'collectors' do
       end
 
       context 'when overriding an already evaluated resource' do
+        let(:logs) { [] }
+        let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
         let(:manifest) { <<-MANIFEST }
           define foo($message) {
             notify { "testing": message => $message }
@@ -327,6 +326,12 @@ describe 'collectors' do
           delayed {'do it now': }
         MANIFEST
 
+        around(:each) do |example|
+          Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+            example.run
+          end
+        end
+
         it 'and --strict=off, it silently skips the override' do
           Puppet[:strict] = :off
           expect_the_message_to_be(['given'], manifest)

data/spec/integration/parser/compiler_spec.rb

@@ -72,14 +72,14 @@ describe Puppet::Parser::Compiler do
     # hidden away in the implementation and we keep losing the race.)
     # --daniel 2011-04-21
     now = Time.now
-    allow(Time).to receive(:now).and_return(now)
+    Time.stubs(:now).returns(now)
 
     @node = Puppet::Node.new("testnode",
                              :facts => Puppet::Node::Facts.new("facts", {}),
                              :environment => environment)
     @known_resource_types = environment.known_resource_types
     @compiler = Puppet::Parser::Compiler.new(@node)
-    @scope = Puppet::Parser::Scope.new(@compiler, :source => double('source'))
+    @scope = Puppet::Parser::Scope.new(@compiler, :source => stub('source'))
     @scope_resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope)
     @scope.resource = @scope_resource
   end
@@ -145,8 +145,8 @@ describe Puppet::Parser::Compiler do
           }
         MANIFEST
 
-      expect_any_instance_of(Puppet::Parser::Resource::Catalog).to receive(:to_resource) do |catalog|
-        expect(Puppet.lookup(:current_environment).name).to eq(:production)
+      Puppet::Parser::Resource::Catalog.any_instance.expects(:to_resource).with do |catalog|
+        Puppet.lookup(:current_environment).name == :production
       end
 
       Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
@@ -211,7 +211,7 @@ describe Puppet::Parser::Compiler do
   describe "the compiler when using 4.x language constructs" do
     include PuppetSpec::Compiler
 
-    if Puppet.features.microsoft_windows?
+    if Puppet::Util::Platform.windows?
       it "should be able to determine the configuration version from a local version control repository" do
         pending("Bug #14071 about semantics of Puppet::Util::Execute on Windows")
         # This should always work, because we should always be
@@ -447,10 +447,10 @@ describe Puppet::Parser::Compiler do
       Puppet[:code] = 'class foo { }'
       first_time = Time.at(1)
       second_time = Time.at(200)
-      allow(Time).to receive(:now).and_return(first_time)
+      Time.stubs(:now).returns(first_time)
       node = Puppet::Node.new('mynode')
       expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i)
-      allow(Time).to receive(:now).and_return(second_time)
+      Time.stubs(:now).returns(second_time)
       expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i) # no change because files didn't change
       Puppet[:code] = nil
       expect(Puppet::Parser::Compiler.compile(node).version).to eq(second_time.to_i)
@@ -483,13 +483,6 @@ describe Puppet::Parser::Compiler do
     end
 
     describe "relationships to non existing resources (even with strict==off)" do
-      # At some point in the future, this test can be modified to simply ignore the strict flag,
-      # but since the current version is a change from being under control of strict, this is now
-      # explicit - the standard setting is strict == warning, here setting it to off
-      #
-      before(:each) do
-        Puppet[:strict] = :off
-      end
 
       [ 'before',
         'subscribe',
@@ -841,17 +834,6 @@ describe Puppet::Parser::Compiler do
           MANIFEST
         end.to raise_error(/Foo\[bar\]:\s+parameter 'a' expects a value for key 'd'\s+parameter 'a' unrecognized key 'c'/m)
       end
-
-      it 'handles Sensitive type in resource array' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          define foo(Sensitive[String] $password) {
-            notify{ "${title}": message => "${password}" }
-          }
-          foo { ['testA', 'testB']: password =>Sensitive('some password') }
-        MANIFEST
-        expect(catalog).to have_resource("Notify[testA]").with_parameter(:message, 'Sensitive [value redacted]')
-        expect(catalog).to have_resource("Notify[testB]").with_parameter(:message, 'Sensitive [value redacted]')
-      end
     end
 
     context 'when using typed parameters in class' do

data/spec/integration/parser/scope_spec.rb

@@ -14,7 +14,7 @@ describe "Two step scoping for variables" do
   end
 
   before :each do
-    expect(Puppet).not_to receive(:deprecation_warning)
+    Puppet.expects(:deprecation_warning).never
   end
 
   describe "using unsupported operators" do

data/spec/integration/parser/undef_param_spec.rb

@@ -7,7 +7,7 @@ describe "Parameter passing" do
   before :each do
     # DataBinding will be consulted before falling back to a default value,
     # but we aren't testing that here
-    allow(Puppet::DataBinding.indirection).to receive(:find)
+    Puppet::DataBinding.indirection.stubs(:find)
   end
 
   def expect_the_message_to_be(message, node = Puppet::Node.new('the node'))

data/spec/integration/provider/service/init_spec.rb

@@ -1,11 +1,14 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-provider = Puppet::Type.type(:service).provider(:init)
+test_title = 'Integration Tests for Puppet::Type::Service::Provider::Init'
+
+describe test_title, unless: Puppet::Util::Platform.jruby? do
+  let(:provider) { Puppet::Type.type(:service).provider(:init) }
 
-describe provider do
   describe "when running on FreeBSD" do
     before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('FreeBSD')
+      Facter.stubs(:value).with(:operatingsystem).returns 'FreeBSD'
     end
 
     it "should set its default path to include /etc/rc.d and /usr/local/etc/rc.d" do
@@ -15,7 +18,7 @@ describe provider do
 
   describe "when running on HP-UX" do
     before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('HP-UX')
+      Facter.stubs(:value).with(:operatingsystem).returns 'HP-UX'
     end
 
     it "should set its default path to include /sbin/init.d" do
@@ -25,7 +28,7 @@ describe provider do
 
   describe "when running on Archlinux" do
     before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('Archlinux')
+      Facter.stubs(:value).with(:operatingsystem).returns 'Archlinux'
     end
 
     it "should set its default path to include /etc/rc.d" do
@@ -35,7 +38,7 @@ describe provider do
 
   describe "when not running on FreeBSD, HP-UX or Archlinux" do
     before :each do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('RedHat')
+      Facter.stubs(:value).with(:operatingsystem).returns 'RedHat'
     end
 
     it "should set its default path to include /etc/init.d" do

data/spec/integration/provider/service/systemd_spec.rb

@@ -1,21 +1,24 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:systemd), '(integration)' do
+test_title = 'Integration Tests for Puppet::Type::Service::Provider::Systemd'
+
+describe test_title, unless: Puppet::Util::Platform.jruby? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:systemd) }
+
   # TODO: Unfortunately there does not seem a way to stub the executable
   #       checks in the systemd provider because they happen at load time.
-
-  it "should be considered suitable if /proc/1/comm is present and contains 'systemd'",
-    :if => File.exist?('/proc/1/comm') && Puppet::FileSystem.read('/proc/1/comm').include?('systemd') do
-    expect(described_class).to be_suitable
+  it "should be considered suitable if /bin/systemctl is present", :if => File.executable?('/bin/systemctl') do
+    expect(provider_class).to be_suitable
   end
 
-  it "should not be considered suitable if /proc/1/comm is present it does not contain 'systemd'",
-    :if => File.exist?('/proc/1/comm') && !Puppet::FileSystem.read('/proc/1/comm').include?('systemd') do
-    expect(described_class).not_to be_suitable
+  it "should be considered suitable if /usr/bin/systemctl is present", :if => File.executable?('/usr/bin/systemctl')  do
+    expect(provider_class).to be_suitable
   end
 
-  it "should not be considered suitable if /proc/1/comm is absent",
-    :if => !File.exist?('/proc/1/comm') do
-    expect(described_class).not_to be_suitable
+  it "should not be cosidered suitable if systemctl is absent",
+    :unless => (File.executable?('/bin/systemctl') or File.executable?('/usr/bin/systemctl')) do
+    expect(provider_class).not_to be_suitable
   end
 end

data/spec/integration/provider/service/windows_spec.rb

@@ -1,25 +1,28 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:windows), '(integration)',
-  :if => Puppet.features.microsoft_windows? do
+test_title = 'Integration Tests for Puppet::Type::Service::Provider::Windows'
+
+describe test_title, '(integration)', :if => Puppet::Util::Platform.windows? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:windows) }
 
   require 'puppet/util/windows'
 
   before :each do
-    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(described_class)
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns provider_class
   end
 
-  context 'should return valid values when querying a service that does not exist' do
+  context 'should fail querying services that do not exist' do
     let(:service) do
       Puppet::Type.type(:service).new(:name => 'foobarservice1234')
     end
 
-    it "with :false when asked if enabled" do
-      expect(service.provider.enabled?).to eql(:false)
+    it "with a Puppet::Error when querying enabled?" do
+      expect { service.provider.enabled? }.to raise_error(Puppet::Error)
     end
 
-    it "with :stopped when asked about status" do
-      expect(service.provider.status).to eql(:stopped)
+    it "with a Puppet::Error when querying status" do
+      expect { service.provider.status }.to raise_error(Puppet::Error)
     end
   end