puppet 0.24.6 → 0.24.7

data/spec/unit/indirector/ldap.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/indirector/ldap'
+
+describe Puppet::Indirector::Ldap do
+    before do
+        @indirection = stub 'indirection', :name => :testing
+        Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
+        @ldap_class = Class.new(Puppet::Indirector::Ldap) do
+            def self.to_s
+                "Testing::Mytype"
+            end
+        end
+
+        @connection = mock 'ldap'
+
+        @searcher = @ldap_class.new
+    end
+
+    describe "when searching ldap" do
+        before do
+            # Stub everything, and we can selectively replace with an expect as
+            # we need to for testing.
+            @searcher.stubs(:connection).returns(@connection)
+            @searcher.stubs(:search_filter).returns(:filter)
+            @searcher.stubs(:search_base).returns(:base)
+            @searcher.stubs(:process)
+
+            @request = stub 'request', :key => "yay"
+        end
+
+        it "should call the ldapsearch method with the search filter" do
+            @searcher.expects(:search_filter).with("yay").returns("yay's filter")
+            @searcher.expects(:ldapsearch).with("yay's filter")
+            @searcher.find @request
+        end
+
+        it "should fail if no block is passed to the ldapsearch method" do
+            proc { @searcher.ldapsearch("blah") }.should raise_error(ArgumentError)
+        end
+
+        it "should use the results of the ldapbase method as the ldap search base" do
+            @searcher.stubs(:search_base).returns("mybase")
+            @connection.expects(:search).with do |*args|
+                args[0].should == "mybase"
+                true
+            end
+            @searcher.find @request
+        end
+
+        it "should default to the value of the :search_base setting as the result of the ldapbase method" do
+            Puppet.expects(:[]).with(:ldapbase).returns("myldapbase")
+            searcher = @ldap_class.new
+            searcher.search_base.should == "myldapbase"
+        end
+
+        it "should use the results of the :search_attributes method as the list of attributes to return" do
+            @searcher.stubs(:search_attributes).returns(:myattrs)
+            @connection.expects(:search).with do |*args|
+                args[3].should == :myattrs
+                true
+            end
+            @searcher.find @request
+        end
+
+        it "should use depth 2 when searching" do
+            @connection.expects(:search).with do |*args|
+                args[1].should == 2
+                true
+            end
+            @searcher.find @request
+        end
+
+        it "should call process() on the first found entry" do
+            @connection.expects(:search).yields("myresult")
+            @searcher.expects(:process).with("myresult")
+            @searcher.find @request
+        end
+
+        it "should reconnect and retry the search if there is a failure" do
+            run = false
+            @connection.stubs(:search).with do |*args|
+                if run
+                    true
+                else
+                    run = true
+                    raise "failed"
+                end
+            end.yields("myresult")
+            @searcher.expects(:process).with("myresult")
+
+            @searcher.find @request
+        end
+
+        it "should not reconnect on failure more than once" do
+            count = 0
+            @connection.stubs(:search).with do |*args|
+                count += 1
+                raise ArgumentError, "yay"
+            end
+            proc { @searcher.find(@request) }.should raise_error(Puppet::Error)
+            count.should == 2
+        end
+
+        it "should return true if an entry is found" do
+            @connection.expects(:search).yields("result")
+            @searcher.ldapsearch("whatever") { |r| }.should be_true
+        end
+    end
+
+    describe "when connecting to ldap" do
+        confine "LDAP is not available" => Puppet.features.ldap?
+
+        it "should create and start a Util::Ldap::Connection instance" do
+            conn = mock 'connection', :connection => "myconn", :start => nil
+            Puppet::Util::Ldap::Connection.expects(:instance).returns conn
+
+            @searcher.connection.should == "myconn"
+        end
+
+        it "should only create the ldap connection when asked for it the first time" do
+            conn = mock 'connection', :connection => "myconn", :start => nil
+            Puppet::Util::Ldap::Connection.expects(:instance).returns conn
+
+            @searcher.connection
+        end
+
+        it "should cache the connection" do
+            conn = mock 'connection', :connection => "myconn", :start => nil
+            Puppet::Util::Ldap::Connection.expects(:instance).returns conn
+
+            @searcher.connection.should equal(@searcher.connection)
+        end
+    end
+
+    describe "when reconnecting to ldap" do
+        confine "Not running on culain as root" => (Puppet::Util::SUIDManager.uid == 0 and Facter.value("hostname") == "culain")
+
+        it "should reconnect to ldap when connections are lost"
+    end
+end

data/spec/unit/indirector/memory.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/indirector/memory'
+
+require 'shared_behaviours/memory_terminus'
+
+describe Puppet::Indirector::Memory do
+    it_should_behave_like "A Memory Terminus"
+
+    before do
+        Puppet::Indirector::Terminus.stubs(:register_terminus_class)
+        @model = mock 'model'
+        @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
+        Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
+
+        @memory_class = Class.new(Puppet::Indirector::Memory) do
+            def self.to_s
+                "Mystuff::Testing"
+            end
+        end
+
+        @searcher = @memory_class.new
+        @name = "me"
+        @instance = stub 'instance', :name => @name
+
+        @request = stub 'request', :key => @name, :instance => @instance
+    end
+end

data/spec/unit/indirector/module_files.rb

@@ -0,0 +1,259 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-10-19.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/indirector/module_files'
+
+
+describe Puppet::Indirector::ModuleFiles do
+
+    before :each do
+        Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
+        Puppet::Indirector::Terminus.stubs(:register_terminus_class)
+        @model = mock 'model'
+        @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
+        Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
+  
+        @module_files_class = Class.new(Puppet::Indirector::ModuleFiles) do
+            def self.to_s
+                "Testing::Mytype"
+            end
+        end
+  
+        @module_files = @module_files_class.new
+  
+        @uri = "puppetmounts://host/modules/my/local/file"
+        @module = Puppet::Module.new("mymod", "/module/path")
+
+        @request = stub 'request', :key => @uri, :options => {}, :node => nil, :ip => nil, :method => :find
+    end
+
+    describe Puppet::Indirector::ModuleFiles, " when finding files" do
+
+        it "should strip off the leading '/modules' mount name" do
+            Puppet::Module.expects(:find).with('my', "myenv").returns @module
+            @module_files.find(@request)
+        end
+
+        it "should not strip off leading terms that start with '/modules' but are longer words" do
+            @request.stubs(:key).returns "puppetmounts://host/modulestart/my/local/file"
+            Puppet::Module.expects(:find).with('modulestart', "myenv").returns nil
+            @module_files.find(@request)
+        end
+
+        it "should search for a module whose name is the first term in the remaining file path" do
+            Puppet::Module.expects(:find).with('my', "myenv").returns @module
+            @module_files.find(@request)
+        end
+
+        it "should search for a file relative to the module's files directory" do
+            Puppet::Module.expects(:find).with('my', "myenv").returns @module
+            FileTest.expects(:exists?).with("/module/path/files/local/file")
+            @module_files.find(@request)
+        end
+
+        it "should return nil if the module does not exist" do
+            Puppet::Module.expects(:find).with('my', "myenv").returns nil
+            @module_files.find(@request).should be_nil
+        end
+
+        it "should return nil if the module exists but the file does not" do
+            Puppet::Module.expects(:find).with('my', "myenv").returns @module
+            FileTest.expects(:exists?).with("/module/path/files/local/file").returns(false)
+            @module_files.find(@request).should be_nil
+        end
+
+        it "should return an instance of the model if a module is found and the file exists" do
+            Puppet::Module.expects(:find).with('my', "myenv").returns @module
+            FileTest.expects(:exists?).with("/module/path/files/local/file").returns(true)
+            @model.expects(:new).returns(:myinstance)
+            @module_files.find(@request).should == :myinstance
+        end
+
+        it "should use the node's environment to look up the module if the node name is provided" do
+            node = stub "node", :environment => "testing"
+            Puppet::Node.expects(:find).with("mynode").returns(node)
+            Puppet::Module.expects(:find).with('my', "testing")
+
+            @request.stubs(:node).returns "mynode"
+            @module_files.find(@request)
+        end
+
+        it "should use the default environment setting to look up the module if the node name is not provided" do
+            env = stub "environment", :name => "testing"
+            Puppet::Node::Environment.stubs(:new).returns(env)
+            Puppet::Module.expects(:find).with('my', "testing")
+            @module_files.find(@request)
+        end
+    end
+
+    describe Puppet::Indirector::ModuleFiles, " when returning instances" do
+
+        before do
+            Puppet::Module.expects(:find).with('my', "myenv").returns @module
+            FileTest.expects(:exists?).with("/module/path/files/local/file").returns(true)
+            @instance = mock 'instance'
+        end
+
+        it "should create the instance with the key used to find the instance" do
+            @model.expects(:new).with { |key, *options| key == @uri }
+            @module_files.find(@request)
+        end
+
+        it "should create the instance with the path at which the instance was found" do
+            @model.expects(:new).with { |key, options| options[:path] == "/module/path/files/local/file" }
+            @module_files.find(@request)
+        end
+
+        it "should set the provided :links setting on to the instance if one is provided" do
+            @model.expects(:new).returns(@instance)
+            @instance.expects(:links=).with(:mytest)
+
+            @request.options[:links] = :mytest
+            @module_files.find(@request)
+        end
+
+        it "should not set a :links value if no :links parameter is provided" do
+            @model.expects(:new).returns(@instance)
+            @module_files.find(@request)
+        end
+    end
+
+    describe Puppet::Indirector::ModuleFiles, " when authorizing" do
+
+        before do
+            @configuration = mock 'configuration'
+            Puppet::FileServing::Configuration.stubs(:create).returns(@configuration)
+        end
+
+        it "should have an authorization hook" do
+            @module_files.should respond_to(:authorized?)
+        end
+
+        it "should deny the :destroy method" do
+            @request.expects(:method).returns :destroy
+            @module_files.authorized?(@request).should be_false
+        end
+
+        it "should deny the :save method" do
+            @request.expects(:method).returns :save
+            @module_files.authorized?(@request).should be_false
+        end
+
+        it "should use the file server configuration to determine authorization" do
+            @configuration.expects(:authorized?)
+            @module_files.authorized?(@request)
+        end
+
+        it "should use the path directly from the URI if it already includes /modules" do
+            @request.expects(:key).returns "puppetmounts://host/modules/my/file"
+            @configuration.expects(:authorized?).with { |uri, *args| uri == "/modules/my/file" }
+            @module_files.authorized?(@request)
+        end
+
+        it "should add /modules to the file path if it's not included in the URI" do
+            @request.expects(:key).returns "puppetmounts://host/my/file"
+            @configuration.expects(:authorized?).with { |uri, *args| uri == "/modules/my/file" }
+            @module_files.authorized?(@request)
+        end
+
+        it "should pass the node name to the file server configuration" do
+            @request.expects(:key).returns "puppetmounts://host/my/file"
+            @configuration.expects(:authorized?).with { |key, options| options[:node] == "mynode" }
+            @request.stubs(:node).returns "mynode"
+            @module_files.authorized?(@request)
+        end
+
+        it "should pass the IP address to the file server configuration" do
+            @request.expects(:ip).returns "myip"
+            @configuration.expects(:authorized?).with { |key, options| options[:ipaddress] == "myip" }
+            @module_files.authorized?(@request)
+        end
+
+        it "should return false if the file server configuration denies authorization" do
+            @configuration.expects(:authorized?).returns(false)
+            @module_files.authorized?(@request).should be_false
+        end
+
+        it "should return true if the file server configuration approves authorization" do
+            @configuration.expects(:authorized?).returns(true)
+            @module_files.authorized?(@request).should be_true
+        end
+    end
+
+    describe Puppet::Indirector::ModuleFiles, " when searching for files" do
+
+        it "should strip off the leading '/modules' mount name" do
+            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
+            Puppet::Module.expects(:find).with('my', "myenv").returns @module
+            @module_files.search(@request)
+        end
+
+        it "should not strip off leading terms that start with '/modules' but are longer words" do
+            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
+            Puppet::Module.expects(:find).with('modulestart', "myenv").returns nil
+            @request.stubs(:key).returns "puppetmounts://host/modulestart/my/local/file"
+            @module_files.search @request
+        end
+
+        it "should search for a module whose name is the first term in the remaining file path" do
+            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
+            Puppet::Module.expects(:find).with('my', "myenv").returns @module
+            @module_files.search(@request)
+        end
+
+        it "should search for a file relative to the module's files directory" do
+            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
+            Puppet::Module.expects(:find).with('my', "myenv").returns @module
+            FileTest.expects(:exists?).with("/module/path/files/local/file")
+            @module_files.search(@request)
+        end
+
+        it "should return nil if the module does not exist" do
+            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
+            Puppet::Module.expects(:find).with('my', "myenv").returns nil
+            @module_files.search(@request).should be_nil
+        end
+
+        it "should return nil if the module exists but the file does not" do
+            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
+            Puppet::Module.expects(:find).with('my', "myenv").returns @module
+            FileTest.expects(:exists?).with("/module/path/files/local/file").returns(false)
+            @module_files.search(@request).should be_nil
+        end
+
+        it "should use the node's environment to look up the module if the node name is provided" do
+            node = stub "node", :environment => "testing"
+            Puppet::Node.expects(:find).with("mynode").returns(node)
+            Puppet::Module.expects(:find).with('my', "testing")
+            @request.stubs(:node).returns "mynode"
+            @module_files.search(@request)
+        end
+
+        it "should use the default environment setting to look up the module if the node name is not provided and the environment is not set to ''" do
+            env = stub 'env', :name => "testing"
+            Puppet::Node::Environment.stubs(:new).returns(env)
+            Puppet::Module.expects(:find).with('my', "testing")
+            @module_files.search(@request)
+        end
+
+        it "should use :path2instances from the terminus_helper to return instances if a module is found and the file exists" do
+            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
+            Puppet::Module.expects(:find).with('my', "myenv").returns @module
+            FileTest.expects(:exists?).with("/module/path/files/local/file").returns(true)
+            @module_files.expects(:path2instances).with(@request, "/module/path/files/local/file")
+            @module_files.search(@request)
+        end
+
+        it "should pass the request directly to :path2instances" do
+            Puppet::Node::Environment.stubs(:new).returns(stub('env', :name => "myenv"))
+            Puppet::Module.expects(:find).with('my', "myenv").returns @module
+            FileTest.expects(:exists?).with("/module/path/files/local/file").returns(true)
+            @module_files.expects(:path2instances).with(@request, "/module/path/files/local/file")
+            @module_files.search(@request)
+        end
+    end
+end

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

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/node/exec'
+
+describe Puppet::Node::Exec do
+    before do
+        @indirection = mock 'indirection'
+        Puppet.settings.stubs(:value).with(:external_nodes).returns("/echo")
+        @searcher = Puppet::Node::Exec.new
+    end
+
+    describe "when constructing the command to run" do
+        it "should use the external_node script as the command" do
+            Puppet.expects(:[]).with(:external_nodes).returns("/bin/echo")
+            @searcher.command.should == %w{/bin/echo}
+        end
+
+        it "should throw an exception if no external node command is set" do
+            Puppet.expects(:[]).with(:external_nodes).returns("none")
+            proc { @searcher.find(stub('request', :key => "foo")) }.should raise_error(ArgumentError)
+        end
+    end
+
+    describe "when handling the results of the command" do
+        before do
+            @node = stub 'node', :fact_merge => nil
+            @name = "yay"
+            Puppet::Node.expects(:new).with(@name).returns(@node)
+            @result = {}
+            # Use a local variable so the reference is usable in the execute() definition.
+            result = @result
+            @searcher.meta_def(:execute) do |command|
+                return YAML.dump(result)
+            end
+
+            @request = stub 'request', :key => @name
+        end
+
+        it "should translate the YAML into a Node instance" do
+            # Use an empty hash
+            @searcher.find(@request).should equal(@node)
+        end
+
+        it "should set the resulting parameters as the node parameters" do
+            @result[:parameters] = {"a" => "b", "c" => "d"}
+            @node.expects(:parameters=).with "a" => "b", "c" => "d"
+            @searcher.find(@request)
+        end
+
+        it "should set the resulting classes as the node classes" do
+            @result[:classes] = %w{one two}
+            @node.expects(:classes=).with %w{one two}
+            @searcher.find(@request)
+        end
+
+        it "should merge the node's facts with its parameters" do
+            @node.expects(:fact_merge)
+            @searcher.find(@request)
+        end
+
+        it "should set the node's environment if one is provided" do
+            @result[:environment] = "yay"
+            @node.expects(:environment=).with "yay"
+            @searcher.find(@request)
+        end
+    end
+end