puppet 5.5.12-universal-darwin → 5.5.13-universal-darwin

data/spec/unit/provider/macauthorization_spec.rb

@@ -1,22 +1,15 @@
-#! /usr/bin/env ruby
-#
-# Unit testing for the macauthorization provider
-#
-
 require 'spec_helper'
-
 require 'puppet'
 
+RSpec::Matchers.define_negated_matcher :neq, :eq
+
 module Puppet::Util::Plist
 end
 
-provider_class = Puppet::Type.type(:macauthorization).provider(:macauthorization)
-
-describe provider_class do
-
+describe Puppet::Type.type(:macauthorization).provider(:macauthorization) do
   before :each do
     # Create a mock resource
-    @resource = stub 'resource'
+    @resource = double('resource')
 
     @authname = "foo.spam.eggs.puppettest"
     @authplist = {}
@@ -28,18 +21,18 @@ describe provider_class do
     authdb["rights"] = { "fooright" => "foo" }
 
     # Stub out Plist::parse_xml
-    Puppet::Util::Plist.stubs(:parse_plist).returns(authdb)
-    Puppet::Util::Plist.stubs(:write_plist_file)
+    allow(Puppet::Util::Plist).to receive(:parse_plist).and_return(authdb)
+    allow(Puppet::Util::Plist).to receive(:write_plist_file)
 
     # A catch all; no parameters set
-    @resource.stubs(:[]).returns(nil)
+    allow(@resource).to receive(:[]).and_return(nil)
 
     # But set name, ensure
-    @resource.stubs(:[]).with(:name).returns @authname
-    @resource.stubs(:[]).with(:ensure).returns :present
-    @resource.stubs(:ref).returns "MacAuthorization[#{@authname}]"
+    allow(@resource).to receive(:[]).with(:name).and_return(@authname)
+    allow(@resource).to receive(:[]).with(:ensure).and_return(:present)
+    allow(@resource).to receive(:ref).and_return("MacAuthorization[#{@authname}]")
 
-    @provider = provider_class.new(@resource)
+    @provider = described_class.new(@resource)
   end
 
   it "should have a create method" do
@@ -74,63 +67,50 @@ describe provider_class do
 
   describe "when destroying a right" do
     before :each do
-      @resource.stubs(:[]).with(:auth_type).returns(:right)
+      allow(@resource).to receive(:[]).with(:auth_type).and_return(:right)
     end
 
     it "should call the internal method destroy_right" do
-      @provider.expects(:destroy_right)
+      expect(@provider).to receive(:destroy_right)
       @provider.destroy
     end
     it "should call the external command 'security authorizationdb remove @authname" do
-      @provider.expects(:security).with("authorizationdb", :remove, @authname)
+      expect(@provider).to receive(:security).with("authorizationdb", :remove, @authname)
       @provider.destroy
     end
   end
 
   describe "when destroying a rule" do
     before :each do
-      @resource.stubs(:[]).with(:auth_type).returns(:rule)
+      allow(@resource).to receive(:[]).with(:auth_type).and_return(:rule)
     end
 
     it "should call the internal method destroy_rule" do
-      @provider.expects(:destroy_rule)
+      expect(@provider).to receive(:destroy_rule)
       @provider.destroy
     end
   end
 
   describe "when flushing a right" do
     before :each do
-      @resource.stubs(:[]).with(:auth_type).returns(:right)
+      allow(@resource).to receive(:[]).with(:auth_type).and_return(:right)
     end
 
     it "should call the internal method flush_right" do
-      @provider.expects(:flush_right)
+      expect(@provider).to receive(:flush_right)
       @provider.flush
     end
 
     it "should call the internal method set_right" do
-      @provider.expects(:execute).with { |cmds, args|
-        cmds.include?("read") and
-        cmds.include?(@authname) and
-        args[:combine] == false
-      }.once
-      @provider.expects(:set_right)
+      expect(@provider).to receive(:execute).with(include("read").and(include(@authname)), hash_including(combine: false)).once
+      expect(@provider).to receive(:set_right)
       @provider.flush
     end
 
     it "should read and write to the auth database with the right arguments" do
-      @provider.expects(:execute).with { |cmds, args|
-        cmds.include?("read") and
-        cmds.include?(@authname) and
-        args[:combine] == false
-      }.once
-
-      @provider.expects(:execute).with { |cmds, args|
-        cmds.include?("write") and
-        cmds.include?(@authname) and
-        args[:combine] == false and
-        args[:stdinfile] != nil
-      }.once
+      expect(@provider).to receive(:execute).with(include("read").and(include(@authname)), hash_including(combine: false)).once
+      expect(@provider).to receive(:execute).with(include("write").and(include(@authname)), hash_including(combine: false, stdinfile: neq(nil))).once
+
       @provider.flush
     end
 
@@ -138,18 +118,17 @@ describe provider_class do
 
   describe "when flushing a rule" do
     before :each do
-      @resource.stubs(:[]).with(:auth_type).returns(:rule)
+      allow(@resource).to receive(:[]).with(:auth_type).and_return(:rule)
     end
 
     it "should call the internal method flush_rule" do
-      @provider.expects(:flush_rule)
+      expect(@provider).to receive(:flush_rule)
       @provider.flush
     end
 
     it "should call the internal method set_rule" do
-      @provider.expects(:set_rule)
+      expect(@provider).to receive(:set_rule)
       @provider.flush
     end
   end
-
 end

data/spec/unit/provider/mcx/mcxcontent_spec.rb

@@ -1,34 +1,32 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:mcx).provider(:mcxcontent)
 
 # describe creates a new ExampleGroup object.
 describe provider_class do
-
   # :each executes before each test.
   # :all executes once for the test group and before :each.
   before :each do
     # Create a mock resource
-    @resource = stub 'resource'
+    @resource = double('resource')
 
     @provider = provider_class.new
     @attached_to = "/Users/foobar"
     @ds_path = "/Local/Default/Users/foobar"
 
     # A catch all; no parameters set
-    @resource.stubs(:[]).returns(nil)
+    allow(@resource).to receive(:[]).and_return(nil)
 
     # But set name, ensure and enable
-    @resource.stubs(:[]).with(:name).returns @attached_to
-    @resource.stubs(:[]).with(:ensure).returns :present
-    @resource.stubs(:ref).returns "Mcx[#{@attached_to}]"
+    allow(@resource).to receive(:[]).with(:name).and_return(@attached_to)
+    allow(@resource).to receive(:[]).with(:ensure).and_return(:present)
+    allow(@resource).to receive(:ref).and_return("Mcx[#{@attached_to}]")
 
     # stub out the provider methods that actually touch the filesystem
     # or execute commands
-    @provider.class.stubs(:execute).returns('')
-    @provider.stubs(:execute).returns('')
-    @provider.stubs(:resource).returns @resource
+    allow(@provider.class).to receive(:execute).and_return('')
+    allow(@provider).to receive(:execute).and_return('')
+    allow(@provider).to receive(:resource).and_return(@resource)
   end
 
   it "should have a create method." do
@@ -53,51 +51,51 @@ describe provider_class do
 
   describe "when managing the resource" do
     it "should execute external command dscl from :create" do
-      @provider.stubs(:has_mcx?).returns(false)
-      @provider.class.expects(:dscl).returns('').once
+      allow(@provider).to receive(:has_mcx?).and_return(false)
+      expect(@provider.class).to receive(:dscl).and_return('').once
       @provider.create
     end
 
     it "deletes existing mcx prior to import from :create" do
-      @provider.stubs(:has_mcx?).returns(true)
-      @provider.class.expects(:dscl).with('localhost', '-mcxdelete', @ds_path, anything()).once
-      @provider.class.expects(:dscl).with('localhost', '-mcximport', @ds_path, anything()).once
+      allow(@provider).to receive(:has_mcx?).and_return(true)
+      expect(@provider.class).to receive(:dscl).with('localhost', '-mcxdelete', @ds_path, any_args()).once
+      expect(@provider.class).to receive(:dscl).with('localhost', '-mcximport', @ds_path, any_args()).once
       @provider.create
     end
 
     it "should execute external command dscl from :destroy" do
-      @provider.class.expects(:dscl).with('localhost', '-mcxdelete', @ds_path).returns('').once
+      expect(@provider.class).to receive(:dscl).with('localhost', '-mcxdelete', @ds_path).and_return('').once
       @provider.destroy
     end
 
     it "should execute external command dscl from :exists?" do
-      @provider.class.expects(:dscl).with('localhost', '-mcxexport', @ds_path).returns('').once
+      expect(@provider.class).to receive(:dscl).with('localhost', '-mcxexport', @ds_path).and_return('').once
       @provider.exists?
     end
 
     it "should execute external command dscl from :content" do
-      @provider.class.expects(:dscl).with('localhost', '-mcxexport', @ds_path).returns('')
+      expect(@provider.class).to receive(:dscl).with('localhost', '-mcxexport', @ds_path).and_return('')
       @provider.content
     end
 
     it "should execute external command dscl from :content=" do
-      @provider.stubs(:has_mcx?).returns(false)
-      @provider.class.expects(:dscl).returns('').once
+      allow(@provider).to receive(:has_mcx?).and_return(false)
+      expect(@provider.class).to receive(:dscl).and_return('').once
       @provider.content=''
     end
 
     it "deletes existing mcx prior to import from :content=" do
-      @provider.stubs(:has_mcx?).returns(true)
-      @provider.class.expects(:dscl).with('localhost', '-mcxdelete', @ds_path, anything()).once
-      @provider.class.expects(:dscl).with('localhost', '-mcximport', @ds_path, anything()).once
+      allow(@provider).to receive(:has_mcx?).and_return(true)
+      expect(@provider.class).to receive(:dscl).with('localhost', '-mcxdelete', @ds_path, any_args()).once
+      expect(@provider.class).to receive(:dscl).with('localhost', '-mcximport', @ds_path, any_args()).once
       @provider.content=''
     end
   end
 
   describe "when creating and parsing the name for ds_type" do
     before :each do
-      @provider.class.stubs(:dscl).returns('')
-      @resource.stubs(:[]).with(:name).returns "/Foo/bar"
+      allow(@provider.class).to receive(:dscl).and_return('')
+      allow(@resource).to receive(:[]).with(:name).and_return("/Foo/bar")
     end
 
     it "should not accept /Foo/bar" do
@@ -105,30 +103,30 @@ describe provider_class do
     end
 
     it "should accept /Foo/bar with ds_type => user" do
-      @resource.stubs(:[]).with(:ds_type).returns "user"
+      allow(@resource).to receive(:[]).with(:ds_type).and_return("user")
       expect { @provider.create }.to_not raise_error
     end
 
     it "should accept /Foo/bar with ds_type => group" do
-      @resource.stubs(:[]).with(:ds_type).returns "group"
+      allow(@resource).to receive(:[]).with(:ds_type).and_return("group")
       expect { @provider.create }.to_not raise_error
     end
 
     it "should accept /Foo/bar with ds_type => computer" do
-      @resource.stubs(:[]).with(:ds_type).returns "computer"
+      allow(@resource).to receive(:[]).with(:ds_type).and_return("computer")
       expect { @provider.create }.to_not raise_error
     end
 
     it "should accept :name => /Foo/bar with ds_type => computerlist" do
-      @resource.stubs(:[]).with(:ds_type).returns "computerlist"
+      allow(@resource).to receive(:[]).with(:ds_type).and_return("computerlist")
       expect { @provider.create }.to_not raise_error
     end
   end
 
   describe "when creating and :name => foobar" do
     before :each do
-      @provider.class.stubs(:dscl).returns('')
-      @resource.stubs(:[]).with(:name).returns "foobar"
+      allow(@provider.class).to receive(:dscl).and_return('')
+      allow(@resource).to receive(:[]).with(:name).and_return("foobar")
     end
 
     it "should not accept unspecified :ds_type and :ds_name" do
@@ -136,42 +134,42 @@ describe provider_class do
     end
 
     it "should not accept unspecified :ds_type" do
-      @resource.stubs(:[]).with(:ds_type).returns "user"
+      allow(@resource).to receive(:[]).with(:ds_type).and_return("user")
       expect { @provider.create }.to raise_error(MCXContentProviderException)
     end
 
     it "should not accept unspecified :ds_name" do
-      @resource.stubs(:[]).with(:ds_name).returns "foo"
+      allow(@resource).to receive(:[]).with(:ds_name).and_return("foo")
       expect { @provider.create }.to raise_error(MCXContentProviderException)
     end
 
     it "should accept :ds_type => user, ds_name => foo" do
-      @resource.stubs(:[]).with(:ds_type).returns "user"
-      @resource.stubs(:[]).with(:ds_name).returns "foo"
+      allow(@resource).to receive(:[]).with(:ds_type).and_return("user")
+      allow(@resource).to receive(:[]).with(:ds_name).and_return("foo")
       expect { @provider.create }.to_not raise_error
     end
 
     it "should accept :ds_type => group, ds_name => foo" do
-      @resource.stubs(:[]).with(:ds_type).returns "group"
-      @resource.stubs(:[]).with(:ds_name).returns "foo"
+      allow(@resource).to receive(:[]).with(:ds_type).and_return("group")
+      allow(@resource).to receive(:[]).with(:ds_name).and_return("foo")
       expect { @provider.create }.to_not raise_error
     end
 
     it "should accept :ds_type => computer, ds_name => foo" do
-      @resource.stubs(:[]).with(:ds_type).returns "computer"
-      @resource.stubs(:[]).with(:ds_name).returns "foo"
+      allow(@resource).to receive(:[]).with(:ds_type).and_return("computer")
+      allow(@resource).to receive(:[]).with(:ds_name).and_return("foo")
       expect { @provider.create }.to_not raise_error
     end
 
     it "should accept :ds_type => computerlist, ds_name => foo" do
-      @resource.stubs(:[]).with(:ds_type).returns "computerlist"
-      @resource.stubs(:[]).with(:ds_name).returns "foo"
+      allow(@resource).to receive(:[]).with(:ds_type).and_return("computerlist")
+      allow(@resource).to receive(:[]).with(:ds_name).and_return("foo")
       expect { @provider.create }.to_not raise_error
     end
 
     it "should not accept :ds_type => bogustype, ds_name => foo" do
-      @resource.stubs(:[]).with(:ds_type).returns "bogustype"
-      @resource.stubs(:[]).with(:ds_name).returns "foo"
+      allow(@resource).to receive(:[]).with(:ds_type).and_return("bogustype")
+      allow(@resource).to receive(:[]).with(:ds_name).and_return("foo")
       expect { @provider.create }.to raise_error(MCXContentProviderException)
     end
   end
@@ -182,10 +180,10 @@ describe provider_class do
     end
 
     it "should call external command dscl -list /Local/Default/<ds_type> on each known ds_type" do
-      @provider.class.expects(:dscl).with('localhost', '-list', "/Local/Default/Users").returns('')
-      @provider.class.expects(:dscl).with('localhost', '-list', "/Local/Default/Groups").returns('')
-      @provider.class.expects(:dscl).with('localhost', '-list', "/Local/Default/Computers").returns('')
-      @provider.class.expects(:dscl).with('localhost', '-list', "/Local/Default/ComputerLists").returns('')
+      expect(@provider.class).to receive(:dscl).with('localhost', '-list', "/Local/Default/Users").and_return('')
+      expect(@provider.class).to receive(:dscl).with('localhost', '-list', "/Local/Default/Groups").and_return('')
+      expect(@provider.class).to receive(:dscl).with('localhost', '-list', "/Local/Default/Computers").and_return('')
+      expect(@provider.class).to receive(:dscl).with('localhost', '-list', "/Local/Default/ComputerLists").and_return('')
       @provider.class.instances
     end
   end

data/spec/unit/provider/mount/parsed_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'shared_behaviours/all_parsedfile_providers'
 
@@ -51,9 +50,6 @@ FSTAB
       expect { described_class.to_line(parse[0]) }.to_not raise_error
     end
 
-#   it_should_behave_like "all parsedfile providers",
-#     provider_class, my_fixtures('*.fstab')
-
     describe "on Solaris", :if => Facter.value(:osfamily) == 'Solaris' do
       it "should extract device from the first field" do
         expect(described_class.parse_line(vfstab_sample)[:device]).to eq('/dev/dsk/c0d0s0')
@@ -109,13 +105,12 @@ FSTAB
         expect(described_class.parse_line(fstab_sample)[:pass]).to eq("2")
       end
     end
-
   end
 
   describe "mountinstances" do
     it "should get name from mountoutput found on Solaris" do
-      Facter.stubs(:value).with(:osfamily).returns 'Solaris'
-      described_class.stubs(:mountcmd).returns(File.read(my_fixture('solaris.mount')))
+      allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
+      allow(described_class).to receive(:mountcmd).and_return(File.read(my_fixture('solaris.mount')))
       mounts = described_class.mountinstances
       expect(mounts.size).to eq(6)
       expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
@@ -127,8 +122,8 @@ FSTAB
     end
 
     it "should get name from mountoutput found on HP-UX" do
-      Facter.stubs(:value).with(:osfamily).returns 'HP-UX'
-      described_class.stubs(:mountcmd).returns(File.read(my_fixture('hpux.mount')))
+      allow(Facter).to receive(:value).with(:osfamily).and_return('HP-UX')
+      allow(described_class).to receive(:mountcmd).and_return(File.read(my_fixture('hpux.mount')))
       mounts = described_class.mountinstances
       expect(mounts.size).to eq(17)
       expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
@@ -151,8 +146,8 @@ FSTAB
     end
 
     it "should get name from mountoutput found on Darwin" do
-      Facter.stubs(:value).with(:osfamily).returns 'Darwin'
-      described_class.stubs(:mountcmd).returns(File.read(my_fixture('darwin.mount')))
+      allow(Facter).to receive(:value).with(:osfamily).and_return('Darwin')
+      allow(described_class).to receive(:mountcmd).and_return(File.read(my_fixture('darwin.mount')))
       mounts = described_class.mountinstances
       expect(mounts.size).to eq(6)
       expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
@@ -164,8 +159,8 @@ FSTAB
     end
 
     it "should get name from mountoutput found on Linux" do
-      Facter.stubs(:value).with(:osfamily).returns 'Gentoo'
-      described_class.stubs(:mountcmd).returns(File.read(my_fixture('linux.mount')))
+      allow(Facter).to receive(:value).with(:osfamily).and_return('Gentoo')
+      allow(described_class).to receive(:mountcmd).and_return(File.read(my_fixture('linux.mount')))
       mounts = described_class.mountinstances
       expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
       expect(mounts[1]).to eq({ :name => '/lib64/rc/init.d', :mounted => :yes })
@@ -176,8 +171,8 @@ FSTAB
     end
 
     it "should get name from mountoutput found on AIX" do
-      Facter.stubs(:value).with(:osfamily).returns 'AIX'
-      described_class.stubs(:mountcmd).returns(File.read(my_fixture('aix.mount')))
+      allow(Facter).to receive(:value).with(:osfamily).and_return('AIX')
+      allow(described_class).to receive(:mountcmd).and_return(File.read(my_fixture('aix.mount')))
       mounts = described_class.mountinstances
       expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
       expect(mounts[1]).to eq({ :name => '/usr', :mounted => :yes })
@@ -191,17 +186,16 @@ FSTAB
     end
 
     it "should raise an error if a line is not understandable" do
-      described_class.stubs(:mountcmd).returns("bazinga!")
+      allow(described_class).to receive(:mountcmd).and_return("bazinga!")
       expect { described_class.mountinstances }.to raise_error Puppet::Error, 'Could not understand line bazinga! from mount output'
     end
-
   end
 
   it "should support AIX's paragraph based /etc/filesystems" do
     pending "This test only works on AIX" unless Facter.value(:osfamily) == 'AIX'
-    Facter.stubs(:value).with(:osfamily).returns 'AIX'
-    described_class.stubs(:default_target).returns my_fixture('aix.filesystems')
-    described_class.stubs(:mountcmd).returns File.read(my_fixture('aix.mount'))
+    allow(Facter).to receive(:value).with(:osfamily).and_return('AIX')
+    allow(described_class).to receive(:default_target).and_return(my_fixture('aix.filesystems'))
+    allow(described_class).to receive(:mountcmd).and_return(File.read(my_fixture('aix.mount')))
     instances = described_class.instances
     expect(instances[0].name).to eq("/")
     expect(instances[0].device).to eq("/dev/hd4")
@@ -229,7 +223,7 @@ FSTAB
         # Stub the mount output to our fixture.
         begin
           mount = my_fixture(platform + '.mount')
-          described_class.stubs(:mountcmd).returns File.read(mount)
+          allow(described_class).to receive(:mountcmd).and_return(File.read(mount))
         rescue
           skip "is #{platform}.mount missing at this point?"
         end
@@ -237,7 +231,7 @@ FSTAB
         # Note: we have to stub default_target before creating resources
         # because it is used by Puppet::Type::Mount.new to populate the
         # :target property.
-        described_class.stubs(:default_target).returns fstab
+        allow(described_class).to receive(:default_target).and_return(fstab)
         @retrieve = described_class.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
       end
 
@@ -270,7 +264,7 @@ FSTAB
         # Stub the mount output to our fixture.
         begin
           mount = my_fixture(platform + '.mount')
-          described_class.stubs(:mountcmd).returns File.read(mount)
+          allow(described_class).to receive(:mountcmd).and_return(File.read(mount))
         rescue
           skip "is #{platform}.mount missing at this point?"
         end
@@ -278,7 +272,7 @@ FSTAB
         # Note: we have to stub default_target before creating resources
         # because it is used by Puppet::Type::Mount.new to populate the
         # :target property.
-        described_class.stubs(:default_target).returns fstab
+        allow(described_class).to receive(:default_target).and_return(fstab)
 
         @res_ghost = Puppet::Type::Mount.new(:name => '/ghost')    # in no fake fstab
         @res_mounted = Puppet::Type::Mount.new(:name => '/')       # in every fake fstab