puppet 0.24.9 → 0.25.0

data/spec/unit/indirector/key/ca.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-3-7.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/key/ca'
+
+describe Puppet::SSL::Key::Ca do
+    it "should have documentation" do
+        Puppet::SSL::Key::Ca.doc.should be_instance_of(String)
+    end
+
+    it "should use the :privatekeydir as the collection directory" do
+        Puppet.settings.expects(:value).with(:privatekeydir).returns "/key/dir"
+        Puppet::SSL::Key::Ca.collection_directory.should == "/key/dir"
+    end
+
+    it "should store the ca key at the :cakey location" do
+        Puppet.settings.stubs(:use)
+        Puppet.settings.stubs(:value).returns "whatever"
+        Puppet.settings.stubs(:value).with(:cakey).returns "/ca/key"
+        file = Puppet::SSL::Key::Ca.new
+        file.stubs(:ca?).returns true
+        file.path("whatever").should == "/ca/key"
+    end
+end

data/spec/unit/indirector/key/file.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-3-7.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/key/file'
+
+describe Puppet::SSL::Key::File do
+    it "should have documentation" do
+        Puppet::SSL::Key::File.doc.should be_instance_of(String)
+    end
+
+    it "should use the :privatekeydir as the collection directory" do
+        Puppet.settings.expects(:value).with(:privatekeydir).returns "/key/dir"
+        Puppet::SSL::Key::File.collection_directory.should == "/key/dir"
+    end
+
+    it "should store the ca key at the :cakey location" do
+        Puppet.settings.stubs(:use)
+        Puppet.settings.stubs(:value).returns "whatever"
+        Puppet.settings.stubs(:value).with(:cakey).returns "/ca/key"
+        file = Puppet::SSL::Key::File.new
+        file.stubs(:ca?).returns true
+        file.path("whatever").should == "/ca/key"
+    end
+
+    describe "when choosing the path for the public key" do
+        it "should use the :capub setting location if the key is for the certificate authority" do
+            Puppet.settings.stubs(:value).returns "/fake/dir"
+            Puppet.settings.stubs(:value).with(:capub).returns "/ca/pubkey"
+            Puppet.settings.stubs(:use)
+
+            @searcher = Puppet::SSL::Key::File.new
+            @searcher.stubs(:ca?).returns true
+            @searcher.public_key_path("whatever").should == "/ca/pubkey"
+        end
+
+        it "should use the host name plus '.pem' in :publickeydir for normal hosts" do
+            Puppet.settings.stubs(:value).with(:privatekeydir).returns "/private/key/dir"
+            Puppet.settings.stubs(:value).with(:publickeydir).returns "/public/key/dir"
+            Puppet.settings.stubs(:use)
+
+            @searcher = Puppet::SSL::Key::File.new
+            @searcher.stubs(:ca?).returns false
+            @searcher.public_key_path("whatever").should == "/public/key/dir/whatever.pem"
+        end
+    end
+
+    describe "when managing private keys" do
+        before do
+            @searcher = Puppet::SSL::Key::File.new
+
+            @private_key_path = File.join("/fake/key/path")
+            @public_key_path = File.join("/other/fake/key/path")
+
+            @searcher.stubs(:public_key_path).returns @public_key_path
+            @searcher.stubs(:path).returns @private_key_path
+
+            FileTest.stubs(:directory?).returns true
+            FileTest.stubs(:writable?).returns true
+
+            @public_key = stub 'public_key'
+            @real_key = stub 'sslkey', :public_key => @public_key
+
+            @key = stub 'key', :name => "myname", :content => @real_key
+
+            @request = stub 'request', :key => "myname", :instance => @key
+        end
+
+        it "should save the public key when saving the private key" do
+            Puppet.settings.stubs(:writesub)
+
+            fh = mock 'filehandle'
+
+            Puppet.settings.expects(:writesub).with(:publickeydir, @public_key_path).yields fh
+            @public_key.expects(:to_pem).returns "my pem"
+
+            fh.expects(:print).with "my pem"
+
+            @searcher.save(@request)
+        end
+
+        it "should destroy the public key when destroying the private key" do
+            File.stubs(:unlink).with(@private_key_path)
+            FileTest.stubs(:exist?).with(@private_key_path).returns true
+            FileTest.expects(:exist?).with(@public_key_path).returns true
+            File.expects(:unlink).with(@public_key_path)
+
+            @searcher.destroy(@request)
+        end
+
+        it "should not fail if the public key does not exist when deleting the private key" do
+            File.stubs(:unlink).with(@private_key_path)
+
+            FileTest.stubs(:exist?).with(@private_key_path).returns true
+            FileTest.expects(:exist?).with(@public_key_path).returns false
+            File.expects(:unlink).with(@public_key_path).never
+
+            @searcher.destroy(@request)
+        end
+    end
+end

data/spec/unit/indirector/node/active_record.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/node'
+
+describe "Puppet::Node::ActiveRecord" do
+    confine "Missing Rails" => Puppet.features.rails?
+    before do 
+        require 'puppet/indirector/node/active_record'
+    end
+
+    it "should be a subclass of the ActiveRecord terminus class" do
+        Puppet::Node::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
+    end
+
+    it "should use Puppet::Rails::Host as its ActiveRecord model" do
+        Puppet::Node::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
+    end
+
+    it "should call fact_merge when a node is found" do
+        db_instance = stub 'db_instance'
+        Puppet::Node::ActiveRecord.ar_model.expects(:find_by_name).returns db_instance
+
+        node = Puppet::Node.new("foo")
+        db_instance.expects(:to_puppet).returns node
+        ar = Puppet::Node::ActiveRecord.new
+
+        node.expects(:fact_merge)
+
+        request = Puppet::Indirector::Request.new(:node, :find, "what.ever")
+        ar.find(request)
+    end
+end

data/spec/unit/indirector/node/ldap.rb

@@ -12,7 +12,7 @@ describe Puppet::Node::Ldap do
     describe "when searching for a single node" do
         before :each do
             @searcher = Puppet::Node::Ldap.new
-            
+
             @name = "mynode.domain.com"
             @node = stub 'node', :name => @name, :name= => nil
             @node.stub_everything

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

@@ -8,6 +8,6 @@ describe Puppet::Node::Rest do
     before do
         @searcher = Puppet::Node::Rest.new
     end
-    
-    
+
+
 end

data/spec/unit/indirector/queue.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/indirector/queue'
+
+class Puppet::Indirector::Queue::TestClient
+end
+
+class FooExampleData
+    attr_accessor :name
+
+    def self.json_create(json)
+        new(json['data'].to_sym)
+    end
+
+    def initialize(name = nil)
+        @name = name if name
+    end
+
+    def render(format = :json)
+        to_json
+    end
+
+    def to_json(*args)
+        {:json_class => self.class.to_s, :data => name}.to_json(*args)
+    end
+end
+
+describe Puppet::Indirector::Queue do
+    confine "JSON library is missing; cannot test queueing" => Puppet.features.json?
+
+    before :each do
+        @model = mock 'model'
+        @indirection = stub 'indirection', :name => :my_queue, :register_terminus_type => nil, :model => @model
+        Puppet::Indirector::Indirection.stubs(:instance).with(:my_queue).returns(@indirection)
+        @store_class = Class.new(Puppet::Indirector::Queue) do
+            def self.to_s
+                'MyQueue::MyType'
+            end
+        end
+        @store = @store_class.new
+
+        @subject_class = FooExampleData
+        @subject = @subject_class.new
+        @subject.name = :me
+
+        Puppet.settings.stubs(:value).returns("bogus setting data")
+        Puppet.settings.stubs(:value).with(:queue_type).returns(:test_client)
+        Puppet::Util::Queue.stubs(:queue_type_to_class).with(:test_client).returns(Puppet::Indirector::Queue::TestClient)
+
+        @request = stub 'request', :key => :me, :instance => @subject
+    end
+
+    it "should require JSON" do
+        Puppet.features.expects(:json?).returns false
+
+        lambda { @store_class.new }.should raise_error(ArgumentError)
+    end
+
+    it 'should use the correct client type and queue' do
+        @store.queue.should == :my_queue
+        @store.client.should be_an_instance_of(Puppet::Indirector::Queue::TestClient)
+    end
+
+    describe "when saving" do
+        it 'should render the instance using json' do
+            @subject.expects(:render).with(:json)
+            @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"
+
+            @store.client.expects(:send_message).with(:my_queue, "myjson")
+
+            @store.save(@request)
+        end
+
+        it "should catch any exceptions raised" do
+            @store.client.expects(:send_message).raises ArgumentError
+
+            lambda { @store.save(@request) }.should raise_error(Puppet::Error)
+        end
+    end
+
+    describe "when subscribing to the queue" do
+        before 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")
+
+            @store_class.client.expects(:subscribe).yields("mymessage")
+            @store_class.subscribe {|o| o }
+        end
+
+        it "should yield each interned received message" do
+            @model.stubs(:convert_from).returns "something"
+
+            @subject_two = @subject_class.new
+            @subject_two.name = :too
+
+            @store_class.client.expects(:subscribe).with(:my_queue).multiple_yields(@subject, @subject_two)
+
+            received = []
+            @store_class.subscribe do |obj|
+                received.push(obj)
+            end
+
+            received.should == %w{something something}
+        end
+
+        it "should log but not propagate errors" do
+            @store_class.client.expects(:subscribe).yields("foo")
+            @store_class.expects(:intern).raises ArgumentError
+            Puppet.expects(:err)
+            @store_class.subscribe {|o| o }
+        end
+    end
+end
+

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

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/report/rest'
+
+describe Puppet::Transaction::Report::Rest do
+    it "should be a subclass of Puppet::Indirector::REST" do
+        Puppet::Transaction::Report::Rest.superclass.should equal(Puppet::Indirector::REST)
+    end
+    
+    it "should use the :report_server setting in preference to :reportserver" do
+        Puppet.settings[:reportserver] = "reportserver"
+        Puppet.settings[:report_server] = "report_server"
+        Puppet::Transaction::Report::Rest.server.should == "report_server"
+    end
+    
+    it "should use the :report_server setting in preference to :server" do
+        Puppet.settings[:server] = "server"
+        Puppet.settings[:report_server] = "report_server"
+        Puppet::Transaction::Report::Rest.server.should == "report_server"
+    end
+    
+    it "should have a value for report_server and report_port" do
+        Puppet::Transaction::Report::Rest.server.should_not be_nil
+        Puppet::Transaction::Report::Rest.port.should_not be_nil
+    end
+end

data/spec/unit/indirector/request.rb

@@ -9,6 +9,10 @@ describe Puppet::Indirector::Request do
             lambda { Puppet::Indirector::Request.new }.should raise_error(ArgumentError)
         end
 
+        it "should always convert the indirection name to a symbol" do
+            Puppet::Indirector::Request.new("ind", :method, "mykey").indirection_name.should == :ind
+        end
+
         it "should use provided value as the key if it is a string" do
             Puppet::Indirector::Request.new(:ind, :method, "mykey").key.should == "mykey"
         end
@@ -75,6 +79,83 @@ describe Puppet::Indirector::Request do
         it "should keep its options as a hash even if another option is specified" do
             Puppet::Indirector::Request.new(:ind, :method, :key, :foo => "bar").options.should be_instance_of(Hash)
         end
+
+        it "should treat options other than :ip, :node, and :authenticated as options rather than attributes" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, :server => "bar").options[:server].should == "bar"
+        end
+
+        it "should normalize options to use symbols as keys" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, "foo" => "bar").options[:foo].should == "bar"
+        end
+
+        describe "and the request key is a URI" do
+            describe "and the URI is a 'file' URI" do
+                before do
+                    @request = Puppet::Indirector::Request.new(:ind, :method, "file:///my/file with spaces")
+                end
+
+                it "should set the request key to the unescaped full file path" do
+                    @request.key.should == "/my/file with spaces"
+                end
+
+                it "should not set the protocol" do
+                    @request.protocol.should be_nil
+                end
+
+                it "should not set the port" do
+                    @request.port.should be_nil
+                end
+
+                it "should not set the server" do
+                    @request.server.should be_nil
+                end
+            end
+
+            it "should set the protocol to the URI scheme" do
+                Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").protocol.should == "http"
+            end
+
+            it "should set the server if a server is provided" do
+                Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").server.should == "host"
+            end
+
+            it "should set the server and port if both are provided" do
+                Puppet::Indirector::Request.new(:ind, :method, "http://host:543/stuff").port.should == 543
+            end
+
+            it "should default to the masterport if the URI scheme is 'puppet'" do
+                Puppet.settings.expects(:value).with(:masterport).returns "321"
+                Puppet::Indirector::Request.new(:ind, :method, "puppet://host/stuff").port.should == 321
+            end
+
+            it "should use the provided port if the URI scheme is not 'puppet'" do
+                Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").port.should == 80
+            end
+
+            it "should set the request key to the unescaped unqualified path from the URI" do
+                Puppet::Indirector::Request.new(:ind, :method, "http:///stuff with spaces").key.should == "stuff with spaces"
+            end
+
+            it "should set the :uri attribute to the full URI" do
+                Puppet::Indirector::Request.new(:ind, :method, "http:///stuff").uri.should == "http:///stuff"
+            end
+        end
+
+        it "should allow indication that it should not read a cached instance" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, :ignore_cache => true).should be_ignore_cache
+        end
+
+        it "should default to not ignoring the cache" do
+            Puppet::Indirector::Request.new(:ind, :method, :key).should_not be_ignore_cache
+        end
+
+        it "should allow indication that it should not not read an instance from the terminus" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, :ignore_terminus => true).should be_ignore_terminus
+        end
+
+        it "should default to not ignoring the terminus" do
+            Puppet::Indirector::Request.new(:ind, :method, :key).should_not be_ignore_terminus
+        end
     end
 
     it "should look use the Indirection class to return the appropriate indirection" do
@@ -84,4 +165,144 @@ describe Puppet::Indirector::Request do
 
         request.indirection.should equal(ind)
     end
+
+    it "should use its indirection to look up the appropriate model" do
+        ind = mock 'indirection'
+        Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
+        request = Puppet::Indirector::Request.new(:myind, :method, :key)
+
+        ind.expects(:model).returns "mymodel"
+
+        request.model.should == "mymodel"
+    end
+
+    it "should fail intelligently when asked to find a model but the indirection cannot be found" do
+        Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns nil
+        request = Puppet::Indirector::Request.new(:myind, :method, :key)
+
+        lambda { request.model }.should raise_error(ArgumentError)
+    end
+
+    it "should have a method for determining if the request is plural or singular" do
+        Puppet::Indirector::Request.new(:myind, :method, :key).should respond_to(:plural?)
+    end
+
+    it "should be considered plural if the method is 'search'" do
+        Puppet::Indirector::Request.new(:myind, :search, :key).should be_plural
+    end
+
+    it "should not be considered plural if the method is not 'search'" do
+        Puppet::Indirector::Request.new(:myind, :find, :key).should_not be_plural
+    end
+
+    it "should use its uri, if it has one, as its string representation" do
+        Puppet::Indirector::Request.new(:myind, :find, "foo://bar/baz").to_s.should == "foo://bar/baz"
+    end
+
+    it "should use its indirection name and key, if it has no uri, as its string representation" do
+        Puppet::Indirector::Request.new(:myind, :find, "key") == "/myind/key"
+    end
+
+    it "should be able to return the URI-escaped key" do
+        Puppet::Indirector::Request.new(:myind, :find, "my key").escaped_key.should == URI.escape("my key")
+    end
+
+    it "should have an environment accessor" do
+        Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => "foo").should respond_to(:environment)
+    end
+
+    it "should set its environment to an environment instance when a string is specified as its environment" do
+        Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => "foo").environment.should == Puppet::Node::Environment.new("foo")
+    end
+
+    it "should use any passed in environment instances as its environment" do
+        env = Puppet::Node::Environment.new("foo")
+        Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => env).environment.should equal(env)
+    end
+
+    it "should use the default environment when none is provided" do
+        Puppet::Indirector::Request.new(:myind, :find, "my key" ).environment.should equal(Puppet::Node::Environment.new)
+    end
+
+    it "should support converting its options to a hash" do
+        Puppet::Indirector::Request.new(:myind, :find, "my key" ).should respond_to(:to_hash)
+    end
+
+    it "should include all of its attributes when its options are converted to a hash" do
+        Puppet::Indirector::Request.new(:myind, :find, "my key", :node => 'foo').to_hash[:node].should == 'foo'
+    end
+
+    describe "when building a query string from its options" do
+        before do
+            @request = Puppet::Indirector::Request.new(:myind, :find, "my key")
+        end
+
+        it "should return an empty query string if there are no options" do
+            @request.stubs(:options).returns nil
+            @request.query_string.should == ""
+        end
+
+        it "should return an empty query string if the options are empty" do
+            @request.stubs(:options).returns({})
+            @request.query_string.should == ""
+        end
+
+        it "should prefix the query string with '?'" do
+            @request.stubs(:options).returns(:one => "two")
+            @request.query_string.should =~ /^\?/
+        end
+
+        it "should include all options in the query string, separated by '&'" do
+            @request.stubs(:options).returns(:one => "two", :three => "four")
+            @request.query_string.sub(/^\?/, '').split("&").sort.should == %w{one=two three=four}.sort
+        end
+
+        it "should ignore nil options" do
+            @request.stubs(:options).returns(:one => "two", :three => nil)
+            @request.query_string.should_not be_include("three")
+        end
+
+        it "should convert 'true' option values into strings" do
+            @request.stubs(:options).returns(:one => true)
+            @request.query_string.should == "?one=true"
+        end
+
+        it "should convert 'false' option values into strings" do
+            @request.stubs(:options).returns(:one => false)
+            @request.query_string.should == "?one=false"
+        end
+
+        it "should convert to a string all option values that are integers" do
+            @request.stubs(:options).returns(:one => 50)
+            @request.query_string.should == "?one=50"
+        end
+
+        it "should convert to a string all option values that are floating point numbers" do
+            @request.stubs(:options).returns(:one => 1.2)
+            @request.query_string.should == "?one=1.2"
+        end
+
+        it "should CGI-escape all option values that are strings" do
+            escaping = CGI.escape("one two")
+            @request.stubs(:options).returns(:one => "one two")
+            @request.query_string.should == "?one=#{escaping}"
+        end
+
+        it "should YAML-dump and CGI-escape arrays" do
+            escaping = CGI.escape(YAML.dump(%w{one two}))
+            @request.stubs(:options).returns(:one => %w{one two})
+            @request.query_string.should == "?one=#{escaping}"
+        end
+
+        it "should convert to a string and CGI-escape all option values that are symbols" do
+            escaping = CGI.escape("sym bol")
+            @request.stubs(:options).returns(:one => :"sym bol")
+            @request.query_string.should == "?one=#{escaping}"
+        end
+
+        it "should fail if options other than booleans or strings are provided" do
+            @request.stubs(:options).returns(:one => {:one => :two})
+            lambda { @request.query_string }.should raise_error(ArgumentError)
+        end
+    end
 end