puppet 0.24.6 → 0.24.7

data/spec/unit/property/list.rb

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+require 'puppet/property/list'
+
+list_class = Puppet::Property::List
+
+describe list_class do
+
+    it "should be a subclass of Property" do
+        list_class.superclass.must == Puppet::Property
+    end
+
+    describe "as an instance" do
+        before do
+            # Wow that's a messy interface to the resource.
+            list_class.initvars
+            @resource = stub 'resource', :[]= => nil, :property => nil
+            @property = list_class.new(:resource => @resource)
+        end
+
+        it "should have a , as default delimiter" do
+            @property.delimiter.should == ","
+        end
+
+        it "should have a :membership as default membership" do
+            @property.membership.should == :membership
+        end
+
+        it "should return the same value passed into should_to_s" do
+            @property.should_to_s("foo") == "foo"
+        end
+
+        it "should return the passed in array values joined with the delimiter from is_to_s" do
+            @property.is_to_s(["foo","bar"]).should == "foo,bar"
+        end
+
+        describe "when adding should to current" do
+            it "should add the arrays when current is an array" do
+                @property.add_should_with_current(["foo"], ["bar"]).should == ["foo", "bar"]
+            end
+
+            it "should return should if current is not a array" do
+                @property.add_should_with_current(["foo"], :absent).should == ["foo"]
+            end
+
+            it "should return only the uniq elements" do
+                @property.add_should_with_current(["foo", "bar"], ["foo", "baz"]).should == ["foo", "bar", "baz"]
+            end
+        end
+
+        describe "when calling inclusive?" do
+            it "should use the membership method to look up on the @resource" do
+                @property.expects(:membership).returns(:membership)
+                @resource.expects(:[]).with(:membership)
+                @property.inclusive?
+            end
+
+            it "should return true when @resource[membership] == inclusive" do
+                @property.stubs(:membership).returns(:membership)
+                @resource.stubs(:[]).with(:membership).returns(:inclusive)
+                @property.inclusive?.must == true
+            end
+
+            it "should return false when @resource[membership] != inclusive" do
+                @property.stubs(:membership).returns(:membership)
+                @resource.stubs(:[]).with(:membership).returns(:minimum)
+                @property.inclusive?.must == false
+            end
+        end
+
+        describe "when calling should" do
+            it "should return nil if @should is nil" do
+                @property.should.must == nil
+            end
+
+            it "should return the sorted values of @should as a string if inclusive" do
+                @property.should = ["foo", "bar"]
+                @property.expects(:inclusive?).returns(true)
+                @property.should.must == "bar,foo"
+            end
+
+            it "should return the uniq sorted values of @should + retrieve as a string if !inclusive" do
+                @property.should = ["foo", "bar"]
+                @property.expects(:inclusive?).returns(false)
+                @property.expects(:retrieve).returns(["foo","baz"])
+                @property.should.must == "bar,baz,foo"
+            end
+        end
+
+        describe "when calling retrieve" do
+            before do
+                @provider = mock("provider")
+                @property.stubs(:provider).returns(@provider)
+            end
+
+            it "should send 'name' to the provider" do
+                @provider.expects(:send).with(:group)
+                @property.expects(:name).returns(:group)
+                @property.retrieve
+            end
+
+            it "should return an array with the provider returned info" do
+                @provider.stubs(:send).with(:group).returns("foo,bar,baz")
+                @property.stubs(:name).returns(:group)
+                @property.retrieve == ["foo", "bar", "baz"]
+            end
+
+            it "should return :absent when the provider returns :absent" do
+                @provider.stubs(:send).with(:group).returns(:absent)
+                @property.stubs(:name).returns(:group)
+                @property.retrieve == :absent
+            end
+        end
+
+        describe "when calling insync?" do
+            it "should return true unless @should is defined and not nil" do
+                @property.insync?("foo") == true
+            end
+
+            it "should return true unless the passed in values is not nil" do
+                @property.should = "foo"
+                @property.insync?(nil) == true
+            end
+
+            it "should call prepare_is_for_comparison with value passed in and should" do
+                @property.should = "foo"
+                @property.expects(:prepare_is_for_comparison).with("bar")
+                @property.expects(:should)
+                @property.insync?("bar")
+            end
+
+            it "should return true if prepared value == should value" do
+                @property.should = "bar,foo"
+                @property.expects(:inclusive?).returns(true)
+                @property.insync?(["bar","foo"]).must == true
+            end
+
+            it "should return false if prepared value != should value" do
+                @property.should = "bar,baz,foo"
+                @property.expects(:inclusive?).returns(true)
+                @property.insync?(["bar","foo"]).must == false
+            end
+        end
+
+        describe "when calling dearrayify" do
+            it "should sort and join the array with 'delimiter'" do
+                array = mock "array"
+                array.expects(:sort).returns(array)
+                array.expects(:join).with(@property.delimiter)
+                @property.dearrayify(array)
+            end
+        end
+    end
+end

data/spec/unit/property/ordered_list.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+require 'puppet/property/ordered_list'
+
+ordered_list_class = Puppet::Property::OrderedList
+
+describe ordered_list_class do
+
+    it "should be a subclass of List" do
+        ordered_list_class.superclass.must == Puppet::Property::List
+    end
+
+    describe "as an instance" do
+        before do
+            # Wow that's a messy interface to the resource.
+            ordered_list_class.initvars
+            @resource = stub 'resource', :[]= => nil, :property => nil
+            @property = ordered_list_class.new(:resource => @resource)
+        end
+
+        describe "when adding should to current" do
+            it "should add the arrays when current is an array" do
+                @property.add_should_with_current(["should"], ["current"]).should == ["should", "current"]
+            end
+
+            it "should return 'should' if current is not a array" do
+                @property.add_should_with_current(["should"], :absent).should == ["should"]
+            end
+
+            it "should return only the uniq elements leading with the order of 'should'" do
+                @property.add_should_with_current(["this", "is", "should"], ["is", "this", "current"]).should == ["this", "is", "should", "current"]
+            end
+        end
+
+        describe "when calling should" do
+            it "should return nil if @should is nil" do
+                @property.should.must == nil
+            end
+
+            it "should return the values of @should (without sorting) as a string if inclusive" do
+                @property.should = ["foo", "bar"]
+                @property.expects(:inclusive?).returns(true)
+                @property.should.must == "foo,bar"
+            end
+
+            it "should return the uniq values of @should + retrieve as a string if !inclusive with the @ values leading" do
+                @property.should = ["foo", "bar"]
+                @property.expects(:inclusive?).returns(false)
+                @property.expects(:retrieve).returns(["foo","baz"])
+                @property.should.must == "foo,bar,baz"
+            end
+        end
+
+        describe "when calling dearrayify" do
+            it "should join the array with the delimiter" do
+                array = mock "array"
+                array.expects(:join).with(@property.delimiter)
+                @property.dearrayify(array)
+            end
+        end
+    end
+end

data/spec/unit/provider/augeas/augeas.rb

@@ -0,0 +1,238 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:augeas).provider(:augeas)
+
+describe provider_class do
+    describe "command parsing" do
+        it "should break apart a single line into three tokens" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands("set /Jar/Jar Binks")
+            tokens.size.should == 1
+            tokens[0].size.should == 3      
+            tokens[0][0].should == "set"
+            tokens[0][1].should == "/Jar/Jar"
+            tokens[0][2].should == "Binks"            
+        end
+        
+        it "should break apart a multiple line into six tokens" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands("set /Jar/Jar Binks\nrm anakin skywalker")
+            tokens.size.should == 2
+            tokens[0].size.should == 3      
+            tokens[1].size.should == 3            
+            tokens[0][0].should == "set"
+            tokens[0][1].should == "/Jar/Jar"
+            tokens[0][2].should == "Binks"            
+            tokens[1][0].should == "rm"
+            tokens[1][1].should == "anakin"
+            tokens[1][2].should == "skywalker"                
+        end        
+        
+        it "should handle arrays" do
+            provider = provider_class.new()
+            commands = ["set /Jar/Jar Binks", "rm anakin skywalker"]
+            tokens = provider.parse_commands(commands)
+            tokens.size.should == 2
+            tokens[0].size.should == 3      
+            tokens[1].size.should == 3            
+            tokens[0][0].should == "set"
+            tokens[0][1].should == "/Jar/Jar"
+            tokens[0][2].should == "Binks"            
+            tokens[1][0].should == "rm"
+            tokens[1][1].should == "anakin"
+            tokens[1][2].should == "skywalker"                
+        end                
+        
+        it "should concat the last values" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands("set /Jar/Jar Binks is my copilot")
+            tokens.size.should == 1
+            tokens[0].size.should == 3      
+            tokens[0][0].should == "set"
+            tokens[0][1].should == "/Jar/Jar"
+            tokens[0][2].should == "Binks is my copilot"            
+        end
+    end
+    
+    describe "get filters" do
+        before do
+            augeas_stub = stub("augeas", :get => "value")
+            @provider = provider_class.new()        
+            @provider.stubs(:open_augeas).returns(augeas_stub)        
+        end
+        
+        it "should return false for a = nonmatch" do
+            command = ["get", "fake value", "==", "value"]
+            @provider.process_get(command).should == true
+        end
+        
+        it "should return true for a != match" do
+            command = ["get", "fake value", "!=", "value"]
+            @provider.process_get(command).should == false
+        end        
+        
+        it "should return true for a =~ match" do
+            command = ["get", "fake value", "=~", "val*"]
+            @provider.process_get(command).should == true
+        end           
+        
+        it "should return false for a == nonmatch" do
+            command = ["get", "fake value", "=~", "num*"]
+            @provider.process_get(command).should == false
+        end 
+    end
+    
+    describe "match filters" do
+        before do
+            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
+            @provider = provider_class.new()        
+            @provider.stubs(:open_augeas).returns(augeas_stub)        
+        end
+        
+        it "should return true for size match" do
+            command = ["match", "fake value", "size", "==", "3"]
+            @provider.process_match(command).should == true
+        end
+        
+        it "should return false for a size non match" do
+            command = ["match", "fake value", "size", "<", "3"]
+            @provider.process_match(command).should == false
+        end    
+        
+        it "should return true for includes match" do
+            command = ["get", "fake value", "include", "values"]
+            @provider.process_match(command).should == true
+        end           
+        
+        it "should return false for includes non match" do
+            command = ["get", "fake value", "include", "JarJar"]
+            @provider.process_match(command).should == false
+        end           
+        
+        it "should return true for an array match" do
+            command = ["get", "fake value", "==", "['set', 'of', 'values']"]
+            @provider.process_match(command).should == true
+        end  
+        
+        it "should return false for an array non match" do
+            command = ["get", "fake value", "==", "['this', 'should', 'not', 'match']"]
+            @provider.process_match(command).should == false
+        end                 
+    end    
+    
+    describe "need_to_run" do
+        it "should handle no filters" do
+            resource = stub("resource", :[] => "")
+            provider = provider_class.new(resource)
+            provider.need_to_run?.should == true        
+        end
+        
+        it "should return true when a get filter matches" do
+            resource = stub("resource", :[] => "get path == value")
+            provider = provider_class.new(resource)
+            augeas_stub = stub("augeas", :get => "value")
+            provider.stubs(:open_augeas).returns(augeas_stub)              
+            provider.need_to_run?.should == true       
+        end       
+        
+        it "should return false when a get filter does not match" do
+            resource = stub("resource", :[] => "get path == another value")
+            provider = provider_class.new(resource)
+            augeas_stub = stub("augeas", :get => "value")
+            provider.stubs(:open_augeas).returns(augeas_stub)              
+            provider.need_to_run?.should == false       
+        end            
+        
+        it "should return true when a match filter matches" do
+            resource = stub("resource", :[] => "match path size == 3")
+            provider = provider_class.new(resource)
+            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
+            provider.stubs(:open_augeas).returns(augeas_stub)              
+            provider.need_to_run?.should == true       
+        end       
+        
+        it "should return false when a match filter does not match" do
+            resource = stub("resource", :[] => "match path size == 2")
+            provider = provider_class.new(resource)
+            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
+            provider.stubs(:open_augeas).returns(augeas_stub)              
+            provider.need_to_run?.should == false       
+        end       
+    end
+    
+    describe "augeas integration" do
+        
+        before do
+            @resource = stub("resource")
+            @provider = provider_class.new(@resource)
+            @augeas = stub("augeas")
+            @provider.stubs(:open_augeas).returns(@augeas)
+        end
+    
+        it "should handle set commands" do
+            command = [["set", "/Jar/Jar", "Binks"]]
+            context = "/some/path"
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:set).with("/some/path/Jar/Jar", "Binks")
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end
+        
+        it "should handle rm commands" do
+            command = [["rm", "/Jar/Jar"]]
+            context = ""
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:rm).with("/Jar/Jar")
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end        
+        
+        it "should handle remove commands" do
+            command = [["remove", "Jar/Jar"]]
+            context = ""
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:rm).with("/Jar/Jar")
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end              
+        
+        it "should handle clear commands" do
+            command = [["clear", "/Jar/Jar"]]
+            context = "/foo"
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:clear).with("/foo/Jar/Jar")
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end        
+        
+        it "should handle insert commands" do
+            command = [["insert", "/Jar/Jar"]]
+            context = "/foo"
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:insert).with("/foo/Jar/Jar")
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end     
+        
+        it "should handle ins commands" do
+            command = [["ins", "/Jar/Jar"]]
+            context = "/foo"
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:insert).with("/foo/Jar/Jar")
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end      
+        
+        it "should handle multiple commands" do
+            command = [["ins", "/Jar/Jar"], ["clear", "/Jar/Jar"]]
+            context = "/foo"
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:insert).with("/foo/Jar/Jar")
+            @augeas.expects(:clear).with("/foo/Jar/Jar")            
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end    
+    end
+end