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

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

@@ -1,10 +1,4 @@
-#! /usr/bin/env ruby
-#
-# Unit testing for the Windows service Provider
-#
-
 require 'spec_helper'
-
 require 'win32/service' if Puppet.features.microsoft_windows?
 
 describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.microsoft_windows? do
@@ -14,20 +8,20 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
   let(:config)   { Struct::ServiceConfigInfo.new }
   let(:status)   { Struct::ServiceStatus.new }
   let(:service_util) { Puppet::Util::Windows::Service }
-  let(:service_handle) { mock() }
+  let(:service_handle) { double() }
 
   before :each do
     # make sure we never actually execute anything (there are two execute methods)
-    provider.class.expects(:execute).never
-    provider.expects(:execute).never
+    allow(provider.class).to receive(:execute)
+    allow(provider).to receive(:execute)
 
-    service_util.stubs(:exists?).with(resource[:name]).returns(true)
+    allow(service_util).to receive(:exists?).with(resource[:name]).and_return(true)
   end
 
   describe ".instances" do
     it "should enumerate all services" do
       list_of_services = {'snmptrap' => {}, 'svchost' => {}, 'sshd' => {}}
-      service_util.expects(:services).returns(list_of_services)
+      expect(service_util).to receive(:services).and_return(list_of_services)
 
       expect(described_class.instances.map(&:name)).to match_array(['snmptrap', 'svchost', 'sshd'])
     end
@@ -35,24 +29,24 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#start" do
     before(:each) do
-      provider.stubs(:status).returns(:stopped)
+      allow(provider).to receive(:status).and_return(:stopped)
     end
 
     it "should resume a paused service" do
-      provider.stubs(:status).returns(:paused)
-      service_util.expects(:resume).with(name)
+      allow(provider).to receive(:status).and_return(:paused)
+      expect(service_util).to receive(:resume).with(name)
       provider.start
     end
 
     it "should start the service" do
-      service_util.expects(:service_start_type).with(name).returns(:SERVICE_AUTO_START)
-      service_util.expects(:start).with(name)
+      expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_AUTO_START)
+      expect(service_util).to receive(:start).with(name)
       provider.start
     end
 
     context "when the service is disabled" do
       before :each do
-        service_util.expects(:service_start_type).with(name).returns(:SERVICE_DISABLED)
+        expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_DISABLED)
       end
 
       it "should refuse to start if not managing enable" do
@@ -61,16 +55,16 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
       it "should enable if managing enable and enable is true" do
         resource[:enable] = :true
-        service_util.expects(:start).with(name)
-        service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START)
+        expect(service_util).to receive(:start).with(name)
+        expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START)
 
         provider.start
       end
 
       it "should manual start if managing enable and enable is false" do
         resource[:enable] = :false
-        service_util.expects(:start).with(name)
-        service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
+        expect(service_util).to receive(:start).with(name)
+        expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
 
         provider.start
       end
@@ -79,7 +73,7 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#stop" do
     it "should stop a running service" do
-      service_util.expects(:stop).with(name)
+      expect(service_util).to receive(:stop).with(name)
 
       provider.stop
     end
@@ -87,7 +81,7 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#status" do
     it "should report a nonexistent service as stopped" do
-      service_util.stubs(:exists?).with(resource[:name]).returns(false)
+      allow(service_util).to receive(:exists?).with(resource[:name]).and_return(false)
 
       expect(provider.status).to eql(:stopped)
     end
@@ -97,7 +91,7 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
       :SERVICE_PAUSE_PENDING
     ].each do |state|
       it "should report a #{state} service as paused" do
-        service_util.expects(:service_state).with(name).returns(state)
+        expect(service_util).to receive(:service_state).with(name).and_return(state)
         expect(provider.status).to eq(:paused)
       end
     end
@@ -107,7 +101,7 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
       :SERVICE_STOP_PENDING
     ].each do |state|
       it "should report a #{state} service as stopped" do
-        service_util.expects(:service_state).with(name).returns(state)
+        expect(service_util).to receive(:service_state).with(name).and_return(state)
         expect(provider.status).to eq(:stopped)
       end
     end
@@ -118,7 +112,7 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
       :SERVICE_START_PENDING,
     ].each do |state|
       it "should report a #{state} service as running" do
-        service_util.expects(:service_state).with(name).returns(state)
+        expect(service_util).to receive(:service_state).with(name).and_return(state)
 
         expect(provider.status).to eq(:running)
       end
@@ -129,16 +123,14 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
     it "should use the supplied restart command if specified" do
       resource[:restart] = 'c:/bin/foo'
 
-      provider.expects(:execute).never
-      provider.expects(:execute).with(['c:/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['c:/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
 
       provider.restart
     end
 
     it "should restart the service" do
-      seq = sequence("restarting")
-      provider.expects(:stop).in_sequence(seq)
-      provider.expects(:start).in_sequence(seq)
+      expect(provider).to receive(:stop).ordered
+      expect(provider).to receive(:start).ordered
 
       provider.restart
     end
@@ -146,18 +138,18 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#enabled?" do
     it "should report a nonexistent service as false" do
-      service_util.stubs(:exists?).with(resource[:name]).returns(false)
+      allow(service_util).to receive(:exists?).with(resource[:name]).and_return(false)
 
       expect(provider.enabled?).to eql(:false)
     end
 
     it "should report a service with a startup type of manual as manual" do
-      service_util.expects(:service_start_type).with(name).returns(:SERVICE_DEMAND_START)
+      expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_DEMAND_START)
       expect(provider.enabled?).to eq(:manual)
     end
 
     it "should report a service with a startup type of disabled as false" do
-      service_util.expects(:service_start_type).with(name).returns(:SERVICE_DISABLED)
+      expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_DISABLED)
       expect(provider.enabled?).to eq(:false)
     end
 
@@ -170,7 +162,7 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
         :SERVICE_SYSTEM_START
       ].each do |start_type|
         it "should report a service with a startup type of '#{start_type}' as true" do
-          service_util.expects(:service_start_type).with(name).returns(start_type)
+          expect(service_util).to receive(:service_start_type).with(name).and_return(start_type)
           expect(provider.enabled?).to eq(:true)
         end
       end
@@ -179,12 +171,12 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#enable" do
     it "should set service start type to Service_Auto_Start when enabled" do
-      service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START)
+      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START)
       provider.enable
     end
 
     it "raises an error if set_startup_mode fails" do
-      service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START).raises(Puppet::Error.new('foobar'))
+      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.enable
@@ -194,12 +186,12 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#disable" do
     it "should set service start type to Service_Disabled when disabled" do
-      service_util.expects(:set_startup_mode).with(name, :SERVICE_DISABLED)
+      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DISABLED)
       provider.disable
     end
 
     it "raises an error if set_startup_mode fails" do
-      service_util.expects(:set_startup_mode).with(name, :SERVICE_DISABLED).raises(Puppet::Error.new('foobar'))
+      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DISABLED).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.disable
@@ -209,12 +201,12 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#manual_start" do
     it "should set service start type to Service_Demand_Start (manual) when manual" do
-      service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
+      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
       provider.manual_start
     end
 
     it "raises an error if set_startup_mode fails" do
-      service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START).raises(Puppet::Error.new('foobar'))
+      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.manual_start

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'shared_behaviours/all_parsedfile_providers'
 require 'puppet_spec/files'
@@ -12,9 +11,9 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
     @keyfile = tmpfile('authorized_keys')
     @provider_class = provider_class
     @provider_class.initvars
-    @provider_class.any_instance.stubs(:target).returns @keyfile
+    allow_any_instance_of(@provider_class).to receive(:target).and_return(@keyfile)
     @user = 'random_bob'
-    Puppet::Util.stubs(:uid).with(@user).returns 12345
+    allow(Puppet::Util).to receive(:uid).with(@user).and_return(12345)
   end
 
   def mkkey(args)
@@ -29,10 +28,10 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
   end
 
   def genkey(key)
-    @provider_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
-    File.stubs(:chown)
-    File.stubs(:chmod)
-    Puppet::Util::SUIDManager.stubs(:asuser).yields
+    allow(@provider_class).to receive(:filetype).and_return(Puppet::Util::FileType::FileTypeRam)
+    allow(File).to receive(:chown)
+    allow(File).to receive(:chmod)
+    allow(Puppet::Util::SUIDManager).to receive(:asuser).and_yield
     key.flush
     @provider_class.target_object(@keyfile).read
   end
@@ -40,7 +39,6 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
   it_should_behave_like "all parsedfile providers", provider_class
 
   it "should be able to generate a basic authorized_keys file" do
-
     key = mkkey(:name    => "Just_Testing",
                 :key     => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
                 :type    => "ssh-dss",
@@ -52,7 +50,6 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
   end
 
   it "should be able to generate an authorized_keys file with options" do
-
     key = mkkey(:name    => "root@localhost",
                 :key     => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
                 :type    => "ssh-rsa",
@@ -155,12 +152,12 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
 end
 
 describe provider_class, :unless => Puppet.features.microsoft_windows? do
-  before :each do
-    @resource = Puppet::Type.type(:ssh_authorized_key).new(:name => "foo", :user => "random_bob")
+  let(:resource) { Puppet::Type.type(:ssh_authorized_key).new(:name => "foo", :user => "random_bob") }
+  let(:provider) { provider_class.new(resource) }
 
-    @provider = provider_class.new(@resource)
-    provider_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
-    Puppet::Util::SUIDManager.stubs(:asuser).yields
+  before(:each) do
+    allow(provider_class).to receive(:filetype).and_return(Puppet::Util::FileType::FileTypeRam)
+    allow(Puppet::Util::SUIDManager).to receive(:asuser).and_yield
 
     provider_class.initvars
   end
@@ -168,105 +165,94 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
   describe "when flushing" do
     before :each do
       # Stub file and directory operations
-      Dir.stubs(:mkdir)
-      File.stubs(:chmod)
-      File.stubs(:chown)
+      allow(Dir).to receive(:mkdir)
+      allow(File).to receive(:chmod)
+      allow(File).to receive(:chown)
     end
 
     describe "and both a user and a target have been specified" do
       before :each do
-        Puppet::Util.stubs(:uid).with("random_bob").returns 12345
-        @resource[:user] = "random_bob"
+        allow(Puppet::Util).to receive(:uid).with("random_bob").and_return(12345)
+        resource[:user] = "random_bob"
         target = "/tmp/.ssh_dir/place_to_put_authorized_keys"
-        @resource[:target] = target
+        resource[:target] = target
       end
 
       it "should create the directory" do
-        Puppet::FileSystem.stubs(:exist?).with("/tmp/.ssh_dir").returns false
-        Dir.expects(:mkdir).with("/tmp/.ssh_dir", 0700)
-        @provider.flush
+        allow(Puppet::FileSystem).to receive(:exist?).with("/tmp/.ssh_dir").and_return(false)
+        expect(Dir).to receive(:mkdir).with("/tmp/.ssh_dir", 0700)
+        provider.flush
       end
 
       it "should absolutely not chown the directory to the user" do
-        File.expects(:chown).never
-        @provider.flush
-      end
-
-      it "should absolutely not chown the key file to the user" do
-        File.expects(:chown).never
-        @provider.flush
+        expect(File).not_to receive(:chown)
+        provider.flush
       end
 
       it "should chmod the key file to 0600" do
-        File.expects(:chmod).with(0600, "/tmp/.ssh_dir/place_to_put_authorized_keys")
-        @provider.flush
+        expect(File).to receive(:chmod).with(0600, "/tmp/.ssh_dir/place_to_put_authorized_keys")
+        provider.flush
       end
     end
 
     describe "and a user has been specified with no target" do
+      #
+      # I'd like to use random_bob here and something like
+      #
+      #    File.stubs(:expand_path).with("~random_bob/.ssh").returns "/users/r/random_bob/.ssh"
+      #
+      # but mocha objects strenuously to stubbing File.expand_path
+      # so I'm left with using nobody.
+      let(:dir) { File.expand_path("~nobody/.ssh") }
       before :each do
-        @resource[:user] = "nobody"
-        #
-        # I'd like to use random_bob here and something like
-        #
-        #    File.stubs(:expand_path).with("~random_bob/.ssh").returns "/users/r/random_bob/.ssh"
-        #
-        # but mocha objects strenuously to stubbing File.expand_path
-        # so I'm left with using nobody.
-        @dir = File.expand_path("~nobody/.ssh")
+        resource[:user] = "nobody"
       end
 
       it "should create the directory if it doesn't exist" do
-        Puppet::FileSystem.stubs(:exist?).with(@dir).returns false
-        Dir.expects(:mkdir).with(@dir,0700)
-        @provider.flush
-      end
-
-      it "should not create or chown the directory if it already exist" do
-        Puppet::FileSystem.stubs(:exist?).with(@dir).returns false
-        Dir.expects(:mkdir).never
-        @provider.flush
+        allow(Puppet::FileSystem).to receive(:exist?).with(dir).and_return(false)
+        expect(Dir).to receive(:mkdir).with(dir, 0700)
+        provider.flush
       end
 
       it "should absolutely not chown the directory to the user if it creates it" do
-        Puppet::FileSystem.stubs(:exist?).with(@dir).returns false
-        Dir.stubs(:mkdir).with(@dir,0700)
-        File.expects(:chown).never
-        @provider.flush
+        allow(Puppet::FileSystem).to receive(:exist?).with(dir).and_return(false)
+        allow(Dir).to receive(:mkdir).with(dir, 0700)
+        expect(File).not_to receive(:chown)
+        provider.flush
       end
 
-      it "should not create or chown the directory if it already exist" do
-        Puppet::FileSystem.stubs(:exist?).with(@dir).returns false
-        Dir.expects(:mkdir).never
-        File.expects(:chown).never
-        @provider.flush
+      it "should not create or chown the directory if it already exists" do
+        allow(Puppet::FileSystem).to receive(:exist?).with(dir).and_return(true)
+        expect(Dir).not_to receive(:mkdir)
+        expect(File).not_to receive(:chown)
+        provider.flush
       end
 
       it "should absolutely not chown the key file to the user" do
-        File.expects(:chown).never
-        @provider.flush
+        expect(File).not_to receive(:chown)
+        provider.flush
       end
 
       it "should chmod the key file to 0600" do
-        File.expects(:chmod).with(0600, File.expand_path("~nobody/.ssh/authorized_keys"))
-        @provider.flush
+        expect(File).to receive(:chmod).with(0600, File.expand_path("~nobody/.ssh/authorized_keys"))
+        provider.flush
       end
     end
 
     describe "and a target has been specified with no user" do
       it "should raise an error" do
-        @resource = Puppet::Type.type(:ssh_authorized_key).new(:name => "foo", :target => "/tmp/.ssh_dir/place_to_put_authorized_keys")
-        @provider = provider_class.new(@resource)
+        resource = Puppet::Type.type(:ssh_authorized_key).new(:name => "foo", :target => "/tmp/.ssh_dir/place_to_put_authorized_keys")
+        provider = provider_class.new(resource)
 
-        expect { @provider.flush }.to raise_error(Puppet::Error, /Cannot write SSH authorized keys without user/)
+        expect { provider.flush }.to raise_error(Puppet::Error, /Cannot write SSH authorized keys without user/)
       end
     end
 
     describe "and an invalid user has been specified with no target" do
       it "should catch an exception and raise a Puppet error" do
-        @resource[:user] = "thisusershouldnotexist"
+        resource[:user] = "thisusershouldnotexist"
 
-        expect { @provider.flush }.to raise_error(Puppet::Error)
+        expect { provider.flush }.to raise_error(Puppet::Error)
       end
     end
   end

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe "sshkey parsed provider" do
@@ -41,7 +40,7 @@ describe "sshkey parsed provider" do
   context "with the sample file" do
     ['sample', 'sample_with_blank_lines'].each do |sample_file|
       let :fixture do my_fixture(sample_file) end
-      before :each do subject.stubs(:default_target).returns(fixture) end
+      before :each do allow(subject).to receive(:default_target).and_return(fixture) end
 
       it "should parse to records on prefetch" do
         expect(subject.target_records(fixture)).to be_empty
@@ -49,7 +48,7 @@ describe "sshkey parsed provider" do
 
         records = subject.target_records(fixture)
         expect(records).to be_an Array
-        expect(records).to be_all {|x| expect(x).to be_an Hash }
+        expect(records).to(be_all {|x| expect(x).to be_an Hash })
       end
 
       it "should reconstitute the file from records" do
@@ -71,22 +70,22 @@ describe "sshkey parsed provider" do
   context 'default ssh_known_hosts target path' do
     ['9.10', '9.11', '10.10'].each do |version|
       it 'should be `/etc/ssh_known_hosts` when OSX version 10.10 or older`' do
-        Facter.expects(:value).with(:operatingsystem).returns('Darwin')
-        Facter.expects(:value).with(:macosx_productversion_major).returns(version)
+        expect(Facter).to receive(:value).with(:operatingsystem).and_return('Darwin')
+        expect(Facter).to receive(:value).with(:macosx_productversion_major).and_return(version)
         expect(subject.default_target).to eq('/etc/ssh_known_hosts')
       end
     end
 
     ['10.11', '10.13', '11.0', '11.11'].each do |version|
       it 'should be `/etc/ssh/ssh_known_hosts` when OSX version 10.11 or newer`' do
-        Facter.expects(:value).with(:operatingsystem).returns('Darwin')
-        Facter.expects(:value).with(:macosx_productversion_major).returns(version)
+        expect(Facter).to receive(:value).with(:operatingsystem).and_return('Darwin')
+        expect(Facter).to receive(:value).with(:macosx_productversion_major).and_return(version)
         expect(subject.default_target).to eq('/etc/ssh/ssh_known_hosts')
       end
     end
 
     it 'should be `/etc/ssh/ssh_known_hosts` on other operating systems' do
-      Facter.expects(:value).with(:operatingsystem).returns('RedHat')
+      expect(Facter).to receive(:value).with(:operatingsystem).and_return('RedHat')
       expect(subject.default_target).to eq('/etc/ssh/ssh_known_hosts')
     end
   end