puppet 6.19.0-x86-mingw32 → 7.3.0-x86-mingw32

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

@@ -11,9 +11,7 @@ describe Puppet::Type.type(:package).provider(:apt) do
   end
 
   let(:provider) do
-    provider = subject()
-    provider.resource = resource
-    provider
+    resource.provider
   end
 
   it "should be the default provider on :osfamily => Debian" do
@@ -88,7 +86,7 @@ Version table:
 
   describe ".instances" do
     before do
-      allow(Puppet::Type::Package::ProviderDpkg).to receive(:instances).and_return([resource])
+      allow(Puppet::Type::Package::ProviderDpkg).to receive(:instances).and_return([provider])
     end
 
     context "when package is manual marked" do
@@ -97,8 +95,7 @@ Version table:
       end
 
       it 'sets mark to manual' do
-        expect(resource).to receive(:mark=).with(:manual)
-        described_class.instances
+        expect(described_class.instances.map(&:mark)).to eq([:manual])
       end
     end
 
@@ -108,8 +105,7 @@ Version table:
       end
 
       it 'does not set mark to manual' do
-        expect(resource).not_to receive(:mark=).with(:manual)
-        described_class.instances
+        expect(described_class.instances.map(&:mark)).to eq([nil])
       end
     end
   end

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

@@ -1,17 +1,18 @@
 require 'spec_helper'
 require 'puppet/provider/package'
 
+Puppet::Type.type(:package).provide(:test_base_provider, parent: Puppet::Provider::Package) do
+  def query; end
+end
+
 describe Puppet::Provider::Package do
+  let(:provider) {  Puppet::Type.type(:package).provider(:test_base_provider).new }
+
   it 'returns absent for uninstalled packages when not purgeable' do
-    provider = Puppet::Provider::Package.new
-    expect(provider).to receive(:query).and_return(nil)
-    expect(provider.class).to receive(:feature?).with(:purgeable).and_return(false)
     expect(provider.properties[:ensure]).to eq(:absent)
   end
 
   it 'returns purged for uninstalled packages when purgeable' do
-    provider = Puppet::Provider::Package.new
-    expect(provider).to receive(:query).and_return(nil)
     expect(provider.class).to receive(:feature?).with(:purgeable).and_return(true)
     expect(provider.properties[:ensure]).to eq(:purged)
   end

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

@@ -392,39 +392,13 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       allow(Tempfile).to receive(:open).and_yield(tempfile)
     end
 
-    it "installs first if package is not present and ensure holding" do
-      allow(provider).to receive(:execute)
-      allow(provider).to receive(:package_not_installed?).and_return(true)
-      expect(provider).to receive(:install).once
-      expect(provider).to receive(:hold)
-      provider.deprecated_hold
-    end
-
-    it "skips install new package if hold is true" do
-      allow(provider).to receive(:execute)
-      allow(provider).to receive(:package_not_installed?).and_return(true)
-      expect(provider).to receive(:install).once
-      expect(provider).to receive(:hold)
-      provider.deprecated_hold
-    end
-
-    it "skips install new package if package is allready installed" do
-      allow(provider).to receive(:execute)
-      allow(provider).to receive(:package_not_installed?).and_return(false)
-      expect(provider).not_to receive(:install)
-      expect(provider).to receive(:hold)
-      provider.deprecated_hold
-    end
-
     it "executes dpkg --set-selections when holding" do
-      allow(provider).to receive(:package_not_installed?).and_return(false)
       allow(provider).to receive(:install)
       expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
     end
 
     it "executes dpkg --set-selections when unholding" do
-      allow(provider).to receive(:package_not_installed?).and_return(false)
       allow(provider).to receive(:install)
       expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
@@ -467,26 +441,4 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
     provider.purge
   end
 
-  context "package_not_installed?" do
-    context "allow_virtual false" do
-        before do
-          allow(resource).to receive(:allow_virtual?).and_return(false)
-        end
-
-      it "returns true if package is not found" do
-        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_raise(Puppet::ExecutionFailure.new("eh"))
-        expect(provider.package_not_installed?).to eq(true)
-      end
-
-      it "returns true if package is not installed" do
-        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_return("unknown ok not-installed #{resource_name}")
-        expect(provider.package_not_installed?).to eq(true)
-      end
-
-      it "returns false if package is installed" do
-        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_return("install ok installed resource_name 1.2.3")
-        expect(provider.package_not_installed?).to eq(false)
-      end
-    end
-  end
 end

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

@@ -12,6 +12,10 @@ context Puppet::Type.type(:package).provider(:gem) do
   let(:provider_gem_cmd) { '/provider/gem' }
   let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}} }
 
+  before do
+    allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+  end
+
   context 'installing myresource' do
     let(:resource) do
       Puppet::Type.type(:package).new(
@@ -36,6 +40,34 @@ context Puppet::Type.type(:package).provider(:gem) do
         allow(provider).to receive(:rubygem_version).and_return('1.9.9')
       end
 
+      context 'on windows' do
+        let(:path) do
+          "C:\\Program Files\\Puppet Labs\\Puppet\\puppet\\bin;C:\\Program Files\\Puppet Labs\\Puppet\\bin;C:\\Ruby26-x64\\bin;C:\\Windows\\system32\\bin"
+        end
+
+        let(:expected_path) do
+          "C:\\Program Files\\Puppet Labs\\Puppet\\bin;C:\\Ruby26-x64\\bin;C:\\Windows\\system32\\bin"
+        end
+
+        before do
+          allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
+          allow(Puppet::Util).to receive(:get_env)
+          allow(Puppet::Util).to receive(:get_env).with('PATH').and_return(path)
+          allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
+          stub_const('::File::PATH_SEPARATOR', ';')
+        end
+
+        it 'removes puppet/bin from PATH' do
+          expect(described_class).to receive(:execute) \
+            .with(
+              anything,
+              hash_including(custom_environment: hash_including(PATH: expected_path))
+            )
+            .and_return("")
+          provider.install
+        end
+      end
+
       it "should use the path to the gem command" do
         allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
         expect(described_class).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return("")

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

@@ -32,10 +32,12 @@ describe Puppet::Type.type(:package).provider(:pacman) do
     end
 
     it "should call yaourt to install the right package quietly when yaourt is installed" do
-      allow(described_class).to receive(:yaourt?).and_return(true)
-      args = ['--noconfirm', '--needed', '--noprogressbar', '-S', resource[:name]]
-      expect(provider).to receive(:yaourt).at_least(:once).with(*args).and_return('')
-      provider.install
+      without_partial_double_verification do
+        allow(described_class).to receive(:yaourt?).and_return(true)
+        args = ['--noconfirm', '--needed', '--noprogressbar', '-S', resource[:name]]
+        expect(provider).to receive(:yaourt).at_least(:once).with(*args).and_return('')
+        provider.install
+      end
     end
 
     it "should raise an Puppet::Error if the installation failed" do
@@ -74,10 +76,12 @@ describe Puppet::Type.type(:package).provider(:pacman) do
       end
 
       it "should call yaourt to install the right package quietly when yaourt is installed" do
-        expect(described_class).to receive(:yaourt?).and_return(true)
-        args = ['--noconfirm', '--needed', '--noprogressbar', '-x', '--arg=value', '-S', resource[:name]]
-        expect(provider).to receive(:yaourt).at_least(:once).with(*args).and_return('')
-        provider.install
+        without_partial_double_verification do
+          expect(described_class).to receive(:yaourt?).and_return(true)
+          args = ['--noconfirm', '--needed', '--noprogressbar', '-x', '--arg=value', '-S', resource[:name]]
+          expect(provider).to receive(:yaourt).at_least(:once).with(*args).and_return('')
+          provider.install
+        end
       end
     end
 
@@ -172,10 +176,12 @@ describe Puppet::Type.type(:package).provider(:pacman) do
     end
 
     it "should call yaourt to remove the right package quietly" do
-      allow(described_class).to receive(:yaourt?).and_return(true)
-      args = ["--noconfirm", "--noprogressbar", "-R", resource[:name]]
-      expect(provider).to receive(:yaourt).with(*args)
-      provider.uninstall
+      without_partial_double_verification do
+        allow(described_class).to receive(:yaourt?).and_return(true)
+        args = ["--noconfirm", "--noprogressbar", "-R", resource[:name]]
+        expect(provider).to receive(:yaourt).with(*args)
+        provider.uninstall
+      end
     end
 
     it "adds any uninstall_options" do

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

@@ -14,9 +14,8 @@ describe Puppet::Type.type(:package).provider(:pip) do
   it { is_expected.to be_version_ranges }
 
   before do
-    @resource = Puppet::Resource.new(:package, "fake_package")
-    allow(@resource).to receive(:original_parameters).and_return({})
-    @provider = described_class.new(@resource)
+    @resource = Puppet::Type.type(:package).new(name: "fake_package", provider: :pip)
+    @provider = @resource.provider
     @client = double('client')
     allow(@client).to receive(:call).with('package_releases', 'real_package').and_return(["1.3", "1.2.5", "1.2.4"])
     allow(@client).to receive(:call).with('package_releases', 'fake_package').and_return([])
@@ -335,7 +334,6 @@ describe Puppet::Type.type(:package).provider(:pip) do
 
     it "should install" do
       @resource[:ensure] = :installed
-      @resource[:source] = nil
       expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "fake_package"]])
       @provider.install
     end
@@ -368,7 +366,6 @@ describe Puppet::Type.type(:package).provider(:pip) do
 
     it "should install a particular version" do
       @resource[:ensure] = "0.0.0"
-      @resource[:source] = nil
       # TJK
       expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "fake_package==0.0.0"]])
       @provider.install
@@ -376,7 +373,6 @@ describe Puppet::Type.type(:package).provider(:pip) do
 
     it "should upgrade" do
       @resource[:ensure] = :latest
-      @resource[:source] = nil
       # TJK
       expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "--upgrade", "fake_package"]])
       @provider.install
@@ -384,7 +380,6 @@ describe Puppet::Type.type(:package).provider(:pip) do
 
     it "should handle install options" do
       @resource[:ensure] = :installed
-      @resource[:source] = nil
       @resource[:install_options] = [{"--timeout" => "10"}, "--no-index"]
       expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "--timeout=10", "--no-index", "fake_package"]])
       @provider.install
@@ -415,7 +410,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
     let(:pip) { '/fake/bin/pip' }
 
     it "should look up version if pip is present" do
-      allow(described_class).to receive(:pip_cmd).and_return(pip)
+      allow(described_class).to receive(:cmd).and_return(pip)
       process = ['pip 8.0.2 from /usr/local/lib/python2.7/dist-packages (python 2.7)']
       allow(described_class).to receive(:execpipe).with([pip, '--version']).and_yield(process)
 
@@ -423,7 +418,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
     end
 
     it "parses multiple lines of output" do
-      allow(described_class).to receive(:pip_cmd).and_return(pip)
+      allow(described_class).to receive(:cmd).and_return(pip)
       process = [
         "/usr/local/lib/python2.7/dist-packages/urllib3/contrib/socks.py:37: DependencyWarning: SOCKS support in urllib3 requires the installation of optional dependencies: specifically, PySocks. For more information, see https://urllib3.readthedocs.io/en/latest/contrib.html#socks-proxies",
         "  DependencyWarning",
@@ -435,7 +430,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
     end
 
     it "raises if there isn't a version string" do
-      allow(described_class).to receive(:pip_cmd).and_return(pip)
+      allow(described_class).to receive(:cmd).and_return(pip)
       allow(described_class).to receive(:execpipe).with([pip, '--version']).and_yield([""])
       expect {
         described_class.pip_version(pip)
@@ -444,7 +439,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
 
     it "quotes commands with spaces" do
       pip = 'C:\Program Files\Python27\Scripts\pip.exe'
-      allow(described_class).to receive(:pip_cmd).and_return(pip)
+      allow(described_class).to receive(:cmd).and_return(pip)
       process = ["pip 18.1 from c:\program files\python27\lib\site-packages\pip (python 2.7)\r\n"]
       allow(described_class).to receive(:execpipe).with(["\"#{pip}\"", '--version']).and_yield(process)
 

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

@@ -8,10 +8,6 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
   it { is_expected.not_to be_uninstallable }
 
   describe "when installing it should fail when" do
-    before :each do
-      expect(Puppet::Util).not_to receive(:execute)
-    end
-
     it "no source is specified" do
       expect { provider.install }.to raise_error(Puppet::Error, /must specify a package source/)
     end

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

@@ -15,19 +15,20 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
   end
 
   if Puppet::Util::Platform.windows?
-    let(:provider_gem_cmd) { 'gem' }
+    let(:provider_gem_cmd) { 'C:\Program Files\Puppet Labs\Puppet\puppet\bin\gem.bat' }
   else
     let(:provider_gem_cmd) { '/opt/puppetlabs/puppet/bin/gem' }
   end
 
   custom_environment = {"HOME"=>ENV["HOME"]}
-  custom_environment['PKG_CONFIG_PATH'] = '/opt/puppetlabs/puppet/lib/pkgconfig' unless Puppet::Util::Platform.windows?
+  custom_environment['PKG_CONFIG_PATH'] = '/opt/puppetlabs/puppet/lib/pkgconfig'
 
   let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => custom_environment} }
 
   before :each do
     resource.provider = provider
     allow(described_class).to receive(:command).with(:gemcmd).and_return(provider_gem_cmd)
+    allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
   end
 
   context "when installing" do

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

@@ -4,6 +4,16 @@ describe 'Puppet::Type::Service::Provider::Smf',
          unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:provider_class) { Puppet::Type.type(:service).provider(:smf) }
 
+  def set_resource_params(params = {})
+    params.each do |param, value|
+      if value.nil?
+        @provider.resource.delete(param) if @provider.resource[param]
+      else
+        @provider.resource[param] = value
+      end
+    end
+  end
+
   before(:each) do
     # Create a mock resource
     @resource = Puppet::Type.type(:service).new(
@@ -18,14 +28,13 @@ describe 'Puppet::Type::Service::Provider::Smf',
     allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
     allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.2')
   end
-
   context ".instances" do
     it "should have an instances method" do
       expect(provider_class).to respond_to :instances
     end
 
     it "should get a list of services (excluding legacy)" do
-      expect(provider_class).to receive(:svcs).with('-H', '-o', 'state,fmri').and_return(File.read(my_fixture('svcs.out')))
+      expect(provider_class).to receive(:svcs).with('-H', '-o', 'state,fmri').and_return(File.read(my_fixture('svcs_instances.out')))
       instances = provider_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
       # we dont manage legacy
       expect(instances.size).to eq(3)
@@ -35,255 +44,482 @@ describe 'Puppet::Type::Service::Provider::Smf',
     end
   end
 
-  it "should have a restart method" do
-    expect(@provider).to respond_to(:restart)
-  end
+  describe '#service_exists?' do
+    it 'returns true if the service exists' do
+      expect(@provider).to receive(:service_fmri)
+      expect(@provider.service_exists?).to be(true)
+    end
 
-  it "should have a restartcmd method" do
-    expect(@provider).to respond_to(:restartcmd)
-  end
+    it 'returns false if the service does not exist' do
+      expect(@provider).to receive(:service_fmri).and_raise(
+        Puppet::ExecutionFailure, 'svcs failed!'
+      )
 
-  it "should have a start method" do
-    expect(@provider).to respond_to(:start)
+      expect(@provider.service_exists?).to be(false)
+    end
   end
 
-  it "should have a stop method" do
-    expect(@provider).to respond_to(:stop)
-  end
+  describe '#setup_service' do
+    it 'noops if the service resource does not have the manifest parameter passed-in' do
+      expect(@provider).not_to receive(:svccfg)
 
-  it "should have an enabled? method" do
-    expect(@provider).to respond_to(:enabled?)
-  end
+      set_resource_params({ :manifest => nil })
+      @provider.setup_service
+    end
 
-  it "should have an enable method" do
-    expect(@provider).to respond_to(:enable)
-  end
+    context 'when the service resource has a manifest parameter passed-in' do
+      let(:manifest) { 'foo' }
+      before(:each) { set_resource_params({ :manifest => manifest }) }
+
+      it 'noops if the service resource already exists' do
+        expect(@provider).not_to receive(:svccfg)
+
+        expect(@provider).to receive(:service_exists?).and_return(true)
+        @provider.setup_service
+      end
 
-  it "should have a disable method" do
-    expect(@provider).to respond_to(:disable)
+      it "imports the service resource's manifest" do
+        expect(@provider).to receive(:service_exists?).and_return(false)
+
+        expect(@provider).to receive(:svccfg).with(:import, manifest)
+        @provider.setup_service
+      end
+
+      it 'raises a Puppet::Error if SMF fails to import the manifest' do
+        expect(@provider).to receive(:service_exists?).and_return(false)
+
+        failure_reason = 'svccfg failed!'
+        expect(@provider).to receive(:svccfg).with(:import, manifest).and_raise(Puppet::ExecutionFailure, failure_reason)
+        expect { @provider.setup_service }.to raise_error do |error|
+          expect(error).to be_a(Puppet::Error)
+          expect(error.message).to match(failure_reason)
+        end
+      end
+    end
   end
 
-  describe "when checking status" do
-    before(:each) do
-      allow(@provider).to receive(:complete_service?).and_return(true)
+  describe '#service_fmri' do
+    it 'returns the memoized the fmri if it exists' do
+      @provider.instance_variable_set(:@fmri, 'resource_fmri')
+      expect(@provider.service_fmri).to eql('resource_fmri')
     end
 
-    it "should call the external command 'svcs /system/myservice' once" do
-      expect(@provider).to receive(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").and_return("online\t-")
-      @provider.status
+    it 'raises a Puppet::Error if the service resource matches multiple FMRIs' do
+      expect(@provider).to receive(:svcs).with('-l', @provider.resource[:name]).and_return(File.read(my_fixture('svcs_multiple_fmris.out')))
+
+      expect { @provider.service_fmri }.to raise_error do |error|
+        expect(error).to be_a(Puppet::Error)
+        expect(error.message).to match(@provider.resource[:name])
+        expect(error.message).to match('multiple')
+
+        matched_fmris = ["svc:/application/tstapp:one", "svc:/application/tstapp:two"]
+        expect(error.message).to match(matched_fmris.join(', '))
+      end
     end
 
-    it "should return stopped if svcs can't find the service" do
-      allow(@provider).to receive(:svcs).and_raise(Puppet::ExecutionFailure.new("no svc found"))
-      expect(@provider.status).to eq(:stopped)
+    it 'raises a Puppet:ExecutionFailure if svcs fails' do
+      expect(@provider).to receive(:svcs).with('-l', @provider.resource[:name]).and_raise(
+        Puppet::ExecutionFailure, 'svcs failed!'
+      )
+
+      expect { @provider.service_fmri }.to raise_error do |error|
+        expect(error).to be_a(Puppet::ExecutionFailure)
+        expect(error.message).to match('svcs failed!')
+      end
     end
 
-    it "should return stopped for an incomplete service on Solaris 11" do
-      allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.3')
-      allow(@provider).to receive(:complete_service?).and_return(false)
-      expect(@provider.status).to eq(:stopped)
+    it "returns the service resource's fmri and memoizes it" do
+      expect(@provider).to receive(:svcs).with('-l', @provider.resource[:name]).and_return(File.read(my_fixture('svcs_fmri.out')))
+
+      expected_fmri = 'svc:/application/tstapp:default'
+
+      expect(@provider.service_fmri).to eql(expected_fmri)
+      expect(@provider.instance_variable_get(:@fmri)).to eql(expected_fmri)
     end
+  end
 
-    it "should return running if online in svcs output" do
-      allow(@provider).to receive(:svcs).and_return("online\t-")
-      expect(@provider.status).to eq(:running)
+  describe '#enabled?' do
+    let(:fmri) { 'resource_fmri' }
+    before(:each) do
+      allow(@provider).to receive(:service_fmri).and_return(fmri)
     end
 
-    it "should return stopped if disabled in svcs output" do
-      allow(@provider).to receive(:svcs).and_return("disabled\t-")
-      expect(@provider.status).to eq(:stopped)
+    it 'returns :true if the service is enabled' do
+      expect(@provider).to receive(:svccfg).with('-s', fmri, 'listprop', 'general/enabled').and_return(
+        'general/enabled boolean  true'
+      )
+
+      expect(@provider.enabled?).to be(:true)
     end
 
-    it "should return maintenance if in maintenance in svcs output" do
-      allow(@provider).to receive(:svcs).and_return("maintenance\t-")
-      expect(@provider.status).to eq(:maintenance)
+    it 'return :false if the service is not enabled' do
+      expect(@provider).to receive(:svccfg).with('-s', fmri, 'listprop', 'general/enabled').and_return(
+        'general/enabled boolean  false'
+      )
+
+      expect(@provider.enabled?).to be(:false)
     end
 
-    it "should return degraded if in degraded in svcs output" do
-      allow(@provider).to receive(:svcs).and_return("degraded\t-")
-      expect(@provider.status).to eq(:degraded)
+    it 'returns :false if the service does not exist' do
+      expect(@provider).to receive(:service_exists?).and_return(false)
+      expect(@provider.enabled?).to be(:false)
     end
+  end
 
-    it "should return target state if transitioning in svcs output" do
-      allow(@provider).to receive(:svcs).and_return("online\tdisabled")
-      expect(@provider.status).to eq(:stopped)
+  describe '#restartcmd' do
+    let(:fmri) { 'resource_fmri' }
+    before(:each) do
+      allow(@provider).to receive(:service_fmri).and_return(fmri)
     end
 
-    it "should throw error if it's a legacy service in svcs output" do
-      allow(@provider).to receive(:svcs).and_return("legacy_run\t-")
-      expect { @provider.status }.to raise_error(Puppet::Error, "Cannot manage legacy services through SMF")
+    it 'returns the right command for restarting the service for Solaris versions newer than 11.2' do
+      expect(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.3')
+
+      expect(@provider.restartcmd).to eql([@provider.command(:adm), :restart, '-s', fmri])
     end
-  end
 
-  context "when starting" do
-    it "should enable the service if it is not enabled" do
-      expect(@provider).to receive(:status).and_return(:stopped)
-      expect(@provider).to receive(:texecute).with(:start, ['/usr/sbin/svcadm', :enable, '-rs', '/system/myservice'], true)
-      expect(@provider).to receive(:wait).with('online')
-      @provider.start
+    it 'returns the right command for restarting the service on Solaris 11.2' do
+      expect(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.2')
+
+      expect(@provider.restartcmd).to eql([@provider.command(:adm), :restart, '-s', fmri])
     end
 
-    it "should always execute external command 'svcadm enable /system/myservice'" do
-      expect(@provider).to receive(:status).and_return(:running)
-      expect(@provider).to receive(:texecute).with(:start, ['/usr/sbin/svcadm', :enable, '-rs', '/system/myservice'], true)
-      expect(@provider).to receive(:wait).with('online')
-      @provider.start
+    it 'returns the right command for restarting the service for Solaris versions older than Solaris 11.2' do
+      expect(Facter).to receive(:value).with(:operatingsystemrelease).and_return('10.3')
+
+      expect(@provider.restartcmd).to eql([@provider.command(:adm), :restart, fmri])
     end
+  end
 
-    it "should execute external command 'svcadm clear /system/myservice' if in maintenance" do
-      allow(@provider).to receive(:status).and_return(:maintenance)
-      expect(@provider).to receive(:texecute).with(:start, ["/usr/sbin/svcadm", :clear, "/system/myservice"], true)
-      expect(@provider).to receive(:wait).with('online')
-      @provider.start
+  describe '#service_states' do
+    let(:fmri) { 'resource_fmri' }
+    before(:each) do
+      allow(@provider).to receive(:service_fmri).and_return(fmri)
     end
 
-    it "should execute external command 'svcadm clear /system/myservice' if in degraded" do
-      allow(@provider).to receive(:status).and_return(:degraded)
-      expect(@provider).to receive(:texecute).with(:start, ["/usr/sbin/svcadm", :clear, "/system/myservice"], true)
-      expect(@provider).to receive(:wait).with('online')
-      @provider.start
+    it 'returns the current and next states of the service' do
+      expect(@provider).to receive(:svcs).with('-H', '-o', 'state,nstate', fmri).and_return(
+        'online         disabled'
+      )
+
+      expect(@provider.service_states).to eql({ :current => 'online', :next => 'disabled' })
     end
 
-    it "should error if timeout occurs while starting the service" do
-      expect(@provider).to receive(:status).and_return(:stopped)
-      expect(@provider).to receive(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, '-rs', "/system/myservice"], true)
-      expect(Timeout).to receive(:timeout).with(60).and_raise(Timeout::Error)
-      expect { @provider.start }.to raise_error Puppet::Error, ('Timed out waiting for /system/myservice to transition states')
+    it "returns nil for the next state if svcs marks it as '-'" do
+      expect(@provider).to receive(:svcs).with('-H', '-o', 'state,nstate', fmri).and_return(
+        'online         -'
+      )
+
+      expect(@provider.service_states).to eql({ :current => 'online', :next => nil })
     end
   end
 
-  context "when starting a service with a manifest" do
+  describe '#wait' do
+    # TODO: Document this method!
+    def transition_service(from, to, tries)
+      intermediate_returns = [{ :current => from, :next => to }] * (tries - 1)
+      final_return = { :current => to, :next => nil }
+
+      allow(@provider).to receive(:service_states).and_return(*intermediate_returns.push(final_return))
+    end
+
     before(:each) do
-      @resource = Puppet::Type.type(:service).new(:name => "/system/myservice", :ensure => :running, :enable => :true, :manifest => "/tmp/myservice.xml")
-      @provider = provider_class.new(@resource)
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+      allow(Timeout).to receive(:timeout).and_yield
+      allow(Kernel).to receive(:sleep)
     end
 
-    it "should import the manifest if service is missing" do
-      allow(@provider).to receive(:complete_service?).and_return(true)
-      expect(@provider).to receive(:svcs).with('-l', '/system/myservice').and_raise(Puppet::ExecutionFailure, "Exited 1")
-      expect(@provider).to receive(:svccfg).with(:import, "/tmp/myservice.xml")
-      expect(@provider).to receive(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, '-rs', "/system/myservice"], true)
-      expect(@provider).to receive(:wait).with('online')
-      expect(@provider).to receive(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").and_return("online\t-")
-      @provider.start
+    it 'waits for the service to enter the desired state' do
+      transition_service('online', 'disabled', 1)
+      @provider.wait('offline', 'disabled', 'uninitialized')
     end
 
-    it "should handle failures if importing a manifest" do
-      expect(@provider).to receive(:svcs).with('-l', '/system/myservice').and_raise(Puppet::ExecutionFailure, "Exited 1")
-      expect(@provider).to receive(:svccfg).and_raise(Puppet::ExecutionFailure.new("can't svccfg import"))
-      expect { @provider.start }.to raise_error(Puppet::Error, "Cannot config /system/myservice to enable it: can't svccfg import")
+    it 'times out and raises a Puppet::Error after sixty seconds' do
+      expect(Timeout).to receive(:timeout).with(60).and_raise(Timeout::Error, 'method timed out!')
+
+      expect { @provider.wait('online') }.to raise_error do |error|
+        expect(error).to be_a(Puppet::Error)
+        expect(error.message).to match(@provider.resource[:name])
+      end
+    end
+
+    it 'sleeps a bit before querying the service state' do
+      transition_service('disabled', 'online', 10)
+      expect(Kernel).to receive(:sleep).with(1).exactly(9).times
+
+      @provider.wait('online')
     end
   end
 
-  context "when stopping" do
-    it "should execute external command 'svcadm disable /system/myservice'" do
-      expect(@provider).to receive(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, '-s', "/system/myservice"], true)
-      expect(@provider).to receive(:wait).with('offline', 'disabled', 'uninitialized')
-      @provider.stop
+  describe '#restart' do
+    let(:fmri) { 'resource_fmri' }
+
+    before(:each) do
+      allow(@provider).to receive(:service_fmri).and_return(fmri)
+      allow(@provider).to receive(:texecute)
+      allow(@provider).to receive(:wait)
+    end
+
+    it 'should restart the service' do
+      expect(@provider).to receive(:texecute)
+      @provider.restart
     end
 
-    it "should error if timeout occurs while stopping the service" do
-      expect(@provider).to receive(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, '-s', "/system/myservice"], true)
-      expect(Timeout).to receive(:timeout).with(60).and_raise(Timeout::Error)
-      expect { @provider.stop }.to raise_error Puppet::Error, ('Timed out waiting for /system/myservice to transition states')
+    it 'should wait for the service to restart' do
+      expect(@provider).to receive(:wait).with('online')
+      @provider.restart
     end
   end
 
-  context "when restarting" do
-    it "should error if timeout occurs while restarting the service" do
-      expect(@provider).to receive(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, '-s', "/system/myservice"], true)
-      expect(Timeout).to receive(:timeout).with(60).and_raise(Timeout::Error)
-      expect { @provider.restart }.to raise_error Puppet::Error, ('Timed out waiting for /system/myservice to transition states')
+  describe '#status' do
+    let(:states) do
+      {
+        :current => 'online',
+        :next    => nil
+      }
     end
 
-    context 'with :operatingsystemrelease == 10_u10' do
-      it "should call 'svcadm restart /system/myservice'" do
-        allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('10_u10')
-        expect(@provider).to receive(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, "/system/myservice"], true)
-        expect(@provider).to receive(:wait).with('online')
-        @provider.restart
-      end
+    before(:each) do
+      allow(@provider).to receive(:service_states).and_return(states)
+
+      allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('10.3')
     end
 
-    context 'with :operatingsystemrelease == 11.2' do
-      it "should call 'svcadm restart -s /system/myservice'" do
-        allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.2')
-        expect(@provider).to receive(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, '-s', "/system/myservice"], true)
-        expect(@provider).to receive(:wait).with('online')
-        @provider.restart
+    it "should run the status command if it's passed in" do
+      set_resource_params({ :status => 'status_cmd' })
+      expect(@provider).to receive(:ucommand).with(:status, false) do |_, _|
+        expect($CHILD_STATUS).to receive(:exitstatus).and_return(0)
       end
+      expect(@provider).not_to receive(:service_states)
+
+      expect(@provider.status).to eql(:running)
     end
 
-    context 'with :operatingsystemrelease > 11.2' do
-      it "should call 'svcadm restart -s /system/myservice'" do
-        allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.3')
-        expect(@provider).to receive(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, '-s', "/system/myservice"], true)
-        expect(@provider).to receive(:wait).with('online')
-        @provider.restart
+    shared_examples 'returns the right status' do |svcs_state, expected_state|
+      it "returns '#{expected_state}' if the svcs state is '#{svcs_state}'" do
+
+        states[:current] = svcs_state
+        expect(@provider.status).to eql(expected_state)
       end
     end
-  end
 
-  describe '#service_fmri' do
-    it 'raises a Puppet::Error if the service resource matches multiple FMRIs' do
-      allow(@provider).to receive(:svcs).with('-l', @provider.resource[:name]).and_return(File.read(my_fixture('svcs_multiple_fmris.out')))
+    include_examples 'returns the right status', 'online', :running
+    include_examples 'returns the right status', 'offline', :stopped
+    include_examples 'returns the right status', 'disabled', :stopped
+    include_examples 'returns the right status', 'uninitialized', :stopped
+    include_examples 'returns the right status', 'maintenance', :maintenance
+    include_examples 'returns the right status', 'degraded', :degraded
 
-      expect { @provider.service_fmri }.to raise_error do |error|
+    it "raises a Puppet::Error if the svcs state is 'legacy_run'" do
+      states[:current] = 'legacy_run'
+      expect { @provider.status }.to raise_error do |error|
         expect(error).to be_a(Puppet::Error)
-        expect(error.message).to match(@provider.resource[:name])
-        expect(error.message).to match('multiple')
-
-        matched_fmris = ["svc:/application/tstapp:one", "svc:/application/tstapp:two"]
-        expect(error.message).to match(matched_fmris.join(', '))
+        expect(error.message).to match('legacy')
       end
     end
 
-    it 'raises a Puppet:ExecutionFailure if svcs fails' do
-      allow(@provider).to receive(:svcs).with('-l', @provider.resource[:name]).and_raise(
-        Puppet::ExecutionFailure, 'svcs failed!'
-      )
-
-      expect { @provider.service_fmri }.to raise_error do |error|
-        expect(error).to be_a(Puppet::ExecutionFailure)
-        expect(error.message).to match('svcs failed!')
+    it "raises a Puppet::Error if the svcs state is unmanageable" do
+      states[:current] = 'unmanageable state'
+      expect { @provider.status }.to raise_error do |error|
+        expect(error).to be_a(Puppet::Error)
+        expect(error.message).to match(states[:current])
       end
     end
 
-    it "returns the service resource's fmri and memoizes it" do
-      allow(@provider).to receive(:svcs).with('-l', @provider.resource[:name]).and_return(File.read(my_fixture('svcs_fmri.out')))
+    it "returns 'stopped' if the service does not exist" do
+      expect(@provider).to receive(:service_states).and_raise(Puppet::ExecutionFailure, 'service does not exist!')
+      expect(@provider.status).to eql(:stopped)
+    end
 
-      expected_fmri = 'svc:/application/tstapp:default'
+    it "uses the current state for comparison if the next state is not provided" do
+      states[:next] = 'disabled'
+      expect(@provider.status).to eql(:stopped)
+    end
 
-      expect(@provider.service_fmri).to eql(expected_fmri)
-      expect(@provider.instance_variable_get(:@fmri)).to eql(expected_fmri)
+    it "should return stopped for an incomplete service on Solaris 11" do
+      allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.3')
+      allow(@provider).to receive(:complete_service?).and_return(false)
+      expect(@provider.status).to eq(:stopped)
     end
   end
 
-  describe '#complete_service?' do
-    let(:fmri) { 'service_fmri' }
-
+  describe '#maybe_clear_service_then_svcadm' do
+    let(:fmri) { 'resource_fmri' }
     before(:each) do
       allow(@provider).to receive(:service_fmri).and_return(fmri)
     end
 
-    it 'should raise a Puppet::Error if it is called on an older Solaris machine' do
-      allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('10.0')
+    it 'applies the svcadm subcommand with the given flags' do
+      expect(@provider).to receive(:adm).with('enable', '-rst', fmri)
+      @provider.maybe_clear_service_then_svcadm(:stopped, 'enable', '-rst')
+    end
 
-      expect { @provider.complete_service? }.to raise_error(Puppet::Error)
+    [:maintenance, :degraded].each do |status|
+      it "clears the service before applying the svcadm subcommand if the service status is #{status}" do
+        expect(@provider).to receive(:adm).with('clear', fmri)
+        expect(@provider).to receive(:adm).with('enable', '-rst', fmri)
+
+        @provider.maybe_clear_service_then_svcadm(status, 'enable', '-rst')
+      end
     end
+  end
 
-    it 'should return false for an incomplete service' do
-      allow(@provider).to receive(:svccfg).with('-s', fmri, 'listprop', 'general/complete').and_return("")
-      expect(@provider.complete_service?).to be false
+  describe '#flush' do
+    def mark_property_for_syncing(property, value)
+      properties_to_sync = @provider.instance_variable_get(:@properties_to_sync)
+      properties_to_sync[property] = value
     end
 
-    it 'should return true for a complete service' do
-      allow(@provider).to receive(:svccfg)
-        .with('-s', fmri, 'listprop', 'general/complete')
-        .and_return("general/complete astring")
+    it 'should noop if enable and ensure do not need to be syncd' do
+      expect(@provider).not_to receive(:setup_service)
+      @provider.flush
+    end
 
-      expect(@provider.complete_service?).to be true
+    context 'enable or ensure need to be syncd' do
+      let(:stopped_states) do
+        ['offline', 'disabled', 'uninitialized']
+      end
+
+      let(:fmri) { 'resource_fmri' }
+      let(:mock_status) { :maintenance }
+      before(:each) do
+        allow(@provider).to receive(:setup_service)
+        allow(@provider).to receive(:service_fmri).and_return(fmri)
+
+        # We will update this mock on a per-test basis.
+        allow(@provider).to receive(:status).and_return(mock_status)
+        allow(@provider).to receive(:wait)
+      end
+
+      context 'only ensure needs to be syncd' do
+        it 'stops the service if ensure == stopped' do
+          mark_property_for_syncing(:ensure, :stopped)
+
+          expect(@provider).to receive(:maybe_clear_service_then_svcadm).with(mock_status, 'disable', '-st')
+          expect(@provider).to receive(:wait).with(*stopped_states)
+
+          @provider.flush
+        end
+
+        it 'starts the service if ensure == running' do
+          mark_property_for_syncing(:ensure, :running)
+
+          expect(@provider).to receive(:maybe_clear_service_then_svcadm).with(mock_status, 'enable', '-rst')
+          expect(@provider).to receive(:wait).with('online')
+
+          @provider.flush
+        end
+      end
+
+      context 'enable needs to be syncd' do
+        before(:each) do
+          # We will stub this value out later, this default is useful
+          # for the final state tests.
+          mark_property_for_syncing(:enable, true)
+        end
+
+        it 'enables the service' do
+          mark_property_for_syncing(:enable, true)
+
+          expect(@provider).to receive(:maybe_clear_service_then_svcadm).with(mock_status, 'enable', '-rs')
+
+          expect(@provider).to receive(:adm).with('mark', '-I', 'maintenance', fmri)
+
+          @provider.flush
+        end
+
+        it 'disables the service' do
+          mark_property_for_syncing(:enable, false)
+
+          expect(@provider).to receive(:maybe_clear_service_then_svcadm).with(mock_status, 'disable', '-s')
+
+          expect(@provider).to receive(:adm).with('mark', '-I', 'maintenance', fmri)
+
+          @provider.flush
+        end
+
+        context 'when the final service state is running' do
+          before(:each) do
+            allow(@provider).to receive(:status).and_return(:running)
+          end
+
+          it 'starts the service if enable was false' do
+            mark_property_for_syncing(:enable, false)
+
+            expect(@provider).to receive(:adm).with('disable', '-s', fmri)
+            expect(@provider).to receive(:adm).with('enable', '-rst', fmri)
+            expect(@provider).to receive(:wait).with('online')
+
+            @provider.flush
+          end
+
+          it 'waits for the service to start if enable was true' do
+            mark_property_for_syncing(:enable, true)
+
+            expect(@provider).to receive(:adm).with('enable', '-rs', fmri)
+            expect(@provider).to receive(:wait).with('online')
+
+            @provider.flush
+          end
+        end
+
+        context 'when the final service state is stopped' do
+          before(:each) do
+            allow(@provider).to receive(:status).and_return(:stopped)
+          end
+
+          it 'stops the service if enable was true' do
+            mark_property_for_syncing(:enable, true)
+
+            expect(@provider).to receive(:adm).with('enable', '-rs', fmri)
+            expect(@provider).to receive(:adm).with('disable', '-st', fmri)
+            expect(@provider).to receive(:wait).with(*stopped_states)
+
+            @provider.flush
+          end
+
+          it 'waits for the service to stop if enable was false' do
+            mark_property_for_syncing(:enable, false)
+
+            expect(@provider).to_not receive(:adm).with('disable', '-st', fmri)
+            expect(@provider).to receive(:wait).with(*stopped_states)
+
+            @provider.flush
+          end
+        end
+
+        it 'marks the service as being under maintenance if the final state is maintenance' do
+          expect(@provider).to receive(:status).and_return(:maintenance)
+
+          expect(@provider).to receive(:adm).with('clear', fmri)
+          expect(@provider).to receive(:adm).with('enable', '-rs', fmri)
+
+          expect(@provider).to receive(:adm).with('mark', '-I', 'maintenance', fmri)
+          expect(@provider).to receive(:wait).with('maintenance')
+
+          @provider.flush
+        end
+
+        it 'uses the ensure value as the final state if ensure also needs to be syncd' do
+          mark_property_for_syncing(:ensure, :running)
+          expect(@provider).to receive(:status).and_return(:stopped)
+
+          expect(@provider).to receive(:adm).with('enable', '-rs', fmri)
+          expect(@provider).to receive(:wait).with('online')
+
+          @provider.flush
+        end
+
+        it 'marks the final state of a degraded service as running' do
+          expect(@provider).to receive(:status).and_return(:degraded)
+
+          expect(@provider).to receive(:adm).with('clear', fmri)
+          expect(@provider).to receive(:adm).with('enable', '-rs', fmri)
+
+          expect(@provider).to receive(:wait).with('online')
+
+          @provider.flush
+        end
+      end
     end
   end
 end