puppet 6.24.0-x64-mingw32 → 7.0.0-x64-mingw32

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

@@ -8,6 +8,10 @@ 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/parsedfile_spec.rb

@@ -79,16 +79,6 @@ describe Puppet::Provider::ParsedFile do
 
       provider.instances
     end
-
-    it "should raise if parsing returns nil" do
-      expect(provider).to receive(:targets).and_return(%w{/one})
-      expect_any_instance_of(Puppet::Util::FileType::FileTypeFlat).to receive(:read).and_return('a=b')
-      expect(provider).to receive(:parse).and_return(nil)
-
-      expect {
-        provider.instances
-      }.to raise_error(Puppet::DevError, %r{Prefetching /one for provider parsedfile_provider returned nil})
-    end
   end
 
   describe "when matching resources to existing records" do

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

@@ -83,7 +83,6 @@ describe 'Puppet::Type::Service::Provider::Init',
       allow(provider_class).to receive(:defpath).and_return('tmp')
 
       @services = ['one', 'two', 'three', 'four', 'umountfs']
-      allow(Dir).to receive(:entries).and_call_original
       allow(Dir).to receive(:entries).with('tmp').and_return(@services)
       expect(FileTest).to receive(:directory?).with('tmp').and_return(true)
       allow(FileTest).to receive(:executable?).and_return(true)

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

@@ -32,7 +32,6 @@ describe 'Puppet::Type::Service::Provider::Openwrt',
     allow(File).to receive(:directory?).with('/etc/init.d').and_return(true)
 
     allow(Puppet::FileSystem).to receive(:exist?).with('/etc/init.d/myservice').and_return(true)
-    allow(FileTest).to receive(:file?).and_call_original
     allow(FileTest).to receive(:file?).with('/etc/init.d/myservice').and_return(true)
     allow(FileTest).to receive(:executable?).with('/etc/init.d/myservice').and_return(true)
   end
@@ -48,8 +47,7 @@ describe 'Puppet::Type::Service::Provider::Openwrt',
     let(:services) {['dnsmasq', 'dropbear', 'firewall', 'led', 'puppet', 'uhttpd' ]}
 
     before :each do
-      allow(Dir).to receive(:entries).and_call_original
-      allow(Dir).to receive(:entries).with('/etc/init.d').and_return(services)
+      allow(Dir).to receive(:entries).and_return(services)
       allow(FileTest).to receive(:directory?).and_return(true)
       allow(FileTest).to receive(:executable?).and_return(true)
     end

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