puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/property_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/property'
 
@@ -59,73 +60,73 @@ describe Puppet::Property do
 
   describe "when returning the default event name" do
     it "should use the current 'should' value to pick the event name" do
-      expect(property).to receive(:should).and_return("myvalue")
-      expect(subclass).to receive(:value_option).with('myvalue', :event).and_return(:event_name)
+      property.expects(:should).returns "myvalue"
+      subclass.expects(:value_option).with('myvalue', :event).returns :event_name
 
       property.event_name
     end
 
     it "should return any event defined with the specified value" do
-      expect(property).to receive(:should).and_return(:myval)
-      expect(subclass).to receive(:value_option).with(:myval, :event).and_return(:event_name)
+      property.expects(:should).returns :myval
+      subclass.expects(:value_option).with(:myval, :event).returns :event_name
 
       expect(property.event_name).to eq(:event_name)
     end
 
     describe "and the property is 'ensure'" do
       before :each do
-        allow(property).to receive(:name).and_return(:ensure)
-        expect(resource).to receive(:type).and_return(:mytype)
+        property.stubs(:name).returns :ensure
+        resource.expects(:type).returns :mytype
       end
 
       it "should use <type>_created if the 'should' value is 'present'" do
-        expect(property).to receive(:should).and_return(:present)
+        property.expects(:should).returns :present
         expect(property.event_name).to eq(:mytype_created)
       end
 
       it "should use <type>_removed if the 'should' value is 'absent'" do
-        expect(property).to receive(:should).and_return(:absent)
+        property.expects(:should).returns :absent
         expect(property.event_name).to eq(:mytype_removed)
       end
 
       it "should use <type>_changed if the 'should' value is not 'absent' or 'present'" do
-        expect(property).to receive(:should).and_return(:foo)
+        property.expects(:should).returns :foo
         expect(property.event_name).to eq(:mytype_changed)
       end
 
       it "should use <type>_changed if the 'should value is nil" do
-        expect(property).to receive(:should).and_return(nil)
+        property.expects(:should).returns nil
         expect(property.event_name).to eq(:mytype_changed)
       end
     end
 
     it "should use <property>_changed if the property is not 'ensure'" do
-      allow(property).to receive(:name).and_return(:myparam)
-      expect(property).to receive(:should).and_return(:foo)
+      property.stubs(:name).returns :myparam
+      property.expects(:should).returns :foo
       expect(property.event_name).to eq(:myparam_changed)
     end
 
     it "should use <property>_changed if no 'should' value is set" do
-      allow(property).to receive(:name).and_return(:myparam)
-      expect(property).to receive(:should).and_return(nil)
+      property.stubs(:name).returns :myparam
+      property.expects(:should).returns nil
       expect(property.event_name).to eq(:myparam_changed)
     end
   end
 
   describe "when creating an event" do
     before :each do
-      allow(property).to receive(:should).and_return("myval")
+      property.stubs(:should).returns "myval"
     end
 
     it "should use an event from the resource as the base event" do
       event = Puppet::Transaction::Event.new
-      expect(resource).to receive(:event).and_return(event)
+      resource.expects(:event).returns event
 
       expect(property.event).to equal(event)
     end
 
     it "should have the default event name" do
-      expect(property).to receive(:event_name).and_return(:my_event)
+      property.expects(:event_name).returns :my_event
       expect(property.event.name).to eq(:my_event)
     end
 
@@ -134,23 +135,23 @@ describe Puppet::Property do
     end
 
     it "should have the 'should' value set" do
-      allow(property).to receive(:should).and_return("foo")
+      property.stubs(:should).returns "foo"
       expect(property.event.desired_value).to eq("foo")
     end
 
     it "should provide its path as the source description" do
-      allow(property).to receive(:path).and_return("/my/param")
+      property.stubs(:path).returns "/my/param"
       expect(property.event.source_description).to eq("/my/param")
     end
 
     it "should have the 'invalidate_refreshes' value set if set on a value" do
-      allow(property).to receive(:event_name).and_return(:my_event)
-      allow(property).to receive(:should).and_return("foo")
-      foo = double()
-      expect(foo).to receive(:invalidate_refreshes).and_return(true)
-      collection = double()
-      expect(collection).to receive(:match?).with("foo").and_return(foo)
-      allow(property.class).to receive(:value_collection).and_return(collection)
+      property.stubs(:event_name).returns :my_event
+      property.stubs(:should).returns "foo"
+      foo = mock()
+      foo.expects(:invalidate_refreshes).returns(true)
+      collection = mock()
+      collection.expects(:match?).with("foo").returns(foo)
+      property.class.stubs(:value_collection).returns(collection)
       expect(property.event.invalidate_refreshes).to be_truthy
     end
 
@@ -174,15 +175,15 @@ describe Puppet::Property do
     end
 
     it "should validate each value separately" do
-      expect(property).to receive(:validate).with("one")
-      expect(property).to receive(:validate).with("two")
+      property.expects(:validate).with("one")
+      property.expects(:validate).with("two")
 
       property.value = %w{one two}
     end
 
     it "should munge each value separately and use any result as the actual value" do
-      expect(property).to receive(:munge).with("one").and_return(:one)
-      expect(property).to receive(:munge).with("two").and_return(:two)
+      property.expects(:munge).with("one").returns :one
+      property.expects(:munge).with("two").returns :two
 
       # Do this so we get the whole array back.
       subclass.array_matching = :all
@@ -279,7 +280,7 @@ describe Puppet::Property do
     it "should validate that all required features are present" do
       subclass.newvalue(:foo, :required_features => [:a, :b])
 
-      expect(resource.provider).to receive(:satisfies?).with([:a, :b]).and_return(true)
+      resource.provider.expects(:satisfies?).with([:a, :b]).returns true
 
       property.should = :foo
     end
@@ -287,7 +288,7 @@ describe Puppet::Property do
     it "should fail if required features are missing" do
       subclass.newvalue(:foo, :required_features => [:a, :b])
 
-      expect(resource.provider).to receive(:satisfies?).with([:a, :b]).and_return(false)
+      resource.provider.expects(:satisfies?).with([:a, :b]).returns false
 
       expect { property.should = :foo }.to raise_error(Puppet::Error)
     end
@@ -295,7 +296,7 @@ describe Puppet::Property do
     it "should internally raise an ArgumentError if required features are missing" do
       subclass.newvalue(:foo, :required_features => [:a, :b])
 
-      expect(resource.provider).to receive(:satisfies?).with([:a, :b]).and_return(false)
+      resource.provider.expects(:satisfies?).with([:a, :b]).returns false
 
       expect { property.validate_features_per_value :foo }.to raise_error(ArgumentError)
     end
@@ -303,7 +304,7 @@ describe Puppet::Property do
     it "should validate that all required features are present for regexes" do
       subclass.newvalue(/./, :required_features => [:a, :b])
 
-      expect(resource.provider).to receive(:satisfies?).with([:a, :b]).and_return(true)
+      resource.provider.expects(:satisfies?).with([:a, :b]).returns true
 
       property.should = "foo"
     end
@@ -311,7 +312,7 @@ describe Puppet::Property do
     it "should support specifying an individual required feature" do
       subclass.newvalue(/./, :required_features => :a)
 
-      expect(resource.provider).to receive(:satisfies?).and_return(true)
+      resource.provider.expects(:satisfies?).returns true
 
       property.should = "foo"
     end
@@ -348,7 +349,7 @@ describe Puppet::Property do
     it "should set the value" do
       subclass.newvalue(:foo)
       property.should = :foo
-      expect(property).to receive(:set).with(:foo)
+      property.expects(:set).with(:foo)
       property.sync
     end
   end
@@ -377,13 +378,13 @@ describe Puppet::Property do
     describe "that was defined without a block" do
       it "should call the settor on the provider" do
         subclass.newvalue(:bar)
-        expect(resource.provider).to receive(:foo=).with(:bar)
+        resource.provider.expects(:foo=).with :bar
         property.set(:bar)
       end
 
        it "should generate setter named from :method argument and propagate call to the provider" do
         subclass.newvalue(:bar, :method => 'set_vv')
-        expect(resource.provider).to receive(:foo=).with(:bar)
+        resource.provider.expects(:foo=).with :bar
         property.set_vv(:bar)
       end
     end
@@ -391,14 +392,14 @@ describe Puppet::Property do
     describe "that was defined with a block" do
       it "should call the method created for the value if the value is not a regex" do
         subclass.newvalue(:bar) {}
-        expect(property).to receive(:set_bar)
+        property.expects(:set_bar)
         property.set(:bar)
       end
 
       it "should call the provided block if the value is a regex" do
-        thing = double
+        thing = mock
         subclass.newvalue(/./) { thing.test }
-        expect(thing).to receive(:test)
+        thing.expects(:test)
         property.set("foo")
       end
     end
@@ -555,7 +556,7 @@ describe Puppet::Property do
 
   describe "#insync_values?" do
     it "should log an exception when insync? throws one" do
-      expect(property).to receive(:insync?).and_raise(ArgumentError)
+      property.expects(:insync?).raises ArgumentError
       expect(property.insync_values?("foo","bar")).to be nil
     end
   end

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