puppet 0.25.5 → 2.6.0

data/spec/unit/network/xmlrpc/client_spec.rb

@@ -0,0 +1,171 @@
+#!/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") }
+
+describe Puppet::Network::XMLRPCClient do
+  describe "when performing the rpc call" do
+    before do
+      Puppet::SSL::Host.any_instance.stubs(:certificate_matches_key?).returns true
+      @client = Puppet::Network::Client.report.xmlrpc_client.new
+      @client.stubs(:call).returns "foo"
+    end
+
+    it "should call the specified namespace and method, with the specified arguments" do
+      @client.expects(:call).with("puppetreports.report", "eh").returns "foo"
+      @client.report("eh")
+    end
+
+    it "should return the results from the call" do
+      @client.expects(:call).returns "foo"
+      @client.report("eh").should == "foo"
+    end
+
+    it "should always close the http connection if it is still open after the call" do
+      http = mock 'http'
+      @client.stubs(:http).returns http
+
+      http.expects(:started?).returns true
+      http.expects(:finish)
+
+      @client.report("eh").should == "foo"
+    end
+
+    it "should always close the http connection if it is still open after a call that raises an exception" do
+      http = mock 'http'
+      @client.stubs(:http).returns http
+
+      @client.expects(:call).raises RuntimeError
+
+      http.expects(:started?).returns true
+      http.expects(:finish)
+
+      lambda { @client.report("eh") }.should raise_error
+    end
+
+    describe "when returning the http instance" do
+      it "should use the http pool to create the instance" do
+        @client.instance_variable_set("@http", nil)
+        @client.expects(:host).returns "myhost"
+        @client.expects(:port).returns "myport"
+        Puppet::Network::HttpPool.expects(:http_instance).with("myhost", "myport", true).returns "http"
+
+        @client.http.should == "http"
+      end
+
+      it "should reuse existing instances" do
+        @client.http.should equal(@client.http)
+      end
+    end
+
+    describe "when recycling the connection" do
+      it "should close the existing instance if it's open" do
+        http = mock 'http'
+        @client.stubs(:http).returns http
+
+        http.expects(:started?).returns true
+        http.expects(:finish)
+
+        @client.recycle_connection
+      end
+
+      it "should force creation of a new instance" do
+        Puppet::Network::HttpPool.expects(:http_instance).returns "second_http"
+
+        @client.recycle_connection
+
+        @client.http.should == "second_http"
+      end
+    end
+
+    describe "and an exception is raised" do
+      it "should raise XMLRPCClientError if XMLRPC::FaultException is raised" do
+        error = XMLRPC::FaultException.new("foo", "bar")
+
+        @client.expects(:call).raises(error)
+
+        lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+      end
+
+      it "should raise XMLRPCClientError if Errno::ECONNREFUSED is raised" do
+        @client.expects(:call).raises(Errno::ECONNREFUSED)
+
+        lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+      end
+
+      it "should log and raise XMLRPCClientError if Timeout::Error is raised" do
+        Puppet.expects(:err)
+        @client.expects(:call).raises(Timeout::Error)
+
+        lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+      end
+
+      it "should log and raise XMLRPCClientError if SocketError is raised" do
+        Puppet.expects(:err)
+        @client.expects(:call).raises(SocketError)
+
+        lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+      end
+
+      it "should log, recycle the connection, and retry if Errno::EPIPE is raised" do
+        @client.expects(:call).times(2).raises(Errno::EPIPE).then.returns "eh"
+
+        Puppet.expects(:info)
+        @client.expects(:recycle_connection)
+
+        @client.report("eh")
+      end
+
+      it "should log, recycle the connection, and retry if EOFError is raised" do
+        @client.expects(:call).times(2).raises(EOFError).then.returns "eh"
+
+        Puppet.expects(:info)
+        @client.expects(:recycle_connection)
+
+        @client.report("eh")
+      end
+
+      it "should log and retry if an exception containing 'Wrong size' is raised" do
+        error = RuntimeError.new("Wrong size. Was 15, should be 30")
+        @client.expects(:call).times(2).raises(error).then.returns "eh"
+
+        Puppet.expects(:warning)
+
+        @client.report("eh")
+      end
+
+      it "should raise XMLRPCClientError if OpenSSL::SSL::SSLError is raised" do
+        @client.expects(:call).raises(OpenSSL::SSL::SSLError)
+
+        lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+      end
+
+      it "should log and raise XMLRPCClientError if OpenSSL::SSL::SSLError is raised with certificate issues" do
+        error = OpenSSL::SSL::SSLError.new("hostname was not match")
+        @client.expects(:call).raises(error)
+
+        Puppet.expects(:warning)
+
+        lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+      end
+
+      it "should log, recycle the connection, and retry if OpenSSL::SSL::SSLError is raised containing 'bad write retry'" do
+        error = OpenSSL::SSL::SSLError.new("bad write retry")
+        @client.expects(:call).times(2).raises(error).then.returns "eh"
+
+        @client.expects(:recycle_connection)
+
+        Puppet.expects(:warning)
+
+        @client.report("eh")
+      end
+
+      it "should log and raise XMLRPCClientError if any other exception is raised" do
+        @client.expects(:call).raises(RuntimeError)
+
+        Puppet.expects(:err)
+
+        lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+      end
+    end
+  end
+end

data/spec/unit/node/environment_spec.rb

@@ -0,0 +1,248 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/node/environment'
+require 'puppet/util/execution'
+
+describe Puppet::Node::Environment do
+  after do
+    Puppet::Node::Environment.clear
+  end
+
+  it "should include the Cacher module" do
+    Puppet::Node::Environment.ancestors.should be_include(Puppet::Util::Cacher)
+  end
+
+  it "should use the filetimeout for the ttl for the modulepath" do
+    Puppet::Node::Environment.attr_ttl(:modulepath).should == Integer(Puppet[:filetimeout])
+  end
+
+  it "should use the filetimeout for the ttl for the module list" do
+    Puppet::Node::Environment.attr_ttl(:modules).should == Integer(Puppet[:filetimeout])
+  end
+
+  it "should use the filetimeout for the ttl for the manifestdir" do
+    Puppet::Node::Environment.attr_ttl(:manifestdir).should == Integer(Puppet[:filetimeout])
+  end
+
+  it "should use the default environment if no name is provided while initializing an environment" do
+    Puppet.settings.expects(:value).with(:environment).returns("one")
+    Puppet::Node::Environment.new.name.should == :one
+  end
+
+  it "should treat environment instances as singletons" do
+    Puppet::Node::Environment.new("one").should equal(Puppet::Node::Environment.new("one"))
+  end
+
+  it "should treat an environment specified as names or strings as equivalent" do
+    Puppet::Node::Environment.new(:one).should equal(Puppet::Node::Environment.new("one"))
+  end
+
+  it "should return its name when converted to a string" do
+    Puppet::Node::Environment.new(:one).to_s.should == "one"
+  end
+
+  it "should just return any provided environment if an environment is provided as the name" do
+    one = Puppet::Node::Environment.new(:one)
+    Puppet::Node::Environment.new(one).should equal(one)
+  end
+
+  describe "when managing known resource types" do
+    before do
+      @env = Puppet::Node::Environment.new("dev")
+      @collection = Puppet::Resource::TypeCollection.new(@env)
+      @collection.stubs(:perform_initial_import)
+    end
+
+    it "should create a resource type collection if none exists" do
+      Puppet::Resource::TypeCollection.expects(:new).with(@env).returns @collection
+      @env.known_resource_types.should equal(@collection)
+    end
+
+    it "should reuse any existing resource type collection" do
+      @env.known_resource_types.should equal(@env.known_resource_types)
+    end
+
+    it "should perform the initial import when creating a new collection" do
+      @collection.expects(:perform_initial_import)
+      Puppet::Resource::TypeCollection.expects(:new).returns @collection
+
+      @env.known_resource_types
+    end
+
+    it "should create and return a new collection rather than returning a stale collection" do
+      @env.known_resource_types.expects(:stale?).returns true
+
+      Puppet::Resource::TypeCollection.expects(:new).returns @collection
+
+      @env.known_resource_types.should equal(@collection)
+    end
+  end
+
+  [:modulepath, :manifestdir].each do |setting|
+    it "should validate the #{setting} directories" do
+      path = %w{/one /two}.join(File::PATH_SEPARATOR)
+
+      env = Puppet::Node::Environment.new("testing")
+      env.stubs(:[]).with(setting).returns path
+
+      env.expects(:validate_dirs).with(%w{/one /two})
+
+      env.send(setting)
+    end
+
+    it "should return the validated dirs for #{setting}" do
+      path = %w{/one /two}.join(File::PATH_SEPARATOR)
+
+      env = Puppet::Node::Environment.new("testing")
+      env.stubs(:[]).with(setting).returns path
+      env.stubs(:validate_dirs).returns %w{/one /two}
+
+      env.send(setting).should == %w{/one /two}
+    end
+  end
+
+  it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do
+    Puppet::Util::Execution.withenv("PUPPETLIB" => %w{/l1 /l2}.join(File::PATH_SEPARATOR)) do
+      env = Puppet::Node::Environment.new("testing")
+      module_path = %w{/one /two}.join(File::PATH_SEPARATOR)
+      env.expects(:validate_dirs).with(%w{/l1 /l2 /one /two}).returns %w{/l1 /l2 /one /two}
+      env.expects(:[]).with(:modulepath).returns module_path
+
+      env.modulepath.should == %w{/l1 /l2 /one /two}
+    end
+  end
+
+  describe "when validating modulepath or manifestdir directories" do
+    it "should not return non-directories" do
+      env = Puppet::Node::Environment.new("testing")
+
+      FileTest.expects(:directory?).with("/one").returns true
+      FileTest.expects(:directory?).with("/two").returns false
+
+      env.validate_dirs(%w{/one /two}).should == %w{/one}
+    end
+
+    it "should use the current working directory to fully-qualify unqualified paths" do
+      FileTest.stubs(:directory?).returns true
+      env = Puppet::Node::Environment.new("testing")
+
+      two = File.join(Dir.getwd, "two")
+      env.validate_dirs(%w{/one two}).should == ["/one", two]
+    end
+  end
+
+  describe "when modeling a specific environment" do
+    it "should have a method for returning the environment name" do
+      Puppet::Node::Environment.new("testing").name.should == :testing
+    end
+
+    it "should provide an array-like accessor method for returning any environment-specific setting" do
+      env = Puppet::Node::Environment.new("testing")
+      env.should respond_to(:[])
+    end
+
+    it "should ask the Puppet settings instance for the setting qualified with the environment name" do
+      Puppet.settings.expects(:value).with("myvar", :testing).returns("myval")
+      env = Puppet::Node::Environment.new("testing")
+      env["myvar"].should == "myval"
+    end
+
+    it "should be able to return an individual module that exists in its module path" do
+      env = Puppet::Node::Environment.new("testing")
+
+      mod = mock 'module'
+      Puppet::Module.expects(:new).with("one", env).returns mod
+      mod.expects(:exist?).returns true
+
+      env.module("one").should equal(mod)
+    end
+
+    it "should return nil if asked for a module that does not exist in its path" do
+      env = Puppet::Node::Environment.new("testing")
+
+      mod = mock 'module'
+      Puppet::Module.expects(:new).with("one", env).returns mod
+      mod.expects(:exist?).returns false
+
+      env.module("one").should be_nil
+    end
+
+    it "should be able to return its modules" do
+      Puppet::Node::Environment.new("testing").should respond_to(:modules)
+    end
+
+    describe ".modules" do
+      it "should return a module named for every directory in each module path" do
+        env = Puppet::Node::Environment.new("testing")
+        env.expects(:modulepath).at_least_once.returns %w{/a /b}
+        Dir.expects(:entries).with("/a").returns %w{foo bar}
+        Dir.expects(:entries).with("/b").returns %w{bee baz}
+
+        env.modules.collect{|mod| mod.name}.sort.should == %w{foo bar bee baz}.sort
+      end
+
+      it "should remove duplicates" do
+        env = Puppet::Node::Environment.new("testing")
+        env.expects(:modulepath).returns( %w{/a /b} ).at_least_once
+        Dir.expects(:entries).with("/a").returns %w{foo}
+        Dir.expects(:entries).with("/b").returns %w{foo}
+
+        env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
+      end
+
+      it "should ignore invalid modules" do
+        env = Puppet::Node::Environment.new("testing")
+        env.stubs(:modulepath).returns %w{/a}
+        Dir.expects(:entries).with("/a").returns %w{foo bar}
+
+        Puppet::Module.expects(:new).with { |name, env| name == "foo" }.returns mock("foomod", :name => "foo")
+        Puppet::Module.expects(:new).with { |name, env| name == "bar" }.raises( Puppet::Module::InvalidName, "name is invalid" )
+
+        env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
+      end
+
+      it "should create modules with the correct environment" do
+        env = Puppet::Node::Environment.new("testing")
+        env.expects(:modulepath).at_least_once.returns %w{/a}
+        Dir.expects(:entries).with("/a").returns %w{foo}
+
+        env.modules.each {|mod| mod.environment.should == env }
+      end
+
+      it "should cache the module list" do
+        env = Puppet::Node::Environment.new("testing")
+        env.expects(:modulepath).at_least_once.returns %w{/a}
+        Dir.expects(:entries).once.with("/a").returns %w{foo}
+
+        env.modules
+        env.modules
+      end
+    end
+  end
+
+  describe Puppet::Node::Environment::Helper do
+    before do
+      @helper = Object.new
+      @helper.extend(Puppet::Node::Environment::Helper)
+    end
+
+    it "should be able to set and retrieve the environment" do
+      @helper.environment = :foo
+      @helper.environment.name.should == :foo
+    end
+
+    it "should accept an environment directly" do
+      env = Puppet::Node::Environment.new :foo
+      @helper.environment = env
+      @helper.environment.name.should == :foo
+    end
+
+    it "should accept an environment as a string" do
+      env = Puppet::Node::Environment.new "foo"
+      @helper.environment = env
+      @helper.environment.name.should == :foo
+    end
+  end
+end

data/spec/unit/node/facts_spec.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/node/facts'
+
+describe Puppet::Node::Facts, "when indirecting" do
+  before do
+    @facts = Puppet::Node::Facts.new("me")
+  end
+
+  it "should be able to convert all fact values to strings" do
+    @facts.values["one"] = 1
+    @facts.stringify
+    @facts.values["one"].should == "1"
+  end
+
+  it "should add the node's certificate name as the 'clientcert' fact when adding local facts" do
+    @facts.add_local_facts
+    @facts.values["clientcert"].should == Puppet.settings[:certname]
+  end
+
+  it "should add the Puppet version as a 'clientversion' fact when adding local facts" do
+    @facts.add_local_facts
+    @facts.values["clientversion"].should == Puppet.version.to_s
+  end
+
+  it "should add the current environment as a fact if one is not set when adding local facts" do
+    @facts.add_local_facts
+    @facts.values["environment"].should == Puppet[:environment]
+  end
+
+  it "should not replace any existing environment fact when adding local facts" do
+    @facts.values["environment"] = "foo"
+    @facts.add_local_facts
+    @facts.values["environment"].should == "foo"
+  end
+
+  it "should be able to downcase fact values" do
+    Puppet.settings.stubs(:value).returns "eh"
+    Puppet.settings.expects(:value).with(:downcasefacts).returns true
+
+    @facts.values["one"] = "Two"
+
+    @facts.downcase_if_necessary
+    @facts.values["one"].should == "two"
+  end
+
+  it "should only try to downcase strings" do
+    Puppet.settings.stubs(:value).returns "eh"
+    Puppet.settings.expects(:value).with(:downcasefacts).returns true
+
+    @facts.values["now"] = Time.now
+
+    @facts.downcase_if_necessary
+    @facts.values["now"].should be_instance_of(Time)
+  end
+
+  it "should not downcase facts if not configured to do so" do
+    Puppet.settings.stubs(:value).returns "eh"
+    Puppet.settings.expects(:value).with(:downcasefacts).returns false
+
+    @facts.values["one"] = "Two"
+    @facts.downcase_if_necessary
+    @facts.values["one"].should == "Two"
+  end
+
+  describe "when indirecting" do
+    before do
+      @indirection = stub 'indirection', :request => mock('request'), :name => :facts
+
+      # We have to clear the cache so that the facts ask for our indirection stub,
+      # instead of anything that might be cached.
+      Puppet::Util::Cacher.expire
+
+      @facts = Puppet::Node::Facts.new("me", "one" => "two")
+    end
+
+    it "should redirect to the specified fact store for retrieval" do
+      Puppet::Node::Facts.stubs(:indirection).returns(@indirection)
+      @indirection.expects(:find)
+      Puppet::Node::Facts.find(:my_facts)
+    end
+
+    it "should redirect to the specified fact store for storage" do
+      Puppet::Node::Facts.stubs(:indirection).returns(@indirection)
+      @indirection.expects(:save)
+      @facts.save
+    end
+
+    it "should default to the 'facter' terminus" do
+      Puppet::Node::Facts.indirection.terminus_class.should == :facter
+    end
+  end
+
+  describe "when storing and retrieving" do
+    it "should add metadata to the facts" do
+      facts = Puppet::Node::Facts.new("me", "one" => "two", "three" => "four")
+      facts.values[:_timestamp].should be_instance_of(Time)
+    end
+  end
+end