puppet 4.0.0-x64-mingw32 → 4.1.0-x64-mingw32

data/spec/integration/util/windows/security_spec.rb

@@ -15,7 +15,6 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
     @sids = {
       :current_user => Puppet::Util::Windows::SID.name_to_sid(Puppet::Util::Windows::ADSI::User.current_user_name),
       :system => Win32::Security::SID::LocalSystem,
-      :admin => Puppet::Util::Windows::SID.name_to_sid("Administrator"),
       :administrators => Win32::Security::SID::BuiltinAdministrators,
       :guest => Puppet::Util::Windows::SID.name_to_sid("Guest"),
       :users => Win32::Security::SID::BuiltinUsers,
@@ -387,9 +386,14 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
         end
 
         describe "#owner=" do
+          it "should accept the guest sid" do
+            winsec.set_owner(sids[:guest], path)
+            expect(winsec.get_owner(path)).to eq(sids[:guest])
+          end
+
           it "should accept a user sid" do
-            winsec.set_owner(sids[:admin], path)
-            expect(winsec.get_owner(path)).to eq(sids[:admin])
+            winsec.set_owner(sids[:current_user], path)
+            expect(winsec.get_owner(path)).to eq(sids[:current_user])
           end
 
           it "should accept a group sid" do
@@ -407,14 +411,19 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
         end
 
         describe "#group=" do
+          it "should accept the test group" do
+            winsec.set_group(sids[:guest], path)
+            expect(winsec.get_group(path)).to eq(sids[:guest])
+          end
+
           it "should accept a group sid" do
             winsec.set_group(sids[:power_users], path)
             expect(winsec.get_group(path)).to eq(sids[:power_users])
           end
 
           it "should accept a user sid" do
-            winsec.set_group(sids[:admin], path)
-            expect(winsec.get_group(path)).to eq(sids[:admin])
+            winsec.set_group(sids[:current_user], path)
+            expect(winsec.get_group(path)).to eq(sids[:current_user])
           end
 
           it "should combine owner and group rights when they are the same sid" do

data/spec/lib/matchers/resource.rb

@@ -36,7 +36,7 @@ module Matchers; module Resource
       if resource = actual_catalog.resource(expected_resource)
         resource_match(expected_resource, resource)
       else
-        @mismatch = "expected #{@actual.to_dot} to include #{@expected[0]}"
+        @mismatch = "expected #{@actual.to_dot} to include #{expected_resource}"
         false
       end
     end
@@ -50,4 +50,25 @@ module Matchers; module Resource
       @mismatch
     end
   end
+
+
+  matcher :be_resource do |expected_resource|
+    def resource_match(expected_resource, actual_resource)
+      if actual_resource.ref == expected_resource
+        true
+      else
+        @mismatch = "expected #{expected_resource} but was #{actual_resource.ref}"
+        false
+      end
+    end
+
+    match do |actual_resource|
+      resource_match(expected_resource, actual_resource)
+    end
+
+    def failure_message
+      @mismatch
+    end
+  end
+
 end; end

data/spec/lib/puppet_spec/matchers.rb

@@ -58,10 +58,10 @@ end
 RSpec::Matchers.define :have_printed do |expected|
 
   case expected
-    when String, Regexp
-      expected = expected
-    else
-      expected = expected.to_s
+  when String, Regexp, Proc
+    expected = expected
+  else
+    expected = expected.to_s
   end
 
   chain :and_exit_with do |code|
@@ -79,6 +79,8 @@ RSpec::Matchers.define :have_printed do |expected|
         actual.include?(expected)
       when Regexp
         expected.match(actual)
+      when Proc
+        expected.call(actual)
       else
         raise ArgumentError, "No idea how to match a #{actual.class.name}"
     end

data/spec/unit/application/master_spec.rb

@@ -314,10 +314,32 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
         @master.main
       end
 
-      it "should drop privileges if running as root" do
-        Puppet.features.stubs(:root?).returns true
+      def a_user_type_for(username)
+        user = mock 'user'
+        Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == username }.returns user
+        user
+      end
+
+      context "user privileges" do
+        it "should drop privileges if running as root and the puppet user exists" do
+          Puppet.features.stubs(:root?).returns true
+          a_user_type_for("puppet").expects(:exists?).returns true
+
+          Puppet::Util.expects(:chuser)
+
+          @master.main
+        end
+
+        it "should exit and log an error if running as root and the puppet user does not exist" do
+          Puppet.features.stubs(:root?).returns true
+          a_user_type_for("puppet").expects(:exists?).returns false
+
+          expect { @master.main }.to raise_error(Puppet::Error, /Could not change user to puppet\. User does not exist and is required to continue\./)
+        end
+      end
 
-        Puppet::Util.expects(:chuser)
+      it "should log a deprecation notice when running a WEBrick server" do
+        Puppet.expects(:deprecation_warning).with("The WEBrick Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppetlabs.com/deprecate-rack-webrick-servers for more information.")
 
         @master.main
       end
@@ -340,22 +362,26 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
         before do
           require 'puppet/network/http/rack'
           Puppet::Network::HTTP::Rack.stubs(:new).returns(@app)
-        end
 
-        it "it should not start a daemon" do
           @master.options.stubs(:[]).with(:rack).returns(:true)
+        end
 
+        it "it should not start a daemon" do
           @daemon.expects(:start).never
 
           @master.main
         end
 
         it "it should return the app" do
-          @master.options.stubs(:[]).with(:rack).returns(:true)
-
           app = @master.main
           expect(app).to equal(@app)
         end
+
+        it "should log a deprecation notice" do
+          Puppet.expects(:deprecation_warning).with("The Rack Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppetlabs.com/deprecate-rack-webrick-servers for more information.")
+
+          @master.main
+        end
       end
     end
   end

data/spec/unit/data_providers/function_data_provider_spec.rb

@@ -38,7 +38,7 @@ describe "when using function data provider" do
   # The result should be that the data set in the environment wins over those set in the
   # module.
   #
-  it 'it gets data from module and environment functions and combines them with env having higher precedence' do
+  it 'gets data from module and environment functions and combines them with env having higher precedence' do
     Puppet[:code] = 'include abc'
     node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
     compiler = Puppet::Parser::Compiler.new(node)
@@ -47,6 +47,15 @@ describe "when using function data provider" do
     expect(resources_in(catalog)).to include(*resources_created_in_fixture)
   end
 
+  it 'gets data from module having a puppet function delivering module data' do
+    Puppet[:code] = 'include xyz'
+    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
+    compiler = Puppet::Parser::Compiler.new(node)
+    catalog = compiler.compile()
+    resources_created_in_fixture = ["Notify[env_test1]", "Notify[env_test2]", "Notify[module_test3]"]
+    expect(resources_in(catalog)).to include(*resources_created_in_fixture)
+  end
+
   it 'raises an error if the environment data function does not return a hash' do
     Puppet[:code] = 'include abc'
     # find the loaders to patch with faulty function

data/spec/unit/file_serving/metadata_spec.rb

@@ -179,7 +179,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
 
       stat = Puppet::FileSystem.stat(path)
 
-      win_stat = Puppet::FileServing::Metadata::WindowsStat.new(stat, path)
+      win_stat = Puppet::FileServing::Metadata::WindowsStat.new(stat, path, :ignore)
 
       expect(win_stat.owner).to eq('S-1-5-32-544')
       expect(win_stat.group).to eq('S-1-0-0')

data/spec/unit/file_serving/terminus_helper_spec.rb

@@ -26,12 +26,11 @@ describe Puppet::FileServing::TerminusHelper do
 
   it "should pass through links, checksum_type, and source_permissions" do
     file = stub 'file', :checksum_type= => nil, :links= => nil, :collect => nil
-    [[:checksum_type, :sha256], [:links, true]].each {|k, v|
+    [[:checksum_type, :sha256], [:links, true], [:source_permissions, :use]].each {|k, v|
       file.expects(k.to_s+'=').with(v)
       @request.options[k] = v
     }
-    @request.options[:source_permissions] = :yes
-    file.expects(:collect).with(:yes)
+    file.expects(:collect)
     @model.expects(:new).with("/my/file", {:relative_path => :file}).returns(file)
     @helper.path2instance(@request, "/my/file", {:relative_path => :file})
   end

data/spec/unit/file_system_spec.rb

@@ -5,6 +5,18 @@ require 'puppet/util/platform'
 describe "Puppet::FileSystem" do
   include PuppetSpec::Files
 
+  def with_file_content(content)
+    path = tmpfile('file-system')
+    file = File.new(path, 'wb')
+    file.sync = true
+    file.print content
+
+    yield path
+
+  ensure
+    file.close
+  end
+
   context "#exclusive_open" do
     it "opens ands allows updating of an existing file" do
       file = file_containing("file_to_update", "the contents")
@@ -96,6 +108,32 @@ describe "Puppet::FileSystem" do
     end
   end
 
+  context "read_preserve_line_endings" do
+    it "should read a file with line feed" do
+      with_file_content("file content \n") do |file|
+        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \n")
+      end
+    end
+
+    it "should read a file with carriage return line feed" do
+      with_file_content("file content \r\n") do |file|
+        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \r\n")
+      end
+    end
+
+    it "should read a mixed file using only the first line newline when lf" do
+      with_file_content("file content \nsecond line \r\n") do |file|
+        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \nsecond line \r\n")
+      end
+    end
+
+    it "should read a mixed file using only the first line newline when crlf" do
+      with_file_content("file content \r\nsecond line \n") do |file|
+        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \r\nsecond line \n")
+      end
+    end
+  end
+
   describe "symlink",
     :if => ! Puppet.features.manages_symlinks? &&
     Puppet.features.microsoft_windows? do

data/spec/unit/functions/defined_spec.rb

@@ -0,0 +1,289 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe "the 'defined' function" do
+  after(:all) { Puppet::Pops::Loaders.clear }
+
+  # This loads the function once and makes it easy to call it
+  # It does not matter that it is not bound to the env used later since the function
+  # looks up everything via the scope that is given to it.
+  # The individual tests needs to have a fresh env/catalog set up
+  #
+  let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
+  let(:func) { loaders.puppet_system_loader.load(:function, 'defined') }
+
+  before :each do
+    # A fresh environment is needed for each test since tests creates types and resources
+    environment = Puppet::Node::Environment.create(:testing, [])
+    @node = Puppet::Node.new('yaynode', :environment => environment)
+    @known_resource_types = environment.known_resource_types
+    @compiler = Puppet::Parser::Compiler.new(@node)
+    @scope = Puppet::Parser::Scope.new(@compiler)
+  end
+
+  def newclass(name)
+    @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
+  end
+
+  def newdefine(name)
+    @known_resource_types.add Puppet::Resource::Type.new(:definition, name)
+  end
+
+  def newresource(type, title)
+    resource = Puppet::Resource.new(type, title)
+    @compiler.add_resource(@scope, resource)
+    resource
+  end
+
+  #--- CLASS
+  #
+  context 'can determine if a class' do
+    context 'is defined' do
+
+      it 'by using the class name in string form' do
+        newclass 'yayness'
+        expect(func.call(@scope, 'yayness')).to be_truthy
+      end
+
+      it 'by using a Type[Class[name]] type reference' do
+        name = 'yayness'
+        newclass name
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(class_type)
+        expect(func.call(@scope, type_type)).to be_truthy
+      end
+    end
+
+    context 'is not defined' do
+      it 'by using the class name in string form' do
+        expect(func.call(@scope, 'yayness')).to be_falsey
+      end
+
+      it 'even if there is a define, by using a Type[Class[name]] type reference' do
+        name = 'yayness'
+        newdefine name
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(class_type)
+        expect(func.call(@scope, type_type)).to be_falsey
+      end
+    end
+
+    context 'is defined and realized' do
+      it 'by using a Class[name] reference' do
+        name = 'cowabunga'
+        newclass name
+        newresource(:class, name)
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        expect(func.call(@scope, class_type)).to be_truthy
+      end
+    end
+
+    context 'is not realized' do
+      it '(although defined) by using a Class[name] reference' do
+        name = 'cowabunga'
+        newclass name
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        expect(func.call(@scope, class_type)).to be_falsey
+      end
+
+      it '(and not defined) by using a Class[name] reference' do
+        name = 'cowabunga'
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        expect(func.call(@scope, class_type)).to be_falsey
+      end
+    end
+  end
+
+  #---RESOURCE TYPE
+  #
+  context 'can determine if a resource type' do
+    context 'is defined' do
+
+      it 'by using the type name (of a built in type) in string form' do
+        expect(func.call(@scope, 'file')).to be_truthy
+      end
+
+      it 'by using the type name (of a resource type) in string form' do
+        newdefine 'yayness'
+        expect(func.call(@scope, 'yayness')).to be_truthy
+      end
+
+      it 'by using a File type reference (built in type)' do
+        resource_type = Puppet::Pops::Types::TypeFactory.resource('file')
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_truthy
+      end
+
+      it 'by using a Type[File] type reference' do
+        resource_type = Puppet::Pops::Types::TypeFactory.resource('file')
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_truthy
+      end
+
+      it 'by using a Resource[T] type reference (defined type)' do
+        name = 'yayness'
+        newdefine name
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(name)
+        expect(func.call(@scope, resource_type)).to be_truthy
+      end
+
+      it 'by using a Type[Resource[T]] type reference (defined type)' do
+        name = 'yayness'
+        newdefine name
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(name)
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_truthy
+      end
+    end
+
+    context 'is not defined' do
+      it 'by using the resource name in string form' do
+        expect(func.call(@scope, 'notatype')).to be_falsey
+      end
+
+      it 'even if there is a class with the same name, by using a Type[Resource[T]] type reference' do
+        name = 'yayness'
+        newclass name
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(name)
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_falsey
+      end
+    end
+
+    context 'is defined and instance realized' do
+      it 'by using a Resource[T, title] reference for a built in type' do
+        type_name = 'file'
+        title = '/tmp/myfile'
+        newdefine type_name
+        newresource(type_name, title)
+        class_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
+        expect(func.call(@scope, class_type)).to be_truthy
+      end
+
+      it 'by using a Resource[T, title] reference for a defined type' do
+        type_name = 'meme'
+        title = 'cowabunga'
+        newdefine type_name
+        newresource(type_name, title)
+        class_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
+        expect(func.call(@scope, class_type)).to be_truthy
+      end
+    end
+
+    context 'is not realized' do
+      it '(although defined) by using a Resource[T, title] reference or Type[Resource[T, title]] reference' do
+        type_name = 'meme'
+        title = 'cowabunga'
+        newdefine type_name
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
+        expect(func.call(@scope, resource_type)).to be_falsey
+
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_falsey
+      end
+
+      it '(and not defined) by using a Resource[T, title] reference or Type[Resource[T, title]] reference' do
+        type_name = 'meme'
+        title = 'cowabunga'
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
+        expect(func.call(@scope, resource_type)).to be_falsey
+
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_falsey
+      end
+    end
+  end
+
+  #---VARIABLES
+  #
+  context 'can determine if a variable' do
+    context 'is defined' do
+      it 'by giving the variable in string form' do
+        @scope['x'] = 'something'
+        expect(func.call(@scope, '$x')).to be_truthy
+      end
+
+      it 'by giving a :: prefixed variable in string form' do
+        @compiler.topscope['x'] = 'something'
+        expect(func.call(@scope, '$::x')).to be_truthy
+      end
+
+      it 'by giving a numeric variable in string form (when there is a match scope)' do
+        # with no match scope, there are no numeric variables defined
+        expect(func.call(@scope, '$0')).to be_falsey
+        expect(func.call(@scope, '$42')).to be_falsey
+        pattern = Regexp.new('.*')
+        @scope.new_match_scope(pattern.match('anything'))
+
+        # with a match scope, all numeric variables are set (the match defines if they have a value or not, but they are defined)
+        # even if their value is undef.
+        expect(func.call(@scope, '$0')).to be_truthy
+        expect(func.call(@scope, '$42')).to be_truthy
+      end
+    end
+
+    context 'is undefined' do
+      it 'by giving a :: prefixed or regular variable in string form' do
+        expect(func.call(@scope, '$x')).to be_falsey
+        expect(func.call(@scope, '$::x')).to be_falsey
+      end
+    end
+  end
+
+  context 'has any? semantics when given multiple arguments' do
+    it 'and one of the names is a defined user defined type' do
+      newdefine 'yayness'
+      expect(func.call(@scope, 'meh', 'yayness', 'booness')).to be_truthy
+    end
+
+    it 'and one of the names is a built type' do
+      expect(func.call(@scope, 'meh', 'file', 'booness')).to be_truthy
+    end
+
+    it 'and one of the names is a defined class' do
+      newclass 'yayness'
+      expect(func.call(@scope, 'meh', 'yayness', 'booness')).to be_truthy
+    end
+
+    it 'is true when at least one variable exists in scope' do
+      @scope['x'] = 'something'
+      expect(func.call(@scope, '$y', '$x', '$z')).to be_truthy
+    end
+
+    it 'is false when none of the names are defined' do
+      expect(func.call(@scope, 'meh', 'yayness', 'booness')).to be_falsey
+    end
+  end
+
+  it 'raises an argument error when asking if Resource type is defined' do
+    resource_type = Puppet::Pops::Types::TypeFactory.resource
+    expect { func.call(@scope, resource_type)}.to raise_error(ArgumentError, /reference to all.*type/)
+  end
+
+  it 'raises an argument error if you ask if Class is defined' do
+    class_type = Puppet::Pops::Types::TypeFactory.host_class
+    expect { func.call(@scope, class_type) }.to raise_error(ArgumentError, /reference to all.*class/)
+  end
+
+  it 'raises error if referencing undef' do
+    expect{func.call(@scope, nil)}.to raise_error(ArgumentError, /mis-matched arguments/)
+  end
+
+  it 'raises error if referencing a number' do
+    expect{func.call(@scope, 42)}.to raise_error(ArgumentError, /mis-matched arguments/)
+  end
+
+  it 'is false if referencing empty string' do
+    expect(func.call(@scope, '')).to be_falsey
+  end
+
+  it "is true if referencing 'main'" do
+    # mimic what compiler does with "main" in intial import
+    newclass ''
+    newresource :class, ''
+    expect(func.call(@scope, 'main')).to be_truthy
+  end
+
+end