puppet 0.24.6 → 0.24.7

data/spec/unit/provider/confine.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/provider/confine'
+
+describe Puppet::Provider::Confine do
+    it "should require a value" do
+        lambda { Puppet::Provider::Confine.new() }.should raise_error(ArgumentError)
+    end
+
+    it "should always convert values to an array" do
+        Puppet::Provider::Confine.new("/some/file").values.should be_instance_of(Array)
+    end
+
+    it "should have a 'true' test" do
+        Puppet::Provider::Confine.test(:true).should be_instance_of(Class)
+    end
+
+    it "should have a 'false' test" do
+        Puppet::Provider::Confine.test(:false).should be_instance_of(Class)
+    end
+
+    it "should have a 'feature' test" do
+        Puppet::Provider::Confine.test(:feature).should be_instance_of(Class)
+    end
+
+    it "should have an 'exists' test" do
+        Puppet::Provider::Confine.test(:exists).should be_instance_of(Class)
+    end
+
+    it "should have a 'variable' test" do
+        Puppet::Provider::Confine.test(:variable).should be_instance_of(Class)
+    end
+
+    describe "when testing all values" do
+        before do
+            @confine = Puppet::Provider::Confine.new(%w{a b c})
+            @confine.label = "foo"
+        end
+
+        it "should be invalid if any values fail" do
+            @confine.stubs(:pass?).returns true
+            @confine.expects(:pass?).with("b").returns false
+            @confine.should_not be_valid
+        end
+
+        it "should be valid if all values pass" do
+            @confine.stubs(:pass?).returns true
+            @confine.should be_valid
+        end
+
+        it "should short-cut at the first failing value" do
+            @confine.expects(:pass?).once.returns false
+            @confine.valid?
+        end
+
+        it "should log failing confines with the label and message" do
+            @confine.stubs(:pass?).returns false
+            @confine.expects(:message).returns "My message"
+            @confine.expects(:label).returns "Mylabel"
+            Puppet.expects(:debug).with("Mylabel: My message")
+            @confine.valid?
+        end
+    end
+
+    describe "when testing the result of the values" do
+        before { @confine = Puppet::Provider::Confine.new(%w{a b c d}) }
+
+        it "should return an array with the result of the test for each value" do
+            @confine.stubs(:pass?).returns true
+            @confine.expects(:pass?).with("b").returns false
+            @confine.expects(:pass?).with("d").returns false
+
+            @confine.result.should == [true, false, true, false]
+        end
+    end
+end

data/spec/unit/provider/confine/exists.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/provider/confine/exists'
+
+describe Puppet::Provider::Confine::Exists do
+    before do
+        @confine = Puppet::Provider::Confine::Exists.new("/my/file")
+        @confine.label = "eh"
+    end
+
+    it "should be named :exists" do
+        Puppet::Provider::Confine::Exists.name.should == :exists
+    end
+
+    it "should use the 'pass?' method to test validity" do
+        @confine.expects(:pass?).with("/my/file")
+        @confine.valid?
+    end
+
+    it "should return false if the value is false" do
+        @confine.pass?(false).should be_false
+    end
+
+    it "should return false if the value does not point to a file" do
+        FileTest.expects(:exist?).with("/my/file").returns false
+        @confine.pass?("/my/file").should be_false
+    end
+
+    it "should return true if the value points to a file" do
+        FileTest.expects(:exist?).with("/my/file").returns true
+        @confine.pass?("/my/file").should be_true
+    end
+
+    it "should produce a message saying that a file is missing" do
+        @confine.message("/my/file").should be_include("does not exist")
+    end
+
+    describe "and the confine is for binaries" do
+        before { @confine.stubs(:for_binary).returns true }
+        it "should use its 'binary' method to look up the full path of the file" do
+            @confine.expects(:binary).returns nil
+            @confine.pass?("/my/file")
+        end
+
+        it "should return false if no binary can be found" do
+            @confine.expects(:binary).with("/my/file").returns nil
+            @confine.pass?("/my/file").should be_false
+        end
+
+        it "should return true if the binary can be found and the file exists" do
+            @confine.expects(:binary).with("/my/file").returns "/my/file"
+            FileTest.expects(:exist?).with("/my/file").returns true
+            @confine.pass?("/my/file").should be_true
+        end
+
+        it "should return false if the binary can be found but the file does not exist" do
+            @confine.expects(:binary).with("/my/file").returns "/my/file"
+            FileTest.expects(:exist?).with("/my/file").returns true
+            @confine.pass?("/my/file").should be_true
+        end
+    end
+
+    it "should produce a summary containing all missing files" do
+        FileTest.stubs(:exist?).returns true
+        FileTest.expects(:exist?).with("/two").returns false
+        FileTest.expects(:exist?).with("/four").returns false
+
+        confine = Puppet::Provider::Confine::Exists.new %w{/one /two /three /four}
+        confine.summary.should == %w{/two /four}
+    end
+
+    it "should summarize multiple instances by returning a flattened array of their summaries" do
+        c1 = mock '1', :summary => %w{one}
+        c2 = mock '2', :summary => %w{two}
+        c3 = mock '3', :summary => %w{three}
+
+        Puppet::Provider::Confine::Exists.summarize([c1, c2, c3]).should == %w{one two three}
+    end
+end

data/spec/unit/provider/confine/false.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/provider/confine/false'
+
+describe Puppet::Provider::Confine::False do
+    it "should be named :false" do
+        Puppet::Provider::Confine::False.name.should == :false
+    end
+
+    it "should require a value" do
+        lambda { Puppet::Provider::Confine.new() }.should raise_error(ArgumentError)
+    end
+
+    describe "when testing values" do
+        before { @confine = Puppet::Provider::Confine::False.new("foo") }
+
+        it "should use the 'pass?' method to test validity" do
+            @confine = Puppet::Provider::Confine::False.new("foo")
+            @confine.label = "eh"
+            @confine.expects(:pass?).with("foo")
+            @confine.valid?
+        end
+
+        it "should return true if the value is false" do
+            @confine.pass?(false).should be_true
+        end
+
+        it "should return false if the value is not false" do
+            @confine.pass?("else").should be_false
+        end
+
+        it "should produce a message that a value is true" do
+            @confine = Puppet::Provider::Confine::False.new("foo")
+            @confine.message("eh").should be_include("true")
+        end
+    end
+
+    it "should be able to produce a summary with the number of incorrectly true values" do
+        confine = Puppet::Provider::Confine::False.new %w{one two three four}
+        confine.expects(:pass?).times(4).returns(true).returns(false).returns(true).returns(false)
+        confine.summary.should == 2
+    end
+
+    it "should summarize multiple instances by summing their summaries" do
+        c1 = mock '1', :summary => 1
+        c2 = mock '2', :summary => 2
+        c3 = mock '3', :summary => 3
+
+        Puppet::Provider::Confine::False.summarize([c1, c2, c3]).should == 6
+    end
+end

data/spec/unit/provider/confine/feature.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/provider/confine/feature'
+
+describe Puppet::Provider::Confine::Feature do
+    it "should be named :feature" do
+        Puppet::Provider::Confine::Feature.name.should == :feature
+    end
+
+    it "should require a value" do
+        lambda { Puppet::Provider::Confine::Feature.new() }.should raise_error(ArgumentError)
+    end
+
+    it "should always convert values to an array" do
+        Puppet::Provider::Confine::Feature.new("/some/file").values.should be_instance_of(Array)
+    end
+
+    describe "when testing values" do
+        before do
+            @features = mock 'features'
+            Puppet.stubs(:features).returns @features
+            @confine = Puppet::Provider::Confine::Feature.new("myfeature")
+            @confine.label = "eh"
+        end
+
+        it "should use the Puppet features instance to test validity" do
+            @features.expects(:myfeature?)
+            @confine.valid?
+        end
+
+        it "should return true if the feature is present" do
+            @features.expects(:myfeature?).returns true
+            @confine.pass?("myfeature").should be_true
+        end
+
+        it "should return false if the value is false" do
+            @features.expects(:myfeature?).returns false
+            @confine.pass?("myfeature").should be_false
+        end
+
+        it "should log that a feature is missing" do
+            @confine.message("myfeat").should be_include("missing")
+        end
+    end
+
+    it "should summarize multiple instances by returning a flattened array of all missing features" do
+        confines = []
+        confines << Puppet::Provider::Confine::Feature.new(%w{one two})
+        confines << Puppet::Provider::Confine::Feature.new(%w{two})
+        confines << Puppet::Provider::Confine::Feature.new(%w{three four})
+
+        features = mock 'feature'
+        features.stub_everything
+        Puppet.stubs(:features).returns features
+
+        Puppet::Provider::Confine::Feature.summarize(confines).sort.should == %w{one two three four}.sort
+    end
+end

data/spec/unit/provider/confine/true.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/provider/confine/true'
+
+describe Puppet::Provider::Confine::True do
+    it "should be named :true" do
+        Puppet::Provider::Confine::True.name.should == :true
+    end
+
+    it "should require a value" do
+        lambda { Puppet::Provider::Confine::True.new() }.should raise_error(ArgumentError)
+    end
+
+    describe "when testing values" do
+        before do
+            @confine = Puppet::Provider::Confine::True.new("foo")
+            @confine.label = "eh"
+        end
+
+        it "should use the 'pass?' method to test validity" do
+            @confine.expects(:pass?).with("foo")
+            @confine.valid?
+        end
+
+        it "should return true if the value is not false" do
+            @confine.pass?("else").should be_true
+        end
+
+        it "should return false if the value is false" do
+            @confine.pass?(nil).should be_false
+        end
+
+        it "should produce the message that a value is false" do
+            @confine.message("eh").should be_include("false")
+        end
+    end
+
+    it "should produce the number of false values when asked for a summary" do
+        @confine = Puppet::Provider::Confine::True.new %w{one two three four}
+        @confine.expects(:pass?).times(4).returns(true).returns(false).returns(true).returns(false)
+        @confine.summary.should == 2
+    end
+
+    it "should summarize multiple instances by summing their summaries" do
+        c1 = mock '1', :summary => 1
+        c2 = mock '2', :summary => 2
+        c3 = mock '3', :summary => 3
+
+        Puppet::Provider::Confine::True.summarize([c1, c2, c3]).should == 6
+    end
+end

data/spec/unit/provider/confine/variable.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/provider/confine/variable'
+
+describe Puppet::Provider::Confine::Variable do
+    it "should be named :variable" do
+        Puppet::Provider::Confine::Variable.name.should == :variable
+    end
+
+    it "should require a value" do
+        lambda { Puppet::Provider::Confine::Variable.new() }.should raise_error(ArgumentError)
+    end
+
+    it "should always convert values to an array" do
+        Puppet::Provider::Confine::Variable.new("/some/file").values.should be_instance_of(Array)
+    end
+
+    it "should have an accessor for its name" do
+        Puppet::Provider::Confine::Variable.new(:bar).should respond_to(:name)
+    end
+
+    describe "when testing values" do
+        before do
+            @confine = Puppet::Provider::Confine::Variable.new("foo")
+            @confine.name = :myvar
+        end
+
+        it "should use settings if the variable name is a valid setting" do
+            Puppet.settings.expects(:valid?).with(:myvar).returns true
+            Puppet.settings.expects(:value).with(:myvar).returns "foo"
+            @confine.valid?
+        end
+
+        it "should use Facter if the variable name is not a valid setting" do
+            Puppet.settings.expects(:valid?).with(:myvar).returns false
+            Facter.expects(:value).with(:myvar).returns "foo"
+            @confine.valid?
+        end
+
+        it "should be valid if the value matches the facter value" do
+            @confine.expects(:test_value).returns "foo"
+
+            @confine.should be_valid
+        end
+
+        it "should return false if the value does not match the facter value" do
+            @confine.expects(:test_value).returns "fee"
+
+            @confine.should_not be_valid
+        end
+
+        it "should be case insensitive" do
+            @confine.expects(:test_value).returns "FOO"
+
+            @confine.should be_valid
+        end
+
+        it "should not care whether the value is a string or symbol" do
+            @confine.expects(:test_value).returns "FOO"
+
+            @confine.should be_valid
+        end
+
+        it "should produce a message that the fact value is not correct" do
+            @confine = Puppet::Provider::Confine::Variable.new(%w{bar bee})
+            @confine.name = "eh"
+            message = @confine.message("value")
+            message.should be_include("facter")
+            message.should be_include("bar,bee")
+        end
+
+        it "should be valid if the test value matches any of the provided values" do
+            @confine = Puppet::Provider::Confine::Variable.new(%w{bar bee})
+            @confine.expects(:test_value).returns "bee"
+            @confine.should be_valid
+        end
+    end
+
+    describe "when summarizing multiple instances" do
+        it "should return a hash of failing variables and their values" do
+            c1 = Puppet::Provider::Confine::Variable.new("one")
+            c1.name = "uno"
+            c1.expects(:valid?).returns false
+            c2 = Puppet::Provider::Confine::Variable.new("two")
+            c2.name = "dos"
+            c2.expects(:valid?).returns true
+            c3 = Puppet::Provider::Confine::Variable.new("three")
+            c3.name = "tres"
+            c3.expects(:valid?).returns false
+
+            Puppet::Provider::Confine::Variable.summarize([c1, c2, c3]).should == {"uno" => %w{one}, "tres" => %w{three}}
+        end
+
+        it "should combine the values of multiple confines with the same fact" do
+            c1 = Puppet::Provider::Confine::Variable.new("one")
+            c1.name = "uno"
+            c1.expects(:valid?).returns false
+            c2 = Puppet::Provider::Confine::Variable.new("two")
+            c2.name = "uno"
+            c2.expects(:valid?).returns false
+
+            Puppet::Provider::Confine::Variable.summarize([c1, c2]).should == {"uno" => %w{one two}}
+        end
+    end
+end

data/spec/unit/provider/confine_collection.rb

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/provider/confine_collection'
+
+describe Puppet::Provider::ConfineCollection do
+    it "should be able to add confines" do
+        Puppet::Provider::ConfineCollection.new("label").should respond_to(:confine)
+    end
+
+    it "should require a label at initialization" do
+        lambda { Puppet::Provider::ConfineCollection.new }.should raise_error(ArgumentError)
+    end
+
+    it "should make its label available" do
+        Puppet::Provider::ConfineCollection.new("mylabel").label.should == "mylabel"
+    end
+
+    describe "when creating confine instances" do
+        it "should create an instance of the named test with the provided values" do
+            test_class = mock 'test_class'
+            test_class.expects(:new).with(%w{my values}).returns(stub('confine', :label= => nil))
+            Puppet::Provider::Confine.expects(:test).with(:foo).returns test_class
+
+            Puppet::Provider::ConfineCollection.new("label").confine :foo => %w{my values}
+        end
+
+        it "should copy its label to the confine instance" do
+            confine = mock 'confine'
+            test_class = mock 'test_class'
+            test_class.expects(:new).returns confine
+            Puppet::Provider::Confine.expects(:test).returns test_class
+
+            confine.expects(:label=).with("label")
+
+            Puppet::Provider::ConfineCollection.new("label").confine :foo => %w{my values}
+        end
+
+        describe "and the test cannot be found" do
+            it "should create a Facter test with the provided values and set the name to the test name" do
+                confine = Puppet::Provider::Confine.test(:variable).new(%w{my values})
+                confine.expects(:name=).with(:foo)
+                confine.class.expects(:new).with(%w{my values}).returns confine
+                Puppet::Provider::ConfineCollection.new("label").confine(:foo => %w{my values})
+            end
+        end
+
+        describe "and the 'for_binary' option was provided" do
+            it "should mark the test as a binary confine" do
+                confine = Puppet::Provider::Confine.test(:exists).new(:bar)
+                confine.expects(:for_binary=).with true
+                Puppet::Provider::Confine.test(:exists).expects(:new).with(:bar).returns confine
+                Puppet::Provider::ConfineCollection.new("label").confine :exists => :bar, :for_binary => true
+            end
+        end
+    end
+
+    it "should be valid if no confines are present" do
+        Puppet::Provider::ConfineCollection.new("label").should be_valid
+    end
+
+    it "should be valid if all confines pass" do
+        c1 = stub 'c1', :valid? => true, :label= => nil
+        c2 = stub 'c2', :valid? => true, :label= => nil
+
+        Puppet::Provider::Confine.test(:true).expects(:new).returns(c1)
+        Puppet::Provider::Confine.test(:false).expects(:new).returns(c2)
+
+        confiner = Puppet::Provider::ConfineCollection.new("label")
+        confiner.confine :true => :bar, :false => :bee
+
+        confiner.should be_valid
+    end
+
+    it "should not be valid if any confines fail" do
+        c1 = stub 'c1', :valid? => true, :label= => nil
+        c2 = stub 'c2', :valid? => false, :label= => nil
+
+        Puppet::Provider::Confine.test(:true).expects(:new).returns(c1)
+        Puppet::Provider::Confine.test(:false).expects(:new).returns(c2)
+
+        confiner = Puppet::Provider::ConfineCollection.new("label")
+        confiner.confine :true => :bar, :false => :bee
+
+        confiner.should_not be_valid
+    end
+
+    describe "when providing a summary" do
+        before do
+            @confiner = Puppet::Provider::ConfineCollection.new("label")
+        end
+
+        it "should return a hash" do
+            @confiner.summary.should be_instance_of(Hash)
+        end
+
+        it "should return an empty hash if the confiner is valid" do
+            @confiner.summary.should == {}
+        end
+
+        it "should add each test type's summary to the hash" do
+            @confiner.confine :true => :bar, :false => :bee
+            Puppet::Provider::Confine.test(:true).expects(:summarize).returns :tsumm
+            Puppet::Provider::Confine.test(:false).expects(:summarize).returns :fsumm
+
+            @confiner.summary.should == {:true => :tsumm, :false => :fsumm}
+        end
+
+        it "should not include tests that return 0" do
+            @confiner.confine :true => :bar, :false => :bee
+            Puppet::Provider::Confine.test(:true).expects(:summarize).returns 0
+            Puppet::Provider::Confine.test(:false).expects(:summarize).returns :fsumm
+
+            @confiner.summary.should == {:false => :fsumm}
+        end
+
+        it "should not include tests that return empty arrays" do
+            @confiner.confine :true => :bar, :false => :bee
+            Puppet::Provider::Confine.test(:true).expects(:summarize).returns []
+            Puppet::Provider::Confine.test(:false).expects(:summarize).returns :fsumm
+
+            @confiner.summary.should == {:false => :fsumm}
+        end
+
+        it "should not include tests that return empty hashes" do
+            @confiner.confine :true => :bar, :false => :bee
+            Puppet::Provider::Confine.test(:true).expects(:summarize).returns({})
+            Puppet::Provider::Confine.test(:false).expects(:summarize).returns :fsumm
+
+            @confiner.summary.should == {:false => :fsumm}
+        end
+    end
+end