puppet 6.0.0-x86-mingw32 → 6.0.1-x86-mingw32

data/spec/unit/task_spec.rb

@@ -68,8 +68,7 @@ describe Puppet::Module::Task do
     task_files = %w{task1.elf task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
     Dir.expects(:glob).with(tasks_glob).returns(task_files)
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' =>
-    [{"name" => "task1.sh"}]})
+    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [{"name" => "task1.sh"}]})
 
     expect(tasks.count).to eq(1)
     expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
@@ -77,6 +76,52 @@ describe Puppet::Module::Task do
     expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([["#{tasks_path}/task1.sh"]])
   end
 
+  it "constructs a task as expected when task metadata declares additional files" do
+    task_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
+    Dir.expects(:glob).with(tasks_glob).returns(task_files)
+    Puppet::Module::Task.expects(:find_extra_files).returns([{'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"}])
+    tasks = Puppet::Module::Task.tasks_in_module(mymod)
+    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'files' => ["mymod/lib/file0.elf"]})
+
+    expect(tasks.count).to eq(1)
+    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
+    expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json"])
+    expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([["#{tasks_path}/task1.sh", "/path/to/file0.elf"]])
+  end
+
+  it "constructs a task as expected when a task implementation declares additional files" do
+    task_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
+    Dir.expects(:glob).with(tasks_glob).returns(task_files)
+    Puppet::Module::Task.expects(:find_extra_files).returns([{'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"}])
+    tasks = Puppet::Module::Task.tasks_in_module(mymod)
+    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [{"name" => "task1.sh", "files" => ["mymod/lib/file0.elf"]}]})
+
+    expect(tasks.count).to eq(1)
+    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
+    expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json"])
+    expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([["#{tasks_path}/task1.sh", "/path/to/file0.elf"]])
+  end
+
+  it "constructs a task as expected when task metadata and a task implementation both declare additional files" do
+    task_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
+    Dir.expects(:glob).with(tasks_glob).returns(task_files)
+    Puppet::Module::Task.expects(:find_extra_files).returns([
+      {'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"},
+      {'name' => 'yourmod/files/file1.txt', 'path' => "/other/path/to/file1.txt"}
+    ])
+    tasks = Puppet::Module::Task.tasks_in_module(mymod)
+    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [{"name" => "task1.sh", "files" => ["mymod/lib/file0.elf"]}]})
+
+    expect(tasks.count).to eq(1)
+    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
+    expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json"])
+    expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([[
+      "#{tasks_path}/task1.sh",
+      "/path/to/file0.elf",
+      "/other/path/to/file1.txt"
+    ]])
+  end
+
   it "constructs a task as expected when a task has files" do
     og_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
     Dir.expects(:glob).with(tasks_glob).returns(og_files)
@@ -136,7 +181,7 @@ describe Puppet::Module::Task do
     it "loads metadata for a task" do
       metadata  = {'desciption': 'some info'}
       Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe task1.json})
-      Puppet::Module::Task.any_instance.stubs(:read_metadata).returns(metadata)
+      Puppet::Module::Task.stubs(:read_metadata).returns(metadata)
 
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
@@ -180,7 +225,7 @@ describe Puppet::Module::Task do
       metadata  = {'desciption' => 'some info',
         'implementations' => [ {"name" => "task1.exe"}, ] }
       Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe task1.sh task1.json})
-      Puppet::Module::Task.any_instance.stubs(:read_metadata).returns(metadata)
+      Puppet::Module::Task.stubs(:read_metadata).returns(metadata)
 
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
@@ -192,7 +237,7 @@ describe Puppet::Module::Task do
       metadata  = {'desciption' => 'some info',
                    'implementations' => [ {"name" => "task2.sh"}, ] }
       Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe task2.sh task1.json})
-      Puppet::Module::Task.any_instance.stubs(:read_metadata).returns(metadata)
+      Puppet::Module::Task.stubs(:read_metadata).returns(metadata)
 
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
 

data/spec/unit/type/group_spec.rb

@@ -2,8 +2,21 @@
 require 'spec_helper'
 
 describe Puppet::Type.type(:group) do
-  before do
+  let(:mock_group_provider) do
+    described_class.provide(:mock_group_provider) do
+      has_features :manages_members
+      mk_resource_methods
+      def create; end
+      def delete; end
+      def exists?; get(:ensure) != :absent; end
+      def flush; end
+      def self.instances; []; end
+    end
+  end
+
+  before(:each) do
     @class = Puppet::Type.type(:group)
+    described_class.stubs(:defaultprovider).returns mock_group_provider
   end
 
   it "should have a system_groups feature" do
@@ -70,23 +83,108 @@ describe Puppet::Type.type(:group) do
     expect(type.exists?).to eq(true)
   end
 
-  describe "should delegate :members implementation to the provider:"  do
+  describe "when managing members" do
+    def stub_property(resource_hash)
+      described_class.new(resource_hash).property(:members)
+    end
+
+    describe "validation" do
+      it "raises an error for a non-String value" do
+        expect {
+          described_class.new(:name => 'foo', :members => true)
+        }.to raise_error(Puppet::Error)
+      end
+
+      it "raises an error for an array value containing a non-String element" do
+        expect {
+          described_class.new(:name => 'foo', :members => [ true, 'foo' ])
+        }.to raise_error(Puppet::Error)
+      end
+
+      it "raises an error when the members are specified as UIDs instead of usernames" do
+        expect {
+          described_class.new(:name => 'foo', :members => [ '123', '456' ])
+        }.to raise_error(Puppet::Error)
+      end
+
+      it "raises an error when an empty string is passed for a member's username" do
+        expect {
+          described_class.new(:name => 'foo', :members => [ 'foo', '' ])
+        }.to raise_error(Puppet::Error)
+      end
+
+      it "passes for a single member" do
+        expect {
+          described_class.new(:name => 'foo', :members => 'foo')
+        }.to_not raise_error
+      end
+
+      it "passes for a member whose username has a number" do
+        expect {
+          described_class.new(:name => 'foo', :members => 'foo123')
+        }.to_not raise_error
+      end
+
+      it "passes for an array of members" do
+        expect {
+          described_class.new(:name => 'foo', :members => [ 'foo', 'bar' ])
+        }.to_not raise_error
+      end
 
-    let (:provider) { @class.provide(:testing) { has_features :manages_members } }
-    let (:provider_instance) { provider.new }
-    let (:type) { @class.new(:name => "group", :provider => provider_instance, :members => ['user1']) }
+      it "passes for a comma-separated list of members" do
+        expect {
+          described_class.new(:name => 'foo', :members => 'foo,bar')
+        }.to_not raise_error
+      end
+    end
 
-    it "insync? calls members_insync?" do
-      provider_instance.expects(:members_insync?).with(['user1'], ['user1']).returns true
-      expect(type.property(:members).insync?(['user1'])).to be_truthy
+    describe "#inclusive?" do
+      it "returns false when auth_membership == false" do
+        members_property = stub_property(
+          :name => 'foo',
+          :auth_membership => false,
+          :members => []
+        )
+
+        expect(members_property.inclusive?).to be false
+      end
+
+      it "returns true when auth_membership == true" do
+        members_property = stub_property(
+          :name => 'foo',
+          :auth_membership => true,
+          :members => []
+        )
+
+        expect(members_property.inclusive?).to be true
+      end
     end
 
-    it "is_to_s and should_to_s call members_to_s" do
-      provider_instance.expects(:members_to_s).with(['user2', 'user1']).returns "user2 (), user1 ()"
-      provider_instance.expects(:members_to_s).with(['user1']).returns "user1 ()"
+    describe "#should= munging the @should instance variable" do
+      def should_var_of(property)
+        property.instance_variable_get(:@should)
+      end
 
-      expect(type.property(:members).is_to_s('user1')).to eq('user1 ()')
-      expect(type.property(:members).should_to_s('user2,user1')).to eq('user2 (), user1 ()')
+      it "leaves a single member as-is" do
+        members_property = stub_property(:name => 'foo', :members => [])
+        members_property.should = 'foo'
+
+        expect(should_var_of(members_property)).to eql([ 'foo' ])
+      end
+
+      it "leaves an array of members as-is" do
+        members_property = stub_property(:name => 'foo', :members => [])
+        members_property.should = [ 'foo', 'bar' ]
+
+        expect(should_var_of(members_property)).to eql(['foo', 'bar'])
+      end
+
+      it "munges a comma-separated list of members into an array" do
+        members_property = stub_property(:name => 'foo', :members => [])
+        members_property.should = 'foo,bar' 
+
+        expect(should_var_of(members_property)).to eql(['foo', 'bar'])
+      end
     end
   end
 end

data/spec/unit/util/execution_spec.rb

@@ -119,6 +119,17 @@ describe Puppet::Util::Execution, if: !Puppet::Util::Platform.jruby? do
         call_exec_posix("/bin/echo 'foo' ; \n /bin/echo 'bar' ;", {:uid => 50, :gid => 55}, @stdin, @stdout, @stderr)
       end
 
+      context 'cwd option' do
+        let(:cwd) { 'cwd' }
+
+        it 'should run the command in the specified working directory' do
+          Dir.expects(:chdir).with(cwd)
+          Kernel.expects(:exec).with('test command')
+
+          call_exec_posix('test command', { :cwd => cwd }, @stdin, @stdout, @stderr)
+        end
+      end
+
       it "should return the pid of the child process" do
         expect(call_exec_posix('test command', {}, @stdin, @stdout, @stderr)).to eq(pid)
       end
@@ -144,6 +155,24 @@ describe Puppet::Util::Execution, if: !Puppet::Util::Platform.jruby? do
         call_exec_windows('test command', {}, @stdin, @stdout, @stderr)
       end
 
+      context 'cwd option' do
+        let(:cwd) { 'cwd' }
+        it "should execute the command in the specified working directory" do
+          Dir.expects(:chdir).with(cwd).yields
+          Process.expects(:create).with(
+            :command_line => "test command",
+            :startup_info => {
+              :stdin => @stdin,
+              :stdout => @stdout,
+              :stderr => @stderr
+            },
+            :close_handles => false
+          )
+  
+          call_exec_windows('test command', { :cwd => cwd }, @stdin, @stdout, @stderr)
+        end
+      end
+
       it "should return the process info of the child process" do
         expect(call_exec_windows('test command', {}, @stdin, @stdout, @stderr)).to eq(proc_info_stub)
       end
@@ -219,6 +248,36 @@ describe Puppet::Util::Execution, if: !Puppet::Util::Platform.jruby? do
           end
         end
 
+        describe "cwd option" do
+          def expect_cwd_to_be(cwd)
+            Puppet::Util::Execution.expects(executor).with(
+              anything,
+              has_entries(:cwd => cwd),
+              anything,
+              anything,
+              anything
+            ).returns(rval)
+          end
+
+          it 'should raise an ArgumentError if the specified working directory does not exist' do
+            cwd = 'cwd'
+            Puppet::FileSystem.stubs(:directory?).with(cwd).returns(false)
+
+            expect {
+              Puppet::Util::Execution.execute('test command', cwd: cwd)
+            }.to raise_error do |error|
+              expect(error).to be_a(ArgumentError)
+              expect(error.message).to match(cwd)
+            end
+          end
+
+          it "should set the cwd to the user-specified one" do
+            Puppet::FileSystem.stubs(:directory?).with('cwd').returns(true)
+            expect_cwd_to_be('cwd')
+            Puppet::Util::Execution.execute('test command', cwd: 'cwd')
+          end
+        end
+
         describe "on POSIX", :if => Puppet.features.posix? do
           describe "when squelch is not set" do
             it "should set stdout to a pipe" do

data/spec/unit/util/posix_spec.rb

@@ -12,6 +12,34 @@ describe Puppet::Util::POSIX do
     @posix = PosixTest.new
   end
 
+  describe '.groups_of' do
+    let(:mock_groups) do
+      [
+        ['group1', ['user1', 'user2']],
+        ['group2', ['user2']],
+        ['group1', ['user1', 'user2']],
+        ['group3', ['user1']],
+        ['group4', ['user2']]
+      ].map do |(name, members)|
+        group_struct = stub("Group #{name}")
+        group_struct.stubs(:name).returns(name)
+        group_struct.stubs(:mem).returns(members)
+
+        group_struct
+      end
+    end
+
+    before(:each) do
+      Puppet::Etc.stubs(:group).multiple_yields(*mock_groups)
+    end
+
+    it 'returns the groups of the given user' do
+      expect(Puppet::Util::POSIX.groups_of('user1')).to eql(
+        ['group1', 'group3']
+      )
+    end
+  end
+
   [:group, :gr].each do |name|
     it "should return :gid as the field for #{name}" do
       expect(@posix.idfield(name)).to eq(:gid)

data/spec/unit/util/storage_spec.rb

@@ -225,5 +225,112 @@ describe Puppet::Util::Storage do
 
       expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
     end
+
+    it "expires entries with a :checked older than statettl seconds ago" do
+      Puppet[:statettl] = '1d'
+      recent_checked = Time.now
+      stale_checked = Time.now - (Puppet[:statettl] + 1)
+      Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
+      Puppet::Util::Storage.cache(:stale)[:checked] = stale_checked
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :stale => {
+            :checked => stale_checked
+          }
+        }
+      )
+
+      Puppet::Util::Storage.store
+      Puppet::Util::Storage.clear
+
+      expect(Puppet::Util::Storage.state).to eq({})
+
+      Puppet::Util::Storage.load
+
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          }
+        }
+      )
+    end
+
+
+    it "does not expire entries when statettl is 0" do
+      Puppet[:statettl] = '0'
+      recent_checked = Time.now
+      older_checked = Time.now - 10_000_000
+      Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
+      Puppet::Util::Storage.cache(:older)[:checked] = older_checked
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :older => {
+            :checked => older_checked
+          }
+        }
+      )
+
+      Puppet::Util::Storage.store
+      Puppet::Util::Storage.clear
+
+      expect(Puppet::Util::Storage.state).to eq({})
+
+      Puppet::Util::Storage.load
+
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :older => {
+            :checked => older_checked
+          }
+        }
+      )
+    end
+
+
+    it "does not expire entries when statettl is 'unlimited'" do
+      Puppet[:statettl] = 'unlimited'
+      recent_checked = Time.now
+      older_checked = Time.now - 10_000_000
+      Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
+      Puppet::Util::Storage.cache(:older)[:checked] = older_checked
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :older => {
+            :checked => older_checked
+          }
+        }
+      )
+
+      Puppet::Util::Storage.store
+      Puppet::Util::Storage.clear
+
+      expect(Puppet::Util::Storage.state).to eq({})
+
+      Puppet::Util::Storage.load
+
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :older => {
+            :checked => older_checked
+          }
+        }
+      )
+    end
   end
 end