puppet 0.25.5 → 2.6.0

data/spec/unit/property/list.rb

@@ -1,166 +0,0 @@
-#!/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
-
-        it "should be able to correctly convert ':absent' to a string" do
-            @property.is_to_s(:absent).should == "absent"
-        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.must be_insync("foo")
-            end
-
-            it "should return true unless the passed in values is not nil" do
-                @property.should = "foo"
-                @property.must be_insync(nil)
-            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 'is' value is array of comma delimited should values" do
-                @property.should = "bar,foo"
-                @property.expects(:inclusive?).returns(true)
-                @property.must be_insync(["bar","foo"])
-            end
-
-            it "should return true if 'is' value is :absent and should value is empty string" do
-                @property.should = ""
-                @property.expects(:inclusive?).returns(true)
-                @property.must be_insync([])
-            end
-
-            it "should return false if prepared value != should value" do
-                @property.should = "bar,baz,foo"
-                @property.expects(:inclusive?).returns(true)
-                @property.must_not be_insync(["bar","foo"])
-            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

@@ -1,64 +0,0 @@
-#!/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.rb

@@ -1,31 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Puppet::Provider do
-    it "should have a specifity class method" do
-        Puppet::Provider.should respond_to(:specificity)
-    end
-
-    it "should consider two defaults to be higher specificity than one default" do
-        one = Class.new(Puppet::Provider)
-        one.initvars
-        one.defaultfor :operatingsystem => "solaris"
-
-        two = Class.new(Puppet::Provider)
-        two.initvars
-        two.defaultfor :operatingsystem => "solaris", :operatingsystemrelease => "5.10"
-
-        two.specificity.should > one.specificity
-    end
-
-    it "should consider a subclass more specific than its parent class" do
-        one = Class.new(Puppet::Provider)
-        one.initvars
-
-        two = Class.new(one)
-        two.initvars
-
-        two.specificity.should > one.specificity
-    end
-end

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

@@ -1,413 +0,0 @@
-#!/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
-        before do
-            @resource = stub("resource")
-            @provider = provider_class.new(@resource)
-        end
-
-        it "should break apart a single line into three tokens and clean up the context" do
-            @resource.stubs(:[]).returns("/context")
-            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 == "/context/Jar/Jar"
-            tokens[0][2].should == "Binks"
-        end
-
-        it "should break apart a multiple line into six tokens" do
-            @resource.stubs(:[]).returns("")
-            tokens = @provider.parse_commands("set /Jar/Jar Binks\nrm anakin")
-            tokens.size.should == 2
-            tokens[0].size.should == 3
-            tokens[1].size.should == 2
-            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"
-        end
-
-        it "should strip whitespace and ignore blank lines" do
-            @resource.stubs(:[]).returns("")
-            tokens = @provider.parse_commands("  set /Jar/Jar Binks \t\n  \n\n  rm anakin ")
-            tokens.size.should == 2
-            tokens[0].size.should == 3
-            tokens[1].size.should == 2
-            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"
-        end
-
-        it "should handle arrays" do
-            @resource.stubs(:[]).returns("/foo/")
-            commands = ["set /Jar/Jar Binks", "rm anakin"]
-            tokens = @provider.parse_commands(commands)
-            tokens.size.should == 2
-            tokens[0].size.should == 3
-            tokens[1].size.should == 2
-            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 == "/foo/anakin"
-        end
-
-        # This is not supported in the new parsing class
-        #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
-
-        it "should accept spaces in the value and single ticks" do
-            @resource.stubs(:[]).returns("/foo/")
-            tokens = @provider.parse_commands("set JarJar 'Binks is my copilot'")
-            tokens.size.should == 1
-            tokens[0].size.should == 3
-            tokens[0][0].should == "set"
-            tokens[0][1].should == "/foo/JarJar"
-            tokens[0][2].should == "Binks is my copilot"
-        end
-
-        it "should accept spaces in the value and double ticks" do
-            @resource.stubs(:[]).returns("/foo/")
-            tokens = @provider.parse_commands('set /JarJar "Binks is my copilot"')
-            tokens.size.should == 1
-            tokens[0].size.should == 3
-            tokens[0][0].should == "set"
-            tokens[0][1].should == '/JarJar'
-            tokens[0][2].should == 'Binks is my copilot'
-        end
-
-        it "should accept mixed ticks" do
-            @resource.stubs(:[]).returns("/foo/")
-            tokens = @provider.parse_commands('set JarJar "Some \'Test\'"')
-            tokens.size.should == 1
-            tokens[0].size.should == 3
-            tokens[0][0].should == "set"
-            tokens[0][1].should == '/foo/JarJar'
-            tokens[0][2].should == "Some \'Test\'"
-        end
-
-        it "should handle predicates with literals" do
-            @resource.stubs(:[]).returns("/foo/")
-            tokens = @provider.parse_commands("rm */*[module='pam_console.so']")
-            tokens.should == [["rm", "/foo/*/*[module='pam_console.so']"]]
-        end
-
-        it "should handle whitespace in predicates" do
-            @resource.stubs(:[]).returns("/foo/")
-            tokens = @provider.parse_commands("ins 42 before /files/etc/hosts/*/ipaddr[ . = '127.0.0.1' ]")
-            tokens.should == [["ins", "42", "before","/files/etc/hosts/*/ipaddr[ . = '127.0.0.1' ]"]]
-        end
-
-        it "should handle multiple predicates" do
-            @resource.stubs(:[]).returns("/foo/")
-            tokens = @provider.parse_commands("clear pam.d/*/*[module = 'system-auth'][type = 'account']")
-            tokens.should == [["clear", "/foo/pam.d/*/*[module = 'system-auth'][type = 'account']"]]
-        end
-
-        it "should handle nested predicates" do
-            @resource.stubs(:[]).returns("/foo/")
-            args = ["clear", "/foo/pam.d/*/*[module[ ../type = 'type] = 'system-auth'][type[last()] = 'account']"]
-            tokens = @provider.parse_commands(args.join(" "))
-            tokens.should == [ args ]
-        end
-
-        it "should handle escaped doublequotes in doublequoted string" do
-            @resource.stubs(:[]).returns("/foo/")
-            tokens = @provider.parse_commands("set /foo \"''\\\"''\"")
-            tokens.should == [[ "set", "/foo", "''\\\"''" ]]
-        end
-
-        it "should allow escaped spaces and brackets in paths" do
-            @resource.stubs(:[]).returns("/foo/")
-            args = [ "set", "/white\\ space/\\[section", "value" ]
-            tokens = @provider.parse_commands(args.join(" \t "))
-            tokens.should == [ args ]
-        end
-
-        it "should allow single quoted escaped spaces in paths" do
-            @resource.stubs(:[]).returns("/foo/")
-            args = [ "set", "'/white\\ space/key'", "value" ]
-            tokens = @provider.parse_commands(args.join(" \t "))
-            tokens.should == [[ "set", "/white\\ space/key", "value" ]]
-        end
-
-        it "should allow double quoted escaped spaces in paths" do
-            @resource.stubs(:[]).returns("/foo/")
-            args = [ "set", '"/white\\ space/key"', "value" ]
-            tokens = @provider.parse_commands(args.join(" \t "))
-            tokens.should == [[ "set", "/white\\ space/key", "value" ]]
-        end
-
-        it "should remove trailing slashes" do
-            @resource.stubs(:[]).returns("/foo/")
-            tokens = @provider.parse_commands("set foo/ bar")
-            tokens.should == [[ "set", "/foo/foo", "bar" ]]
-        end
-    end
-
-    describe "get filters" do
-        before do
-            augeas_stub = stub("augeas", :get => "value")
-            @provider = provider_class.new()
-            @provider.aug= 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
-            resource = stub("resource", :[] => "")
-            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
-            @provider = provider_class.new(resource)
-            @provider.aug= 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 = ["match", "fake value", "include values"]
-            @provider.process_match(command).should == true
-        end
-
-        it "should return false for includes non match" do
-            command = ["match", "fake value", "include JarJar"]
-            @provider.process_match(command).should == false
-        end
-
-        it "should return true for includes match" do
-            command = ["match", "fake value", "not_include JarJar"]
-            @provider.process_match(command).should == true
-        end
-
-        it "should return false for includes non match" do
-            command = ["match", "fake value", "not_include values"]
-            @provider.process_match(command).should == false
-        end
-
-        it "should return true for an array match" do
-            command = ["match", "fake value", "== ['set', 'of', 'values']"]
-            @provider.process_match(command).should == true
-        end
-
-        it "should return false for an array non match" do
-            command = ["match", "fake value", "== ['this', 'should', 'not', 'match']"]
-            @provider.process_match(command).should == false
-        end
-
-        it "should return false for an array match with noteq" do
-            command = ["match", "fake value", "!= ['set', 'of', 'values']"]
-            @provider.process_match(command).should == false
-        end
-
-        it "should return true for an array non match with noteq" do
-            command = ["match", "fake value", "!= ['this', 'should', 'not', 'match']"]
-            @provider.process_match(command).should == true
-        end
-    end
-
-    describe "need to run" do
-        it "should handle no filters" do
-            resource = stub("resource")
-            resource.stubs(:[]).returns(false).then.returns("").then.returns("")
-            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
-            augeas_stub.stubs("close")
-            provider = provider_class.new(resource)
-            provider.aug= augeas_stub
-            provider.stubs(:get_augeas_version).returns("0.3.5")
-            provider.need_to_run?.should == true
-        end
-
-        it "should return true when a get filter matches" do
-            resource = stub("resource")
-            resource.stubs(:[]).returns(false).then.returns("get path == value").then.returns("")
-            provider = provider_class.new(resource)
-            augeas_stub = stub("augeas", :get => "value")
-            augeas_stub.stubs("close")
-            provider.aug= augeas_stub
-            provider.stubs(:get_augeas_version).returns("0.3.5")
-            provider.need_to_run?.should == true
-        end
-
-        it "should return false when a get filter does not match" do
-            resource = stub("resource")
-            resource.stubs(:[]).returns(false).then.returns("get path == another value").then.returns("")
-            provider = provider_class.new(resource)
-            augeas_stub = stub("augeas", :get => "value")
-            augeas_stub.stubs("close")
-            provider.aug= augeas_stub
-            provider.stubs(:get_augeas_version).returns("0.3.5")
-            provider.need_to_run?.should == false
-        end
-
-        it "should return true when a match filter matches" do
-            resource = stub("resource")
-            resource.stubs(:[]).returns(false).then.returns("match path size == 3").then.returns("")
-            provider = provider_class.new(resource)
-            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
-            augeas_stub.stubs("close")
-            provider.aug= augeas_stub
-            provider.stubs(:get_augeas_version).returns("0.3.5")
-            provider.need_to_run?.should == true
-        end
-
-        it "should return false when a match filter does not match" do
-            resource = stub("resource")
-            resource.stubs(:[]).returns(false).then.returns("match path size == 2").then.returns("")
-            provider = provider_class.new(resource)
-            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
-            augeas_stub.stubs("close")
-            provider.aug= augeas_stub
-            provider.stubs(:get_augeas_version).returns("0.3.5")
-            provider.need_to_run?.should == false
-        end
-
-        #This is a copy of the last one, with setting the force to true
-        it "setting force should not change the above logic" do
-            resource = stub("resource")
-            resource.stubs(:[]).returns(true).then.returns("match path size == 2").then.returns("")
-            provider = provider_class.new(resource)
-            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
-            augeas_stub.stubs("close")
-            provider.aug= augeas_stub
-            provider.stubs(:get_augeas_version).returns("0.3.5")
-            provider.need_to_run?.should == false
-        end
-    end
-
-    describe "augeas execution integration" do
-
-        before do
-            @resource = stub("resource")
-            @provider = provider_class.new(@resource)
-            @augeas = stub("augeas")
-            @provider.aug= @augeas
-            @provider.stubs(:get_augeas_version).returns("0.3.5")
-        end
-
-        it "should handle set commands" do
-            command = "set JarJar Binks"
-            context = "/some/path/"
-            @resource.expects(:[]).times(2).returns(command).then.returns(context)
-            @augeas.expects(:set).with("/some/path/JarJar", "Binks").returns(true)
-            @augeas.expects(:save).returns(true)
-            @augeas.expects(:close)
-            @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)
-            @augeas.expects(:close)
-            @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)
-            @augeas.expects(:close)
-            @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").returns(true)
-            @augeas.expects(:save).returns(true)
-            @augeas.expects(:close)
-            @provider.execute_changes.should == :executed
-        end
-
-
-        it "should handle ins commands with before" do
-            command = "ins Binks before Jar/Jar"
-            context = "/foo"
-            @resource.expects(:[]).times(2).returns(command).then.returns(context)
-            @augeas.expects(:insert).with("/foo/Jar/Jar", "Binks", true)
-            @augeas.expects(:save).returns(true)
-            @augeas.expects(:close)
-            @provider.execute_changes.should == :executed
-        end
-
-        it "should handle ins commands with after" do
-            command = "ins Binks after /Jar/Jar"
-            context = "/foo"
-            @resource.expects(:[]).times(2).returns(command).then.returns(context)
-            @augeas.expects(:insert).with("/Jar/Jar", "Binks", false)
-            @augeas.expects(:save).returns(true)
-            @augeas.expects(:close)
-            @provider.execute_changes.should == :executed
-        end
-
-        it "should handle ins with no context" do
-            command = "ins Binks after /Jar/Jar"
-            context = "" # this is the default
-            @resource.expects(:[]).times(2).returns(command).then.returns(context)
-            @augeas.expects(:insert).with("/Jar/Jar", "Binks", false)
-            @augeas.expects(:save).returns(true)
-            @augeas.expects(:close)
-            @provider.execute_changes.should == :executed
-        end
-
-        it "should handle multiple commands" do
-            command = ["ins Binks after /Jar/Jar", "clear Jar/Jar"]
-            context = "/foo/"
-            @resource.expects(:[]).times(2).returns(command).then.returns(context)
-            @augeas.expects(:insert).with("/Jar/Jar", "Binks", false)
-            @augeas.expects(:clear).with("/foo/Jar/Jar").returns(true)
-            @augeas.expects(:save).returns(true)
-            @augeas.expects(:close)
-            @provider.execute_changes.should == :executed
-        end
-    end
-end