puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

data/spec/unit/provider/aix_object_spec.rb

@@ -156,7 +156,7 @@ describe 'Puppet::Provider::AixObject' do
       provider.instance_variable_set(:@object_info, { :foo => 'foo', :baz => 'baz' })
 
       (provider.class.mappings[:aix_attribute].keys + [:attributes]).each do |property|
-        expect(provider).to receive(:get).with(property).and_return('value')
+        provider.expects(:get).with(property).returns('value')
 
         expect(provider.send(property)).to eql('value')
       end
@@ -167,7 +167,7 @@ describe 'Puppet::Provider::AixObject' do
 
       value = '15'
       provider.class.mappings[:aix_attribute].keys.each do |property|
-        expect(provider).to receive(:set).with(property, value)
+        provider.expects(:set).with(property, value)
 
         provider.send("#{property}=".to_sym, value)
       end
@@ -295,8 +295,8 @@ bin:2
 
     it 'lists all of the objects' do
       lscmd = 'lsgroups'
-      allow(provider.class).to receive(:command).with(:list).and_return(lscmd)
-      allow(provider.class).to receive(:execute).with([lscmd, '-c', '-a', 'id', 'ALL']).and_return(output)
+      provider.class.stubs(:command).with(:list).returns(lscmd)
+      provider.class.stubs(:execute).with([lscmd, '-c', '-a', 'id', 'ALL']).returns(output)
 
       expected_objects = [
         { :name => 'system', :id => '0' },
@@ -316,7 +316,7 @@ bin:2
     end
 
     it 'returns all of the available instances' do
-      allow(provider.class).to receive(:list_all).and_return(objects)
+      provider.class.stubs(:list_all).returns(objects)
 
       expect(provider.class.instances.map(&:name)).to eql(['group1', 'group2'])
     end
@@ -419,20 +419,20 @@ bin:2
 
   describe '#ia_module_args' do
     it 'returns no arguments if the ia_load_module parameter is not specified' do
-      allow(provider.resource).to receive(:[]).with(:ia_load_module).and_return(nil)
+      provider.resource.stubs(:[]).with(:ia_load_module).returns(nil)
       expect(provider.ia_module_args).to eql([])
     end
 
     it 'returns the ia_load_module as a CLI argument' do
-      allow(provider.resource).to receive(:[]).with(:ia_load_module).and_return('module')
+      provider.resource.stubs(:[]).with(:ia_load_module).returns('module')
       expect(provider.ia_module_args).to eql(['-R', 'module'])
     end
   end
 
   describe '#lscmd' do
     it 'returns the lscmd' do
-      allow(provider.class).to receive(:command).with(:list).and_return('list')
-      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
+      provider.class.stubs(:command).with(:list).returns('list')
+      provider.stubs(:ia_module_args).returns(['ia_module_args'])
 
       expect(provider.lscmd).to eql(
         ['list', '-c', 'ia_module_args', provider.resource.name]
@@ -449,8 +449,8 @@ bin:2
     end
 
     it 'returns the addcmd passing in the attributes as CLI arguments' do
-      allow(provider.class).to receive(:command).with(:add).and_return('add')
-      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
+      provider.class.stubs(:command).with(:add).returns('add')
+      provider.stubs(:ia_module_args).returns(['ia_module_args'])
 
       expect(provider.addcmd(attributes)).to eql(
         ['add', 'ia_module_args', 'attribute1=value1', 'attribute2=value2', provider.resource.name]
@@ -460,8 +460,8 @@ bin:2
 
   describe '#deletecmd' do
     it 'returns the lscmd' do
-      allow(provider.class).to receive(:command).with(:delete).and_return('delete')
-      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
+      provider.class.stubs(:command).with(:delete).returns('delete')
+      provider.stubs(:ia_module_args).returns(['ia_module_args'])
 
       expect(provider.deletecmd).to eql(
         ['delete', 'ia_module_args', provider.resource.name]
@@ -478,8 +478,8 @@ bin:2
     end
 
     it 'returns the addcmd passing in the attributes as CLI arguments' do
-      allow(provider.class).to receive(:command).with(:modify).and_return('modify')
-      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
+      provider.class.stubs(:command).with(:modify).returns('modify')
+      provider.stubs(:ia_module_args).returns(['ia_module_args'])
 
       expect(provider.modifycmd(attributes)).to eql(
         ['modify', 'ia_module_args', 'attribute1=value1', 'attribute2=value2', provider.resource.name]
@@ -496,9 +496,9 @@ bin:2
     end
 
     it 'modifies the AIX object with the new attributes' do
-      allow(provider).to receive(:modifycmd).with(new_attributes).and_return('modify_cmd')
-      expect(provider).to receive(:execute).with('modify_cmd')
-      expect(provider).to receive(:object_info).with(true)
+      provider.stubs(:modifycmd).with(new_attributes).returns('modify_cmd')
+      provider.expects(:execute).with('modify_cmd')
+      provider.expects(:object_info).with(true)
 
       provider.modify_object(new_attributes)
     end
@@ -516,20 +516,20 @@ bin:2
     end
 
     it 'returns :absent if the AIX object does not exist' do
-      allow(provider).to receive(:exists?).and_return(false)
+      provider.stubs(:exists?).returns(false)
       object_info[property] = 15
       
       expect(provider.get(property)).to eql(:absent)
     end
 
     it 'returns :absent if the property is not present on the system' do
-      allow(provider).to receive(:exists?).and_return(true)
+      provider.stubs(:exists?).returns(true)
 
       expect(provider.get(property)).to eql(:absent)
     end
 
     it "returns the property's value" do
-      allow(provider).to receive(:exists?).and_return(true)
+      provider.stubs(:exists?).returns(true)
       object_info[property] = 15
 
       expect(provider.get(property)).to eql(15)
@@ -557,9 +557,9 @@ bin:2
     end
 
     it "raises a Puppet::Error if it fails to set the property's value" do
-      allow(provider).to receive(:modify_object)
+      provider.stubs(:modify_object)
         .with({ :id => value.to_s })
-        .and_raise(Puppet::ExecutionFailure, 'failed to modify the AIX object!')
+        .raises(Puppet::ExecutionFailure, 'failed to modify the AIX object!')
 
       expect { provider.set(property, value) }.to raise_error do |error|
         expect(error).to be_a(Puppet::Error)
@@ -567,7 +567,7 @@ bin:2
     end
 
     it "sets the given property's value to the passed-in value" do
-      expect(provider).to receive(:modify_object).with({ :id => value.to_s })
+      provider.expects(:modify_object).with({ :id => value.to_s })
 
       provider.set(property, value)
     end
@@ -618,9 +618,9 @@ bin:2
     end
 
     it 'raises a Puppet::Error if it fails to set the new AIX attributes' do
-      allow(provider).to receive(:modify_object)
+      provider.stubs(:modify_object)
         .with(new_attributes)
-        .and_raise(Puppet::ExecutionFailure, 'failed to modify the AIX object!')
+        .raises(Puppet::ExecutionFailure, 'failed to modify the AIX object!')
       
       expect { provider.attributes = new_attributes }.to raise_error do |error|
         expect(error).to be_a(Puppet::Error)
@@ -630,7 +630,7 @@ bin:2
     end
 
     it 'sets the new AIX attributes' do
-      expect(provider).to receive(:modify_object).with(new_attributes)
+      provider.expects(:modify_object).with(new_attributes)
 
       provider.attributes = new_attributes
     end
@@ -650,7 +650,7 @@ bin:2
       )
 
       # Mock out our lscmd
-      allow(provider).to receive(:lscmd).and_return("lsuser #{resource[:name]}")
+      provider.stubs(:lscmd).returns("lsuser #{resource[:name]}")
     end
 
     it 'memoizes the result' do
@@ -659,7 +659,7 @@ bin:2
     end
 
     it 'returns nil if the AIX object does not exist' do
-      allow(provider).to receive(:execute).with(provider.lscmd).and_raise(
+      provider.stubs(:execute).with(provider.lscmd).raises(
         Puppet::ExecutionFailure, 'lscmd failed!'
       )
 
@@ -668,7 +668,7 @@ bin:2
 
     it 'collects the Puppet properties' do
       output = 'mock_output'
-      allow(provider).to receive(:execute).with(provider.lscmd).and_return(output)
+      provider.stubs(:execute).with(provider.lscmd).returns(output)
 
       # Mock the AIX attributes on the system
       mock_attributes = {
@@ -677,9 +677,9 @@ bin:2
         :attribute1 => 'value1',
         :attribute2 => 'value2'
       }
-      allow(provider.class).to receive(:parse_aix_objects)
+      provider.class.stubs(:parse_aix_objects)
         .with(output)
-        .and_return([{ :name => resource.name, :attributes => mock_attributes }])
+        .returns([{ :name => resource.name, :attributes => mock_attributes }])
 
       expected_property_values = {
         :uid        => 1,
@@ -696,12 +696,12 @@ bin:2
 
   describe '#exists?' do
     it 'should return true if the AIX object exists' do
-      allow(provider).to receive(:object_info).and_return({})
+      provider.stubs(:object_info).returns({})
       expect(provider.exists?).to be(true)
     end
 
     it 'should return false if the AIX object does not exist' do
-      allow(provider).to receive(:object_info).and_return(nil)
+      provider.stubs(:object_info).returns(nil)
       expect(provider.exists?).to be(false)
     end
   end
@@ -710,11 +710,9 @@ bin:2
     let(:property_attributes) do
       {}
     end
-
     def stub_attributes_property(attributes)
-      allow(provider.resource).to receive(:should).with(:attributes).and_return(attributes)
+      provider.resource.stubs(:should).with(:attributes).returns(attributes)
     end
-
     def set_property(puppet_property, aix_attribute, property_to_attribute, should_value = nil)
       property_to_attribute ||= lambda { |x| x }
 
@@ -723,7 +721,7 @@ bin:2
         aix_attribute: aix_attribute,
         property_to_attribute: property_to_attribute
       )
-      allow(provider.resource).to receive(:should).with(puppet_property).and_return(should_value)
+      provider.resource.stubs(:should).with(puppet_property).returns(should_value)
 
       if should_value
         property_attributes[aix_attribute] = property_to_attribute.call(should_value)
@@ -755,8 +753,8 @@ bin:2
     end
 
     it "raises a Puppet::Error if it fails to create the AIX object" do
-      allow(provider).to receive(:addcmd)
-      allow(provider).to receive(:execute).and_raise(
+      provider.stubs(:addcmd)
+      provider.stubs(:execute).raises(
         Puppet::ExecutionFailure, "addcmd failed!"
       )
 
@@ -771,10 +769,10 @@ bin:2
       attributes = { :fsize => 1000 }
       stub_attributes_property(attributes)
 
-      expect(provider).to receive(:addcmd)
+      provider.expects(:addcmd)
         .with(attributes.merge(property_attributes))
-        .and_return('addcmd')
-      expect(provider).to receive(:execute).with('addcmd')
+        .returns('addcmd')
+      provider.expects(:execute).with('addcmd')
 
       provider.create
     end
@@ -782,11 +780,11 @@ bin:2
  
   describe "#delete" do
     before(:each) do
-      allow(provider).to receive(:deletecmd).and_return('deletecmd')
+      provider.stubs(:deletecmd).returns('deletecmd')
     end
 
     it "raises a Puppet::Error if it fails to delete the AIX object" do
-      allow(provider).to receive(:execute).with(provider.deletecmd).and_raise(
+      provider.stubs(:execute).with(provider.deletecmd).raises(
         Puppet::ExecutionFailure, "deletecmd failed!"
       )
 
@@ -798,8 +796,8 @@ bin:2
     end
 
     it "deletes the AIX object" do
-      expect(provider).to receive(:execute).with(provider.deletecmd)
-      expect(provider).to receive(:object_info).with(true)
+      provider.expects(:execute).with(provider.deletecmd)
+      provider.expects(:object_info).with(true)
 
       provider.delete
     end

data/spec/unit/provider/command_spec.rb

@@ -9,8 +9,8 @@ describe Puppet::Provider::Command do
   let(:executable) { "foo" }
   let(:executable_absolute_path) { "/foo/bar" }
 
-  let(:executor) { double('executor') }
-  let(:resolver) { double('resolver') }
+  let(:executor) { mock('executor') }
+  let(:resolver) { mock('resolver') }
 
   let(:path_resolves_to_itself) do
     resolves = Object.new
@@ -23,37 +23,37 @@ describe Puppet::Provider::Command do
   end
 
   it "executes a simple command" do
-    expect(executor).to receive(:execute).with([executable], no_options)
+    executor.expects(:execute).with([executable], no_options)
 
     command = Puppet::Provider::Command.new(name, executable, path_resolves_to_itself, executor)
     command.execute()
   end
 
   it "executes a command with extra options" do
-    expect(executor).to receive(:execute).with([executable], the_options)
+    executor.expects(:execute).with([executable], the_options)
 
     command = Puppet::Provider::Command.new(name, executable, path_resolves_to_itself, executor, the_options)
     command.execute()
   end
 
   it "executes a command with arguments" do
-    expect(executor).to receive(:execute).with([executable, "arg1", "arg2"], no_options)
+    executor.expects(:execute).with([executable, "arg1", "arg2"], no_options)
 
     command = Puppet::Provider::Command.new(name, executable, path_resolves_to_itself, executor)
     command.execute("arg1", "arg2")
   end
 
   it "resolves to an absolute path for better execution" do
-    expect(resolver).to receive(:which).with(executable).and_return(executable_absolute_path)
-    expect(executor).to receive(:execute).with([executable_absolute_path], no_options)
+    resolver.expects(:which).with(executable).returns(executable_absolute_path)
+    executor.expects(:execute).with([executable_absolute_path], no_options)
 
     command = Puppet::Provider::Command.new(name, executable, resolver, executor)
     command.execute()
   end
 
   it "errors when the executable resolves to nothing" do
-    expect(resolver).to receive(:which).with(executable).and_return(nil)
-    expect(executor).not_to receive(:execute)
+    resolver.expects(:which).with(executable).returns(nil)
+    executor.expects(:execute).never
 
     command = Puppet::Provider::Command.new(name, executable, resolver, executor)
 

data/spec/unit/provider/exec/posix_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix? do
@@ -50,7 +51,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
 
       it "should fail if the command isn't executable" do
         FileUtils.touch(command)
-        allow(File).to receive(:executable?).with(command).and_return(false)
+        File.stubs(:executable?).with(command).returns(false)
 
         expect { provider.run(command) }.to raise_error(ArgumentError, "'#{command}' is not executable")
       end
@@ -62,7 +63,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
         provider.resource[:path] = [File.dirname(command)]
         filename = File.basename(command)
 
-        expect(Puppet::Util::Execution).to receive(:execute).with(filename, instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+        Puppet::Util::Execution.expects(:execute).with(filename, instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
 
         provider.run(filename)
       end
@@ -76,7 +77,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
       it "should fail if the command is in the path but not executable" do
         command = make_exe
         File.chmod(0644, command)
-        allow(FileTest).to receive(:executable?).with(command).and_return(false)
+        FileTest.stubs(:executable?).with(command).returns(false)
         resource[:path] = [File.dirname(command)]
         filename = File.basename(command)
 
@@ -93,7 +94,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
       provider.resource[:path] = ['/bogus/bin']
       command = make_exe
 
-      expect(Puppet::Util::Execution).to receive(:execute).with("#{command} bar --sillyarg=true --blah", instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+      Puppet::Util::Execution.expects(:execute).with("#{command} bar --sillyarg=true --blah", instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
 
       provider.run("#{command} bar --sillyarg=true --blah")
     end
@@ -109,7 +110,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
       provider.resource[:environment] = ['WHATEVER=/something/else', 'WHATEVER=/foo']
       command = make_exe
 
-      expect(Puppet::Util::Execution).to receive(:execute).with(command, instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+      Puppet::Util::Execution.expects(:execute).with(command, instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
 
       provider.run(command)
 
@@ -118,11 +119,11 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
 
     it "should set umask before execution if umask parameter is in use" do
       provider.resource[:umask] = '0027'
-      expect(Puppet::Util).to receive(:withumask).with(0027)
+      Puppet::Util.expects(:withumask).with(0027)
       provider.run(provider.resource[:command])
     end
 
-    describe "posix locale settings" do
+    describe "posix locale settings", :unless => RUBY_PLATFORM == 'java' do
       # a sentinel value that we can use to emulate what locale environment variables might be set to on an international
       # system.
       lang_sentinel_value = "en_US.UTF-8"
@@ -161,7 +162,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
       end
     end
 
-    describe "posix user-related environment vars" do
+    describe "posix user-related environment vars", :unless => RUBY_PLATFORM == 'java' do
       # a temporary hash that contains sentinel values for each of the user-related environment variables that we
       # are expected to unset during an "exec"
       user_sentinel_env = {}

data/spec/unit/provider/exec/shell_spec.rb

@@ -1,6 +1,8 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:exec).provider(:shell), :unless => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:exec).provider(:shell),
+         unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:resource) { Puppet::Type.type(:exec).new(:title => 'foo', :provider => 'shell') }
   let(:provider) { described_class.new(resource) }
 

data/spec/unit/provider/exec/windows_spec.rb

@@ -1,6 +1,8 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
-describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet::Util::Platform.windows? do
   include PuppetSpec::Files
 
   let(:resource) { Puppet::Type.type(:exec).new(:title => 'C:\foo', :provider => :windows) }
@@ -43,7 +45,7 @@ describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet.features.mic
   end
 
   describe "#checkexe" do
-    describe "when the command is absolute", :if => Puppet.features.microsoft_windows? do
+    describe "when the command is absolute", :if => Puppet::Util::Platform.windows? do
       it "should return if the command exists and is a file" do
         command = tmpfile('command')
         FileUtils.touch(command)
@@ -66,12 +68,12 @@ describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet.features.mic
     describe "when the command is relative" do
       describe "and a path is specified" do
         before :each do
-          allow(provider).to receive(:which)
+          provider.stubs(:which)
         end
 
         it "should search for executables with no extension" do
           provider.resource[:path] = [File.expand_path('/bogus/bin')]
-          expect(provider).to receive(:which).with('foo').and_return('foo')
+          provider.expects(:which).with('foo').returns('foo')
 
           provider.checkexe('foo')
         end