puppet 0.24.9 → 0.25.0

data/spec/unit/node.rb

@@ -76,6 +76,11 @@ describe Puppet::Node, "when merging facts" do
         Puppet::Node::Facts.stubs(:find).with(@node.name).returns(Puppet::Node::Facts.new(@node.name, "one" => "c", "two" => "b"))
     end
 
+    it "should fail intelligently if it cannot find facts" do
+        Puppet::Node::Facts.expects(:find).with(@node.name).raises "foo"
+        lambda { @node.fact_merge }.should raise_error(Puppet::Error)
+    end
+
     it "should prefer parameters already set on the node over facts from the node" do
         @node.parameters = {"one" => "a"}
         @node.fact_merge
@@ -93,6 +98,22 @@ describe Puppet::Node, "when merging facts" do
         @node.merge "two" => "three"
         @node.parameters["two"].should == "three"
     end
+
+    it "should add the environment to the list of parameters" do
+        Puppet.settings.stubs(:value).with(:environments).returns("one,two")
+        Puppet.settings.stubs(:value).with(:environment).returns("one")
+        @node = Puppet::Node.new("testnode", :environment => "one")
+        @node.merge "two" => "three"
+        @node.parameters["environment"].should == "one"
+    end
+
+    it "should not set the environment if it is already set in the parameters" do
+        Puppet.settings.stubs(:value).with(:environments).returns("one,two")
+        Puppet.settings.stubs(:value).with(:environment).returns("one")
+        @node = Puppet::Node.new("testnode", :environment => "one")
+        @node.merge "environment" => "two"
+        @node.parameters["environment"].should == "two"
+    end
 end
 
 describe Puppet::Node, "when indirecting" do
@@ -112,7 +133,7 @@ describe Puppet::Node, "when indirecting" do
     end
 
     after do
-        Puppet::Indirector::Indirection.clear_cache
+        Puppet::Util::Cacher.expire
     end
 end
 
@@ -126,37 +147,49 @@ describe Puppet::Node, "when generating the list of names to search through" do
         @node.names.should be_instance_of(Array)
     end
 
-    it "should have the node's fqdn as the second name" do
-        @node.names[1].should == "yay.domain.com"
+    describe "and the node name is fully qualified" do
+        it "should contain an entry for each part of the node name" do
+            @node.names.should be_include("foo.domain.com")
+            @node.names.should be_include("foo.domain")
+            @node.names.should be_include("foo")
+        end
     end
 
-    it "should set the fqdn to the node's 'fqdn' fact if it is available" do
-        @node.parameters["fqdn"] = "boo.domain.com"
-        @node.names[1].should == "boo.domain.com"
+    it "should include the node's fqdn" do
+        @node.names.should be_include("yay.domain.com")
     end
 
-    it "should set the fqdn to the node's hostname and domain if no fqdn is available" do
-        @node.names[1].should == "yay.domain.com"
+    it "should combine and include the node's hostname and domain if no fqdn is available" do
+        @node.names.should be_include("yay.domain.com")
     end
 
     it "should contain an entry for each name available by stripping a segment of the fqdn" do
         @node.parameters["fqdn"] = "foo.deep.sub.domain.com"
-        @node.names[2].should == "foo.deep.sub.domain"
-        @node.names[3].should == "foo.deep.sub"
+        @node.names.should be_include("foo.deep.sub.domain")
+        @node.names.should be_include("foo.deep.sub")
     end
 
     describe "and :node_name is set to 'cert'" do
         before do
+            Puppet.settings.stubs(:value).with(:strict_hostname_checking).returns false
             Puppet.settings.stubs(:value).with(:node_name).returns "cert"
         end
 
         it "should use the passed-in key as the first value" do
             @node.names[0].should == "foo.domain.com"
         end
+
+        describe "and strict hostname checking is enabled" do
+            it "should only use the passed-in key" do
+                Puppet.settings.expects(:value).with(:strict_hostname_checking).returns true
+                @node.names.should == ["foo.domain.com"]
+            end
+        end
     end
 
     describe "and :node_name is set to 'facter'" do
         before do
+            Puppet.settings.stubs(:value).with(:strict_hostname_checking).returns false
             Puppet.settings.stubs(:value).with(:node_name).returns "facter"
         end
 

data/spec/unit/node/environment.rb

@@ -3,8 +3,25 @@
 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 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
@@ -17,21 +34,138 @@ describe Puppet::Node::Environment do
     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
-end
 
-describe Puppet::Node::Environment, " 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
+    it "should return its name when converted to a string" do
+        Puppet::Node::Environment.new(:one).to_s.should == "one"
     end
 
-    it "should provide an array-like accessor method for returning any environment-specific setting" do
+    it "should consider its module path to be the environment-specific modulepath setting" do
+        FileTest.stubs(:directory?).returns true
         env = Puppet::Node::Environment.new("testing")
-        env.should respond_to(:[])
+        module_path = %w{/one /two}.join(File::PATH_SEPARATOR)
+        env.expects(:[]).with(:modulepath).returns module_path
+
+        env.modulepath.should == %w{/one /two}
     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")
+    it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do
+        FileTest.stubs(:directory?).returns true
+        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(:[]).with(:modulepath).returns module_path
+
+            env.modulepath.should == %w{/l1 /l2 /one /two}
+        end
+    end
+
+    it "should not return non-directories in the module path" do
+        env = Puppet::Node::Environment.new("testing")
+        module_path = %w{/one /two}.join(File::PATH_SEPARATOR)
+        env.expects(:[]).with(:modulepath).returns module_path
+
+        FileTest.expects(:directory?).with("/one").returns true
+        FileTest.expects(:directory?).with("/two").returns false
+
+        env.modulepath.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")
-        env["myvar"].should == "myval"
+        module_path = %w{/one two}.join(File::PATH_SEPARATOR)
+        env.expects(:[]).with(:modulepath).returns module_path
+
+        two = File.join(Dir.getwd, "two")
+        env.modulepath.should == ["/one", two]
+    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).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}
+                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.expects(: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
+
+                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).returns %w{/a}
+                Dir.expects(:entries).with("/a").returns %w{foo}
+
+                env.modules.should be_all{|mod| mod.environment == "testing" }
+            end
+
+            it "should cache the module list" do
+                env = Puppet::Node::Environment.new("testing")
+                env.expects(:modulepath).once.returns %w{/a}
+                Dir.expects(:entries).once.with("/a").returns %w{foo}
+
+                env.modules
+                env.modules
+            end
+        end
     end
 end

data/spec/unit/node/facts.rb

@@ -4,41 +4,94 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/node/facts'
 
-describe Puppet::Node::Facts, " when indirecting" do
+describe Puppet::Node::Facts, "when indirecting" do
     before do
-        @indirection = stub 'indirection', :request => mock('request'), :name => :facts
+        @facts = Puppet::Node::Facts.new("me")
+    end
 
-        # We have to clear the cache so that the facts ask for our indirection stub,
-        # instead of anything that might be cached.
-        Puppet::Indirector::Indirection.clear_cache
-        @facts = Puppet::Node::Facts.new("me", "one" => "two")
+    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 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)
+    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 redirect to the specified fact store for storage" do
-        Puppet::Node::Facts.stubs(:indirection).returns(@indirection)
-        @indirection.expects(:save)
-        @facts.save
+    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 default to the 'facter' terminus" do
-        Puppet::Node::Facts.indirection.terminus_class.should == :facter
+    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
 
-    after do
-        mocha_verify
-        Puppet::Indirector::Indirection.clear_cache
+    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
-end
 
-describe Puppet::Node::Facts, " 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)
+    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

data/spec/unit/other/selinux.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/type/selboolean'
+require 'puppet/type/selmodule'
+
+describe Puppet::Type.type(:file), " when manipulating file contexts" do
+    before :each do
+        @file = Puppet::Type::File.new(
+            :name => "/tmp/foo",
+            :ensure => "file",
+            :seluser => "user_u",
+            :selrole => "role_r",
+            :seltype => "type_t" )
+    end
+    it "should use :seluser to get/set an SELinux user file context attribute" do
+        @file.property(:seluser).should == "user_u"
+    end
+    it "should use :selrole to get/set an SELinux role file context attribute" do
+        @file.property(:selrole).should == "role_r"
+    end
+    it "should use :seltype to get/set an SELinux user file context attribute" do
+        @file.property(:seltype).should == "type_t"
+    end
+end
+
+describe Puppet::Type.type(:selboolean), " when manipulating booleans" do
+    before :each do
+        provider_class = Puppet::Type::Selboolean.provider(Puppet::Type::Selboolean.providers[0])
+        Puppet::Type::Selboolean.expects(:defaultprovider).returns provider_class
+
+        @bool = Puppet::Type::Selboolean.new(
+            :name => "foo",
+            :value => "on",
+            :persistent => true )
+    end
+    it "should be able to access :name" do
+        @bool[:name].should == "foo"
+    end
+    it "should be able to access :value" do
+        @bool.property(:value).should == :on
+    end
+    it "should set :value to off" do
+        @bool[:value] = :off
+        @bool.property(:value).should == :off
+    end
+    it "should be able to access :persistent" do
+        @bool[:persistent].should == :true
+    end
+    it "should set :persistent to false" do
+        @bool[:persistent] = false
+        @bool[:persistent].should == :false
+    end
+end
+
+describe Puppet::Type.type(:selmodule), " when checking policy modules" do
+    before :each do
+        provider_class = Puppet::Type::Selmodule.provider(Puppet::Type::Selmodule.providers[0])
+        Puppet::Type::Selmodule.expects(:defaultprovider).returns provider_class
+
+        @module = Puppet::Type::Selmodule.new(
+            :name => "foo",
+            :selmoduledir => "/some/path",
+            :selmodulepath => "/some/path/foo.pp",
+            :syncversion => true)
+    end
+    it "should be able to access :name" do
+        @module[:name].should == "foo"
+    end
+    it "should be able to access :selmoduledir" do
+        @module[:selmoduledir].should == "/some/path"
+    end
+    it "should be able to access :selmodulepath" do
+        @module[:selmodulepath].should == "/some/path/foo.pp"
+    end
+    it "should be able to access :syncversion" do
+        @module.property(:syncversion).should == :true
+    end
+    it "should set the syncversion value to false" do
+        @module[:syncversion] = :false
+        @module.property(:syncversion).should == :false
+    end
+end
+