puppet 4.2.1-x64-mingw32 → 4.2.2-x64-mingw32

data/lib/puppet/pops/parser/lexer2.rb

@@ -131,7 +131,13 @@ class Puppet::Pops::Parser::Lexer2
     "type"     => [:TYPE,     'type',     4],
     "attr"     => [:ATTR,     'attr',     4],
     "private"  => [:PRIVATE,  'private',  7],
+    # The following tokens exist in reserved form. Later they will be made
+    # live subject to a feature switch.
+    "application"  => [:APPLICATION_R,  'application',  11],
+    "consumes"     => [:CONSUMES_R,  'consumes',  8],
+    "produces"     => [:PRODUCES_R,  'produces',  8],
   }
+
   KEYWORDS.each {|k,v| v[1].freeze; v.freeze }
   KEYWORDS.freeze
 

data/lib/puppet/pops/validation/checker4_0.rb

@@ -299,6 +299,12 @@ class Puppet::Pops::Validation::Checker4_0
     'runtime' => true,
   }
 
+  FUTURE_RESERVED_WORDS = {
+    'application' => true,
+    'produces' => true,
+    'consumes' => true
+  }
+
   # for 'class', 'define', and function
   def check_NamedDefinition(o)
     top(o.eContainer, o)
@@ -309,6 +315,12 @@ class Puppet::Pops::Validation::Checker4_0
     if RESERVED_TYPE_NAMES[o.name()]
       acceptor.accept(Issues::RESERVED_TYPE_NAME, o, {:name => o.name})
     end
+
+    # This is perhaps not ideal but it's very difficult to pass a ReservedWord through
+    # the mechanism that creates qualified names (namestack, namepop etc.)
+    if FUTURE_RESERVED_WORDS[o.name]
+      acceptor.accept(Issues::FUTURE_RESERVED_WORD, o, {:word => o.name})
+    end
   end
 
   def check_FunctionDefinition(o)
@@ -495,7 +507,11 @@ class Puppet::Pops::Validation::Checker4_0
   end
 
   def check_ReservedWord(o)
-    acceptor.accept(Issues::RESERVED_WORD, o, :word => o.word)
+    if o.future
+      acceptor.accept(Issues::FUTURE_RESERVED_WORD, o, :word => o.word)
+    else
+      acceptor.accept(Issues::RESERVED_WORD, o, :word => o.word)
+    end
   end
 
   def check_SelectorExpression(o)

data/lib/puppet/pops/validation/validator_factory_4_0.rb

@@ -23,7 +23,9 @@ class Puppet::Pops::Validation::ValidatorFactory_4_0 < Puppet::Pops::Validation:
     p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
     p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
 
-    p[Issues::NAME_WITH_HYPHEN]             = :error
+    p[Issues::FUTURE_RESERVED_WORD]          = :deprecation
+
+    p[Issues::NAME_WITH_HYPHEN]              = :error
     p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
     p
   end

data/lib/puppet/provider/exec.rb

@@ -47,7 +47,12 @@ class Puppet::Provider::Exec < Puppet::Provider
           end
         end
 
-        Timeout::timeout(resource[:timeout]) do
+        # Ruby 2.1 and later interrupt execution in a way that bypasses error
+        # handling by default. Passing Timeout::Error causes an exception to be
+        # raised that can be rescued inside of the block by cleanup routines.
+        #
+        # This is backwards compatible all the way to Ruby 1.8.7.
+        Timeout::timeout(resource[:timeout], Timeout::Error) do
           # note that we are passing "false" for the "override_locale" parameter, which ensures that the user's
           # default/system locale will be respected.  Callers may override this behavior by setting locale-related
           # environment variables (LANG, LC_ALL, etc.) in their 'environment' configuration.

data/lib/puppet/provider/package/yum.rb

@@ -151,9 +151,15 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
       end
     end
 
-    args = ["-d", "0", "-e", "0", "-y", install_options, operation, wanted].compact
-    yum *args
-
+    # Yum on el-4 and el-5 returns exit status 0 when trying to install a package it doesn't recognize;
+    # ensure we capture output to check for errors.
+    no_debug = if Facter.value(:operatingsystemmajrelease).to_i > 5 then ["-d", "0"] else [] end
+    args = no_debug + ["-e", "0", "-y", install_options, operation, wanted].compact
+    output = yum *args
+
+    if output =~ /^No package #{wanted} available\.$/
+      raise Puppet::Error, "Could not find package #{wanted}"
+    end
 
     # If a version was specified, query again to see if it is a matching version
     if should

data/lib/puppet/provider/service/launchd.rb

@@ -65,12 +65,27 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     ]
   end
 
+  # Gets the current Darwin version, example 10.6 returns 9 and 10.10 returns 14
+  # See https://en.wikipedia.org/wiki/Darwin_(operating_system)#Release_history
+  # for more information.
+  #
+  # @api private
+  def self.get_os_version
+    @os_version ||= Facter.value(:operatingsystemmajrelease).to_i
+  end
+
   # Defines the path to the overrides plist file where service enabling
   # behavior is defined in 10.6 and greater.
   #
+  # With the rewrite of launchd in 10.10+, this moves and slightly changes format.
+  #
   # @api private
   def self.launchd_overrides
-    "/var/db/launchd.db/com.apple.launchd/overrides.plist"
+    if self.get_os_version < 14
+      "/var/db/launchd.db/com.apple.launchd/overrides.plist"
+    else
+      "/var/db/com.apple.xpc.launchd/disabled.plist"
+    end
   end
 
   # Caching is enabled through the following three methods. Self.prefetch will
@@ -219,8 +234,10 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     did_enable_job = false
     cmds = []
     cmds << :launchctl << :load
+    # always add -w so it always starts the job, it is a noop if it is not needed, this means we do
+    # not have to rescan all launchd plists.
+    cmds << "-w"
     if self.enabled? == :false  || self.status == :stopped # launchctl won't load disabled jobs
-      cmds << "-w"
       did_enable_job = true
     end
     cmds << job_path
@@ -277,7 +294,11 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
 
     if FileTest.file?(self.class.launchd_overrides) and overrides = self.class.read_plist(self.class.launchd_overrides)
       if overrides.has_key?(resource[:name])
-        overrides_disabled = overrides[resource[:name]]["Disabled"] if overrides[resource[:name]].has_key?("Disabled")
+        if self.class.get_os_version < 14
+          overrides_disabled = overrides[resource[:name]]["Disabled"] if overrides[resource[:name]].has_key?("Disabled")
+        else
+          overrides_disabled = overrides[resource[:name]]
+        end
       end
     end
 
@@ -296,13 +317,21 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   # without actually loading/unloading the job.
   def enable
     overrides = self.class.read_plist(self.class.launchd_overrides)
-    overrides[resource[:name]] = { "Disabled" => false }
+    if self.class.get_os_version < 14
+      overrides[resource[:name]] = { "Disabled" => false }
+    else
+      overrides[resource[:name]] = false
+    end
     Plist::Emit.save_plist(overrides, self.class.launchd_overrides)
   end
 
   def disable
-    job_path, job_plist = plist_from_label(resource[:name])
-    job_plist["Disabled"] = true
-    Plist::Emit.save_plist(job_plist, job_path)
+    overrides = self.class.read_plist(self.class.launchd_overrides)
+    if self.class.get_os_version < 14
+      overrides[resource[:name]] = { "Disabled" => true }
+    else
+      overrides[resource[:name]] = true
+    end
+    Plist::Emit.save_plist(overrides, self.class.launchd_overrides)
   end
 end

data/lib/puppet/provider/service/systemd.rb

@@ -105,7 +105,7 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
   end
 
   def enable
-    output = systemctl("unmask", @resource[:name])
+    self.unmask
     output = systemctl("enable", @resource[:name])
   rescue Puppet::ExecutionFailure
     raise Puppet::Error, "Could not enable #{self.name}: #{output}", $!.backtrace
@@ -113,7 +113,6 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
 
   def mask
     self.disable
-
     begin
       output = systemctl("mask", @resource[:name])
     rescue Puppet::ExecutionFailure
@@ -121,11 +120,20 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
     end
   end
 
+  def unmask
+    begin
+      output = systemctl("unmask", @resource[:name])
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error, "Could not unmask #{self.name}: #{output}", $!.backtrace
+    end
+  end
+
   def restartcmd
     [command(:systemctl), "restart", @resource[:name]]
   end
 
   def startcmd
+    self.unmask
     [command(:systemctl), "start", @resource[:name]]
   end
 

data/lib/puppet/reference/configuration.rb

@@ -22,10 +22,16 @@ config = Puppet::Util::Reference.newreference(:configuration, :depth => 1, :doc
 
     # Now print the data about the item.
     val = object.default
-    if name.to_s == "vardir"
-      val = "/opt/puppetlabs/puppet/cache"
-    elsif name.to_s == "confdir"
-      val = "/etc/puppetlabs/puppet"
+    if name.to_s == 'vardir'
+      val = 'Unix/Linux: /opt/puppetlabs/puppet/cache -- Windows: C:\ProgramData\PuppetLabs\puppet\cache -- Non-root user: ~/.puppetlabs/opt/puppet/cache'
+    elsif name.to_s == 'confdir'
+      val = 'Unix/Linux: /etc/puppetlabs/puppet -- Windows: C:\ProgramData\PuppetLabs\puppet\etc -- Non-root user: ~/.puppetlabs/etc/puppet'
+    elsif name.to_s == 'codedir'
+      val = 'Unix/Linux: /etc/puppetlabs/code -- Windows: C:\ProgramData\PuppetLabs\code -- Non-root user: ~/.puppetlabs/etc/code'
+    elsif name.to_s == 'rundir'
+      val = 'Unix/Linux: /var/run/puppetlabs -- Windows: C:\ProgramData\PuppetLabs\puppet\var\run -- Non-root user: ~/.puppetlabs/var/run'
+    elsif name.to_s == 'logdir'
+      val = 'Unix/Linux: /var/log/puppetlabs/puppet -- Windows: C:\ProgramData\PuppetLabs\puppet\var\log -- Non-root user: ~/.puppetlabs/var/log'
     end
 
     # Leave out the section information; it was apparently confusing people.

data/lib/puppet/type/package.rb

@@ -404,8 +404,9 @@ module Puppet
     end
 
     newparam(:configfiles) do
-      desc "Whether configfiles should be kept or replaced.  Most packages
-        types do not support this parameter. Defaults to `keep`."
+      desc "Whether to keep or replace modified config files when installing or
+        upgrading a package. This only affects the `apt` and `dpkg` providers.
+        Defaults to `keep`."
 
       defaultto :keep
 
@@ -456,10 +457,12 @@ module Puppet
         key and value pair are interpreted in a provider specific way.  Each
         option will automatically be quoted when passed to the install command.
 
-        On Windows, this is the **only** place in Puppet where backslash
-        separators should be used.  Note that backslashes in double-quoted
-        strings _must_ be double-escaped and backslashes in single-quoted
-        strings _may_ be double-escaped.
+        With Windows packages, note that file paths in an install option must
+        use backslashes. (Since install options are passed directly to the
+        installation command, forward slashes won't be automatically converted
+        like they are in `file` resources.) Note also that backslashes in
+        double-quoted strings _must_ be escaped and backslashes in single-quoted
+        strings _can_ be escaped.
       EOT
     end
 

data/lib/puppet/util/execution.rb

@@ -1,3 +1,4 @@
+require 'timeout'
 require 'puppet/file_system/uniquefile'
 
 module Puppet
@@ -192,8 +193,23 @@ module Puppet::Util::Execution
       if execution_stub = Puppet::Util::ExecutionStub.current_value
         return execution_stub.call(*exec_args)
       elsif Puppet.features.posix?
-        child_pid = execute_posix(*exec_args)
-        exit_status = Process.waitpid2(child_pid).last.exitstatus
+        child_pid = nil
+        begin
+          child_pid = execute_posix(*exec_args)
+          exit_status = Process.waitpid2(child_pid).last.exitstatus
+          child_pid = nil
+        rescue Timeout::Error => e
+          # NOTE: For Ruby 2.1+, an explicit Timeout::Error class has to be
+          # passed to Timeout.timeout in order for there to be something for
+          # this block to rescue.
+          unless child_pid.nil?
+            Process.kill(:TERM, child_pid)
+            # Spawn a thread to reap the process if it dies.
+            Thread.new { Process.waitpid(child_pid) }
+          end
+
+          raise e
+        end
       elsif Puppet.features.microsoft_windows?
         process_info = execute_windows(*exec_args)
         begin

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '4.2.1'
+  PUPPETVERSION = '4.2.2'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/unit/file_system_spec.rb

@@ -446,6 +446,26 @@ describe "Puppet::FileSystem" do
       expect(Puppet::FileSystem.readlink(symlink)).to eq(missing_file.to_s)
     end
 
+    it "should be able to unlink a dangling symlink pointed at a file" do
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+      ::File.delete(file)
+      Puppet::FileSystem.unlink(symlink)
+
+      expect(Puppet::FileSystem).to_not be_exist(file)
+      expect(Puppet::FileSystem).to_not be_exist(symlink)
+    end
+
+    it "should be able to unlink a dangling symlink pointed at a directory" do
+      symlink = tmpfile("somedir_link")
+      Puppet::FileSystem.symlink(dir, symlink)
+      Dir.rmdir(dir)
+      Puppet::FileSystem.unlink(symlink)
+
+      expect(Puppet::FileSystem).to_not be_exist(dir)
+      expect(Puppet::FileSystem).to_not be_exist(symlink)
+    end
+
     it "should delete only the symlink and not the target when calling unlink instance method" do
       [file, dir].each do |target|
         symlink = tmpfile("#{Puppet::FileSystem.basename(target)}_link")

data/spec/unit/pops/parser/lexer2_spec.rb

@@ -91,12 +91,25 @@ describe 'Lexer2' do
     "true"     => :BOOLEAN,
     "in"       => :IN,
     "unless"   => :UNLESS,
+    "private"  => :PRIVATE,
+    "type"     => :TYPE,
+    "attr"     => :ATTR,
   }.each do |string, name|
     it "should lex a keyword from '#{string}'" do
       expect(tokens_scanned_from(string)).to match_tokens2(name)
     end
   end
 
+  {
+    "application"  => :APPLICATION_R,
+    "consumes"     => :CONSUMES_R,
+    "produces"     => :PRODUCES_R,
+  }.each do |string, name|
+    it "should lex a (future reserved) keyword from '#{string}'" do
+      expect(tokens_scanned_from(string)).to match_tokens2(name)
+    end
+  end
+
   # TODO: Complete with all edge cases
   [ 'A', 'A::B', '::A', '::A::B',].each do |string|
     it "should lex a CLASSREF on the form '#{string}'" do

data/spec/unit/pops/validator/validator_spec.rb

@@ -119,6 +119,30 @@ describe "validating 4x" do
     end
   end
 
+  context 'for future reserved words' do
+    ['application', 'produces', 'consumes'].each do |word|
+      it "produces an issue for the word '#{word}'" do
+        source = "$a = #{word}"
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::FUTURE_RESERVED_WORD)
+      end
+
+      it 'produces a warning issue when used as a class name' do
+        source = "class #{word} {}"
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::FUTURE_RESERVED_WORD)
+      end
+
+      it 'produces no warning or error when used as a parameter name' do
+        source = "define foo($#{word}) { notice $#{word} }"
+        expect(validate(parse(source)).diagnostics.empty?).to eq(true)
+      end
+
+      it 'produces no warning or error when used as an attribute name' do
+        source = "foo { bar: #{word} => ok }"
+        expect(validate(parse(source)).diagnostics.empty?).to eq(true)
+      end
+    end
+  end
+
   context 'for reserved type names' do
     [# type/Type, is a reserved name but results in syntax error because it is a keyword in lower case form
     'any',

data/spec/unit/provider/package/yum_spec.rb

@@ -181,6 +181,7 @@ describe provider_class do
       Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
       provider.stubs(:which).with("rpm").returns("/bin/rpm")
       Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns("4.10.1\n").at_most_once
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns('6')
     end
 
     it 'should call yum install for :installed' do
@@ -189,6 +190,20 @@ describe provider_class do
       provider.install
     end
 
+    context 'on el-5' do
+      before(:each) do
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns('5')
+      end
+
+      it 'should catch yum install failures when status code is wrong' do
+        resource.stubs(:should).with(:ensure).returns :installed
+        provider.expects(:yum).with('-e', '0', '-y', :install, name).returns("No package #{name} available.")
+        expect {
+          provider.install
+        }.to raise_error(Puppet::Error, "Could not find package #{name}")
+      end
+    end
+
     it 'should use :install to update' do
       provider.expects(:install)
       provider.update

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

@@ -6,8 +6,9 @@ require 'spec_helper'
 describe Puppet::Type.type(:service).provider(:launchd) do
   let (:joblabel) { "com.foo.food" }
   let (:provider) { subject.class }
-  let (:launchd_overrides) { '/var/db/launchd.db/com.apple.launchd/overrides.plist' }
   let(:resource) { Puppet::Type.type(:service).new(:name => joblabel, :provider => :launchd) }
+  let (:launchd_overrides_6_9) { '/var/db/launchd.db/com.apple.launchd/overrides.plist' }
+  let (:launchd_overrides_10_) { '/var/db/com.apple.xpc.launchd/disabled.plist' }
   subject { resource.provider }
 
   describe "the type interface" do
@@ -37,6 +38,56 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     end
   end
 
+  [[10, '10.6'], [13, '10.9']].each do |kernel, version|
+    describe "when checking whether the service is enabled on OS X #{version}" do
+      it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => false}})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
+        expect(subject.enabled?).to eq(:true)
+      end
+      it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => true}})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
+        expect(subject.enabled?).to eq(:false)
+      end
+      it "should return true if the job plist and the global overrides have no disabled keys" do
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {}])
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
+        expect(subject.enabled?).to eq(:true)
+      end
+    end
+  end
+
+  describe "when checking whether the service is enabled on OS X 10.10" do
+    it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
+      provider.expects(:get_os_version).returns(14).at_least_once
+      subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({joblabel => false})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
+      expect(subject.enabled?).to eq(:true)
+    end
+    it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
+      provider.expects(:get_os_version).returns(14).at_least_once
+      subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({joblabel => true})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
+      expect(subject.enabled?).to eq(:false)
+    end
+    it "should return true if the job plist and the global overrides have no disabled keys" do
+      provider.expects(:get_os_version).returns(14).at_least_once
+      subject.expects(:plist_from_label).returns([joblabel, {}])
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
+      expect(subject.enabled?).to eq(:true)
+    end
+  end
+
   describe "when starting the service" do
     it "should call any explicit 'start' command" do
       resource[:start] = "/bin/false"
@@ -47,13 +98,13 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     it "should look for the relevant plist once" do
       subject.expects(:plist_from_label).returns([joblabel, {}]).once
       subject.expects(:enabled?).returns :true
-      subject.expects(:execute).with([:launchctl, :load, joblabel])
+      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel])
       subject.start
     end
     it "should execute 'launchctl load' once without writing to the plist if the job is enabled" do
       subject.expects(:plist_from_label).returns([joblabel, {}])
       subject.expects(:enabled?).returns :true
-      subject.expects(:execute).with([:launchctl, :load, joblabel]).once
+      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel]).once
       subject.start
     end
     it "should execute 'launchctl load' with writing to the plist once if the job is disabled" do
@@ -147,21 +198,45 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     end
   end
 
-  describe "when enabling the service" do
+  [[10, "10.6"], [13, "10.9"]].each do |kernel, version|
+    describe "when enabling the service on OS X #{version}" do
+      it "should write to the global launchd overrides file once" do
+        resource[:enable] = true
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
+        Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], {'Disabled' => false}), launchd_overrides_6_9).once
+        subject.enable
+      end
+    end
+
+    describe "when disabling the service on OS X #{version}" do
+      it "should write to the global launchd overrides file once" do
+        resource[:enable] = false
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
+        Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], {'Disabled' => true}), launchd_overrides_6_9).once
+        subject.disable
+      end
+    end
+  end
+
+  describe "when enabling the service on OS X 10.10" do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = true
-      provider.expects(:read_plist).returns({})
-      Plist::Emit.expects(:save_plist).once
+      provider.expects(:get_os_version).returns(14).at_least_once
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
+      Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], false), launchd_overrides_10_).once
       subject.enable
     end
   end
 
-  describe "when disabling the service" do
+  describe "when disabling the service on OS X 10.10" do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = false
-      provider.stubs(:read_plist).returns({})
-      Plist::Emit.expects(:save_plist).once
-      subject.enable
+      provider.expects(:get_os_version).returns(14).at_least_once
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
+      Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], true), launchd_overrides_10_).once
+      subject.disable
     end
   end