chef 12.5.0.alpha.1 → 12.5.1

data/spec/unit/provider/powershell_script_spec.rb

@@ -38,41 +38,67 @@ describe Chef::Provider::PowershellScript, "action_run" do
   }
 
   context 'when setting interpreter flags' do
-    it "should set the -File flag as the last flag" do
-      expect(provider.flags.split(' ').pop).to eq("-File")
+    context 'on nano' do
+      before(:each) do
+        allow(Chef::Platform).to receive(:windows_nano_server?).and_return(true)
+        allow(provider).to receive(:is_forced_32bit).and_return(false)
+        os_info_double = double("os_info")
+        allow(provider.run_context.node.kernel).to receive(:os_info).and_return(os_info_double)
+        allow(os_info_double).to receive(:system_directory).and_return("C:\\Windows\\system32")
+      end
+
+      it "sets the -Command flag as the last flag" do
+        flags = provider.command.split(' ').keep_if { |flag| flag =~ /^-/ }
+        expect(flags.pop).to eq("-Command")
+      end
     end
 
-    let(:execution_policy_flag) do
-      execution_policy_index = 0
-      provider_flags = provider.flags.split(' ')
-      execution_policy_specified = false
+    context 'not on nano' do
+      before(:each) do
+        allow(Chef::Platform).to receive(:windows_nano_server?).and_return(false)
+        allow(provider).to receive(:is_forced_32bit).and_return(false)
+        os_info_double = double("os_info")
+        allow(provider.run_context.node.kernel).to receive(:os_info).and_return(os_info_double)
+        allow(os_info_double).to receive(:system_directory).and_return("C:\\Windows\\system32")
+      end
 
-      provider_flags.find do | value |
-        execution_policy_index += 1
-        execution_policy_specified = value.downcase == '-ExecutionPolicy'.downcase
+      it "sets the -File flag as the last flag" do
+        flags = provider.command.split(' ').keep_if { |flag| flag =~ /^-/ }
+        expect(flags.pop).to eq("-File")
       end
 
-      execution_policy = execution_policy_specified ? provider_flags[execution_policy_index] : nil
-    end
+      let(:execution_policy_flag) do
+        execution_policy_index = 0
+        provider_flags = provider.flags.split(' ')
+        execution_policy_specified = false
 
-    context 'when running with an unspecified PowerShell version' do
-      let(:powershell_version) { nil }
-      it "should set the -ExecutionPolicy flag to 'Unrestricted' by default" do
-        expect(execution_policy_flag.downcase).to eq('unrestricted'.downcase)
+        provider_flags.find do | value |
+          execution_policy_index += 1
+          execution_policy_specified = value.downcase == '-ExecutionPolicy'.downcase
+        end
+
+        execution_policy = execution_policy_specified ? provider_flags[execution_policy_index] : nil
+      end
+
+      context 'when running with an unspecified PowerShell version' do
+        let(:powershell_version) { nil }
+        it "sets the -ExecutionPolicy flag to 'Unrestricted' by default" do
+          expect(execution_policy_flag.downcase).to eq('unrestricted'.downcase)
+        end
       end
-    end
 
-    { '2.0' => 'Unrestricted',
-      '2.5' => 'Unrestricted',
-      '3.0' => 'Bypass',
-      '3.6' => 'Bypass',
-      '4.0' => 'Bypass',
-      '5.0' => 'Bypass' }.each do | version_policy |
-      let(:powershell_version) { version_policy[0].to_f }
-      context "when running PowerShell version #{version_policy[0]}" do
+      { '2.0' => 'Unrestricted',
+        '2.5' => 'Unrestricted',
+        '3.0' => 'Bypass',
+        '3.6' => 'Bypass',
+        '4.0' => 'Bypass',
+        '5.0' => 'Bypass' }.each do | version_policy |
         let(:powershell_version) { version_policy[0].to_f }
-        it "should set the -ExecutionPolicy flag to '#{version_policy[1]}'" do
-          expect(execution_policy_flag.downcase).to eq(version_policy[1].downcase)
+        context "when running PowerShell version #{version_policy[0]}" do
+          let(:powershell_version) { version_policy[0].to_f }
+          it "sets the -ExecutionPolicy flag to '#{version_policy[1]}'" do
+            expect(execution_policy_flag.downcase).to eq(version_policy[1].downcase)
+          end
         end
       end
     end

data/spec/unit/provider/remote_directory_spec.rb

@@ -79,7 +79,7 @@ describe Chef::Provider::RemoteDirectory do
     end
 
     it "configures access control on intermediate directorys" do
-      directory_resource = @provider.send(:resource_for_directory, File.join(Dir.tmpdir, "intermediate_dir"))
+      directory_resource = @provider.send(:directory_resource, File.join(Dir.tmpdir, "intermediate_dir"))
       expect(directory_resource.path).to  eq(File.join(Dir.tmpdir, "intermediate_dir"))
       expect(directory_resource.mode).to  eq("0750")
       expect(directory_resource.group).to eq("wheel")
@@ -219,4 +219,3 @@ describe Chef::Provider::RemoteDirectory do
 
   end
 end
-

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

@@ -94,7 +94,7 @@ describe Chef::Provider::Service::Aix do
       end
 
       it "service is a group" do
-        expect(@provider).to receive(:shell_out!).with("lssrc -g chef").and_return(@status)
+        expect(@provider).to receive(:shell_out).with("lssrc -g chef").and_return(@status)
         @provider.load_current_resource
         expect(@provider.instance_eval("@is_resource_group")).to be_truthy
       end
@@ -106,7 +106,7 @@ describe Chef::Provider::Service::Aix do
       end
 
       it "service is a group" do
-        expect(@provider).to receive(:shell_out!).with("lssrc -g chef").and_return(@status)
+        expect(@provider).to receive(:shell_out).with("lssrc -g chef").and_return(@status)
         @provider.load_current_resource
         expect(@provider.instance_eval("@is_resource_group")).to be_truthy
       end
@@ -119,7 +119,7 @@ describe Chef::Provider::Service::Aix do
       end
 
       it "service is a subsystem" do
-        expect(@provider).to receive(:shell_out!).with("lssrc -g chef").and_return(@group_status)
+        expect(@provider).to receive(:shell_out).with("lssrc -g chef").and_return(@group_status)
         expect(@provider).to receive(:shell_out!).with("lssrc -s chef").and_return(@service_status)
         @provider.load_current_resource
         expect(@provider.instance_eval("@is_resource_group")).to be_falsey

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

@@ -1,7 +1,7 @@
 #
 # Author:: Lee Jensen (<ljensen@engineyard.com>)
 # Author:: AJ Christensen (<aj@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Copyright:: Copyright (c) 2008-2015 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -108,17 +108,17 @@ describe Chef::Provider::Service::Gentoo do
 
     it "should support the status command automatically" do
       @provider.load_current_resource
-      expect(@new_resource.supports[:status]).to be_truthy
+      expect(@provider.supports[:status]).to be true
     end
 
     it "should support the restart command automatically" do
       @provider.load_current_resource
-      expect(@new_resource.supports[:restart]).to be_truthy
+      expect(@provider.supports[:restart]).to be true
     end
 
     it "should not support the reload command automatically" do
       @provider.load_current_resource
-      expect(@new_resource.supports[:reload]).not_to be_truthy
+      expect(@provider.supports[:reload]).to be_falsey
     end
 
   end

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

@@ -35,10 +35,12 @@ describe Chef::Provider::Service::Openbsd do
     node
   end
 
+  let(:supports) { {:status => false} }
+
   let(:new_resource) do
     new_resource = Chef::Resource::Service.new("sndiod")
     new_resource.pattern("sndiod")
-    new_resource.supports({:status => false})
+    new_resource.supports(supports)
     new_resource
   end
 
@@ -106,9 +108,7 @@ describe Chef::Provider::Service::Openbsd do
     context "when the service supports status" do
       let(:status) { double(:stdout => "", :exitstatus => 0) }
 
-      before do
-        new_resource.supports({:status => true})
-      end
+      let(:supports) { { :status => true } }
 
       it "should run '/etc/rc.d/service_name status'" do
         expect(provider).to receive(:shell_out).with("/etc/rc.d/#{new_resource.service_name} check").and_return(status)
@@ -305,10 +305,12 @@ describe Chef::Provider::Service::Openbsd do
     end
 
     describe Chef::Provider::Service::Openbsd, "restart_service" do
-      it "should call 'restart' on the service_name if the resource supports it" do
-        new_resource.supports({:restart => true})
-        expect(provider).to receive(:shell_out_with_systems_locale!).with("/etc/rc.d/#{new_resource.service_name} restart")
-        provider.restart_service()
+      context "when the new_resource supports restart" do
+        let(:supports) { { restart: true } }
+        it "should call 'restart' on the service_name if the resource supports it" do
+          expect(provider).to receive(:shell_out_with_systems_locale!).with("/etc/rc.d/#{new_resource.service_name} restart")
+          provider.restart_service()
+        end
       end
 
       it "should call the restart_command if one has been specified" do

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

@@ -64,24 +64,76 @@ describe "Chef::Provider::Service::Redhat" do
     end
 
     describe "load current resource" do
-      it "sets the current enabled status to true if the service is enabled for any run level" do
+      before do
         status = double("Status", :exitstatus => 0, :stdout => "" , :stderr => "")
-        expect(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
+        allow(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
+      end
+
+      it "sets supports[:status] to true by default" do
         chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:on  6:off", :stderr => "")
         expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
-        expect(@provider.instance_variable_get("@service_missing")).to be_falsey
+        expect(@provider.service_missing).to be false
         @provider.load_current_resource
-        expect(@current_resource.enabled).to be_truthy
+        expect(@provider.supports[:status]).to be true
+      end
+
+      it "lets the user override supports[:status] in the new_resource" do
+        @new_resource.supports( { status: false } )
+        @new_resource.pattern "myservice"
+        chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:on  6:off", :stderr => "")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+        foo_out = double("ps_command", :exitstatus => 0, :stdout => "a line that matches myservice", :stderr => "")
+        expect(@provider).to receive(:shell_out!).with("foo").and_return(foo_out)
+        expect(@provider.service_missing).to be false
+        expect(@provider).not_to receive(:shell_out).with("/sbin/service chef status")
+        @provider.load_current_resource
+        expect(@provider.supports[:status]).to be false
+      end
+
+      it "sets the current enabled status to true if the service is enabled for any run level" do
+        chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:on  6:off", :stderr => "")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+        expect(@provider.service_missing).to be false
+        @provider.load_current_resource
+        expect(@current_resource.enabled).to be true
       end
 
       it "sets the current enabled status to false if the regex does not match" do
-        status = double("Status", :exitstatus => 0, :stdout => "" , :stderr => "")
-        expect(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
         chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:off   6:off", :stderr => "")
         expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
-        expect(@provider.instance_variable_get("@service_missing")).to be_falsey
+        expect(@provider.service_missing).to be false
         expect(@provider.load_current_resource).to eql(@current_resource)
-        expect(@current_resource.enabled).to be_falsey
+        expect(@current_resource.enabled).to be false
+      end
+
+      it "sets the current enabled status to true if the service is enabled at specified run levels" do
+        @new_resource.run_levels([1, 2])
+        chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:on   2:on   3:off   4:off   5:off   6:off", :stderr => "")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+        expect(@provider.service_missing).to be false
+        @provider.load_current_resource
+        expect(@current_resource.enabled).to be true
+        expect(@provider.current_run_levels).to eql([1, 2])
+      end
+
+      it "sets the current enabled status to false if the service is enabled at a run level it should not" do
+        @new_resource.run_levels([1, 2])
+        chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:on   2:on   3:on   4:off   5:off   6:off", :stderr => "")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+        expect(@provider.service_missing).to be false
+        @provider.load_current_resource
+        expect(@current_resource.enabled).to be false
+        expect(@provider.current_run_levels).to eql([1, 2, 3])
+      end
+
+      it "sets the current enabled status to false if the service is not enabled at specified run levels" do
+        @new_resource.run_levels([ 2 ])
+        chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:on   2:off   3:off   4:off   5:off   6:off", :stderr => "")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+        expect(@provider.service_missing).to be false
+        @provider.load_current_resource
+        expect(@current_resource.enabled).to be false
+        expect(@provider.current_run_levels).to eql([1])
       end
     end
 
@@ -144,6 +196,28 @@ describe "Chef::Provider::Service::Redhat" do
       expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig #{@new_resource.service_name} on")
       @provider.enable_service
     end
+
+    it "should call chkconfig to add 'service_name' at specified run_levels" do
+      allow(@provider).to receive(:run_levels).and_return([1, 2])
+      expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --level 12 #{@new_resource.service_name} on")
+      @provider.enable_service
+    end
+
+    it "should call chkconfig to add 'service_name' at specified run_levels when run_levels do not match" do
+      allow(@provider).to receive(:run_levels).and_return([1, 2])
+      allow(@provider).to receive(:current_run_levels).and_return([1, 3])
+      expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --level 12 #{@new_resource.service_name} on")
+      expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --level 3 #{@new_resource.service_name} off")
+      @provider.enable_service
+    end
+
+    it "should call chkconfig to add 'service_name' at specified run_levels if there is an extra run_level" do
+      allow(@provider).to receive(:run_levels).and_return([1, 2])
+      allow(@provider).to receive(:current_run_levels).and_return([1, 2, 3])
+      expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --level 12 #{@new_resource.service_name} on")
+      expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --level 3 #{@new_resource.service_name} off")
+      @provider.enable_service
+    end
   end
 
   describe "disable_service" do
@@ -151,6 +225,12 @@ describe "Chef::Provider::Service::Redhat" do
       expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig #{@new_resource.service_name} off")
       @provider.disable_service
     end
+
+    it "should call chkconfig to del 'service_name' at specified run_levels" do
+      allow(@provider).to receive(:run_levels).and_return([1, 2])
+      expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --level 12 #{@new_resource.service_name} off")
+      @provider.disable_service
+    end
   end
 
 end

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

@@ -19,6 +19,10 @@
 require 'spec_helper'
 
 describe Chef::Provider::Service::Upstart do
+  let(:shell_out_success) do
+    double('shell_out_with_systems_locale', :exitstatus => 0, :error? => false)
+  end
+
   before(:each) do
     @node =Chef::Node.new
     @node.name('upstarter')
@@ -173,7 +177,7 @@ describe Chef::Provider::Service::Upstart do
       end
 
       it "should run the services status command if one has been specified" do
-        allow(@provider).to receive(:shell_out!).with("/bin/chefhasmonkeypants status").and_return(0)
+        allow(@provider).to receive(:shell_out!).with("/bin/chefhasmonkeypants status").and_return(shell_out_success)
         expect(@current_resource).to receive(:running).with(true)
         @provider.load_current_resource
       end
@@ -246,7 +250,7 @@ describe Chef::Provider::Service::Upstart do
     end
 
     it "should call '/sbin/start service_name' if no start command is specified" do
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/start #{@new_resource.service_name}").and_return(0)
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/start #{@new_resource.service_name}").and_return(shell_out_success)
       @provider.start_service()
     end
 
@@ -261,7 +265,7 @@ describe Chef::Provider::Service::Upstart do
       @new_resource.parameters({ "OSD_ID" => "2" })
       @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
       @provider.current_resource = @current_resource
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/start rsyslog OSD_ID=2").and_return(0)
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/start rsyslog OSD_ID=2").and_return(shell_out_success)
       @provider.start_service()
     end
 
@@ -274,13 +278,13 @@ describe Chef::Provider::Service::Upstart do
 
     it "should call '/sbin/restart service_name' if no restart command is specified" do
       allow(@current_resource).to receive(:running).and_return(true)
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/restart #{@new_resource.service_name}").and_return(0)
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/restart #{@new_resource.service_name}").and_return(shell_out_success)
       @provider.restart_service()
     end
 
     it "should call '/sbin/start service_name' if restart_service is called for a stopped service" do
       allow(@current_resource).to receive(:running).and_return(false)
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/start #{@new_resource.service_name}").and_return(0)
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/start #{@new_resource.service_name}").and_return(shell_out_success)
       @provider.restart_service()
     end
 
@@ -293,7 +297,7 @@ describe Chef::Provider::Service::Upstart do
 
     it "should call '/sbin/reload service_name' if no reload command is specified" do
       allow(@current_resource).to receive(:running).and_return(true)
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/reload #{@new_resource.service_name}").and_return(0)
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/reload #{@new_resource.service_name}").and_return(shell_out_success)
       @provider.reload_service()
     end
 
@@ -306,7 +310,7 @@ describe Chef::Provider::Service::Upstart do
 
     it "should call '/sbin/stop service_name' if no stop command is specified" do
       allow(@current_resource).to receive(:running).and_return(true)
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/stop #{@new_resource.service_name}").and_return(0)
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/stop #{@new_resource.service_name}").and_return(shell_out_success)
       @provider.stop_service()
     end
 

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

@@ -21,369 +21,380 @@ require 'spec_helper'
 require 'mixlib/shellout'
 
 describe Chef::Provider::Service::Windows, "load_current_resource" do
-  before(:each) do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-    @new_resource = Chef::Resource::WindowsService.new("chef")
-    @provider = Chef::Provider::Service::Windows.new(@new_resource, @run_context)
-    @provider.current_resource = Chef::Resource::WindowsService.new("current-chef")
-    Object.send(:remove_const, 'Win32') if defined?(Win32)
-    Win32 = Module.new
+  include_context "Win32"
+
+  let(:new_resource) { Chef::Resource::WindowsService.new("chef") }
+  let(:provider) do
+    prvdr = Chef::Provider::Service::Windows.new(new_resource,
+      Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new))
+    prvdr.current_resource = Chef::Resource::WindowsService.new("current-chef")
+    prvdr
+  end
+
+  before(:all) do
     Win32::Service = Class.new
+  end
+
+  before(:each) do
     Win32::Service::AUTO_START = 0x00000002
     Win32::Service::DEMAND_START = 0x00000003
     Win32::Service::DISABLED = 0x00000004
-    allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+
+    allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
       double("StatusStruct", :current_state => "running"))
-    allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
+    allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
       double("ConfigStruct", :start_type => "auto start"))
     allow(Win32::Service).to receive(:exists?).and_return(true)
     allow(Win32::Service).to receive(:configure).and_return(Win32::Service)
   end
 
-  it "should set the current resources service name to the new resources service name" do
-    @provider.load_current_resource
-    expect(@provider.current_resource.service_name).to eq('chef')
+  after(:each) do
+    Win32::Service.send(:remove_const, 'AUTO_START') if defined?(Win32::Service::AUTO_START)
+    Win32::Service.send(:remove_const, 'DEMAND_START') if defined?(Win32::Service::DEMAND_START)
+    Win32::Service.send(:remove_const, 'DISABLED') if defined?(Win32::Service::DISABLED)
   end
 
-  it "should return the current resource" do
-    expect(@provider.load_current_resource).to equal(@provider.current_resource)
+  it "sets the current resources service name to the new resources service name" do
+    provider.load_current_resource
+    expect(provider.current_resource.service_name).to eq('chef')
   end
 
-  it "should set the current resources status" do
-    @provider.load_current_resource
-    expect(@provider.current_resource.running).to be_truthy
+  it "returns the current resource" do
+    expect(provider.load_current_resource).to equal(provider.current_resource)
   end
 
-  it "should set the current resources start type" do
-    @provider.load_current_resource
-    expect(@provider.current_resource.enabled).to be_truthy
+  it "sets the current resources status" do
+    provider.load_current_resource
+    expect(provider.current_resource.running).to be_truthy
+  end
+
+  it "sets the current resources start type" do
+    provider.load_current_resource
+    expect(provider.current_resource.enabled).to be_truthy
   end
 
   it "does not set the current resources start type if it is neither AUTO START or DISABLED" do
-    allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
+    allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
       double("ConfigStruct", :start_type => "manual"))
-    @provider.load_current_resource
-    expect(@provider.current_resource.enabled).to be_nil
+    provider.load_current_resource
+    expect(provider.current_resource.enabled).to be_nil
   end
 
   describe Chef::Provider::Service::Windows, "start_service" do
     before(:each) do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "stopped"),
         double("StatusStruct", :current_state => "running"))
     end
 
-    it "should call the start command if one is specified" do
-      @new_resource.start_command "sc start chef"
-      expect(@provider).to receive(:shell_out!).with("#{@new_resource.start_command}").and_return("Starting custom service")
-      @provider.start_service
-      expect(@new_resource.updated_by_last_action?).to be_truthy
+    it "calls the start command if one is specified" do
+      new_resource.start_command "sc start chef"
+      expect(provider).to receive(:shell_out!).with("#{new_resource.start_command}").and_return("Starting custom service")
+      provider.start_service
+      expect(new_resource.updated_by_last_action?).to be_truthy
     end
 
-    it "should use the built-in command if no start command is specified" do
-      expect(Win32::Service).to receive(:start).with(@new_resource.service_name)
-      @provider.start_service
-      expect(@new_resource.updated_by_last_action?).to be_truthy
+    it "uses the built-in command if no start command is specified" do
+      expect(Win32::Service).to receive(:start).with(new_resource.service_name)
+      provider.start_service
+      expect(new_resource.updated_by_last_action?).to be_truthy
     end
 
-    it "should do nothing if the service does not exist" do
-      allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
-      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
-      @provider.start_service
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+    it "does nothing if the service does not exist" do
+      allow(Win32::Service).to receive(:exists?).with(new_resource.service_name).and_return(false)
+      expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
+      provider.start_service
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
 
-    it "should do nothing if the service is running" do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+    it "does nothing if the service is running" do
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "running"))
-      @provider.load_current_resource
-      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
-      @provider.start_service
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+      provider.load_current_resource
+      expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
+      provider.start_service
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
 
-    it "should raise an error if the service is paused" do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+    it "raises an error if the service is paused" do
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "paused"))
-      @provider.load_current_resource
-      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
-      expect { @provider.start_service }.to raise_error( Chef::Exceptions::Service )
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+      provider.load_current_resource
+      expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
+      expect { provider.start_service }.to raise_error( Chef::Exceptions::Service )
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
 
-    it "should wait and continue if the service is in start_pending" do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+    it "waits and continues if the service is in start_pending" do
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "start pending"),
         double("StatusStruct", :current_state => "start pending"),
         double("StatusStruct", :current_state => "running"))
-      @provider.load_current_resource
-      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
-      @provider.start_service
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+      provider.load_current_resource
+      expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
+      provider.start_service
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
 
-    it "should fail if the service is in stop_pending" do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+    it "fails if the service is in stop_pending" do
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "stop pending"))
-      @provider.load_current_resource
-      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
-      expect { @provider.start_service }.to raise_error( Chef::Exceptions::Service )
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+      provider.load_current_resource
+      expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
+      expect { provider.start_service }.to raise_error( Chef::Exceptions::Service )
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
 
     describe "running as a different account" do
-      let(:old_run_as_user) { @new_resource.run_as_user }
-      let(:old_run_as_password) { @new_resource.run_as_password }
+      let(:old_run_as_user) { new_resource.run_as_user }
+      let(:old_run_as_password) { new_resource.run_as_password }
 
       before {
-        @new_resource.run_as_user(".\\wallace")
-        @new_resource.run_as_password("Wensleydale")
+        new_resource.run_as_user(".\\wallace")
+        new_resource.run_as_password("Wensleydale")
       }
 
       after {
-        @new_resource.run_as_user(old_run_as_user)
-        @new_resource.run_as_password(old_run_as_password)
+        new_resource.run_as_user(old_run_as_user)
+        new_resource.run_as_password(old_run_as_password)
       }
 
-      it "should call #grant_service_logon if the :run_as_user and :run_as_password attributes are present" do
+      it "calls #grant_service_logon if the :run_as_user and :run_as_password attributes are present" do
         expect(Win32::Service).to receive(:start)
-        expect(@provider).to receive(:grant_service_logon).and_return(true)
-        @provider.start_service
+        expect(provider).to receive(:grant_service_logon).and_return(true)
+        provider.start_service
       end
     end
   end
 
-
   describe Chef::Provider::Service::Windows, "stop_service" do
 
     before(:each) do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "running"),
         double("StatusStruct", :current_state => "stopped"))
     end
 
-    it "should call the stop command if one is specified" do
-      @new_resource.stop_command "sc stop chef"
-      expect(@provider).to receive(:shell_out!).with("#{@new_resource.stop_command}").and_return("Stopping custom service")
-      @provider.stop_service
-      expect(@new_resource.updated_by_last_action?).to be_truthy
+    it "calls the stop command if one is specified" do
+      new_resource.stop_command "sc stop chef"
+      expect(provider).to receive(:shell_out!).with("#{new_resource.stop_command}").and_return("Stopping custom service")
+      provider.stop_service
+      expect(new_resource.updated_by_last_action?).to be_truthy
     end
 
-    it "should use the built-in command if no stop command is specified" do
-      expect(Win32::Service).to receive(:stop).with(@new_resource.service_name)
-      @provider.stop_service
-      expect(@new_resource.updated_by_last_action?).to be_truthy
+    it "uses the built-in command if no stop command is specified" do
+      expect(Win32::Service).to receive(:stop).with(new_resource.service_name)
+      provider.stop_service
+      expect(new_resource.updated_by_last_action?).to be_truthy
     end
 
-    it "should do nothing if the service does not exist" do
-      allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
-      expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
-      @provider.stop_service
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+    it "does nothing if the service does not exist" do
+      allow(Win32::Service).to receive(:exists?).with(new_resource.service_name).and_return(false)
+      expect(Win32::Service).not_to receive(:stop).with(new_resource.service_name)
+      provider.stop_service
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
 
-    it "should do nothing if the service is stopped" do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+    it "does nothing if the service is stopped" do
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "stopped"))
-      @provider.load_current_resource
-      expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
-      @provider.stop_service
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+      provider.load_current_resource
+      expect(Win32::Service).not_to receive(:stop).with(new_resource.service_name)
+      provider.stop_service
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
 
-    it "should raise an error if the service is paused" do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+    it "raises an error if the service is paused" do
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "paused"))
-      @provider.load_current_resource
-      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
-      expect { @provider.stop_service }.to raise_error( Chef::Exceptions::Service )
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+      provider.load_current_resource
+      expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
+      expect { provider.stop_service }.to raise_error( Chef::Exceptions::Service )
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
 
-    it "should wait and continue if the service is in stop_pending" do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+    it "waits and continue if the service is in stop_pending" do
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "stop pending"),
         double("StatusStruct", :current_state => "stop pending"),
         double("StatusStruct", :current_state => "stopped"))
-      @provider.load_current_resource
-      expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
-      @provider.stop_service
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+      provider.load_current_resource
+      expect(Win32::Service).not_to receive(:stop).with(new_resource.service_name)
+      provider.stop_service
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
 
-    it "should fail if the service is in start_pending" do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+    it "fails if the service is in start_pending" do
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "start pending"))
-      @provider.load_current_resource
-      expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
-      expect { @provider.stop_service }.to raise_error( Chef::Exceptions::Service )
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+      provider.load_current_resource
+      expect(Win32::Service).not_to receive(:stop).with(new_resource.service_name)
+      expect { provider.stop_service }.to raise_error( Chef::Exceptions::Service )
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
 
-    it "should pass custom timeout to the stop command if provided" do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+    it "passes custom timeout to the stop command if provided" do
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "running"))
-      @new_resource.timeout 1
-      expect(Win32::Service).to receive(:stop).with(@new_resource.service_name)
+      new_resource.timeout 1
+      expect(Win32::Service).to receive(:stop).with(new_resource.service_name)
       Timeout.timeout(2) do
-        expect { @provider.stop_service }.to raise_error(Timeout::Error)
+        expect { provider.stop_service }.to raise_error(Timeout::Error)
       end
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
 
   end
 
   describe Chef::Provider::Service::Windows, "restart_service" do
 
-    it "should call the restart command if one is specified" do
-      @new_resource.restart_command "sc restart"
-      expect(@provider).to receive(:shell_out!).with("#{@new_resource.restart_command}")
-      @provider.restart_service
-      expect(@new_resource.updated_by_last_action?).to be_truthy
+    it "calls the restart command if one is specified" do
+      new_resource.restart_command "sc restart"
+      expect(provider).to receive(:shell_out!).with("#{new_resource.restart_command}")
+      provider.restart_service
+      expect(new_resource.updated_by_last_action?).to be_truthy
     end
 
-    it "should stop then start the service if it is running" do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+    it "stops then starts the service if it is running" do
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "running"),
         double("StatusStruct", :current_state => "stopped"),
         double("StatusStruct", :current_state => "stopped"),
         double("StatusStruct", :current_state => "running"))
-      expect(Win32::Service).to receive(:stop).with(@new_resource.service_name)
-      expect(Win32::Service).to receive(:start).with(@new_resource.service_name)
-      @provider.restart_service
-      expect(@new_resource.updated_by_last_action?).to be_truthy
+      expect(Win32::Service).to receive(:stop).with(new_resource.service_name)
+      expect(Win32::Service).to receive(:start).with(new_resource.service_name)
+      provider.restart_service
+      expect(new_resource.updated_by_last_action?).to be_truthy
     end
 
-    it "should just start the service if it is stopped" do
-      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
+    it "just starts the service if it is stopped" do
+      allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "stopped"),
         double("StatusStruct", :current_state => "stopped"),
         double("StatusStruct", :current_state => "running"))
-      expect(Win32::Service).to receive(:start).with(@new_resource.service_name)
-      @provider.restart_service
-      expect(@new_resource.updated_by_last_action?).to be_truthy
+      expect(Win32::Service).to receive(:start).with(new_resource.service_name)
+      provider.restart_service
+      expect(new_resource.updated_by_last_action?).to be_truthy
     end
 
-    it "should do nothing if the service does not exist" do
-      allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
-      expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
-      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
-      @provider.restart_service
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+    it "does nothing if the service does not exist" do
+      allow(Win32::Service).to receive(:exists?).with(new_resource.service_name).and_return(false)
+      expect(Win32::Service).not_to receive(:stop).with(new_resource.service_name)
+      expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
+      provider.restart_service
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
 
   end
 
   describe Chef::Provider::Service::Windows, "enable_service" do
     before(:each) do
-      allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
         double("ConfigStruct", :start_type => "disabled"))
     end
 
-    it "should enable service" do
-      expect(Win32::Service).to receive(:configure).with(:service_name => @new_resource.service_name, :start_type => Win32::Service::AUTO_START)
-      @provider.enable_service
-      expect(@new_resource.updated_by_last_action?).to be_truthy
+    it "enables service" do
+      expect(Win32::Service).to receive(:configure).with(:service_name => new_resource.service_name, :start_type => Win32::Service::AUTO_START)
+      provider.enable_service
+      expect(new_resource.updated_by_last_action?).to be_truthy
     end
 
-    it "should do nothing if the service does not exist" do
-      allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
+    it "does nothing if the service does not exist" do
+      allow(Win32::Service).to receive(:exists?).with(new_resource.service_name).and_return(false)
       expect(Win32::Service).not_to receive(:configure)
-      @provider.enable_service
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+      provider.enable_service
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
   end
 
   describe Chef::Provider::Service::Windows, "action_enable" do
     it "does nothing if the service is enabled" do
-      allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
         double("ConfigStruct", :start_type => "auto start"))
-      expect(@provider).not_to receive(:enable_service)
-      @provider.action_enable
+      expect(provider).not_to receive(:enable_service)
+      provider.action_enable
     end
 
     it "enables the service if it is not set to automatic start" do
-      allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
         double("ConfigStruct", :start_type => "disabled"))
-      expect(@provider).to receive(:enable_service)
-      @provider.action_enable
+      expect(provider).to receive(:enable_service)
+      provider.action_enable
     end
   end
 
   describe Chef::Provider::Service::Windows, "action_disable" do
     it "does nothing if the service is disabled" do
-      allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
         double("ConfigStruct", :start_type => "disabled"))
-      expect(@provider).not_to receive(:disable_service)
-      @provider.action_disable
+      expect(provider).not_to receive(:disable_service)
+      provider.action_disable
     end
 
     it "disables the service if it is not set to disabled" do
-      allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
         double("ConfigStruct", :start_type => "auto start"))
-      expect(@provider).to receive(:disable_service)
-      @provider.action_disable
+      expect(provider).to receive(:disable_service)
+      provider.action_disable
     end
   end
 
   describe Chef::Provider::Service::Windows, "disable_service" do
     before(:each) do
-      allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
         double("ConfigStruct", :start_type => "auto start"))
     end
 
-    it "should disable service" do
+    it "disables service" do
       expect(Win32::Service).to receive(:configure)
-      @provider.disable_service
-      expect(@new_resource.updated_by_last_action?).to be_truthy
+      provider.disable_service
+      expect(new_resource.updated_by_last_action?).to be_truthy
     end
 
-    it "should do nothing if the service does not exist" do
-      allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
+    it "does nothing if the service does not exist" do
+      allow(Win32::Service).to receive(:exists?).with(new_resource.service_name).and_return(false)
       expect(Win32::Service).not_to receive(:configure)
-      @provider.disable_service
-      expect(@new_resource.updated_by_last_action?).to be_falsey
+      provider.disable_service
+      expect(new_resource.updated_by_last_action?).to be_falsey
     end
   end
 
   describe Chef::Provider::Service::Windows, "action_configure_startup" do
     { :automatic => "auto start", :manual => "demand start", :disabled => "disabled" }.each do |type,win32|
       it "sets the startup type to #{type} if it is something else" do
-        @new_resource.startup_type(type)
-        allow(@provider).to receive(:current_start_type).and_return("fire")
-        expect(@provider).to receive(:set_startup_type).with(type)
-        @provider.action_configure_startup
+        new_resource.startup_type(type)
+        allow(provider).to receive(:current_start_type).and_return("fire")
+        expect(provider).to receive(:set_startup_type).with(type)
+        provider.action_configure_startup
       end
 
       it "leaves the startup type as #{type} if it is already set" do
-        @new_resource.startup_type(type)
-        allow(@provider).to receive(:current_start_type).and_return(win32)
-        expect(@provider).not_to receive(:set_startup_type).with(type)
-        @provider.action_configure_startup
+        new_resource.startup_type(type)
+        allow(provider).to receive(:current_start_type).and_return(win32)
+        expect(provider).not_to receive(:set_startup_type).with(type)
+        provider.action_configure_startup
       end
     end
   end
 
   describe Chef::Provider::Service::Windows, "set_start_type" do
     it "when called with :automatic it calls Win32::Service#configure with Win32::Service::AUTO_START" do
-      expect(Win32::Service).to receive(:configure).with(:service_name => @new_resource.service_name, :start_type => Win32::Service::AUTO_START)
-      @provider.send(:set_startup_type, :automatic)
+      expect(Win32::Service).to receive(:configure).with(:service_name => new_resource.service_name, :start_type => Win32::Service::AUTO_START)
+      provider.send(:set_startup_type, :automatic)
     end
 
     it "when called with :manual it calls Win32::Service#configure with Win32::Service::DEMAND_START" do
-      expect(Win32::Service).to receive(:configure).with(:service_name => @new_resource.service_name, :start_type => Win32::Service::DEMAND_START)
-      @provider.send(:set_startup_type, :manual)
+      expect(Win32::Service).to receive(:configure).with(:service_name => new_resource.service_name, :start_type => Win32::Service::DEMAND_START)
+      provider.send(:set_startup_type, :manual)
     end
 
     it "when called with :disabled it calls Win32::Service#configure with Win32::Service::DISABLED" do
-      expect(Win32::Service).to receive(:configure).with(:service_name => @new_resource.service_name, :start_type => Win32::Service::DISABLED)
-      @provider.send(:set_startup_type, :disabled)
+      expect(Win32::Service).to receive(:configure).with(:service_name => new_resource.service_name, :start_type => Win32::Service::DISABLED)
+      provider.send(:set_startup_type, :disabled)
     end
 
     it "raises an exception when given an unknown start type" do
-      expect { @provider.send(:set_startup_type, :fire_truck) }.to raise_error(Chef::Exceptions::ConfigurationError)
+      expect { provider.send(:set_startup_type, :fire_truck) }.to raise_error(Chef::Exceptions::ConfigurationError)
     end
   end
 
@@ -409,9 +420,9 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     let(:success_string) { "The task has completed successfully.\r\nSee logfile etc." }
     let(:failure_string) { "Look on my works, ye Mighty, and despair!" }
     let(:command) {
-      dbfile = @provider.grant_dbfile_name(username)
-      policyfile = @provider.grant_policyfile_name(username)
-      logfile = @provider.grant_logfile_name(username)
+      dbfile = provider.grant_dbfile_name(username)
+      policyfile = provider.grant_policyfile_name(username)
+      logfile = provider.grant_logfile_name(username)
 
       %Q{secedit.exe /configure /db "#{dbfile}" /cfg "#{policyfile}" /areas USER_RIGHTS SECURITYPOLICY SERVICES /log "#{logfile}"}
     }
@@ -424,20 +435,20 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
 
     after {
       # only needed for the second test.
-      ::File.delete(@provider.grant_policyfile_name(username)) rescue nil
-      ::File.delete(@provider.grant_logfile_name(username)) rescue nil
-      ::File.delete(@provider.grant_dbfile_name(username)) rescue nil
+      ::File.delete(provider.grant_policyfile_name(username)) rescue nil
+      ::File.delete(provider.grant_logfile_name(username)) rescue nil
+      ::File.delete(provider.grant_dbfile_name(username)) rescue nil
     }
 
     it "calls Mixlib::Shellout with the correct command string" do
       expect_any_instance_of(Mixlib::ShellOut).to receive(:exitstatus).and_return(0)
-      expect(@provider.grant_service_logon(username)).to equal true
+      expect(provider.grant_service_logon(username)).to equal true
     end
 
     it "raises an exception when the grant command fails" do
       expect_any_instance_of(Mixlib::ShellOut).to receive(:exitstatus).and_return(1)
       expect_any_instance_of(Mixlib::ShellOut).to receive(:stdout).and_return(failure_string)
-      expect { @provider.grant_service_logon(username) }.to raise_error(Chef::Exceptions::Service)
+      expect { provider.grant_service_logon(username) }.to raise_error(Chef::Exceptions::Service)
     end
   end
 
@@ -445,17 +456,17 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     include_context "testing private methods"
 
     it "correctly reformats usernames to create valid filenames" do
-      expect(@provider.clean_username_for_path("\\\\problem username/oink.txt")).to eq("_problem_username_oink_txt")
-      expect(@provider.clean_username_for_path("boring_username")).to eq("boring_username")
+      expect(provider.clean_username_for_path("\\\\problem username/oink.txt")).to eq("_problem_username_oink_txt")
+      expect(provider.clean_username_for_path("boring_username")).to eq("boring_username")
     end
 
     it "correctly reformats usernames for the policy file" do
-      expect(@provider.canonicalize_username(".\\maryann")).to eq("maryann")
-      expect(@provider.canonicalize_username("maryann")).to eq("maryann")
+      expect(provider.canonicalize_username(".\\maryann")).to eq("maryann")
+      expect(provider.canonicalize_username("maryann")).to eq("maryann")
 
-      expect(@provider.canonicalize_username("\\\\maryann")).to eq("maryann")
-      expect(@provider.canonicalize_username("mydomain\\\\maryann")).to eq("mydomain\\\\maryann")
-      expect(@provider.canonicalize_username("\\\\mydomain\\\\maryann")).to eq("mydomain\\\\maryann")
+      expect(provider.canonicalize_username("\\\\maryann")).to eq("maryann")
+      expect(provider.canonicalize_username("mydomain\\\\maryann")).to eq("mydomain\\\\maryann")
+      expect(provider.canonicalize_username("\\\\mydomain\\\\maryann")).to eq("mydomain\\\\maryann")
     end
   end
 end