puppet 7.27.0-universal-darwin → 7.29.0-universal-darwin

data/spec/unit/type/service_spec.rb

@@ -1,458 +0,0 @@
-require 'spec_helper'
-
-def safely_load_service_type
-  before(:each) do
-    # We have a :confine block that calls execute in our upstart provider, which fails
-    # on jruby. Thus, we stub it out here since we don't care to do any assertions on it.
-    # This is only an issue if you're running these unit tests on a platform where upstart
-    # is a default provider, like Ubuntu trusty.
-    allow(Puppet::Util::Execution).to receive(:execute)
-    Puppet::Type.type(:service)
-  end
-end
-
-test_title = 'Puppet::Type::Service'
-
-describe test_title do
-  safely_load_service_type
-
-  it "should have an :enableable feature that requires the :enable, :disable, and :enabled? methods" do
-    expect(Puppet::Type.type(:service).provider_feature(:enableable).methods).to eq([:disable, :enable, :enabled?])
-  end
-
-  it "should have a :refreshable feature that requires the :restart method" do
-    expect(Puppet::Type.type(:service).provider_feature(:refreshable).methods).to eq([:restart])
-  end
-end
-
-describe test_title, "when validating attributes" do
-  safely_load_service_type
-
-  [:name, :binary, :hasstatus, :path, :pattern, :start, :restart, :stop, :status, :hasrestart, :control, :timeout].each do |param|
-    it "should have a #{param} parameter" do
-      expect(Puppet::Type.type(:service).attrtype(param)).to eq(:param)
-    end
-  end
-
-  [:ensure, :enable].each do |param|
-    it "should have an #{param} property" do
-      expect(Puppet::Type.type(:service).attrtype(param)).to eq(:property)
-    end
-  end
-end
-
-describe test_title, "when validating attribute values" do
-  safely_load_service_type
-
-  before do
-    @provider = double('provider', :class => Puppet::Type.type(:service).defaultprovider, :clear => nil, :controllable? => false)
-    allow(Puppet::Type.type(:service).defaultprovider).to receive(:new).and_return(@provider)
-  end
-
-  it "should support :running as a value to :ensure" do
-    Puppet::Type.type(:service).new(:name => "yay", :ensure => :running)
-  end
-
-  it "should support :stopped as a value to :ensure" do
-    Puppet::Type.type(:service).new(:name => "yay", :ensure => :stopped)
-  end
-
-  it "should alias the value :true to :running in :ensure" do
-    svc = Puppet::Type.type(:service).new(:name => "yay", :ensure => true)
-    expect(svc.should(:ensure)).to eq(:running)
-  end
-
-  it "should alias the value :false to :stopped in :ensure" do
-    svc = Puppet::Type.type(:service).new(:name => "yay", :ensure => false)
-    expect(svc.should(:ensure)).to eq(:stopped)
-  end
-
-  describe "the enable property" do
-    before :each do
-      allow(@provider.class).to receive(:supports_parameter?).and_return(true)
-    end
-
-    describe "for value without required features" do
-      before :each do
-        allow(@provider).to receive(:satisfies?)
-      end
-
-      it "should not support :mask as a value" do
-        expect { Puppet::Type.type(:service).new(:name => "yay", :enable => :mask) }.to raise_error(
-          Puppet::ResourceError,
-          /Provider .+ must have features 'maskable' to set 'enable' to 'mask'/
-        )
-      end
-
-      it "should not support :manual as a value" do
-        expect { Puppet::Type.type(:service).new(:name => "yay", :enable => :manual) }.to raise_error(
-          Puppet::ResourceError,
-          /Provider .+ must have features 'manual_startable' to set 'enable' to 'manual'/
-        )
-      end
-
-      it "should not support :mask as a value" do
-        expect { Puppet::Type.type(:service).new(:name => "yay", :enable => :delayed) }.to raise_error(
-          Puppet::ResourceError,
-          /Provider .+ must have features 'delayed_startable' to set 'enable' to 'delayed'/
-        )
-      end
-    end
-
-    describe "for value with required features" do
-      before :each do
-        allow(@provider).to receive(:satisfies?).and_return(:true)
-      end
-
-      it "should support :true as a value" do
-        srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :true)
-        expect(srv.should(:enable)).to eq(:true)
-      end
-
-      it "should support :false as a value" do
-        srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :false)
-        expect(srv.should(:enable)).to eq(:false)
-      end
-
-      it "should support :mask as a value" do
-        srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :mask)
-        expect(srv.should(:enable)).to eq(:mask)
-      end
-
-      it "should support :manual as a value on Windows" do
-        allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
-        srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :manual)
-        expect(srv.should(:enable)).to eq(:manual)
-      end
-
-      it "should support :delayed as a value on Windows" do
-        allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
-
-        srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :delayed)
-        expect(srv.should(:enable)).to eq(:delayed)
-      end
-    end
-  end
-
-  describe "the timeout parameter" do
-    before do
-      provider_class_with_timeout = Puppet::Type.type(:service).provide(:simple) do
-        has_features :configurable_timeout
-      end
-      allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class_with_timeout)
-    end
-
-    it "should fail when timeout is not an integer" do
-      expect { Puppet::Type.type(:service).new(:name => "yay", :timeout => 'foobar') }.to raise_error(Puppet::Error)
-    end
-
-    [-999, -1, 0].each do |int|
-      it "should not support #{int} as a value to :timeout" do
-        expect { Puppet::Type.type(:service).new(:name => "yay", :timeout => int) }.to raise_error(Puppet::Error)
-      end
-    end
-
-    [1, 30, 999].each do |int|
-      it "should support #{int} as a value to :timeout" do
-        srv = Puppet::Type.type(:service).new(:name => "yay", :timeout => int)
-        expect(srv[:timeout]).to eq(int)
-      end
-    end
-
-    it "should default :timeout to 10 when provider has no default value" do
-      srv = Puppet::Type.type(:service).new(:name => "yay")
-      expect(srv[:timeout]).to eq(10)
-    end
-
-    it "should default :timeout to provider given default time when it has one" do
-      provider_class_with_timeout = Puppet::Type.type(:service).provide(:simple) do
-        has_features :configurable_timeout
-        def default_timeout
-          30
-        end
-      end
-      allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class_with_timeout)
-
-      srv = Puppet::Type.type(:service).new(:name => "yay")
-      expect(srv[:timeout]).to eq(30)
-    end
-
-    it "should accept string as value" do
-      srv = Puppet::Type.type(:service).new(:name => "yay", :timeout => "25")
-      expect(srv[:timeout]).to eq(25)
-    end
-
-    it "should not support values that cannot be converted to Integer such as Array" do
-      expect { Puppet::Type.type(:service).new(:name => "yay", :timeout => [25]) }.to raise_error(Puppet::Error)
-    end
-  end
-
-  describe "the service logon credentials" do 
-    before do
-      provider_class_with_logon_credentials = Puppet::Type.type(:service).provide(:simple) do
-        has_features :manages_logon_credentials
-        def logonpassword=(value) end
-        def logonaccount_insync?(current) end
-      end
-      allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class_with_logon_credentials)
-    end
-
-    describe "the 'logonaccount' property" do
-      let(:service) {Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'myUser')}
-
-      it "should let superclass implementation resolve insyncness when provider does not respond to the 'logonaccount_insync?' method" do
-        allow(service.provider).to receive(:respond_to?).with(:logonaccount_insync?).and_return(false)
-        expect(service.property(:logonaccount).insync?('myUser')).to eq(true)
-      end
-
-      it "should let provider resolve insyncness when provider responds to the 'logonaccount_insync?' method" do
-        allow(service.provider).to receive(:respond_to?).with(:logonaccount_insync?, any_args).and_return(true)
-        allow(service.provider).to receive(:logonaccount_insync?).and_return(false)
-        
-        expect(service.property(:logonaccount).insync?('myUser')).to eq(false)
-      end
-    end
-
-    describe "the logonpassword parameter" do
-      it "should fail when logonaccount is not being managed as well" do
-        expect { Puppet::Type.type(:service).new(:name => "yay", :logonpassword => 'myPass') }.to raise_error(Puppet::Error, /The 'logonaccount' parameter is mandatory when setting 'logonpassword'./)
-      end
-
-      it "should default to empty string when only logonaccount is being managed" do
-        service = Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'myUser')
-
-        expect { service }.not_to raise_error
-        expect(service[:logonpassword]).to eq("")
-      end
-
-      it "should default to nil when not even logonaccount is being managed" do
-        service = Puppet::Type.type(:service).new(:name => "yay")
-        expect(service[:logonpassword]).to eq(nil)
-      end
-
-      it "should fail when logonpassword includes the ':' character" do
-        expect { Puppet::Type.type(:service).new(:name => "yay", :logonaccount => 'myUser', :logonpassword => 'my:Pass') }.to raise_error(Puppet::Error, /Passwords cannot include ':'/)
-      end
-    end
-  end
-
-  it "should support :true as a value to :hasstatus" do
-    srv = Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :true)
-    expect(srv[:hasstatus]).to eq(:true)
-  end
-
-  it "should support :false as a value to :hasstatus" do
-    srv = Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :false)
-    expect(srv[:hasstatus]).to eq(:false)
-  end
-
-  it "should specify :true as the default value of hasstatus" do
-    srv = Puppet::Type.type(:service).new(:name => "yay")
-    expect(srv[:hasstatus]).to eq(:true)
-  end
-
-  it "should support :true as a value to :hasrestart" do
-    srv = Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :true)
-    expect(srv[:hasrestart]).to eq(:true)
-  end
-
-  it "should support :false as a value to :hasrestart" do
-    srv = Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :false)
-    expect(srv[:hasrestart]).to eq(:false)
-  end
-
-  it "should allow setting the :enable parameter if the provider has the :enableable feature" do
-    allow(Puppet::Type.type(:service).defaultprovider).to receive(:supports_parameter?).and_return(true)
-    expect(Puppet::Type.type(:service).defaultprovider).to receive(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).and_return(true)
-    svc = Puppet::Type.type(:service).new(:name => "yay", :enable => true)
-    expect(svc.should(:enable)).to eq(:true)
-  end
-
-  it "should not allow setting the :enable parameter if the provider is missing the :enableable feature" do
-    allow(Puppet::Type.type(:service).defaultprovider).to receive(:supports_parameter?).and_return(true)
-    expect(Puppet::Type.type(:service).defaultprovider).to receive(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).and_return(false)
-    svc = Puppet::Type.type(:service).new(:name => "yay", :enable => true)
-    expect(svc.should(:enable)).to be_nil
-  end
-
-  it "should split paths on '#{File::PATH_SEPARATOR}'" do
-    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-    allow(FileTest).to receive(:directory?).and_return(true)
-    svc = Puppet::Type.type(:service).new(:name => "yay", :path => "/one/two#{File::PATH_SEPARATOR}/three/four")
-    expect(svc[:path]).to eq(%w{/one/two /three/four})
-  end
-
-  it "should accept arrays of paths joined by '#{File::PATH_SEPARATOR}'" do
-    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-    allow(FileTest).to receive(:directory?).and_return(true)
-    svc = Puppet::Type.type(:service).new(:name => "yay", :path => ["/one#{File::PATH_SEPARATOR}/two", "/three#{File::PATH_SEPARATOR}/four"])
-    expect(svc[:path]).to eq(%w{/one /two /three /four})
-  end
-end
-
-describe test_title, "when setting default attribute values" do
-  safely_load_service_type
-
-  it "should default to the provider's default path if one is available" do
-    allow(FileTest).to receive(:directory?).and_return(true)
-    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-
-    allow(Puppet::Type.type(:service).defaultprovider).to receive(:respond_to?).and_return(true)
-    allow(Puppet::Type.type(:service).defaultprovider).to receive(:defpath).and_return("testing")
-    svc = Puppet::Type.type(:service).new(:name => "other")
-    expect(svc[:path]).to eq(["testing"])
-  end
-
-  it "should default 'pattern' to the binary if one is provided" do
-    svc = Puppet::Type.type(:service).new(:name => "other", :binary => "/some/binary")
-    expect(svc[:pattern]).to eq("/some/binary")
-  end
-
-  it "should default 'pattern' to the name if no pattern is provided" do
-    svc = Puppet::Type.type(:service).new(:name => "other")
-    expect(svc[:pattern]).to eq("other")
-  end
-
-  it "should default 'control' to the upcased service name with periods replaced by underscores if the provider supports the 'controllable' feature" do
-    provider = double('provider', :controllable? => true, :class => Puppet::Type.type(:service).defaultprovider, :clear => nil)
-    allow(Puppet::Type.type(:service).defaultprovider).to receive(:new).and_return(provider)
-    svc = Puppet::Type.type(:service).new(:name => "nfs.client")
-    expect(svc[:control]).to eq("NFS_CLIENT_START")
-  end
-end
-
-describe test_title, "when retrieving the host's current state" do
-  safely_load_service_type
-
-  before do
-    @service = Puppet::Type.type(:service).new(:name => "yay")
-  end
-
-  it "should use the provider's status to determine whether the service is running" do
-    expect(@service.provider).to receive(:status).and_return(:yepper)
-    @service[:ensure] = :running
-    expect(@service.property(:ensure).retrieve).to eq(:yepper)
-  end
-
-  it "should ask the provider whether it is enabled" do
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    expect(@service.provider).to receive(:enabled?).and_return(:yepper)
-    @service[:enable] = true
-    expect(@service.property(:enable).retrieve).to eq(:yepper)
-  end
-end
-
-describe test_title, "when changing the host" do
-  safely_load_service_type
-
-  before do
-    @service = Puppet::Type.type(:service).new(:name => "yay")
-  end
-
-  it "should start the service if it is supposed to be running" do
-    @service[:ensure] = :running
-    expect(@service.provider).to receive(:start)
-    @service.property(:ensure).sync
-  end
-
-  it "should stop the service if it is supposed to be stopped" do
-    @service[:ensure] = :stopped
-    expect(@service.provider).to receive(:stop)
-    @service.property(:ensure).sync
-  end
-
-  it "should enable the service if it is supposed to be enabled" do
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    @service[:enable] = true
-    expect(@service.provider).to receive(:enable)
-    @service.property(:enable).sync
-  end
-
-  it "should disable the service if it is supposed to be disabled" do
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    @service[:enable] = false
-    expect(@service.provider).to receive(:disable)
-    @service.property(:enable).sync
-  end
-
-  it "should let superclass implementation resolve insyncness when provider does not respond to the 'enabled_insync?' method" do
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    @service[:enable] = true
-    allow(@service.provider).to receive(:respond_to?).with(:enabled_insync?).and_return(false)
-
-    expect(@service.property(:enable).insync?(:true)).to eq(true)
-  end
-
-  it "insyncness should be resolved by provider instead of superclass implementation when provider responds to the 'enabled_insync?' method" do
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    @service[:enable] = true
-    allow(@service.provider).to receive(:respond_to?).with(:enabled_insync?, any_args).and_return(true)
-    allow(@service.provider).to receive(:enabled_insync?).and_return(false)
-
-    expect(@service.property(:enable).insync?(:true)).to eq(false)
-  end
-
-  it "should sync the service's enable state when changing the state of :ensure if :enable is being managed" do
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    @service[:enable] = false
-    @service[:ensure] = :stopped
-
-    expect(@service.property(:enable)).to receive(:retrieve).and_return("whatever")
-    expect(@service.property(:enable)).to receive(:insync?).and_return(false)
-    expect(@service.property(:enable)).to receive(:sync)
-
-    allow(@service.provider).to receive(:stop)
-
-    @service.property(:ensure).sync
-  end
-
-  it "should sync the service's logonaccount state when changing the state of :ensure if :logonaccount is being managed" do
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
-
-    @service[:ensure] = :stopped
-    @service[:logonaccount] = 'LocalSystem'
-
-    expect(@service.property(:logonaccount)).to receive(:retrieve).and_return("MyUser")
-    expect(@service.property(:logonaccount)).to receive(:insync?).and_return(false)
-    expect(@service.property(:logonaccount)).to receive(:sync)
-
-    allow(@service.provider).to receive(:stop)
-
-    @service.property(:ensure).sync
-  end
-end
-
-describe test_title, "when refreshing the service" do
-  safely_load_service_type
-
-  before do
-    @service = Puppet::Type.type(:service).new(:name => "yay")
-  end
-
-  it "should restart the service if it is running" do
-    @service[:ensure] = :running
-    expect(@service.provider).to receive(:status).and_return(:running)
-    expect(@service.provider).to receive(:restart)
-    @service.refresh
-  end
-
-  it "should restart the service if it is running, even if it is supposed to stopped" do
-    @service[:ensure] = :stopped
-    expect(@service.provider).to receive(:status).and_return(:running)
-    expect(@service.provider).to receive(:restart)
-    @service.refresh
-  end
-
-  it "should not restart the service if it is not running" do
-    @service[:ensure] = :running
-    expect(@service.provider).to receive(:status).and_return(:stopped)
-    @service.refresh
-  end
-
-  it "should add :ensure as a property if it is not being managed" do
-    expect(@service.provider).to receive(:status).and_return(:running)
-    expect(@service.provider).to receive(:restart)
-    @service.refresh
-  end
-end

data/spec/unit/type/stage_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:stage) do
-  it "should have a 'name' parameter'" do
-    expect(Puppet::Type.type(:stage).new(:name => :foo)[:name]).to eq(:foo)
-  end
-end