puppet 7.34.0-x86-mingw32 → 8.0.1-x86-mingw32

data/spec/unit/type/filebucket_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Puppet::Type.type(:filebucket) do
+  include PuppetSpec::Files
+
+  describe "when validating attributes" do
+    %w{name server port path}.each do |attr|
+      it "should have a '#{attr}' parameter" do
+        expect(Puppet::Type.type(:filebucket).attrtype(attr.intern)).to eq(:param)
+      end
+    end
+
+    it "should have its 'name' attribute set as its namevar" do
+      expect(Puppet::Type.type(:filebucket).key_attributes).to eq([:name])
+    end
+  end
+
+  it "should use the clientbucketdir as the path by default path" do
+    Puppet.settings[:clientbucketdir] = "/my/bucket"
+    expect(Puppet::Type.type(:filebucket).new(:name => "main")[:path]).to eq(Puppet[:clientbucketdir])
+  end
+
+  it "should not have a default port" do
+    Puppet.settings[:serverport] = 50
+    expect(Puppet::Type.type(:filebucket).new(:name => "main")[:port]).to eq(nil)
+  end
+
+  it "should not have a default server" do
+    Puppet.settings[:server] = "myserver"
+    expect(Puppet::Type.type(:filebucket).new(:name => "main")[:server]).to eq(nil)
+  end
+
+  it "be local by default" do
+    bucket = Puppet::Type.type(:filebucket).new :name => "main"
+
+    expect(bucket.bucket).to be_local
+  end
+
+  describe "path" do
+    def bucket(hash)
+      Puppet::Type.type(:filebucket).new({:name => 'main'}.merge(hash))
+    end
+
+    it "should accept false as a value" do
+      expect { bucket(:path => false) }.not_to raise_error
+    end
+
+    it "should accept true as a value" do
+      expect { bucket(:path => true) }.not_to raise_error
+    end
+
+    it "should fail when given an array of values" do
+      expect { bucket(:path => ['one', 'two']) }.
+        to raise_error Puppet::Error, /only have one filebucket path/
+    end
+
+    %w{one ../one one/two}.each do |path|
+      it "should fail if given a relative path of #{path.inspect}" do
+        expect { bucket(:path => path) }.
+          to raise_error Puppet::Error, /Filebucket paths must be absolute/
+      end
+    end
+
+    it "should succeed if given an absolute path" do
+      expect { bucket(:path => make_absolute('/tmp/bucket')) }.not_to raise_error
+    end
+
+    it "not be local if path is false" do
+      expect(bucket(:path => false).bucket).not_to be_local
+    end
+
+    it "be local if both a path and a server are specified" do
+      expect(bucket(:server => "puppet", :path => make_absolute("/my/path")).bucket).to be_local
+    end
+  end
+
+  describe "when creating the filebucket" do
+    before do
+      @bucket = double('bucket', :name= => nil)
+    end
+
+    it "should use any provided path" do
+      path = make_absolute("/foo/bar")
+      bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => path
+      expect(Puppet::FileBucket::Dipper).to receive(:new).with({:Path => path}).and_return(@bucket)
+      bucket.bucket
+    end
+
+    it "should use any provided server and port" do
+      bucket = Puppet::Type.type(:filebucket).new :name => "main", :server => "myserv", :port => "myport", :path => false
+      expect(Puppet::FileBucket::Dipper).to receive(:new).with({:Server => "myserv", :Port => "myport"}).and_return(@bucket)
+      bucket.bucket
+    end
+
+    it "should not try to guess server or port if the path is unset and no server is provided" do
+      Puppet.settings[:server] = "myserv"
+      Puppet.settings[:server_list] = ['server_list_0', 'server_list_1']
+      expect(Puppet::FileBucket::Dipper).to receive(:new).with({:Server => nil, :Port => nil}).and_return(@bucket)
+
+      bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => false
+      bucket.bucket
+    end
+  end
+end

data/spec/unit/type/group_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Puppet::Type.type(:group) do
+  before do
+    @class = Puppet::Type.type(:group)
+  end
+
+  it "should have a system_groups feature" do
+    expect(@class.provider_feature(:system_groups)).not_to be_nil
+  end
+
+  it 'should default to `present`' do
+    expect(@class.new(:name => "foo")[:ensure]).to eq(:present)
+  end
+
+  it 'should set ensure to whatever is passed in' do
+    expect(@class.new(:name => "foo", :ensure => 'absent')[:ensure]).to eq(:absent)
+  end
+
+  describe "when validating attributes" do
+    [:name, :allowdupe].each do |param|
+      it "should have a #{param} parameter" do
+        expect(@class.attrtype(param)).to eq(:param)
+      end
+    end
+
+    [:ensure, :gid].each do |param|
+      it "should have a #{param} property" do
+        expect(@class.attrtype(param)).to eq(:property)
+      end
+    end
+
+    it "should convert gids provided as strings into integers" do
+      expect(@class.new(:name => "foo", :gid => "15")[:gid]).to eq(15)
+    end
+
+    it "should accepts gids provided as integers" do
+      expect(@class.new(:name => "foo", :gid => 15)[:gid]).to eq(15)
+    end
+  end
+
+  it "should have a boolean method for determining if duplicates are allowed" do
+    expect(@class.new(:name => "foo")).to respond_to "allowdupe?"
+  end
+
+  it "should have a boolean method for determining if system groups are allowed" do
+    expect(@class.new(:name => "foo")).to respond_to "system?"
+  end
+
+  it "should call 'create' to create the group" do
+    group = @class.new(:name => "foo", :ensure => :present)
+    expect(group.provider).to receive(:create)
+    group.parameter(:ensure).sync
+  end
+
+  it "should call 'delete' to remove the group" do
+    group = @class.new(:name => "foo", :ensure => :absent)
+    expect(group.provider).to receive(:delete)
+    group.parameter(:ensure).sync
+  end
+
+  it "delegates the existence check to its provider" do
+    provider = @class.provide(:testing) do
+      def exists?
+        true
+      end
+    end
+    provider_instance = provider.new
+
+    type = @class.new(:name => "group", :provider => provider_instance)
+
+    expect(type.exists?).to eq(true)
+  end
+
+  describe "should delegate :members implementation to the provider:"  do
+    let (:provider) do
+      @class.provide(:testing) do
+        has_features :manages_members
+
+        def members
+          []
+        end
+
+        def members_insync?(current, should)
+          current == should
+        end
+
+        def members_to_s(values)
+          values.map { |v| "#{v} ()" }.join(', ')
+        end
+      end
+    end
+    let (:provider_instance) { provider.new }
+    let (:type) { @class.new(:name => "group", :provider => provider_instance, :members => ['user1']) }
+
+    it "insync? calls members_insync?" do
+      expect(type.property(:members).insync?(['user1'])).to be_truthy
+    end
+
+    it "is_to_s and should_to_s call members_to_s" do
+      expect(type.property(:members).is_to_s('user1')).to eq('user1 ()')
+      expect(type.property(:members).should_to_s('user1,user2')).to eq('user1 (), user2 ()')
+    end
+  end
+end

data/spec/unit/type/noop_metaparam_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+require 'puppet/type'
+
+describe Puppet::Type.type(:file).attrclass(:noop) do
+  include PuppetSpec::Files
+
+  before do
+    allow(Puppet.settings).to receive(:use)
+    @file = Puppet::Type.newfile :path => make_absolute("/what/ever")
+  end
+
+  it "should accept true as a value" do
+    expect { @file[:noop] = true }.not_to raise_error
+  end
+
+  it "should accept false as a value" do
+    expect { @file[:noop] = false }.not_to raise_error
+  end
+
+  describe "when set on a resource" do
+    it "should default to the :noop setting" do
+      Puppet[:noop] = true
+      expect(@file.noop).to eq(true)
+    end
+
+    it "should prefer true values from the attribute" do
+      @file[:noop] = true
+      expect(@file.noop).to be_truthy
+    end
+
+    it "should prefer false values from the attribute" do
+      @file[:noop] = false
+      expect(@file.noop).to be_falsey
+    end
+  end
+end

data/spec/unit/type/package/package_settings_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+describe Puppet::Type.type(:package) do
+  before do
+    allow(Puppet::Util::Storage).to receive(:store)
+  end
+
+  it "should have a :package_settings feature that requires :package_settings_insync?, :package_settings and :package_settings=" do
+    expect(described_class.provider_feature(:package_settings).methods).to eq([:package_settings_insync?, :package_settings, :package_settings=])
+  end
+
+  context "when validating attributes" do
+    it "should have a package_settings property" do
+      expect(described_class.attrtype(:package_settings)).to eq(:property)
+    end
+  end
+
+  context "when validating attribute values" do
+    let(:provider) do
+      double('provider',
+             :class => described_class.defaultprovider,
+             :clear => nil,
+             :validate_source => false)
+    end
+
+    before do
+      allow(provider.class).to receive(:supports_parameter?).and_return(true)
+      allow(described_class.defaultprovider).to receive(:new).and_return(provider)
+    end
+
+    describe 'package_settings' do
+      context "with a minimalistic provider supporting package_settings" do
+        context "and {:package_settings => :settings}" do
+          let(:resource) do 
+            described_class.new :name => 'foo', :package_settings => :settings
+          end
+
+          it { expect { resource }.to_not raise_error }
+
+          it "should set package_settings to :settings" do
+            expect(resource.value(:package_settings)).to be :settings
+          end
+        end
+      end
+
+      context "with a provider that supports validation of the package_settings" do
+        context "and {:package_settings => :valid_value}" do
+          before do
+            expect(provider).to receive(:package_settings_validate).once.with(:valid_value).and_return(true)
+          end
+
+          let(:resource) do 
+            described_class.new :name => 'foo', :package_settings => :valid_value
+          end
+
+          it { expect { resource }.to_not raise_error }
+
+          it "should set package_settings to :valid_value" do
+            expect(resource.value(:package_settings)).to eq(:valid_value)
+          end
+        end
+
+        context "and {:package_settings => :invalid_value}" do
+          before do
+            msg = "package_settings must be a Hash, not Symbol"
+            expect(provider).to receive(:package_settings_validate).once.
+              with(:invalid_value).and_raise(ArgumentError, msg)
+          end
+
+          let(:resource) do 
+            described_class.new :name => 'foo', :package_settings => :invalid_value
+          end
+
+          it do
+            expect { resource }.to raise_error Puppet::Error,
+              /package_settings must be a Hash, not Symbol/
+          end
+        end
+      end
+
+      context "with a provider that supports munging of the package_settings" do
+        context "and {:package_settings => 'A'}" do
+          before do
+            expect(provider).to receive(:package_settings_munge).once.with('A').and_return(:a)
+          end
+
+          let(:resource) do 
+            described_class.new :name => 'foo', :package_settings => 'A'
+          end
+
+          it do
+            expect { resource }.to_not raise_error 
+          end
+
+          it "should set package_settings to :a" do
+            expect(resource.value(:package_settings)).to be :a
+          end
+        end
+      end
+    end
+  end
+
+  describe "package_settings property" do
+    let(:provider) do
+      double('provider',
+             :class => described_class.defaultprovider,
+             :clear => nil,
+             :validate_source => false)
+    end
+
+    before do
+      allow(provider.class).to receive(:supports_parameter?).and_return(true)
+      allow(described_class.defaultprovider).to receive(:new).and_return(provider)
+    end
+
+    context "with {package_settings => :should}" do
+      let(:resource) do 
+        described_class.new :name => 'foo', :package_settings => :should
+      end
+
+      describe "#insync?(:is)" do
+        it "returns the result of provider.package_settings_insync?(:should,:is)" do
+          expect(resource.provider).to receive(:package_settings_insync?).once.with(:should,:is).and_return(:ok1)
+          expect(resource.property(:package_settings).insync?(:is)).to be :ok1
+        end
+      end
+
+      describe "#should_to_s(:newvalue)" do
+        it "returns the result of provider.package_settings_should_to_s(:should,:newvalue)" do
+          expect(resource.provider).to receive(:package_settings_should_to_s).once.with(:should,:newvalue).and_return(:ok2)
+          expect(resource.property(:package_settings).should_to_s(:newvalue)).to be :ok2
+        end
+      end
+
+      describe "#is_to_s(:currentvalue)" do
+        it "returns the result of provider.package_settings_is_to_s(:should,:currentvalue)" do
+          expect(resource.provider).to receive(:package_settings_is_to_s).once.with(:should,:currentvalue).and_return(:ok3)
+          expect(resource.property(:package_settings).is_to_s(:currentvalue)).to be :ok3
+        end
+      end
+    end
+
+    context "with any non-nil package_settings" do
+      describe "#change_to_s(:currentvalue,:newvalue)" do
+        let(:resource) do 
+          described_class.new :name => 'foo', :package_settings => {}
+        end
+
+        it "returns the result of provider.package_settings_change_to_s(:currentvalue,:newvalue)" do
+          expect(resource.provider).to receive(:package_settings_change_to_s).once.with(:currentvalue,:newvalue).and_return(:ok4)
+          expect(resource.property(:package_settings).change_to_s(:currentvalue,:newvalue)).to be :ok4
+        end
+      end
+    end
+  end
+end