puppet 0.25.0 → 0.25.1

data/spec/integration/parser/functions/require.rb

@@ -10,6 +10,7 @@ describe "the require function" do
         @compiler = Puppet::Parser::Compiler.new(@node, @parser)
 
         @compiler.send(:evaluate_main)
+        @compiler.catalog.client_version = "0.25"
         @scope = @compiler.topscope
         # preload our functions
         Puppet::Parser::Functions.function(:include)
@@ -20,10 +21,11 @@ describe "the require function" do
         @parser.newclass("requiredclass")
 
         @scope.function_require("requiredclass")
-
-        @compiler.catalog.edge?(@scope.resource,@compiler.findresource(:class,"requiredclass")).should be_true
+        @scope.resource["require"].should_not be_nil
+        ref = @scope.resource["require"]
+        ref.type.should == "Class"
+        ref.title.should == "requiredclass"
     end
-
 end
 
 describe "the include function" do

data/spec/integration/provider/mailalias/aliases.rb

@@ -17,9 +17,9 @@ describe provider_class do
     end
 
     # #1560
-    it "should be able to parse each example" do
-        fakedata("data/providers/mailalias/aliases").each { |file|
+    PuppetTest.fakedata("data/providers/mailalias/aliases").each { |file|
+        it "should be able to parse the examples in #{file}" do
             fakedataparse(file)
-        }
-    end
+        end
+    }
 end

data/spec/integration/resource/catalog.rb

@@ -6,10 +6,10 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Resource::Catalog do
-    describe "when json is available" do
-        confine "JSON library is missing" => Puppet.features.json?
-        it "should support json" do
-            Puppet::Resource::Catalog.supported_formats.should be_include(:json)
+    describe "when pson is available" do
+        confine "PSON library is missing" => Puppet.features.pson?
+        it "should support pson" do
+            Puppet::Resource::Catalog.supported_formats.should be_include(:pson)
         end
     end
 

data/spec/unit/application/puppet.rb

@@ -143,6 +143,7 @@ describe "Puppet" do
                 @interpreter = stub_everything
                 Puppet.stubs(:err)
                 @puppet.stubs(:exit)
+                @puppet.options.stubs(:[]).with(:code).returns "some code"
                 Puppet::Parser::Interpreter.stubs(:new).returns(@interpreter)
             end
 
@@ -331,17 +332,17 @@ describe "Puppet" do
         end
 
         describe "the 'apply' command" do
-            confine "JSON library is missing; cannot test applying catalogs" => Puppet.features.json?
+            confine "PSON library is missing; cannot test applying catalogs" => Puppet.features.pson?
 
             before do
-                #Puppet::Resource::Catalog.stubs(:json_create).returns Puppet::Resource::Catalog.new
-                JSON.stubs(:parse).returns Puppet::Resource::Catalog.new
+                #Puppet::Resource::Catalog.stubs(:pson_create).returns Puppet::Resource::Catalog.new
+                PSON.stubs(:parse).returns Puppet::Resource::Catalog.new
             end
 
             it "should read the catalog in from disk if a file name is provided" do
-                @puppet.options[:catalog] = "/my/catalog.json"
+                @puppet.options[:catalog] = "/my/catalog.pson"
 
-                File.expects(:read).with("/my/catalog.json").returns "something"
+                File.expects(:read).with("/my/catalog.pson").returns "something"
 
                 @puppet.apply
             end
@@ -354,41 +355,41 @@ describe "Puppet" do
                 @puppet.apply
             end
 
-            it "should deserialize the catalog from json" do
-                @puppet.options[:catalog] = "/my/catalog.json"
+            it "should deserialize the catalog from pson" do
+                @puppet.options[:catalog] = "/my/catalog.pson"
 
                 File.expects(:read).returns "something"
-                JSON.expects(:parse).with("something").returns Puppet::Resource::Catalog.new
+                PSON.expects(:parse).with("something").returns Puppet::Resource::Catalog.new
 
                 @puppet.apply
             end
 
             it "should fail helpfully if deserializing fails" do
-                @puppet.options[:catalog] = "/my/catalog.json"
+                @puppet.options[:catalog] = "/my/catalog.pson"
 
                 File.expects(:read).returns "something"
-                JSON.expects(:parse).raises ArgumentError
+                PSON.expects(:parse).raises ArgumentError
 
                 lambda { @puppet.apply }.should raise_error(Puppet::Error)
             end
 
             it "should convert plain data structures into a catalog if deserialization does not do so" do
-                @puppet.options[:catalog] = "/my/catalog.json"
+                @puppet.options[:catalog] = "/my/catalog.pson"
 
                 File.expects(:read).returns "something"
-                JSON.expects(:parse).with("something").returns({:foo => "bar"})
-                Puppet::Resource::Catalog.expects(:json_create).with({:foo => "bar"}).returns(Puppet::Resource::Catalog.new)
+                PSON.expects(:parse).with("something").returns({:foo => "bar"})
+                Puppet::Resource::Catalog.expects(:pson_create).with({:foo => "bar"}).returns(Puppet::Resource::Catalog.new)
 
                 @puppet.apply
             end
 
             it "should convert the catalog to a RAL catalog and use a Configurer instance to apply it" do
-                @puppet.options[:catalog] = "/my/catalog.json"
+                @puppet.options[:catalog] = "/my/catalog.pson"
 
                 File.expects(:read).returns "something"
 
                 catalog = Puppet::Resource::Catalog.new
-                JSON.expects(:parse).returns catalog
+                PSON.expects(:parse).returns catalog
 
                 catalog.expects(:to_ral).returns "mycatalog"
 

data/spec/unit/application/puppetd.rb

@@ -40,7 +40,7 @@ describe "puppetd" do
 
     describe "in preinit" do
         before :each do
-            @pupetd.stubs(:trap)
+            @puppetd.stubs(:trap)
         end
 
         it "should catch INT" do

data/spec/unit/application/puppetdoc.rb

@@ -320,6 +320,12 @@ describe "puppetdoc" do
                 @puppetdoc.rdoc
             end
 
+            it "should call Puppet::Util::RDoc.rdoc in full mode with outputdir set to doc if no --outputdir" do
+                @puppetdoc.options.expects(:[]).with(:outputdir).returns(false)
+                Puppet::Util::RDoc.expects(:rdoc).with('doc', ['modules','manifests'])
+                @puppetdoc.rdoc
+            end
+
             it "should call Puppet::Util::RDoc.manifestdoc in manifest mode" do
                 @puppetdoc.manifest = true
                 Puppet::Util::RDoc.expects(:manifestdoc)

data/spec/unit/application/puppetmasterd.rb

@@ -294,11 +294,11 @@ describe "PuppetMaster" do
                 Puppet.stubs(:err)
                 @puppetmasterd.stubs(:exit)
                 Puppet::Parser::Interpreter.stubs(:new).returns(@interpreter)
-                Puppet.features.stubs(:json?).returns true
+                Puppet.features.stubs(:pson?).returns true
             end
 
-            it "should fail if json isn't available" do
-                Puppet.features.expects(:json?).returns false
+            it "should fail if pson isn't available" do
+                Puppet.features.expects(:pson?).returns false
                 lambda { @puppetmasterd.compile }.should raise_error
             end
 
@@ -310,13 +310,13 @@ describe "PuppetMaster" do
                 @puppetmasterd.compile
             end
 
-            it "should render the catalog to json and print the output" do
+            it "should render the catalog to pson and print the output" do
                 @puppetmasterd.options[:node] = "foo"
                 catalog = Puppet::Resource::Catalog.new
-                catalog.expects(:render).with(:json).returns "myjson"
+                catalog.expects(:render).with(:pson).returns "mypson"
                 Puppet::Resource::Catalog.expects(:find).returns catalog
 
-                $stdout.expects(:puts).with("myjson")
+                $stdout.expects(:puts).with("mypson")
                 @puppetmasterd.compile
             end
 

data/spec/unit/configurer/fact_handler.rb

@@ -102,7 +102,7 @@ describe Puppet::Configurer::FactHandler do
 
         @facthandler.expects(:find_facts).returns facts
 
-        @facthandler.facts_for_uploading.should == {:facts_format => :yaml, :facts => text}
+        @facthandler.facts_for_uploading.should == {:facts_format => :b64_zlib_yaml, :facts => text}
     end
 
     it "should properly accept facts containing a '+'" do
@@ -112,12 +112,12 @@ describe Puppet::Configurer::FactHandler do
 
         @facthandler.expects(:find_facts).returns facts
 
-        @facthandler.facts_for_uploading.should == {:facts_format => :yaml, :facts => text}
+        @facthandler.facts_for_uploading.should == {:facts_format => :b64_zlib_yaml, :facts => text}
     end
 
     it "should hard-code yaml as the serialization" do
         facts = stub 'facts'
-        facts.expects(:render).with(:yaml).returns "my text"
+        facts.expects(:render).with(:b64_zlib_yaml).returns "my text"
         text = CGI.escape("my text")
 
         @facthandler.expects(:find_facts).returns facts

data/spec/unit/file_serving/configuration.rb

@@ -104,17 +104,31 @@ describe Puppet::FileServing::Configuration do
 
         it "should allow all access to modules and plugins if no fileserver.conf exists" do
             FileTest.expects(:exists?).returns false # the file doesn't exist
-            modules = stub 'modules'
+            modules = stub 'modules', :empty? => true
             Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
             modules.expects(:allow).with('*')
 
-            plugins = stub 'plugins'
+            plugins = stub 'plugins', :empty? => true
             Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
             plugins.expects(:allow).with('*')
 
             Puppet::FileServing::Configuration.create
         end
 
+        it "should not allow access from all to modules and plugins if the fileserver.conf provided some rules" do
+            FileTest.expects(:exists?).returns false # the file doesn't exist
+
+            modules = stub 'modules', :empty? => false
+            Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
+            modules.expects(:allow).with('*').never
+
+            plugins = stub 'plugins', :empty? => false
+            Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
+            plugins.expects(:allow).with('*').never
+
+            Puppet::FileServing::Configuration.create
+        end
+
         it "should add modules and plugins mounts even if they are not returned by the parser" do
             @parser.expects(:parse).returns("one" => mock("mount"))
             FileTest.expects(:exists?).returns true # the file doesn't exist

data/spec/unit/indirector/certificate/rest.rb

@@ -20,4 +20,38 @@ describe Puppet::SSL::Certificate::Rest do
     it "should set port_setting to :ca_port" do
         Puppet::SSL::Certificate::Rest.port_setting.should == :ca_port
     end
+
+    it "should make sure found certificates have their names set to the search string" do
+        terminus = Puppet::SSL::Certificate::Rest.new
+
+        # This has 'boo.com' in the CN
+        cert_string = "-----BEGIN CERTIFICATE-----
+MIICPzCCAaigAwIBAgIBBDANBgkqhkiG9w0BAQUFADAWMRQwEgYDVQQDDAtidWNr
+eS5sb2NhbDAeFw0wOTA5MTcxNzI1MzJaFw0xNDA5MTYxNzI1MzJaMBIxEDAOBgNV
+BAMMB2Jvby5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAKG9B+DkTCNh
+F5xHchNDfnbC9NzWKM600oxrr84pgUVAG6B2wAZcdfoEtXszhsY9Jzpwqkvxk4Mx
+AbYqo9+TCi4UoiH6e+vAKOOJD3DHrlf+/RW4hGtyaI41DBhf4+B4/oFz5PH9mvKe
+NSfHFI/yPW+1IXYjxKLQNwF9E7q3JbnzAgMBAAGjgaAwgZ0wOAYJYIZIAYb4QgEN
+BCsWKVB1cHBldCBSdWJ5L09wZW5TU0wgR2VuZXJhdGVkIENlcnRpZmljYXRlMAwG
+A1UdEwEB/wQCMAAwHQYDVR0OBBYEFJOxEUeyf4cNOBmf9zIaE1JTuNdLMAsGA1Ud
+DwQEAwIFoDAnBgNVHSUEIDAeBggrBgEFBQcDAQYIKwYBBQUHAwIGCCsGAQUFBwME
+MA0GCSqGSIb3DQEBBQUAA4GBAFTJxKprMg6tfhGnvEvURPmlJrINn9c2b5Y4AGYp
+tO86PFFkWw/EIJvvJzbj3s+Butr+eUo//+f1xxX7UCwwGqGxKqjtVS219oU/wkx8
+h7rW4Xk7MrLl0auSS1p4wLcAMm+ZImf94+j8Cj+tkr8eGozZceRV13b8+EkdaE3S
+rn/G
+-----END CERTIFICATE-----
+"
+
+        network = stub 'network'
+        terminus.stubs(:network).returns network
+
+        response = stub 'response', :code => "200", :body => cert_string
+        response.stubs(:[]).with('content-type').returns "text/plain"
+        network.expects(:get).returns response
+
+        request = Puppet::Indirector::Request.new(:certificate, :find, "foo.com")
+        result = terminus.find(request)
+        result.should_not be_nil
+        result.name.should == "foo.com"
+    end
 end

data/spec/unit/indirector/queue.rb

@@ -9,25 +9,25 @@ end
 class FooExampleData
     attr_accessor :name
 
-    def self.json_create(json)
-        new(json['data'].to_sym)
+    def self.pson_create(pson)
+        new(pson['data'].to_sym)
     end
 
     def initialize(name = nil)
         @name = name if name
     end
 
-    def render(format = :json)
-        to_json
+    def render(format = :pson)
+        to_pson
     end
 
-    def to_json(*args)
-        {:json_class => self.class.to_s, :data => name}.to_json(*args)
+    def to_pson(*args)
+        {:type => self.class.to_s, :data => name}.to_pson(*args)
     end
 end
 
 describe Puppet::Indirector::Queue do
-    confine "JSON library is missing; cannot test queueing" => Puppet.features.json?
+    confine "PSON library is missing; cannot test queueing" => Puppet.features.pson?
 
     before :each do
         @model = mock 'model'
@@ -51,8 +51,8 @@ describe Puppet::Indirector::Queue do
         @request = stub 'request', :key => :me, :instance => @subject
     end
 
-    it "should require JSON" do
-        Puppet.features.expects(:json?).returns false
+    it "should require PSON" do
+        Puppet.features.expects(:pson?).returns false
 
         lambda { @store_class.new }.should raise_error(ArgumentError)
     end
@@ -63,16 +63,16 @@ describe Puppet::Indirector::Queue do
     end
 
     describe "when saving" do
-        it 'should render the instance using json' do
-            @subject.expects(:render).with(:json)
+        it 'should render the instance using pson' do
+            @subject.expects(:render).with(:pson)
             @store.client.stubs(:send_message)
             @store.save(@request)
         end
 
         it "should send the rendered message to the appropriate queue on the client" do
-            @subject.expects(:render).returns "myjson"
+            @subject.expects(:render).returns "mypson"
 
-            @store.client.expects(:send_message).with(:my_queue, "myjson")
+            @store.client.expects(:send_message).with(:my_queue, "mypson")
 
             @store.save(@request)
         end
@@ -89,8 +89,8 @@ describe Puppet::Indirector::Queue do
             @store_class.stubs(:model).returns @model
         end
 
-        it "should use the model's Format support to intern the message from json" do
-            @model.expects(:convert_from).with(:json, "mymessage")
+        it "should use the model's Format support to intern the message from pson" do
+            @model.expects(:convert_from).with(:pson, "mymessage")
 
             @store_class.client.expects(:subscribe).yields("mymessage")
             @store_class.subscribe {|o| o }

data/spec/unit/indirector/rest.rb

@@ -90,15 +90,37 @@ describe Puppet::Indirector::REST do
             @searcher.deserialize(response).should be_nil
         end
 
-        it "should fail if the response code is not in the 200s" do
-            @model.expects(:convert_from).never
-
-            response = mock 'response'
-            response.stubs(:code).returns "300"
-            response.stubs(:message).returns "There was a problem"
-
-            lambda { @searcher.deserialize(response) }.should raise_error(Net::HTTPError)
-        end
+        [300,400,403,405,500,501,502,503,504].each { |rc|
+            describe "when the response code is #{rc}" do
+                before :each do
+                    @model.expects(:convert_from).never
+
+                    @response = mock 'response'
+                    @response.stubs(:code).returns rc.to_s
+                    @response.stubs(:message).returns "There was a problem (header)"
+                end
+
+                it "should fail" do
+                    @response.stubs(:body).returns nil
+                    lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError)
+                end
+
+                it "should take the error message from the body, if present" do
+                    @response.stubs(:body).returns "There was a problem (body)"
+                    lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError,"Error #{rc} on SERVER: There was a problem (body)")
+                end
+
+                it "should take the error message from the response header if the body is empty" do
+                    @response.stubs(:body).returns ""
+                    lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError,"Error #{rc} on SERVER: There was a problem (header)")
+                end
+
+                it "should take the error message from the response header if the body is absent" do
+                    @response.stubs(:body).returns nil
+                    lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError,"Error #{rc} on SERVER: There was a problem (header)")
+                end
+            end
+        }    
 
         it "should return the results of converting from the format specified by the content-type header if the response code is in the 200s" do
             @model.expects(:convert_from).with("myformat", "mydata").returns "myobject"

data/spec/unit/network/authstore.rb

@@ -4,27 +4,78 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/network/authconfig'
 
-describe Puppet::Network::AuthStore::Declaration do
-
-    describe "when the pattern is simple numeric IP" do
+describe Puppet::Network::AuthStore do
+    describe "when checking if the acl has some entries" do
         before :each do
-            @ip = '100.101.99.98'
-            @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,@ip)
+            @authstore = Puppet::Network::AuthStore.new
         end
-        it "should match the specified IP" do
-            @declaration.should be_match('www.testsite.org',@ip)
+
+        it "should be empty if no ACE have been entered" do
+            @authstore.should be_empty
         end
-        it "should not match other IPs" do
-            @declaration.should_not be_match('www.testsite.org','200.101.99.98')
+
+        it "should not be empty if it is a global allow" do
+            @authstore.allow('*')
+
+            @authstore.should_not be_empty
+        end
+
+        it "should not be empty if at least one allow has been entered" do
+            @authstore.allow('1.1.1.*')
+
+            @authstore.should_not be_empty
+        end
+
+        it "should not be empty if at least one deny has been entered" do
+            @authstore.deny('1.1.1.*')
+
+            @authstore.should_not be_empty
         end
     end
+end
+
+describe Puppet::Network::AuthStore::Declaration do
+
+    ['100.101.99.98','100.100.100.100','1.2.3.4','11.22.33.44'].each { |ip|
+        describe "when the pattern is a simple numeric IP such as #{ip}" do
+            before :each do
+                @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,ip)
+            end
+            it "should match the specified IP" do
+                @declaration.should be_match('www.testsite.org',ip)
+            end
+            it "should not match other IPs" do
+                @declaration.should_not be_match('www.testsite.org','200.101.99.98')
+            end
+        end
+
+        (1..3).each { |n|
+            describe "when the pattern is a IP mask with #{n} numeric segments and a *" do
+                before :each do
+                    @ip_pattern = ip.split('.')[0,n].join('.')+'.*'
+                    @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,@ip_pattern)
+                end
+                it "should match an IP in the range" do
+                    @declaration.should be_match('www.testsite.org',ip)
+                end
+                it "should not match other IPs" do
+                    @declaration.should_not be_match('www.testsite.org','200.101.99.98')
+                end
+                it "should not match IPs that differ in the last non-wildcard segment" do
+                    other = ip.split('.')
+                    other[n-1].succ!
+                    @declaration.should_not be_match('www.testsite.org',other.join('.'))
+                end
+            end
+        }    
+    }
 
     describe "when the pattern is a numeric IP with a back reference" do
         before :each do
             @ip = '100.101.$1'
             @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,@ip).interpolate('12.34'.match(/(.*)/))
         end
-        it "should match an IP with the apropriate interpolation" do
+        it "should match an IP with the appropriate interpolation" do
             @declaration.should be_match('www.testsite.org',@ip.sub(/\$1/,'12.34'))
         end
         it "should not match other IPs" do
@@ -32,20 +83,25 @@ describe Puppet::Network::AuthStore::Declaration do
         end
     end
 
-    describe "when the pattern is a PQDN" do
-        before :each do
-            @host = 'spirit.mars.nasa.gov'
-            @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,@host)
-        end
-        it "should match the specified PQDN" do
-            pending "FQDN consensus"
-            @declaration.should be_match(@host,'200.101.99.98')
-        end
-        it "should not match a similar FQDN" do
-            pending "FQDN consensus"
-            @declaration.should_not be_match(@host+'.','200.101.99.98')
-        end
-    end
+    {
+    'spirit.mars.nasa.gov' => 'a PQDN',
+    'ratchet.2ndsiteinc.com' => 'a PQDN with digits',
+    'a.c.ru' => 'a PQDN with short segments',
+    }.each {|pqdn,desc|
+        describe "when the pattern is #{desc}" do
+            before :each do
+                @host = pqdn
+                @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,@host)
+            end
+            it "should match the specified PQDN" do
+                @declaration.should be_match(@host,'200.101.99.98')
+            end
+            it "should not match a similar FQDN" do
+                pending "FQDN consensus"
+                @declaration.should_not be_match(@host+'.','200.101.99.98')
+            end
+        end
+    }
 
     describe "when the pattern is a FQDN" do
         before :each do
@@ -57,7 +113,6 @@ describe Puppet::Network::AuthStore::Declaration do
             @declaration.should be_match(@host,'200.101.99.98')
         end
         it "should not match a similar PQDN" do
-            #pending "FQDN consensus"
             @declaration.should_not be_match(@host[0..-2],'200.101.99.98')
         end
     end
@@ -70,7 +125,31 @@ describe Puppet::Network::AuthStore::Declaration do
             @pattern = %{^/catalog/([^/]+)$}
             @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,'$1')
         end
-        it "should match an IP with the apropriate interpolation" do
+        it "should match an IP with the appropriate interpolation" do
+            @declaration.interpolate(@item.match(@pattern)).should be_match(@host,'10.0.0.5')
+        end
+    end
+
+    describe "when the pattern is an opaque string with a back reference and the matched data contains dots" do
+        before :each do
+            @host = 'admin.mgmt.nym1'
+            @item = "/catalog/#{@host}"
+            @pattern = %{^/catalog/([^/]+)$}
+            @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,'$1')
+        end
+        it "should match a name with the appropriate interpolation" do
+            @declaration.interpolate(@item.match(@pattern)).should be_match(@host,'10.0.0.5')
+        end
+    end
+
+    describe "when the pattern is an opaque string with a back reference and the matched data contains dots with an initial prefix that looks like an IP address" do
+        before :each do
+            @host = '01.admin.mgmt.nym1'
+            @item = "/catalog/#{@host}"
+            @pattern = %{^/catalog/([^/]+)$}
+            @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,'$1')
+        end
+        it "should match a name with the appropriate interpolation" do
             @declaration.interpolate(@item.match(@pattern)).should be_match(@host,'10.0.0.5')
         end
     end