puppet 4.4.0 → 4.5.0

data/spec/unit/resource/capability_finder_spec.rb

@@ -20,13 +20,21 @@ describe Puppet::Resource::CapabilityFinder do
         end
       end
       begin
-        make_cap_type
-        example.run
+        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+        Puppet.override(:loaders => loaders, :current_environment => env) do
+          make_cap_type
+          example.run
+        end
       ensure
         Puppet::Util.send(:remove_const, 'Puppetdb') if mock_pdb
+        Puppet::Type.rmtype(:cap)
+        Puppet::Pops::Loaders.clear
       end
     end
 
+    let(:env) { Puppet::Node::Environment.create(:testing, []) }
+    let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
     let(:response_body) { [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"ahost"}}] }
     let(:response) { stub('response', :body => response_body.to_json) }
 

data/spec/unit/resource/catalog_spec.rb

@@ -296,6 +296,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog = Puppet::Resource::Catalog.new("host")
       @one = Puppet::Type.type(:notify).new :name => "one"
       @two = Puppet::Type.type(:notify).new :name => "two"
+      @three = Puppet::Type.type(:notify).new :name => "three"
       @dupe = Puppet::Type.type(:notify).new :name => "one"
     end
 
@@ -349,6 +350,32 @@ describe Puppet::Resource::Catalog, "when compiling" do
       expect(@catalog.resource("notify[one]", nil)).to equal(@one)
     end
 
+    it "adds resources before an existing resource" do
+      @catalog.add_resource(@one)
+      @catalog.add_resource_before(@one, @two, @three)
+
+      expect(@catalog.resources).to eq([@two, @three, @one])
+    end
+
+    it "raises if adding a resource before a resource not in the catalog" do
+      expect {
+        @catalog.add_resource_before(@one, @two)
+      }.to raise_error(ArgumentError, "Cannot add resource Notify[two] before Notify[one] because Notify[one] is not yet in the catalog")
+    end
+
+    it "adds resources after an existing resource in reverse order" do
+      @catalog.add_resource(@one)
+      @catalog.add_resource_after(@one, @two, @three)
+
+      expect(@catalog.resources).to eq([@one, @three, @two])
+    end
+
+    it "raises if adding a resource after a resource not in the catalog" do
+      expect {
+        @catalog.add_resource_after(@one, @two)
+      }.to raise_error(ArgumentError, "Cannot add resource Notify[two] after Notify[one] because Notify[one] is not yet in the catalog")
+    end
+
     describe 'with a duplicate resource' do
       def resource_at(type, name, file, line)
         resource = Puppet::Resource.new(type, name)

data/spec/unit/settings/file_setting_spec.rb

@@ -169,6 +169,12 @@ describe Puppet::Settings::FileSetting do
       expect(resource.title).to eq(@basepath)
     end
 
+    it "should have a working directory with a root directory not called dev", :if => Puppet.features.microsoft_windows? do
+      # Although C:\Dev\.... is a valid path on Windows, some other code may regard it as a path to be ignored.  e.g. /dev/null resolves to C:\dev\null on Windows.
+      path = File.expand_path('somefile')
+      expect(path).to_not match(/^[A-Z]:\/dev/i)
+    end
+
     it "should fully qualified returned files if necessary (#795)" do
       @settings.stubs(:value).with(:myfile, nil, false).returns "myfile"
       path = File.expand_path('myfile')

data/spec/unit/settings_spec.rb

@@ -737,7 +737,7 @@ describe Puppet::Settings do
 
       Puppet::FileSystem.expects(:exist?).with(myfile).returns(true)
 
-      Puppet::FileSystem.expects(:read).with(myfile).returns "[main]"
+      Puppet::FileSystem.expects(:read).with(myfile, :encoding => 'utf-8').returns "[main]"
 
       @settings.send(:parse_config_files)
     end

data/spec/unit/transaction/additional_resource_generator_spec.rb

@@ -12,86 +12,101 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
   include Matchers::Resource
 
   let(:prioritizer) { Puppet::Graph::SequentialPrioritizer.new }
+  let(:env) { Puppet::Node::Environment.create(:testing, []) }
+  let(:node) { Puppet::Node.new('test', :environment => env) }
+  let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
+  around :each do |example|
+    Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+    Puppet.override(:loaders => loaders, :current_environment => env) do
+      Puppet::Type.newtype(:generator) do
+        include PuppetSpec::Compiler
+
+        newparam(:name) do
+          isnamevar
+        end
+
+        newparam(:kind) do
+          defaultto :eval_generate
+          newvalues(:eval_generate, :generate)
+        end
+
+        newparam(:code)
+
+        def respond_to?(method_name)
+          method_name == self[:kind] || super
+        end
+
+        def eval_generate
+          eval_code
+        end
+
+        def generate
+          eval_code
+        end
+
+        def eval_code
+          if self[:code]
+            compile_to_ral(self[:code]).resources.select { |r| r.ref =~ /Notify/ }
+          else
+            []
+          end
+        end
+      end
 
-  def find_vertex(graph, type, title)
-    graph.vertices.find {|v| v.type == type and v.title == title}
-  end
-
-  Puppet::Type.newtype(:generator) do
-    include PuppetSpec::Compiler
-
-    newparam(:name) do
-      isnamevar
-    end
-
-    newparam(:kind) do
-      defaultto :eval_generate
-      newvalues(:eval_generate, :generate)
-    end
-
-    newparam(:code)
+      Puppet::Type.newtype(:autorequire) do
+        newparam(:name) do
+          isnamevar
+        end
 
-    def respond_to?(method_name)
-      method_name == self[:kind] || super
-    end
+        autorequire(:notify) do
+          self[:name]
+        end
+      end
 
-    def eval_generate
-      eval_code
-    end
+      Puppet::Type.newtype(:gen_auto) do
+        newparam(:name) do
+          isnamevar
+        end
 
-    def generate
-      eval_code
-    end
+        newparam(:eval_after) do
+        end
 
-    def eval_code
-      if self[:code]
-        compile_to_ral(self[:code]).resources.select { |r| r.ref =~ /Notify/ }
-      else
-        []
+        def generate()
+          [ Puppet::Type.type(:autorequire).new(:name => self[:eval_after]) ]
+        end
       end
-    end
-  end
 
-  Puppet::Type.newtype(:autorequire) do
-    newparam(:name) do
-      isnamevar
-    end
+      Puppet::Type.newtype(:empty) do
+        newparam(:name) do
+          isnamevar
+        end
+      end
 
-    autorequire(:notify) do
-      self[:name]
-    end
-  end
+      Puppet::Type.newtype(:gen_empty) do
+        newparam(:name) do
+          isnamevar
+        end
 
-  Puppet::Type.newtype(:gen_auto) do
-    newparam(:name) do
-      isnamevar
-    end
+        newparam(:eval_after) do
+        end
 
-    newparam(:eval_after) do
-    end
+        def generate()
+          [ Puppet::Type.type(:empty).new(:name => self[:eval_after], :require => "Notify[#{self[:eval_after]}]") ]
+        end
+      end
 
-    def generate()
-      [ Puppet::Type.type(:autorequire).new(:name => self[:eval_after]) ]
-    end
-  end
+      example.run
 
-  Puppet::Type.newtype(:empty) do
-    newparam(:name) do
-      isnamevar
+      Puppet::Type.rmtype(:gen_empty)
+      Puppet::Type.rmtype(:eval_after)
+      Puppet::Type.rmtype(:autorequire)
+      Puppet::Type.rmtype(:generator)
     end
   end
 
-  Puppet::Type.newtype(:gen_empty) do
-    newparam(:name) do
-      isnamevar
-    end
-
-    newparam(:eval_after) do
-    end
-
-    def generate()
-      [ Puppet::Type.type(:empty).new(:name => self[:eval_after], :require => "Notify[#{self[:eval_after]}]") ]
-    end
+  def find_vertex(graph, type, title)
+    graph.vertices.find {|v| v.type == type and v.title == title}
   end
 
   context "when applying eval_generate" do

data/spec/unit/type/mount_spec.rb

@@ -545,15 +545,23 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
     end
   end
 
-  describe "establishing autorequires" do
+  describe "establishing autorequires and autobefores" do
 
-    def create_resource(path)
+    def create_mount_resource(path)
       described_class.new(
         :name => path,
         :provider => providerclass.new(path)
       )
     end
 
+    def create_file_resource(path)
+      file_class = Puppet::Type.type(:file)
+      file_class.new(
+        :path => path,
+        :provider => file_class.new(:path => path).provider
+      )
+    end
+
     def create_catalog(*resources)
       catalog = Puppet::Resource::Catalog.new
       resources.each do |resource|
@@ -563,38 +571,71 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       catalog
     end
 
-    let(:root_mount) { create_resource("/") }
-    let(:var_mount)  { create_resource("/var") }
-    let(:log_mount)  { create_resource("/var/log") }
+    let(:root_mount) { create_mount_resource("/") }
+    let(:var_mount)  { create_mount_resource("/var") }
+    let(:log_mount)  { create_mount_resource("/var/log") }
+    let(:var_file) { create_file_resource('/var') }
+    let(:log_file) { create_file_resource('/var/log') }
+    let(:puppet_file) { create_file_resource('/var/log/puppet') }
 
     before do
-      create_catalog(root_mount, var_mount, log_mount)
+      create_catalog(root_mount, var_mount, log_mount, var_file, log_file, puppet_file)
     end
 
     it "adds no autorequires for the root mount" do
       expect(root_mount.autorequire).to be_empty
     end
 
-    it "adds the parent autorequire for a mount with one parent" do
+    it "adds the parent autorequire and the file autorequire for a mount with one parent" do
       parent_relationship = var_mount.autorequire[0]
+      file_relationship = var_mount.autorequire[1]
 
-      expect(var_mount.autorequire).to have_exactly(1).item
+      expect(var_mount.autorequire).to have_exactly(2).items
 
       expect(parent_relationship.source).to eq root_mount
       expect(parent_relationship.target).to eq var_mount
+
+      expect(file_relationship.source).to eq var_file
+      expect(file_relationship.target).to eq var_mount
     end
 
-    it "adds both parent autorequires for a mount with two parents" do
+    it "adds both parent autorequires and the file autorequire for a mount with two parents" do
       grandparent_relationship = log_mount.autorequire[0]
       parent_relationship = log_mount.autorequire[1]
+      file_relationship = log_mount.autorequire[2]
 
-      expect(log_mount.autorequire).to have_exactly(2).items
+      expect(log_mount.autorequire).to have_exactly(3).items
 
       expect(grandparent_relationship.source).to eq root_mount
       expect(grandparent_relationship.target).to eq log_mount
 
       expect(parent_relationship.source).to eq var_mount
       expect(parent_relationship.target).to eq log_mount
+
+      expect(file_relationship.source).to eq log_file
+      expect(file_relationship.target).to eq log_mount
+    end
+
+    it "adds the child autobefore for a mount with one file child" do
+      child_relationship = log_mount.autobefore[0]
+
+      expect(log_mount.autobefore).to have_exactly(1).item
+
+      expect(child_relationship.source).to eq log_mount
+      expect(child_relationship.target).to eq puppet_file
+    end
+
+    it "adds both child autobefores for a mount with two file childs" do
+      child_relationship = var_mount.autobefore[0]
+      grandchild_relationship = var_mount.autobefore[1]
+
+      expect(var_mount.autobefore).to have_exactly(2).items
+
+      expect(child_relationship.source).to eq var_mount
+      expect(child_relationship.target).to eq log_file
+
+      expect(grandchild_relationship.source).to eq var_mount
+      expect(grandchild_relationship.target).to eq puppet_file
     end
   end
 end

data/spec/unit/type/service_spec.rb

@@ -218,6 +218,22 @@ describe Puppet::Type.type(:service), "when changing the host" do
     @service.property(:enable).sync
   end
 
+  it "should always consider the enable state of a static service to be in sync" do
+    @service.provider.class.stubs(:supports_parameter?).returns(true)
+    @service.provider.expects(:cached_enabled?).returns('static')
+    @service[:enable] = false
+    Puppet.expects(:debug).with("Unable to enable or disable static service yay")
+    expect(@service.property(:enable).insync?(:true)).to eq(true)
+  end
+
+  it "should determine insyncness normally when the service is not static" do
+    @service.provider.class.stubs(:supports_parameter?).returns(true)
+    @service.provider.expects(:cached_enabled?).returns('true')
+    @service[:enable] = true
+    Puppet.expects(:debug).never
+    expect(@service.property(:enable).insync?(:true)).to eq(true)
+  end
+
   it "should sync the service's enable state when changing the state of :ensure if :enable is being managed" do
     @service.provider.class.stubs(:supports_parameter?).returns(true)
     @service[:enable] = false

data/spec/unit/type_spec.rb

@@ -709,6 +709,20 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       @resource.property(:ensure).stubs(:retrieve).returns :absent
     end
 
+    it "should always retrieve the ensure value by default" do
+      @ensurable_resource = Puppet::Type.type(:file).new(:name => "/not/existent", :mode => "0644")
+      Puppet::Type::File::Ensure.stubs(:ensure).returns :absent
+      Puppet::Type::File::Ensure.any_instance.expects(:retrieve).once
+      @ensurable_resource.retrieve_resource
+    end
+
+    it "should not retrieve the ensure value if specified" do
+      @ensurable_resource = Puppet::Type.type(:service).new(:name => "DummyService", :enable => true)
+      @ensurable_resource.properties.each { |prop| prop.stubs(:retrieve) }
+      Puppet::Type::Service::Ensure.any_instance.expects(:retrieve).never
+      @ensurable_resource.retrieve_resource
+    end
+
     it "should fail if its provider is unsuitable" do
       @resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
       @resource.provider.class.expects(:suitable?).returns false