puppet 0.25.0 → 0.25.1

data/spec/unit/network/formats.rb

@@ -4,13 +4,13 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/network/formats'
 
-class JsonTest
+class PsonTest
     attr_accessor :string
     def ==(other)
         string == other.string
     end
 
-    def self.from_json(data)
+    def self.from_pson(data)
         new(data)
     end
 
@@ -18,11 +18,11 @@ class JsonTest
         @string = string
     end
 
-    def to_json(*args)
+    def to_pson(*args)
         {
-            'json_class' => self.class.name,
+            'type' => self.class.name,
             'data' => @string
-        }.to_json(*args)
+        }.to_pson(*args)
     end
 end
 
@@ -90,6 +90,91 @@ describe "Puppet Network Format" do
         end
     end
 
+    describe "base64 compressed yaml" do
+        before do
+            @yaml = Puppet::Network::FormatHandler.format(:b64_zlib_yaml)
+        end
+
+        it "should have its mime type set to text/b64_zlib_yaml" do
+            @yaml.mime.should == "text/b64_zlib_yaml"
+        end
+
+        it "should render by calling 'to_yaml' on the instance" do
+            instance = mock 'instance'
+            instance.expects(:to_yaml).returns "foo"
+            @yaml.render(instance)
+        end
+
+        it "should fixup generated yaml on render" do
+            instance = mock 'instance', :to_yaml => "foo"
+
+            @yaml.expects(:fixup).with("foo").returns "bar"
+
+            @yaml.render(instance)
+        end
+
+        it "should encode generated yaml on render" do
+            instance = mock 'instance', :to_yaml => "foo"
+
+            @yaml.expects(:encode).with("foo").returns "bar"
+
+            @yaml.render(instance).should == "bar"
+        end
+
+        it "should render multiple instances by calling 'to_yaml' on the array" do
+            instances = [mock('instance')]
+            instances.expects(:to_yaml).returns "foo"
+            @yaml.render_multiple(instances)
+        end
+
+        it "should fixup generated yaml on render" do
+            instances = [mock('instance')]
+            instances.stubs(:to_yaml).returns "foo"
+
+            @yaml.expects(:fixup).with("foo").returns "bar"
+
+            @yaml.render(instances)
+        end
+
+        it "should encode generated yaml on render" do
+            instances = [mock('instance')]
+            instances.stubs(:to_yaml).returns "foo"
+
+            @yaml.expects(:encode).with("foo").returns "bar"
+
+            @yaml.render(instances).should == "bar"
+        end
+
+        it "should intern by calling decode" do
+            text = "foo"
+            @yaml.expects(:decode).with("foo").returns "bar"
+            @yaml.intern(String, text).should == "bar"
+        end
+
+        it "should intern multiples by calling 'decode'" do
+            text = "foo"
+            @yaml.expects(:decode).with("foo").returns "bar"
+            @yaml.intern_multiple(String, text).should == "bar"
+        end
+
+        it "should decode by base64 decoding, uncompressing and Yaml loading" do
+            Base64.expects(:decode64).with("zorg").returns "foo"
+            Zlib::Inflate.expects(:inflate).with("foo").returns "baz"
+            YAML.expects(:load).with("baz").returns "bar"
+            @yaml.decode("zorg").should == "bar"
+        end
+
+        it "should encode by compressing and base64 encoding" do
+            Zlib::Deflate.expects(:deflate).with("foo", Zlib::BEST_COMPRESSION).returns "bar"
+            Base64.expects(:encode64).with("bar").returns "baz"
+            @yaml.encode("foo").should == "baz"
+        end
+
+        it "should fixup incorrect yaml to correct" do
+            @yaml.fixup("&id004 !ruby/object:Puppet::Relationship ?").should == "? &id004 !ruby/object:Puppet::Relationship"
+        end
+    end
+
     it "should include a marshal format" do
         Puppet::Network::FormatHandler.format(:marshal).should_not be_nil
     end
@@ -173,76 +258,76 @@ describe "Puppet Network Format" do
         end
     end
 
-    it "should include a json format" do
-        Puppet::Network::FormatHandler.format(:json).should_not be_nil
+    it "should include a pson format" do
+        Puppet::Network::FormatHandler.format(:pson).should_not be_nil
     end
 
-    describe "json" do
-        confine "Missing 'json' library" => Puppet.features.json?
+    describe "pson" do
+        confine "Missing 'pson' library" => Puppet.features.pson?
 
         before do
-            @json = Puppet::Network::FormatHandler.format(:json)
+            @pson = Puppet::Network::FormatHandler.format(:pson)
         end
 
-        it "should have its mime type set to text/json" do
-            Puppet::Network::FormatHandler.format(:json).mime.should == "text/json"
+        it "should have its mime type set to text/pson" do
+            Puppet::Network::FormatHandler.format(:pson).mime.should == "text/pson"
         end
 
         it "should require the :render_method" do
-            Puppet::Network::FormatHandler.format(:json).required_methods.should be_include(:render_method)
+            Puppet::Network::FormatHandler.format(:pson).required_methods.should be_include(:render_method)
         end
 
         it "should require the :intern_method" do
-            Puppet::Network::FormatHandler.format(:json).required_methods.should be_include(:intern_method)
+            Puppet::Network::FormatHandler.format(:pson).required_methods.should be_include(:intern_method)
         end
 
         it "should have a weight of 10" do
-            @json.weight.should == 10
+            @pson.weight.should == 10
         end
 
         describe "when supported" do
-            it "should render by calling 'to_json' on the instance" do
-                instance = JsonTest.new("foo")
-                instance.expects(:to_json).returns "foo"
-                @json.render(instance).should == "foo"
+            it "should render by calling 'to_pson' on the instance" do
+                instance = PsonTest.new("foo")
+                instance.expects(:to_pson).returns "foo"
+                @pson.render(instance).should == "foo"
             end
 
-            it "should render multiple instances by calling 'to_json' on the array" do
+            it "should render multiple instances by calling 'to_pson' on the array" do
                 instances = [mock('instance')]
 
-                instances.expects(:to_json).returns "foo"
+                instances.expects(:to_pson).returns "foo"
 
-                @json.render_multiple(instances).should == "foo"
+                @pson.render_multiple(instances).should == "foo"
             end
 
-            it "should intern by calling 'JSON.parse' on the text and then using from_json to convert the data into an instance" do
+            it "should intern by calling 'PSON.parse' on the text and then using from_pson to convert the data into an instance" do
                 text = "foo"
-                JSON.expects(:parse).with("foo").returns("json_class" => "JsonTest", "data" => "foo")
-                JsonTest.expects(:from_json).with("foo").returns "parsed_json"
-                @json.intern(JsonTest, text).should == "parsed_json"
+                PSON.expects(:parse).with("foo").returns("type" => "PsonTest", "data" => "foo")
+                PsonTest.expects(:from_pson).with("foo").returns "parsed_pson"
+                @pson.intern(PsonTest, text).should == "parsed_pson"
             end
 
-            it "should not render twice if 'JSON.parse' creates the appropriate instance" do
+            it "should not render twice if 'PSON.parse' creates the appropriate instance" do
                 text = "foo"
-                instance = JsonTest.new("foo")
-                JSON.expects(:parse).with("foo").returns(instance)
-                JsonTest.expects(:from_json).never
-                @json.intern(JsonTest, text).should equal(instance)
+                instance = PsonTest.new("foo")
+                PSON.expects(:parse).with("foo").returns(instance)
+                PsonTest.expects(:from_pson).never
+                @pson.intern(PsonTest, text).should equal(instance)
             end
 
-            it "should intern by calling 'JSON.parse' on the text and then using from_json to convert the actual into an instance if the json has no class/data separation" do
+            it "should intern by calling 'PSON.parse' on the text and then using from_pson to convert the actual into an instance if the pson has no class/data separation" do
                 text = "foo"
-                JSON.expects(:parse).with("foo").returns("foo")
-                JsonTest.expects(:from_json).with("foo").returns "parsed_json"
-                @json.intern(JsonTest, text).should == "parsed_json"
+                PSON.expects(:parse).with("foo").returns("foo")
+                PsonTest.expects(:from_pson).with("foo").returns "parsed_pson"
+                @pson.intern(PsonTest, text).should == "parsed_pson"
             end
 
             it "should intern multiples by parsing the text and using 'class.intern' on each resulting data structure" do
                 text = "foo"
-                JSON.expects(:parse).with("foo").returns ["bar", "baz"]
-                JsonTest.expects(:from_json).with("bar").returns "BAR"
-                JsonTest.expects(:from_json).with("baz").returns "BAZ"
-                @json.intern_multiple(JsonTest, text).should == %w{BAR BAZ}
+                PSON.expects(:parse).with("foo").returns ["bar", "baz"]
+                PsonTest.expects(:from_pson).with("bar").returns "BAR"
+                PsonTest.expects(:from_pson).with("baz").returns "BAZ"
+                @pson.intern_multiple(PsonTest, text).should == %w{BAR BAZ}
             end
         end
     end

data/spec/unit/parser/ast/leaf.rb

@@ -195,11 +195,26 @@ describe Puppet::Parser::AST::HostName do
         host.to_classname.should == "klassname"
     end
 
+    it "should preserve '_' in to_classname with a string nodename" do
+        host = Puppet::Parser::AST::HostName.new( :value => "node_with_underscore")
+        host.to_classname.should == "node_with_underscore"
+    end
+
+    it "should preserve '_' in to_classname with a regex nodename" do
+        host = Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/\dnode_with_underscore\.+/") )
+        host.to_classname.should == "dnode_with_underscore."
+    end
+
     it "should return a string usable as classname when calling to_classname" do
         host = Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/^this-is not@a classname$/") )
         host.to_classname.should == "this-isnotaclassname"
     end
 
+    it "should return a string usable as a tag when calling to_classname" do
+        host = Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/.+.reductivelabs\.com/") )
+        host.to_classname.should == "reductivelabs.com"
+    end
+
     it "should delegate 'match' to the underlying value if it is an HostName" do
         @value.expects(:match).with("value")
         @host.match("value")

data/spec/unit/parser/collector.rb

@@ -498,35 +498,46 @@ describe Puppet::Parser::Collector, "when building its ActiveRecord query for co
         Puppet::Rails::Host.expects(:find_by_name).with(@scope.host).returns(@host)
 
         Puppet::Rails::Resource.stubs(:find).with { |*arguments|
-            options = arguments[3]
+            options = arguments[1]
             options[:conditions][0] =~ /^host_id != \?/ and options[:conditions][1] == 5
         }.returns([@resource])
 
         @collector.evaluate.should == [@resource]
     end
 
-    it "should return parameter names, parameter values when querying ActiveRecord" do
+    it "should join with parameter names, parameter values when querying ActiveRecord" do
+        @collector.equery = "param_names.name = title"
         Puppet::Rails::Resource.stubs(:find).with { |*arguments|
-            options = arguments[3]
-            options[:include] == {:param_values => :param_name}
+            options = arguments[1]
+            options[:joins] == {:param_values => :param_name}
         }.returns([@resource])
 
         @collector.evaluate.should == [@resource]
     end
 
-    it "should return tags when querying ActiveRecord with a tag exported query" do
+    it "should join with tag tables when querying ActiveRecord with a tag exported query" do
         @collector.equery = "puppet_tags.name = test"
         Puppet::Rails::Resource.stubs(:find).with { |*arguments|
-            options = arguments[3]
-            options[:include] == {:param_values => :param_name, :puppet_tags => :resource_tags}
+            options = arguments[1]
+            options[:joins] == {:resource_tags => :puppet_tag}
         }.returns([@resource])
 
         @collector.evaluate.should == [@resource]
     end
 
+    it "should not join parameters when querying ActiveRecord with a tag exported query" do
+        @collector.equery = "puppet_tags.name = test"
+        Puppet::Rails::Resource.stubs(:find).with { |*arguments|
+            options = arguments[1]
+            options[:joins] == {:param_values => :param_name}
+        }.returns([@resource])
+
+        @collector.evaluate.should be_false
+    end
+
     it "should only search for exported resources with the matching type" do
         Puppet::Rails::Resource.stubs(:find).with { |*arguments|
-            options = arguments[3]
+            options = arguments[1]
             options[:conditions][0].include?("(exported=? AND restype=?)") and options[:conditions][1] == true and options[:conditions][2] == "Mytype"
         }.returns([@resource])
 
@@ -536,7 +547,7 @@ describe Puppet::Parser::Collector, "when building its ActiveRecord query for co
     it "should include the export query if one is provided" do
         @collector.equery = "test = true"
         Puppet::Rails::Resource.stubs(:find).with { |*arguments|
-            options = arguments[3]
+            options = arguments[1]
             options[:conditions][0].include?("test = true")
         }.returns([@resource])
 

data/spec/unit/parser/compiler.rb

@@ -86,6 +86,16 @@ describe Puppet::Parser::Compiler do
         it "should copy the parser version to the catalog" do
             @compiler.catalog.version.should == @parser.version
         end
+
+        it "should copy any node classes into the class list" do
+            node = Puppet::Node.new("mynode")
+            node.classes = %w{foo bar}
+            compiler = Puppet::Parser::Compiler.new(node, @parser)
+            p compiler.classlist
+
+            compiler.classlist.should include("foo")
+            compiler.classlist.should include("bar")
+        end
     end
 
     describe "when managing scopes" do
@@ -131,6 +141,15 @@ describe Puppet::Parser::Compiler do
             @compiler.topscope.lookupvar("c").should == "d"
         end
 
+        it "should set the client and server versions on the catalog" do
+            params = {"clientversion" => "2", "serverversion" => "3"}
+            @node.stubs(:parameters).returns(params)
+            compile_stub(:set_node_parameters)
+            @compiler.compile
+            @compiler.catalog.client_version.should == "2"
+            @compiler.catalog.server_version.should == "3"
+        end
+
         it "should evaluate any existing classes named in the node" do
             classes = %w{one two three four}
             main = stub 'main'

data/spec/unit/parser/functions/fqdn_rand.rb

@@ -0,0 +1,62 @@
+#! /usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the fqdn_rand function" do
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function("fqdn_rand").should == "function_fqdn_rand"
+    end
+
+    it "should handle 0 arguments" do
+        @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+        lambda { @scope.function_fqdn_rand([]) }.should_not raise_error(Puppet::ParseError)
+    end
+
+    it "should handle 1 argument'}" do
+        @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+        lambda { @scope.function_fqdn_rand([3]) }.should_not raise_error(Puppet::ParseError)
+    end
+
+
+    (1..10).each { |n|
+        it "should handle #{n} additional arguments" do
+            @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+            lambda { @scope.function_fqdn_rand([3,1,2,3,4,5,6,7,8,9,10][0..n]) }.should_not raise_error(Puppet::ParseError)
+        end
+        it "should handle #{n} additional string arguments" do
+            @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+            lambda { @scope.function_fqdn_rand([3,%w{ 1 2 3 4 5 6 7 8 9 10}].flatten[0..n]) }.should_not raise_error(Puppet::ParseError)
+        end
+    }
+
+    it "should return a value less than max" do
+        @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+        @scope.function_fqdn_rand([3]).should satisfy {|n| n.to_i < 3 }
+    end
+
+    it "should return the same values on subsequent invocations for the same host" do
+        @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1").twice
+        @scope.function_fqdn_rand([3,4]).should eql(@scope.function_fqdn_rand([3, 4]))
+    end
+
+    it "should return different sequences of value for different hosts" do
+        @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+        val1 = @scope.function_fqdn_rand([10000000,4])
+        @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.2")
+        val2 = @scope.function_fqdn_rand([10000000,4])
+        val1.should_not eql(val2)
+    end
+
+    it "should return different values for the same hosts with different seeds" do
+        @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+        val1 = @scope.function_fqdn_rand([10000000,4])
+        @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
+        val2 = @scope.function_fqdn_rand([10000000,42])
+        val1.should_not eql(val2)
+    end
+end

data/spec/unit/parser/functions/regsubst.rb

@@ -28,6 +28,26 @@ describe "the regsubst function" do
             raise_error(Puppet::ParseError))
     end
 
+    it "should raise a ParseError for non-string and non-array target" do
+        lambda { @scope.function_regsubst([4711, "bar", "gazonk"]) }.should(
+            raise_error(Puppet::ParseError))
+    end
+
+    it "should raise a ParseError for array target with non-string element" do
+        lambda { @scope.function_regsubst([["x", ["y"], "z"], "bar", "gazonk"]) }.should(
+            raise_error(Puppet::ParseError))
+    end
+
+    it "should raise a ParseError for a bad regular expression" do
+        lambda { @scope.function_regsubst(["foo", "(bar", "gazonk"]) }.should(
+            raise_error(Puppet::ParseError))
+    end
+
+    it "should raise a ParseError for a non-string regular expression" do
+        lambda { @scope.function_regsubst(["foo", ["bar"], "gazonk"]) }.should(
+            raise_error(Puppet::ParseError))
+    end
+
     it "should handle groups" do
         result = @scope.function_regsubst(
             [ '130.236.254.10',
@@ -85,4 +105,64 @@ describe "the regsubst function" do
         result.should(eql('<130>.<236>.<254>.<10>'))
     end
 
+    it "should apply on all elements of an array" do
+        data = ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40']
+        result = @scope.function_regsubst([ data, '[.]', '-'])
+        result.should(eql(
+            ['130-236.254.10', 'foo-example.com', 'coconut', '10-20.30.40']))
+    end
+
+    it "should apply global substitutions on all elements of an array" do
+        data = ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40']
+        result = @scope.function_regsubst([ data, '[.]', '-', 'G'])
+        result.should(eql(
+            ['130-236-254-10', 'foo-example-com', 'coconut', '10-20-30-40']))
+    end
+
+    it "should handle groups on all elements of an array" do
+        data = ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40']
+        result = @scope.function_regsubst(
+            [ data,
+              '^([0-9]+)[.]([0-9]+)[.]([0-9]+)[.]([0-9]+)$',
+              '\4-\3-\2-\1'
+            ])
+        result.should(eql(
+            ['10-254-236-130', 'foo.example.com', 'coconut', '40-30-20-10']))
+    end
+
+    it "should handle global substitutions with groups on all elements of an array" do
+        data = ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40']
+        result = @scope.function_regsubst(
+            [ data,
+              '([^.]+)',
+              '<\1>',
+              'G'
+            ])
+        result.should(eql(
+            ['<130>.<236>.<254>.<10>', '<foo>.<example>.<com>',
+             '<coconut>', '<10>.<20>.<30>.<40>']))
+    end
+
+    it "should return an array (not a string) for a single element array parameter" do
+        data = ['130.236.254.10']
+        result = @scope.function_regsubst(
+            [ data,
+              '([^.]+)',
+              '<\1>',
+              'G'
+            ])
+        result.should(eql(['<130>.<236>.<254>.<10>']))
+    end
+
+    it "should return a string (not a one element array) for a simple string parameter" do
+        data = '130.236.254.10'
+        result = @scope.function_regsubst(
+            [ data,
+              '([^.]+)',
+              '<\1>',
+              'G'
+            ])
+        result.should(eql('<130>.<236>.<254>.<10>'))
+    end
+
 end