puppet 6.0.10-x86-mingw32 → 6.1.0-x86-mingw32

data/spec/unit/type/user_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 # encoding: UTF-8
 require 'spec_helper'
 
@@ -12,7 +13,7 @@ describe Puppet::Type.type(:user) do
       def flush; end
       def self.instances; []; end
     end
-    allow(described_class).to receive(:defaultprovider).and_return(@provider_class)
+    described_class.stubs(:defaultprovider).returns @provider_class
   end
 
   it "should be able to create an instance" do
@@ -64,12 +65,12 @@ describe Puppet::Type.type(:user) do
     end
 
     it "cannot be set to true for a provider that does not manage homedirs" do
-      allow(provider.class).to receive(:manages_homedir?).and_return(false)
+      provider.class.stubs(:manages_homedir?).returns false
       expect { instance[:managehome] = 'yes' }.to raise_error(Puppet::Error, /can not manage home directories/)
     end
 
     it "can be set to true for a provider that does manage homedirs" do
-      allow(provider.class).to receive(:manages_homedir?).and_return(true)
+      provider.class.stubs(:manages_homedir?).returns true
       instance[:managehome] = 'yes'
     end
   end
@@ -126,8 +127,8 @@ describe Puppet::Type.type(:user) do
     end
 
     it "should set all values to :absent if the user is absent" do
-      expect(@user.property(:ensure)).to receive(:retrieve).and_return(:absent)
-      expect(@user.property(:uid)).not_to receive(:retrieve)
+      @user.property(:ensure).expects(:retrieve).returns :absent
+      @user.property(:uid).expects(:retrieve).never
       expect(@user.retrieve[@user.property(:uid)]).to eq(:absent)
     end
 
@@ -147,13 +148,13 @@ describe Puppet::Type.type(:user) do
 
     it "should call :create on the provider when asked to sync to the :present state" do
       @provider = @provider_class.new(:name => 'foo', :ensure => :absent)
-      expect(@provider).to receive(:create)
+      @provider.expects(:create)
       described_class.new(:name => 'foo', :ensure => :present, :provider => @provider).parameter(:ensure).sync
     end
 
     it "should call :delete on the provider when asked to sync to the :absent state" do
       @provider = @provider_class.new(:name => 'foo', :ensure => :present)
-      expect(@provider).to receive(:delete)
+      @provider.expects(:delete)
       described_class.new(:name => 'foo', :ensure => :absent, :provider => @provider).parameter(:ensure).sync
     end
 
@@ -211,27 +212,27 @@ describe Puppet::Type.type(:user) do
       end
 
       it "should return true if any of the specified groups are equal to the current integer" do
-        expect(Puppet::Util).to receive(:gid).with("foo").and_return(300)
-        expect(Puppet::Util).to receive(:gid).with("bar").and_return(500)
+        Puppet::Util.expects(:gid).with("foo").returns 300
+        Puppet::Util.expects(:gid).with("bar").returns 500
         expect(described_class.new(:name => 'baz', :gid => [ 'foo', 'bar' ]).parameter(:gid)).to be_safe_insync(500)
       end
 
       it "should return false if none of the specified groups are equal to the current integer" do
-        expect(Puppet::Util).to receive(:gid).with("foo").and_return(300)
-        expect(Puppet::Util).to receive(:gid).with("bar").and_return(500)
+        Puppet::Util.expects(:gid).with("foo").returns 300
+        Puppet::Util.expects(:gid).with("bar").returns 500
         expect(described_class.new(:name => 'baz', :gid => [ 'foo', 'bar' ]).parameter(:gid)).to_not be_safe_insync(700)
       end
     end
 
     describe "when syncing" do
       it "should use the first found, specified group as the desired value and send it to the provider" do
-        expect(Puppet::Util).to receive(:gid).with("foo").and_return(nil)
-        expect(Puppet::Util).to receive(:gid).with("bar").and_return(500)
+        Puppet::Util.expects(:gid).with("foo").returns nil
+        Puppet::Util.expects(:gid).with("bar").returns 500
 
         @provider = @provider_class.new(:name => 'foo')
         resource = described_class.new(:name => 'foo', :provider => @provider, :gid => [ 'foo', 'bar' ])
 
-        expect(@provider).to receive(:gid=).with(500)
+        @provider.expects(:gid=).with 500
         resource.parameter(:gid).sync
       end
     end
@@ -256,6 +257,7 @@ describe Puppet::Type.type(:user) do
     end
 
     describe "when testing is in sync" do
+
       before :each do
         # the useradd provider uses a single string to represent groups and so does Puppet::Property::List when converting to should values
         @provider = @provider_class.new(:name => 'foo', :groups => 'a,b,e,f')
@@ -364,7 +366,7 @@ describe Puppet::Type.type(:user) do
         # useradd subclasses nameservice and thus inherits #comments_insync?
         user = described_class.new(:name => 'foo', :comment => @value, :provider => :useradd)
         comment_property = user.properties.find {|p| p.name == :comment}
-        expect(user.provider).to receive(:comments_insync?)
+        user.provider.expects(:comments_insync?)
         comment_property.insync?('bar')
       end
 
@@ -372,7 +374,6 @@ describe Puppet::Type.type(:user) do
         let(:is) { "\u2603" }
         let(:should) { "\u06FF" }
         let(:comment_property) { @user.properties.find { |p| p.name == :comment } }
-
         context "given is and should strings with incompatible encoding" do
           it "should return a formatted string" do
             is.force_encoding(Encoding::ASCII_8BIT)
@@ -408,7 +409,7 @@ describe Puppet::Type.type(:user) do
       Puppet::Resource::Catalog.new :testing do |conf|
         [testuser, testrole].each { |resource| conf.add_resource resource }
       end
-      allow(Puppet::Type::User::ProviderDirectoryservice).to receive(:get_macosx_version_major).and_return("10.5")
+      Puppet::Type::User::ProviderDirectoryservice.stubs(:get_macosx_version_major).returns "10.5"
 
       rel = testuser.autorequire[0]
       expect(rel.source.ref).to eq(testrole.ref)
@@ -430,15 +431,15 @@ describe Puppet::Type.type(:user) do
         def check_valid_shell; end
       end
 
-      allow(described_class).to receive(:defaultprovider).and_return(@shell_provider_class)
+      described_class.stubs(:defaultprovider).returns @shell_provider_class
     end
 
     it "should call :check_valid_shell on the provider when changing shell value" do
       @provider = @shell_provider_class.new(:name => 'foo', :shell => '/bin/bash', :ensure => :present)
-      expect(@provider).to receive(:check_valid_shell)
+      @provider.expects(:check_valid_shell)
       resource = described_class.new(:name => 'foo', :shell => '/bin/zsh', :provider => @provider)
-      allow(Puppet::Util::Storage).to receive(:load)
-      allow(Puppet::Util::Storage).to receive(:store)
+      Puppet::Util::Storage.stubs(:load)
+      Puppet::Util::Storage.stubs(:store)
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource resource
       catalog.apply
@@ -446,10 +447,10 @@ describe Puppet::Type.type(:user) do
 
     it "should call :check_valid_shell on the provider when changing ensure from present to absent" do
       @provider = @shell_provider_class.new(:name => 'foo', :shell => '/bin/bash', :ensure => :absent)
-      expect(@provider).to receive(:check_valid_shell)
+      @provider.expects(:check_valid_shell)
       resource = described_class.new(:name => 'foo', :shell => '/bin/zsh', :provider => @provider)
-      allow(Puppet::Util::Storage).to receive(:load)
-      allow(Puppet::Util::Storage).to receive(:store)
+      Puppet::Util::Storage.stubs(:load)
+      Puppet::Util::Storage.stubs(:store)
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource resource
       catalog.apply

data/spec/unit/type/whit_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 whit = Puppet::Type.type(:whit)

data/spec/unit/type_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet/property/boolean'
@@ -137,18 +138,18 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
 
   it "should delegate to the tagging module when tags are added" do
     resource = klass.new(:name => "foo")
-    allow(resource).to receive(:tag).with(resource_type)
+    resource.stubs(:tag).with(resource_type)
 
-    expect(resource).to receive(:tag).with(:tag1, :tag2)
+    resource.expects(:tag).with(:tag1, :tag2)
 
     resource.tags = [:tag1,:tag2]
   end
 
   it "should add the current type as tag" do
     resource = klass.new(:name => "foo")
-    allow(resource).to receive(:tag)
+    resource.stubs(:tag)
 
-    expect(resource).to receive(:tag).with(resource_type)
+    resource.expects(:tag).with(resource_type)
 
     resource.tags = [:tag1,:tag2]
   end
@@ -254,7 +255,7 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
 
     {:file => "/my/file", :line => 50}.each do |attr, value|
       it "should set the #{attr}" do
-        allow(@resource).to receive(attr).and_return(value)
+        @resource.stubs(attr).returns value
         expect(@resource.event.send(attr)).to eq(value)
       end
     end
@@ -393,8 +394,8 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
       basic = type.provide(:basic) {}
       greater = type.provide(:greater) {}
 
-      allow(basic).to receive(:specificity).and_return(1)
-      allow(greater).to receive(:specificity).and_return(2)
+      basic.stubs(:specificity).returns 1
+      greater.stubs(:specificity).returns 2
 
       expect(type.defaultprovider).to equal(greater)
     end
@@ -602,7 +603,7 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
         resource = Puppet::Resource.new(resource_type, "/foo",
                                         :parameters => {:atboot => :yes, :fstype => "boo", :remounts => true},
                                         :sensitive_parameters => [:remounts])
-        expect_any_instance_of(klass).to receive(:warning).with(/Unable to mark 'remounts' as sensitive: remounts is a parameter and not a property/)
+        klass.any_instance.expects(:warning).with(regexp_matches(/Unable to mark 'remounts' as sensitive: remounts is a parameter and not a property/))
         klass.new(resource)
       end
 
@@ -610,7 +611,7 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
         resource = Puppet::Resource.new(resource_type, "/foo",
                                         :parameters => {:atboot => :yes, :fstype => "boo"},
                                         :sensitive_parameters => [:device])
-        expect_any_instance_of(klass).to receive(:warning).with("Unable to mark 'device' as sensitive: the property itself was not assigned a value.")
+        klass.any_instance.expects(:warning).with("Unable to mark 'device' as sensitive: the property itself was not assigned a value.")
         klass.new(resource)
       end
 
@@ -618,7 +619,7 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
         resource = Puppet::Resource.new(resource_type, "/foo",
                                         :parameters => {:atboot => :yes, :fstype => "boo"},
                                         :sensitive_parameters => [:content])
-        expect_any_instance_of(klass).to receive(:err).with("Unable to mark 'content' as sensitive: the property itself is not defined on #{resource_type}.")
+        klass.any_instance.expects(:err).with("Unable to mark 'content' as sensitive: the property itself is not defined on #{resource_type}.")
         klass.new(resource)
       end
     end
@@ -672,8 +673,8 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
       end
 
       it "should include the file/line in the error" do
-        allow_any_instance_of(Puppet::Type.type(:file)).to receive(:file).and_return("example.pp")
-        allow_any_instance_of(Puppet::Type.type(:file)).to receive(:line).and_return(42)
+        Puppet::Type.type(:file).any_instance.stubs(:file).returns("example.pp")
+        Puppet::Type.type(:file).any_instance.stubs(:line).returns(42)
         expect { Puppet::Type.type(:file).new(:title => "/foo", :source => "unknown:///") }.to raise_error(Puppet::ResourceError, /\(file: example\.pp, line: 42\)/)
       end
     end
@@ -689,15 +690,15 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
     end
 
     it "should set the attributes in the order returned by the class's :allattrs method" do
-      allow(klass).to receive(:allattrs).and_return([:name, :atboot, :noop])
+      klass.stubs(:allattrs).returns([:name, :atboot, :noop])
       resource = Puppet::Resource.new(resource_type, "/foo", :parameters => {:name => "myname", :atboot => :yes, :noop => "whatever"})
 
       set = []
 
-      allow_any_instance_of(klass).to receive(:newattr) do |_, param, hash|
+      klass.any_instance.stubs(:newattr).with do |param, hash|
         set << param
-        double("a property", :value= => nil, :default => nil, :name => nil)
-      end
+        true
+      end.returns(stub_everything("a property"))
 
       klass.new(resource)
 
@@ -706,15 +707,15 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
     end
 
     it "should always set the name and then default provider before anything else" do
-      allow(klass).to receive(:allattrs).and_return([:provider, :name, :atboot])
+      klass.stubs(:allattrs).returns([:provider, :name, :atboot])
       resource = Puppet::Resource.new(resource_type, "/foo", :parameters => {:name => "myname", :atboot => :yes})
 
       set = []
 
-      allow_any_instance_of(klass).to receive(:newattr) do |_, param, hash|
+      klass.any_instance.stubs(:newattr).with do |param, hash|
         set << param
-        double("a property", :value= => nil, :default => nil, :name => nil)
-      end
+        true
+      end.returns(stub_everything("a property"))
 
       klass.new(resource)
       expect(set[0]).to eq(:name)
@@ -727,10 +728,10 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
       # on jruby. Thus, we stub it out here since we don't care to do any assertions on it.
       # This is only an issue if you're running these unit tests on a platform where upstart
       # is a default provider, like Ubuntu trusty.
-      allow(Puppet::Util::Execution).to receive(:execute)
+      Puppet::Util::Execution.stubs(:execute)
 
       defaults = []
-      allow_any_instance_of(Puppet::Type.type(:service)).to receive(:set_default) { |_, value| defaults << value }
+      Puppet::Type.type(:service).any_instance.stubs(:set_default).with { |value| defaults << value; true }
 
       Puppet::Type.type(:service).new :name => "whatever"
 
@@ -747,7 +748,7 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
 
     context "when validating the resource" do
       it "should call the type's validate method if present" do
-        expect_any_instance_of(Puppet::Type.type(:file)).to receive(:validate)
+        Puppet::Type.type(:file).any_instance.expects(:validate)
         Puppet::Type.type(:file).new(:name => make_absolute('/foo'))
       end
 
@@ -762,8 +763,8 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
       end
 
       it "should raise Puppet::ResourceError with manifest file and line on failure" do
-        allow_any_instance_of(Puppet::Type.type(:file)).to receive(:file).and_return("example.pp")
-        allow_any_instance_of(Puppet::Type.type(:file)).to receive(:line).and_return(42)
+        Puppet::Type.type(:file).any_instance.stubs(:file).returns("example.pp")
+        Puppet::Type.type(:file).any_instance.stubs(:line).returns(42)
         expect do
           Puppet::Type.type(:file).new(
             :name => make_absolute('/foo'),
@@ -855,7 +856,7 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
     end
 
     it "should use the Resource Type's namevar to determine how to find the name in the hash" do
-      allow(@type).to receive(:key_attributes).and_return([ :myname ])
+      @type.stubs(:key_attributes).returns([ :myname ])
 
       expect(@type.hash2resource(:myname => "foo").title).to eq("foo")
     end
@@ -889,26 +890,26 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
   describe "when retrieving current property values" do
     before do
       @resource = klass.new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
-      allow(@resource.property(:ensure)).to receive(:retrieve).and_return(:absent)
+      @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")
-      allow(Puppet::Type::File::Ensure).to receive(:ensure).and_return(:absent)
-      expect_any_instance_of(Puppet::Type::File::Ensure).to receive(:retrieve).once
+      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| allow(prop).to receive(:retrieve) }
-      expect_any_instance_of(Puppet::Type::Service::Ensure).not_to receive(:retrieve)
+      @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 = klass.new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
-      expect(@resource.provider.class).to receive(:suitable?).and_return(false)
+      @resource.provider.class.expects(:suitable?).returns false
       expect { @resource.retrieve_resource }.to raise_error(Puppet::Error)
     end
 
@@ -935,14 +936,14 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
     end
 
     it "should not call retrieve on non-ensure properties if the resource is absent and should consider the property absent" do
-      expect(@resource.property(:ensure)).to receive(:retrieve).and_return(:absent)
-      expect(@resource.property(:fstype)).not_to receive(:retrieve)
+      @resource.property(:ensure).expects(:retrieve).returns :absent
+      @resource.property(:fstype).expects(:retrieve).never
       expect(@resource.retrieve_resource[:fstype]).to eq(:absent)
     end
 
     it "should include the result of retrieving each property's current value if the resource is present" do
-      expect(@resource.property(:ensure)).to receive(:retrieve).and_return(:present)
-      expect(@resource.property(:fstype)).to receive(:retrieve).and_return(15)
+      @resource.property(:ensure).expects(:retrieve).returns :present
+      @resource.property(:fstype).expects(:retrieve).returns 15
       @resource.retrieve_resource[:fstype] == 15
     end
   end
@@ -961,8 +962,8 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
       expect(type_resource.parameters[:remounts]).not_to be_a(Puppet::Property)
       expect(type_resource.parameters[:fstype].is_a?(Puppet::Property)).to be_truthy
 
-      expect(type_resource.property(:ensure)).to receive(:retrieve).and_return(:present)
-      expect(type_resource.property(:fstype)).to receive(:retrieve).and_return(15)
+      type_resource.property(:ensure).expects(:retrieve).returns :present
+      type_resource.property(:fstype).expects(:retrieve).returns 15
 
       resource = type_resource.to_resource
 
@@ -977,7 +978,7 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
     describe "when there's one namevar" do
       before do
         @type_class = Puppet::Type.type(:notify)
-        allow(@type_class).to receive(:key_attributes).and_return([:one])
+        @type_class.stubs(:key_attributes).returns([:one])
       end
 
       it "should have a default pattern for when there's one namevar" do
@@ -1032,7 +1033,7 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
     let(:provider) { resource.provider }
 
     it "should be suitable if its type doesn't use providers" do
-      allow(type).to receive(:paramclass).with(:provider).and_return(nil)
+      type.stubs(:paramclass).with(:provider).returns nil
       expect(resource).to be_suitable
     end
 
@@ -1041,18 +1042,18 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
     end
 
     it "should not be suitable if it has a provider which is not suitable" do
-      allow(provider.class).to receive(:suitable?).and_return(false)
+      provider.class.stubs(:suitable?).returns false
       expect(resource).not_to be_suitable
     end
 
     it "should be suitable if it does not have a provider and there is a default provider" do
-      allow(resource).to receive(:provider).and_return(nil)
+      resource.stubs(:provider).returns nil
       expect(resource).to be_suitable
     end
 
     it "should not be suitable if it doesn't have a provider and there is not default provider" do
-      allow(resource).to receive(:provider).and_return(nil)
-      allow(type).to receive(:defaultprovider).and_return(nil)
+      resource.stubs(:provider).returns nil
+      type.stubs(:defaultprovider).returns nil
 
       expect(resource).not_to be_suitable
     end
@@ -1184,29 +1185,27 @@ describe Puppet::Type::RelationshipMetaparam do
   end
 
   it "should be able to validate relationships" do
-    expect(Puppet::Type.metaparamclass(:require).new(:resource => double("resource"))).to respond_to(:validate_relationship)
+    expect(Puppet::Type.metaparamclass(:require).new(:resource => mock("resource"))).to respond_to(:validate_relationship)
   end
 
   describe 'if any specified resource is not in the catalog' do
-    let(:catalog) { double('catalog') }
+    let(:catalog) { mock 'catalog' }
 
     let(:resource) do
-      double(
-        'resource',
+      stub 'resource',
         :catalog => catalog,
         :ref     => 'resource',
         :line=   => nil,
         :line    => nil,
         :file=   => nil,
         :file    => nil
-      )
     end
 
     let(:param) { Puppet::Type.metaparamclass(:require).new(:resource => resource, :value => %w{Foo[bar] Class[test]}) }
 
     before do
-      expect(catalog).to receive(:resource).with("Foo[bar]").and_return("something")
-      expect(catalog).to receive(:resource).with("Class[Test]").and_return(nil)
+      catalog.expects(:resource).with("Foo[bar]").returns "something"
+      catalog.expects(:resource).with("Class[Test]").returns nil
     end
 
     describe "and the resource doesn't have a file or line number" do
@@ -1220,8 +1219,8 @@ describe Puppet::Type::RelationshipMetaparam do
 
     describe "and the resource has a file or line number" do
       before do
-        allow(resource).to receive(:line).and_return('42')
-        allow(resource).to receive(:file).and_return('/hitchhikers/guide/to/the/galaxy')
+        resource.stubs(:line).returns '42'
+        resource.stubs(:file).returns '/hitchhikers/guide/to/the/galaxy'
       end
 
       it "raises an error with context" do
@@ -1281,8 +1280,8 @@ describe Puppet::Type.metaparamclass(:audit) do
 
   describe "when generating the uniqueness key" do
     it "should include all of the key_attributes in alphabetical order by attribute name" do
-      allow(Puppet::Type.type(:file)).to receive(:key_attributes).and_return([:path, :mode, :owner])
-      allow(Puppet::Type.type(:file)).to receive(:title_patterns).and_return(
+      Puppet::Type.type(:file).stubs(:key_attributes).returns [:path, :mode, :owner]
+      Puppet::Type.type(:file).stubs(:title_patterns).returns(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
       )
       myfile = make_absolute('/my/file')