path: root/spec/unit/provider/service/windows_spec.rb

#
# Author:: Nuo Yan <nuo@chef.io>
# Author:: Seth Chisamore <schisamo@chef.io>
# Copyright:: Copyright (c) Chef Software Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

require "spec_helper"

describe Chef::Provider::Service::Windows, "load_current_resource" do
  include_context "Win32"

  before(:all) do
    Chef::ReservedNames::Win32::Security = Class.new unless windows?
  end

  after(:all) do
    Chef::ReservedNames::Win32.send(:remove_const, :Security) unless windows?
  end

  let(:logger) { double("Mixlib::Log::Child").as_null_object }

  let(:chef_service_name) { "chef-client" }
  let(:new_resource) { Chef::Resource::WindowsService.new(chef_service_name) }

  # Actual response from Win32::Service.config_info('chef-client')
  let(:chef_service_binary_path_name) do
    'C:\\opscode\\chef\\embedded\\bin\\ruby.exe C:\\opscode\\chef\\bin\\chef-windows-service'
  end
  let(:chef_service_config_info) do
    double("Struct::ServiceConfigInfo",
      service_type: "own process",
      start_type: "auto start",
      error_control: "ignore",
      binary_path_name: chef_service_binary_path_name,
      load_order_group: "",
      tag_id: 0,
      dependencies: ["Winmgmt"],
      service_start_name: "LocalSystem",
      display_name: "Chef Client Service")
  end

  # Actual response from Win32::Service.services
  let(:chef_service_info) do
    double("Struct::ServiceInfo",
      service_name: chef_service_name,
      display_name: "Chef Client Service",
      service_type: "own process",
      current_state: "running",
      controls_accepted: [],
      win32_exit_code: 1077,
      service_specific_exit_code: 0,
      check_point: 0,
      wait_hint: 0,
      binary_path_name: chef_service_binary_path_name,
      start_type: "auto start",
      error_control: "ignore",
      load_order_group: "",
      tag_id: 0,
      start_name: "LocalSystem",
      dependencies: ["Winmgmt"],
      description: "Runs Chef Client on regular, configurable intervals.",
      interactive: false,
      pid: 0,
      service_flags: 0,
      reset_period: 0,
      reboot_message: nil,
      command: nil,
      num_actions: 0,
      actions: nil,
      delayed_start: 1)
  end

  let(:provider) do
    run_context = Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new)
    allow(run_context).to receive(:logger).and_return(logger)
    prvdr = Chef::Provider::Service::Windows.new(new_resource, run_context)
    prvdr.current_resource = Chef::Resource::WindowsService.new("current-chef")
    prvdr
  end

  let(:service_right) { Chef::Provider::Service::Windows::SERVICE_RIGHT }

  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(:start).with(any_args).and_return(Win32::Service)
    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(chef_service_config_info)

    allow(Win32::Service).to receive(:delayed_start).with(chef_service_name).and_return(1)
    allow(Win32::Service).to receive(:exists?).and_return(true)
    allow(Win32::Service).to receive(:configure).and_return(Win32::Service)
    allow(Chef::ReservedNames::Win32::Security).to receive(:get_account_right).and_return([])
    allow(Chef::ReservedNames::Win32::Security).to receive(:add_account_right).with("localsystem", "SeServiceLogonRight").and_return(0)
  end

  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 "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_service_name)
  end

  it "returns the current resource" do
    expect(provider.load_current_resource).to equal(provider.current_resource)
  end

  it "sets the current resources start type" do
    provider.load_current_resource
    expect(provider.current_resource.enabled).to be_truthy
  end

  context "service does not exist" do
    before do
      allow(Win32::Service).to receive(:exists?).with(chef_service_name).and_return(false)
    end

    %w{running enabled startup_type error_control binary_path_name
      load_order_group dependencies run_as_user display_name }.each do |prop|
        it "does not set #{prop}" do
          expect(provider.current_resource.running).to be_nil
        end
      end
  end

  context "service exists" do
    before do
      allow(Win32::Service).to receive(:exists?).with(chef_service_name).and_return(true)
      allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
        double("Struct::ServiceConfigInfo",
          service_type: "share process",
          start_type: "demand start",
          error_control: "normal",
          binary_path_name: 'C:\\Windows\\system32\\svchost.exe -k LocalServiceNetworkRestricted',
          load_order_group: "TDI",
          tag_id: 0,
          dependencies: %w{NSI Tdx Afd},
          service_start_name: 'NT Authority\\LocalService',
          display_name: "DHCP Client")
      )
    end

    context "startup_type is neither :automatic or :disabled" do
      before do
        allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
          double("Struct::ServiceConfigInfo",
            service_type: "share process",
            start_type: "demand start",
            error_control: "normal",
            binary_path_name: 'C:\\Windows\\system32\\svchost.exe -k LocalServiceNetworkRestricted',
            load_order_group: "TDI",
            tag_id: 0,
            dependencies: %w{NSI Tdx Afd},
            service_start_name: 'NT Authority\\LocalService',
            display_name: "DHCP Client")
        )
      end

      it "does not set the current resources enabled" do
        provider.load_current_resource
        expect(provider.current_resource.enabled).to be_nil
      end
    end

    it "sets the current resources running to true if it's running" do
      allow(provider).to receive(:current_state).and_return("running")
      provider.load_current_resource
      expect(provider.current_resource.running).to be true
    end

    it "sets the current resources running to false if it's in any other state" do
      allow(provider).to receive(:current_state).and_return("other state")
      provider.load_current_resource
      expect(provider.current_resource.running).to be false
    end

    it "sets startup_type" do
      expect(provider.current_resource.startup_type).to be_truthy
    end

    it "sets error_control" do
      provider.load_current_resource
      expect(provider.current_resource.error_control).to be_truthy
    end

    it "sets binary_path_name" do
      provider.load_current_resource
      expect(provider.current_resource.binary_path_name).to be_truthy
    end

    it "sets load_order_group" do
      provider.load_current_resource
      expect(provider.current_resource.load_order_group).to be_truthy
    end

    it "sets dependencies" do
      provider.load_current_resource
      expect(provider.current_resource.dependencies).to be_truthy
    end

    it "sets run_as_user" do
      provider.load_current_resource
      expect(provider.current_resource.run_as_user).to be_truthy
    end

    it "sets display_name" do
      provider.load_current_resource
      expect(provider.current_resource.display_name).to be_truthy
    end

    it "sets delayed start to true if delayed start is enabled" do
      allow(Win32::Service).to receive(:delayed_start).with(chef_service_name).and_return(1)
      provider.load_current_resource
      expect(provider.current_resource.delayed_start).to be true
    end

    it "sets delayed start to false if delayed start is disabled" do
      allow(Win32::Service).to receive(:delayed_start).with(chef_service_name).and_return(0)
      provider.load_current_resource
      expect(provider.current_resource.delayed_start).to be false
    end
  end

  describe Chef::Provider::Service::Windows, "action_create" do
    before do
      provider.new_resource.binary_path_name = chef_service_binary_path_name
    end

    context "service exists" do
      before do
        allow(Win32::Service).to receive(:exists?).with(chef_service_name).and_return(true)
      end

      it "logs debug message" do
        expect(logger).to receive(:trace).with("windows_service[#{chef_service_name}] already exists - nothing to do")
        provider.action_create
      end

      it "does not converge" do
        provider.action_create
        expect(provider.resource_updated?).to be false
      end

      it "does not create service" do
        expect(Win32::Service).to_not receive(:new)
        provider.action_create
      end

      it "does not call converge_delayed_start" do
        expect(provider).to_not receive(:converge_delayed_start)
        provider.action_create
      end
    end

    context "service does not exist" do
      before do
        allow(Win32::Service).to receive(:exists?).with(chef_service_name).and_return(false)
        allow(Win32::Service).to receive(:new).with(anything).and_return(true)
      end

      it "converges resource" do
        provider.action_create
        expect(provider.resource_updated?).to be true
      end

      it "creates service" do
        expect(Win32::Service).to receive(:new)
        provider.action_create
      end

      it "creates service with correct configuration" do
        expect(Win32::Service).to receive(:new).with(
          service_name: chef_service_name,
          service_type: 16,
          start_type: 2,
          error_control: 1,
          binary_path_name: chef_service_binary_path_name,
          service_start_name: "localsystem",
          desired_access: 983551
        )
        provider.action_create
      end

      it "calls converge_delayed_start" do
        expect(provider).to receive(:converge_delayed_start)
        provider.action_create
      end
    end
  end

  describe Chef::Provider::Service::Windows, "action_delete" do
    context "service exists" do
      before do
        allow(Win32::Service).to receive(:exists?).with(chef_service_name).and_return(true)
        allow(Win32::Service).to receive(:delete).with(chef_service_name).and_return(true)
      end

      it "converges resource" do
        provider.action_delete
        expect(provider.resource_updated?).to be true
      end

      it "deletes service" do
        expect(Win32::Service).to receive(:delete).with(chef_service_name)
        provider.action_delete
      end
    end

    context "service does not exist" do
      before do
        allow(Win32::Service).to receive(:exists?).with(chef_service_name).and_return(false)
      end

      it "logs debug message" do
        expect(logger).to receive(:trace).with("windows_service[#{chef_service_name}] does not exist - nothing to do")
        provider.action_delete
      end

      it "does not converge" do
        provider.action_delete
        expect(provider.resource_updated?).to be false
      end

      it "does not delete service" do
        expect(Win32::Service).to_not receive(:delete)
        provider.action_delete
      end
    end
  end

  describe Chef::Provider::Service::Windows, "action_configure" do
    context "service exists" do
      before do
        allow(Win32::Service).to receive(:exists?).with(chef_service_name).and_return(true)
        allow(Win32::Service).to receive(:configure).with(anything).and_return(true)
      end

      # properties that are Strings
      %i{binary_path_name load_order_group dependencies run_as_user
         display_name description}.each do |attr|
           it "configures service if #{attr} has changed" do
             provider.current_resource.send("#{attr}=", "old value")
             provider.new_resource.send("#{attr}=", "new value")

             expect(Win32::Service).to receive(:configure)
             provider.action_configure
           end
         end

      # properties that are Integers
      %i{service_type error_control}.each do |attr|
        it "configures service if #{attr} has changed" do
          provider.current_resource.send("#{attr}=", 1)
          provider.new_resource.send("#{attr}=", 2)

          expect(Win32::Service).to receive(:configure)
          provider.action_configure
        end
      end

      it "configures service if startup_type has changed" do
        provider.current_resource.startup_type = :automatic
        provider.new_resource.startup_type = :manual

        expect(Win32::Service).to receive(:configure)
        provider.action_configure
      end

      it "does not configure service when run_as_user case is different" do
        provider.current_resource.run_as_user = "JohnDoe"
        provider.new_resource.run_as_user = "johndoe"
        expect(Win32::Service).not_to receive(:configure)
        provider.action_configure

        provider.current_resource.run_as_user = "johndoe"
        provider.new_resource.run_as_user = "JohnDoe"
        expect(Win32::Service).not_to receive(:configure)
        provider.action_configure
      end

      it "calls converge_delayed_start" do
        expect(provider).to receive(:converge_delayed_start)
        provider.action_configure
      end
    end

    context "service does not exist" do
      let(:missing_service_warning_message) { "windows_service[#{chef_service_name}] does not exist. Maybe you need to prepend action :create" }

      before do
        allow(Win32::Service).to receive(:exists?).with(chef_service_name).and_return(false)

        # This prevents warnings being logged during unit tests which adds to
        # developer confusion when they aren't familiar with this specific test
        allow(logger).to receive(:warn).with(missing_service_warning_message)
      end

      it "logs warning" do
        expect(logger).to receive(:warn).with(missing_service_warning_message)
        provider.action_configure
      end

      it "does not converge" do
        provider.action_configure
        expect(provider.resource_updated?).to be false
      end

      it "does not configure service" do
        expect(Win32::Service).to_not receive(:configure)
        provider.action_configure
      end

      it "does not call converge_delayed_start" do
        expect(provider).to_not receive(:converge_delayed_start)
        provider.action_configure
      end
    end
  end

  describe Chef::Provider::Service::Windows, "converge_delayed_start" do
    before do
      allow(Win32::Service).to receive(:configure).and_return(true)
    end

    context "delayed start needs to be updated" do
      before do
        provider.current_resource.delayed_start = false
        provider.new_resource.delayed_start = true
      end

      it "configures delayed start" do
        expect(Win32::Service).to receive(:configure)
        provider.send(:converge_delayed_start)
      end

      it "configures delayed start with correct params" do
        expect(Win32::Service).to receive(:configure).with(service_name: chef_service_name, delayed_start: 1)
        provider.send(:converge_delayed_start)
      end

      it "converges resource" do
        provider.send(:converge_delayed_start)
        expect(provider.resource_updated?).to be true
      end
    end

    context "delayed start does not need to be updated" do
      before do
        provider.current_resource.delayed_start = false
        provider.new_resource.delayed_start = false
      end

      it "does not configure delayed start" do
        expect(Win32::Service).to_not receive(:configure)
        provider.send(:converge_delayed_start)
      end

      it "does not converge" do
        provider.send(:converge_delayed_start)
        expect(provider.resource_updated?).to be false
      end
    end
  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(
        double("StatusStruct", current_state: "stopped"),
        double("StatusStruct", current_state: "running")
      )
    end

    context "run_as_user user is specified" do
      let(:run_as_user) { provider.new_resource.class.properties[:run_as_user].default }

      before do
        provider.new_resource.run_as_user run_as_user
      end

      it "configures service run_as_user and run_as_password" do
        expect(provider).to receive(:configure_service_run_as_properties).and_call_original
        expect(Win32::Service).to receive(:configure)
        provider.start_service
      end
    end

    context "run_as_user user is not specified" do
      before do
        expect(provider.new_resource.property_is_set?(:run_as_user)).to be false
      end

      it "does not configure service run_as_user and run_as_password" do
        expect(Win32::Service).not_to receive(:configure)
        provider.start_service
      end
    end

    context "start_command is specified" do
      let(:start_command) { "sc start #{chef_service_name}" }

      before do
        new_resource.start_command start_command
        allow(provider).to receive(:shell_out!).with(start_command)
      end

      it "shells out the start_command" do
        expect(provider).to receive(:shell_out!).with(start_command)
        provider.start_service
      end

      it "does not call Win32::Service.start" do
        expect(Win32::Service).not_to receive(:start)
        provider.start_service
      end

      it "is updated by last action" do
        provider.start_service
        expect(new_resource).to be_updated_by_last_action
      end
    end

    context "start_command is not specified" do
      before do
        expect(new_resource.start_command).to be_nil
      end

      it "uses the built-in command" do
        expect(Win32::Service).to receive(:start).with(new_resource.service_name)
        provider.start_service
      end

      it "does not shell out the start_command" do
        expect(provider).not_to receive(:shell_out!)
        provider.start_service
      end

      it "is updated by last action" do
        provider.start_service
        expect(new_resource).to be_updated_by_last_action
      end
    end

    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)
      provider.start_service
      expect(new_resource).not_to be_updated_by_last_action
    end

    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).not_to be_updated_by_last_action
    end

    context "service is paused" do
      before do
        allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
          double("StatusStruct", current_state: "paused")
        )
        provider.load_current_resource
      end

      it "raises error" do
        expect { provider.start_service }.to raise_error(Chef::Exceptions::Service)
      end

      it "does not start service" do
        expect(Win32::Service).not_to receive(:start)
        expect(provider).not_to receive(:shell_out!)
        expect { provider.start_service }.to raise_error(Chef::Exceptions::Service)
      end

      it "is not updated by last action" do
        expect { provider.start_service }.to raise_error(Chef::Exceptions::Service)
        expect(new_resource).not_to be_updated_by_last_action
      end
    end

    context "service is in start_pending" do
      before 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
      end

      it "waits until service is running" do
        expect(provider).to receive(:wait_for_state).with(Chef::Provider::Service::Windows::RUNNING)
        provider.start_service
      end

      it "does not start service" do
        expect(Win32::Service).not_to receive(:start)
        expect(provider).not_to receive(:shell_out!)
        provider.start_service
      end

      it "is not updated by last action" do
        provider.start_service
        expect(new_resource).not_to be_updated_by_last_action
      end
    end

    context "service is in stop_pending" do
      before do
        allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
          double("StatusStruct", current_state: "stop pending")
        )
        provider.load_current_resource
      end

      it "raises error" do
        expect { provider.start_service }.to raise_error(Chef::Exceptions::Service)
      end

      it "does not start service" do
        expect(Win32::Service).not_to receive(:start)
        expect(provider).not_to receive(:shell_out!)
        expect { provider.start_service }.to raise_error(Chef::Exceptions::Service)
      end

      it "is not updated by last action" do
        expect { provider.start_service }.to raise_error(Chef::Exceptions::Service)
        expect(new_resource).not_to be_updated_by_last_action
      end
    end

    describe "running as a different account" do
      before do
        new_resource.run_as_user(".\\wallace")
        new_resource.run_as_password("Wensleydale")
      end

      it "calls #grant_service_logon if the :run_as_user and :run_as_password properties are present" do
        expect(provider).to receive(:grant_service_logon).and_return(true)
        provider.start_service
      end

      it "does not grant user SeServiceLogonRight if it already has it" do
        expect(Chef::ReservedNames::Win32::Security).to receive(:get_account_right).with("wallace").and_return([service_right])
        expect(Chef::ReservedNames::Win32::Security).not_to receive(:add_account_right).with("wallace", service_right)
        provider.start_service
      end

      it "skips the rights check for LocalSystem" do
        new_resource.run_as_user("LocalSystem")
        expect(Chef::ReservedNames::Win32::Security).not_to receive(:get_account_right)
        expect(Chef::ReservedNames::Win32::Security).not_to receive(:add_account_right)
        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(
        double("StatusStruct", current_state: "running"),
        double("StatusStruct", current_state: "stopped")
      )
    end

    it "calls the stop command if one is specified" do
      new_resource.stop_command "sc stop #{chef_service_name}"
      expect(provider).to receive(:shell_out!).with((new_resource.stop_command).to_s).and_return("Stopping custom service")
      provider.stop_service
      expect(new_resource).to be_updated_by_last_action
    end

    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).to be_updated_by_last_action
    end

    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).to_not be_updated_by_last_action
    end

    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).to_not be_updated_by_last_action
    end

    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).to_not be_updated_by_last_action
    end

    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).to_not be_updated_by_last_action
    end

    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).to_not be_updated_by_last_action
    end

    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)
      Timeout.timeout(2) do
        expect { provider.stop_service }.to raise_error(Timeout::Error)
      end
      expect(new_resource).to_not be_updated_by_last_action
    end

  end

  describe Chef::Provider::Service::Windows, "restart_service" do

    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).to_s)
      provider.restart_service
      expect(new_resource).to be_updated_by_last_action
    end

    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).to be_updated_by_last_action
    end

    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).to be_updated_by_last_action
    end

    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).to_not be_updated_by_last_action
    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(
        double("ConfigStruct", start_type: "disabled")
      )
    end

    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).to be_updated_by_last_action
    end

    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).to_not be_updated_by_last_action
    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(
        double("ConfigStruct", start_type: "auto start")
      )
      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(
        double("ConfigStruct", start_type: "disabled")
      )
      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(
        double("ConfigStruct", start_type: "disabled")
      )
      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(
        double("ConfigStruct", start_type: "auto start")
      )
      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(
        double("ConfigStruct", start_type: "auto start")
      )
    end

    it "disables service" do
      expect(Win32::Service).to receive(:configure)
      provider.disable_service
      expect(new_resource).to be_updated_by_last_action
    end

    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).to_not be_updated_by_last_action
    end
  end

  describe Chef::Provider::Service::Windows, "action_configure_startup" do
    %i{automatic manual disabled}.each do |type|
      it "sets the startup type to #{type} if it is something else" do
        new_resource.startup_type(type)
        allow(provider).to receive(:current_startup_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_startup_type).and_return(type)
        expect(provider).not_to receive(:set_startup_type).with(type)
        provider.action_configure_startup
      end
    end

    it "calls converge_delayed_start" do
      expect(provider).to receive(:converge_delayed_start)
      provider.action_configure_startup
    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)
    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)
    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)
    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)
    end
  end

  shared_context "testing private methods" do

    let(:private_methods) do
      described_class.private_instance_methods
    end

    before do
      described_class.send(:public, *private_methods)
    end

    after do
      described_class.send(:private, *private_methods)
    end
  end

  describe "grant_service_logon" do
    include_context "testing private methods"

    let(:username) { "unit_test_user" }

    it "calls win32 api to grant user SeServiceLogonRight" do
      expect(Chef::ReservedNames::Win32::Security).to receive(:add_account_right).with(username, service_right)
      expect(provider.grant_service_logon(username)).to equal true
    end

    it "strips '.\' from user name when sending to win32 api" do
      expect(Chef::ReservedNames::Win32::Security).to receive(:add_account_right).with(username, service_right)
      expect(provider.grant_service_logon(".\\#{username}")).to equal true
    end

    it "raises an exception when the grant fails" do
      expect(Chef::ReservedNames::Win32::Security).to receive(:add_account_right).and_raise(Chef::Exceptions::Win32APIError, "barf")
      expect { provider.grant_service_logon(username) }.to raise_error(Chef::Exceptions::Service)
    end
  end

  describe "cleaning usernames" 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")
    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("mydomain\\\\maryann")).to eq("mydomain\\\\maryann")
      expect(provider.canonicalize_username("\\\\mydomain\\\\maryann")).to eq("mydomain\\\\maryann")
    end
  end
end