puppet 3.3.2 → 3.4.0.rc1

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -19,7 +19,7 @@ describe Puppet::Configurer::PluginHandler do
 
   it "should use an Agent Downloader, with the name, source, destination, ignore, and environment set correctly, to download plugins when downloading is enabled" do
     downloader = mock 'downloader'
-
+    Puppet.features.stubs(:external_facts?).returns(:true)
     # This is needed in order to make sure we pass on windows
     plugindest = File.expand_path("/tmp/pdest")
 
@@ -27,9 +27,14 @@ describe Puppet::Configurer::PluginHandler do
     Puppet[:plugindest] = plugindest
     Puppet[:pluginsignore] = "pignore"
 
+    Puppet[:pluginfactsource] = "psource"
+    Puppet[:pluginfactdest] = plugindest
+
+    Puppet::Configurer::Downloader.expects(:new).with("pluginfacts", plugindest, "psource", "pignore", "myenv").returns downloader
     Puppet::Configurer::Downloader.expects(:new).with("plugin", plugindest, "psource", "pignore", "myenv").returns downloader
 
-    downloader.expects(:evaluate).returns []
+    downloader.stubs(:evaluate).returns([])
+    downloader.expects(:evaluate).twice
 
     @pluginhandler.environment = "myenv"
     @pluginhandler.download_plugins

data/spec/unit/configurer_spec.rb

@@ -110,6 +110,16 @@ describe Puppet::Configurer do
       @agent.run.should == 0
     end
 
+    it "applies a cached catalog when it can't connect to the master" do
+      error = Errno::ECONNREFUSED.new('Connection refused - connect(2)')
+
+      Puppet::Node.indirection.expects(:find).raises(error)
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entry(:ignore_cache => true)).raises(error)
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entry(:ignore_terminus => true)).returns(@catalog)
+
+      @agent.run.should == 0
+    end
+
     it "should initialize a transaction report if one is not provided" do
       report = Puppet::Transaction::Report.new("apply")
       Puppet::Transaction::Report.expects(:new).returns report
@@ -341,12 +351,12 @@ describe Puppet::Configurer do
       @agent.environment.should == "second_env"
     end
 
-    it "should clear the thread local caches" do
-      Thread.current[:env_module_directories] = false
+    it "should clear the global caches" do
+      $env_module_directories = false
 
       @agent.run
 
-      Thread.current[:env_module_directories].should == nil
+      $env_module_directories.should == nil
     end
 
     describe "when not using a REST terminus for catalogs" do
@@ -454,7 +464,7 @@ describe Puppet::Configurer do
 
     it "should write the last run file" do
       @configurer.save_last_run_summary(@report)
-      FileTest.exists?(Puppet[:lastrunfile]).should be_true
+      Puppet::FileSystem::File.exist?(Puppet[:lastrunfile]).should be_true
     end
 
     it "should write the raw summary as yaml" do
@@ -486,7 +496,7 @@ describe Puppet::Configurer do
         require 'puppet/util/windows/security'
         mode = Puppet::Util::Windows::Security.get_mode(Puppet[:lastrunfile])
       else
-        mode = File.stat(Puppet[:lastrunfile]).mode
+        mode = Puppet::FileSystem::File.new(Puppet[:lastrunfile]).stat.mode
       end
       (mode & 0777).should == 0664
     end

data/spec/unit/{provider/confine → confine}/exists_spec.rb

@@ -1,20 +1,20 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/provider/confine/exists'
+require 'puppet/confine/exists'
 
-describe Puppet::Provider::Confine::Exists do
+describe Puppet::Confine::Exists do
   before do
-    @confine = Puppet::Provider::Confine::Exists.new("/my/file")
+    @confine = Puppet::Confine::Exists.new("/my/file")
     @confine.label = "eh"
   end
 
   it "should be named :exists" do
-    Puppet::Provider::Confine::Exists.name.should == :exists
+    Puppet::Confine::Exists.name.should == :exists
   end
   
   it "should not pass if exists is nil" do
-    confine = Puppet::Provider::Confine::Exists.new(nil)
+    confine = Puppet::Confine::Exists.new(nil)
     confine.label = ":exists => nil"
     confine.expects(:pass?).with(nil)
     confine.should_not be_valid
@@ -30,12 +30,12 @@ describe Puppet::Provider::Confine::Exists do
   end
 
   it "should return false if the value does not point to a file" do
-    FileTest.expects(:exist?).with("/my/file").returns false
+    Puppet::FileSystem::File.expects(:exist?).with("/my/file").returns false
     @confine.pass?("/my/file").should be_false
   end
 
   it "should return true if the value points to a file" do
-    FileTest.expects(:exist?).with("/my/file").returns true
+    Puppet::FileSystem::File.expects(:exist?).with("/my/file").returns true
     @confine.pass?("/my/file").should be_true
   end
 
@@ -62,11 +62,11 @@ describe Puppet::Provider::Confine::Exists do
   end
 
   it "should produce a summary containing all missing files" do
-    FileTest.stubs(:exist?).returns true
-    FileTest.expects(:exist?).with("/two").returns false
-    FileTest.expects(:exist?).with("/four").returns false
+    Puppet::FileSystem::File.stubs(:exist?).returns true
+    Puppet::FileSystem::File.expects(:exist?).with("/two").returns false
+    Puppet::FileSystem::File.expects(:exist?).with("/four").returns false
 
-    confine = Puppet::Provider::Confine::Exists.new %w{/one /two /three /four}
+    confine = Puppet::Confine::Exists.new %w{/one /two /three /four}
     confine.summary.should == %w{/two /four}
   end
 
@@ -75,6 +75,6 @@ describe Puppet::Provider::Confine::Exists do
     c2 = mock '2', :summary => %w{two}
     c3 = mock '3', :summary => %w{three}
 
-    Puppet::Provider::Confine::Exists.summarize([c1, c2, c3]).should == %w{one two three}
+    Puppet::Confine::Exists.summarize([c1, c2, c3]).should == %w{one two three}
   end
 end

data/spec/unit/{provider/confine → confine}/false_spec.rb

@@ -1,22 +1,22 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/provider/confine/false'
+require 'puppet/confine/false'
 
-describe Puppet::Provider::Confine::False do
+describe Puppet::Confine::False do
   it "should be named :false" do
-    Puppet::Provider::Confine::False.name.should == :false
+    Puppet::Confine::False.name.should == :false
   end
 
   it "should require a value" do
-    lambda { Puppet::Provider::Confine.new }.should raise_error(ArgumentError)
+    lambda { Puppet::Confine.new }.should raise_error(ArgumentError)
   end
 
   describe "when testing values" do
-    before { @confine = Puppet::Provider::Confine::False.new("foo") }
+    before { @confine = Puppet::Confine::False.new("foo") }
 
     it "should use the 'pass?' method to test validity" do
-      @confine = Puppet::Provider::Confine::False.new("foo")
+      @confine = Puppet::Confine::False.new("foo")
       @confine.label = "eh"
       @confine.expects(:pass?).with("foo")
       @confine.valid?
@@ -31,13 +31,13 @@ describe Puppet::Provider::Confine::False do
     end
 
     it "should produce a message that a value is true" do
-      @confine = Puppet::Provider::Confine::False.new("foo")
+      @confine = Puppet::Confine::False.new("foo")
       @confine.message("eh").should be_include("true")
     end
   end
 
   it "should be able to produce a summary with the number of incorrectly true values" do
-    confine = Puppet::Provider::Confine::False.new %w{one two three four}
+    confine = Puppet::Confine::False.new %w{one two three four}
     confine.expects(:pass?).times(4).returns(true).returns(false).returns(true).returns(false)
     confine.summary.should == 2
   end
@@ -47,6 +47,6 @@ describe Puppet::Provider::Confine::False do
     c2 = mock '2', :summary => 2
     c3 = mock '3', :summary => 3
 
-    Puppet::Provider::Confine::False.summarize([c1, c2, c3]).should == 6
+    Puppet::Confine::False.summarize([c1, c2, c3]).should == 6
   end
 end

data/spec/unit/{provider/confine → confine}/feature_spec.rb

@@ -1,24 +1,24 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/provider/confine/feature'
+require 'puppet/confine/feature'
 
-describe Puppet::Provider::Confine::Feature do
+describe Puppet::Confine::Feature do
   it "should be named :feature" do
-    Puppet::Provider::Confine::Feature.name.should == :feature
+    Puppet::Confine::Feature.name.should == :feature
   end
 
   it "should require a value" do
-    lambda { Puppet::Provider::Confine::Feature.new }.should raise_error(ArgumentError)
+    lambda { Puppet::Confine::Feature.new }.should raise_error(ArgumentError)
   end
 
   it "should always convert values to an array" do
-    Puppet::Provider::Confine::Feature.new("/some/file").values.should be_instance_of(Array)
+    Puppet::Confine::Feature.new("/some/file").values.should be_instance_of(Array)
   end
 
   describe "when testing values" do
     before do
-      @confine = Puppet::Provider::Confine::Feature.new("myfeature")
+      @confine = Puppet::Confine::Feature.new("myfeature")
       @confine.label = "eh"
     end
 
@@ -44,14 +44,14 @@ describe Puppet::Provider::Confine::Feature do
 
   it "should summarize multiple instances by returning a flattened array of all missing features" do
     confines = []
-    confines << Puppet::Provider::Confine::Feature.new(%w{one two})
-    confines << Puppet::Provider::Confine::Feature.new(%w{two})
-    confines << Puppet::Provider::Confine::Feature.new(%w{three four})
+    confines << Puppet::Confine::Feature.new(%w{one two})
+    confines << Puppet::Confine::Feature.new(%w{two})
+    confines << Puppet::Confine::Feature.new(%w{three four})
 
     features = mock 'feature'
     features.stub_everything
     Puppet.stubs(:features).returns features
 
-    Puppet::Provider::Confine::Feature.summarize(confines).sort.should == %w{one two three four}.sort
+    Puppet::Confine::Feature.summarize(confines).sort.should == %w{one two three four}.sort
   end
 end

data/spec/unit/{provider/confine → confine}/true_spec.rb

@@ -1,20 +1,20 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/provider/confine/true'
+require 'puppet/confine/true'
 
-describe Puppet::Provider::Confine::True do
+describe Puppet::Confine::True do
   it "should be named :true" do
-    Puppet::Provider::Confine::True.name.should == :true
+    Puppet::Confine::True.name.should == :true
   end
 
   it "should require a value" do
-    lambda { Puppet::Provider::Confine::True.new }.should raise_error(ArgumentError)
+    lambda { Puppet::Confine::True.new }.should raise_error(ArgumentError)
   end
 
   describe "when testing values" do
     before do
-      @confine = Puppet::Provider::Confine::True.new("foo")
+      @confine = Puppet::Confine::True.new("foo")
       @confine.label = "eh"
     end
 
@@ -37,7 +37,7 @@ describe Puppet::Provider::Confine::True do
   end
 
   it "should produce the number of false values when asked for a summary" do
-    @confine = Puppet::Provider::Confine::True.new %w{one two three four}
+    @confine = Puppet::Confine::True.new %w{one two three four}
     @confine.expects(:pass?).times(4).returns(true).returns(false).returns(true).returns(false)
     @confine.summary.should == 2
   end
@@ -47,6 +47,6 @@ describe Puppet::Provider::Confine::True do
     c2 = mock '2', :summary => 2
     c3 = mock '3', :summary => 3
 
-    Puppet::Provider::Confine::True.summarize([c1, c2, c3]).should == 6
+    Puppet::Confine::True.summarize([c1, c2, c3]).should == 6
   end
 end

data/spec/unit/{provider/confine → confine}/variable_spec.rb

@@ -1,28 +1,28 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/provider/confine/variable'
+require 'puppet/confine/variable'
 
-describe Puppet::Provider::Confine::Variable do
+describe Puppet::Confine::Variable do
   it "should be named :variable" do
-    Puppet::Provider::Confine::Variable.name.should == :variable
+    Puppet::Confine::Variable.name.should == :variable
   end
 
   it "should require a value" do
-    lambda { Puppet::Provider::Confine::Variable.new }.should raise_error(ArgumentError)
+    lambda { Puppet::Confine::Variable.new }.should raise_error(ArgumentError)
   end
 
   it "should always convert values to an array" do
-    Puppet::Provider::Confine::Variable.new("/some/file").values.should be_instance_of(Array)
+    Puppet::Confine::Variable.new("/some/file").values.should be_instance_of(Array)
   end
 
   it "should have an accessor for its name" do
-    Puppet::Provider::Confine::Variable.new(:bar).should respond_to(:name)
+    Puppet::Confine::Variable.new(:bar).should respond_to(:name)
   end
 
   describe "when testing values" do
     before do
-      @confine = Puppet::Provider::Confine::Variable.new("foo")
+      @confine = Puppet::Confine::Variable.new("foo")
       @confine.name = :myvar
     end
 
@@ -63,7 +63,7 @@ describe Puppet::Provider::Confine::Variable do
     end
 
     it "should produce a message that the fact value is not correct" do
-      @confine = Puppet::Provider::Confine::Variable.new(%w{bar bee})
+      @confine = Puppet::Confine::Variable.new(%w{bar bee})
       @confine.name = "eh"
       message = @confine.message("value")
       message.should be_include("facter")
@@ -71,7 +71,7 @@ describe Puppet::Provider::Confine::Variable do
     end
 
     it "should be valid if the test value matches any of the provided values" do
-      @confine = Puppet::Provider::Confine::Variable.new(%w{bar bee})
+      @confine = Puppet::Confine::Variable.new(%w{bar bee})
       @confine.expects(:test_value).returns "bee"
       @confine.should be_valid
     end
@@ -79,28 +79,28 @@ describe Puppet::Provider::Confine::Variable do
 
   describe "when summarizing multiple instances" do
     it "should return a hash of failing variables and their values" do
-      c1 = Puppet::Provider::Confine::Variable.new("one")
+      c1 = Puppet::Confine::Variable.new("one")
       c1.name = "uno"
       c1.expects(:valid?).returns false
-      c2 = Puppet::Provider::Confine::Variable.new("two")
+      c2 = Puppet::Confine::Variable.new("two")
       c2.name = "dos"
       c2.expects(:valid?).returns true
-      c3 = Puppet::Provider::Confine::Variable.new("three")
+      c3 = Puppet::Confine::Variable.new("three")
       c3.name = "tres"
       c3.expects(:valid?).returns false
 
-      Puppet::Provider::Confine::Variable.summarize([c1, c2, c3]).should == {"uno" => %w{one}, "tres" => %w{three}}
+      Puppet::Confine::Variable.summarize([c1, c2, c3]).should == {"uno" => %w{one}, "tres" => %w{three}}
     end
 
     it "should combine the values of multiple confines with the same fact" do
-      c1 = Puppet::Provider::Confine::Variable.new("one")
+      c1 = Puppet::Confine::Variable.new("one")
       c1.name = "uno"
       c1.expects(:valid?).returns false
-      c2 = Puppet::Provider::Confine::Variable.new("two")
+      c2 = Puppet::Confine::Variable.new("two")
       c2.name = "uno"
       c2.expects(:valid?).returns false
 
-      Puppet::Provider::Confine::Variable.summarize([c1, c2]).should == {"uno" => %w{one two}}
+      Puppet::Confine::Variable.summarize([c1, c2]).should == {"uno" => %w{one two}}
     end
   end
 end

data/spec/unit/{provider/confine_collection_spec.rb → confine_collection_spec.rb}

@@ -1,72 +1,72 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/provider/confine_collection'
+require 'puppet/confine_collection'
 
-describe Puppet::Provider::ConfineCollection do
+describe Puppet::ConfineCollection do
   it "should be able to add confines" do
-    Puppet::Provider::ConfineCollection.new("label").should respond_to(:confine)
+    Puppet::ConfineCollection.new("label").should respond_to(:confine)
   end
 
   it "should require a label at initialization" do
-    lambda { Puppet::Provider::ConfineCollection.new }.should raise_error(ArgumentError)
+    lambda { Puppet::ConfineCollection.new }.should raise_error(ArgumentError)
   end
 
   it "should make its label available" do
-    Puppet::Provider::ConfineCollection.new("mylabel").label.should == "mylabel"
+    Puppet::ConfineCollection.new("mylabel").label.should == "mylabel"
   end
 
   describe "when creating confine instances" do
     it "should create an instance of the named test with the provided values" do
       test_class = mock 'test_class'
       test_class.expects(:new).with(%w{my values}).returns(stub('confine', :label= => nil))
-      Puppet::Provider::Confine.expects(:test).with(:foo).returns test_class
+      Puppet::Confine.expects(:test).with(:foo).returns test_class
 
-      Puppet::Provider::ConfineCollection.new("label").confine :foo => %w{my values}
+      Puppet::ConfineCollection.new("label").confine :foo => %w{my values}
     end
 
     it "should copy its label to the confine instance" do
       confine = mock 'confine'
       test_class = mock 'test_class'
       test_class.expects(:new).returns confine
-      Puppet::Provider::Confine.expects(:test).returns test_class
+      Puppet::Confine.expects(:test).returns test_class
 
       confine.expects(:label=).with("label")
 
-      Puppet::Provider::ConfineCollection.new("label").confine :foo => %w{my values}
+      Puppet::ConfineCollection.new("label").confine :foo => %w{my values}
     end
 
     describe "and the test cannot be found" do
       it "should create a Facter test with the provided values and set the name to the test name" do
-        confine = Puppet::Provider::Confine.test(:variable).new(%w{my values})
+        confine = Puppet::Confine.test(:variable).new(%w{my values})
         confine.expects(:name=).with(:foo)
         confine.class.expects(:new).with(%w{my values}).returns confine
-        Puppet::Provider::ConfineCollection.new("label").confine(:foo => %w{my values})
+        Puppet::ConfineCollection.new("label").confine(:foo => %w{my values})
       end
     end
 
     describe "and the 'for_binary' option was provided" do
       it "should mark the test as a binary confine" do
-        confine = Puppet::Provider::Confine.test(:exists).new(:bar)
+        confine = Puppet::Confine.test(:exists).new(:bar)
         confine.expects(:for_binary=).with true
-        Puppet::Provider::Confine.test(:exists).expects(:new).with(:bar).returns confine
-        Puppet::Provider::ConfineCollection.new("label").confine :exists => :bar, :for_binary => true
+        Puppet::Confine.test(:exists).expects(:new).with(:bar).returns confine
+        Puppet::ConfineCollection.new("label").confine :exists => :bar, :for_binary => true
       end
     end
   end
 
   it "should be valid if no confines are present" do
-    Puppet::Provider::ConfineCollection.new("label").should be_valid
+    Puppet::ConfineCollection.new("label").should be_valid
   end
 
   it "should be valid if all confines pass" do
     c1 = stub 'c1', :valid? => true, :label= => nil
     c2 = stub 'c2', :valid? => true, :label= => nil
 
-    Puppet::Provider::Confine.test(:true).expects(:new).returns(c1)
-    Puppet::Provider::Confine.test(:false).expects(:new).returns(c2)
+    Puppet::Confine.test(:true).expects(:new).returns(c1)
+    Puppet::Confine.test(:false).expects(:new).returns(c2)
 
-    confiner = Puppet::Provider::ConfineCollection.new("label")
+    confiner = Puppet::ConfineCollection.new("label")
     confiner.confine :true => :bar, :false => :bee
 
     confiner.should be_valid
@@ -76,10 +76,10 @@ describe Puppet::Provider::ConfineCollection do
     c1 = stub 'c1', :valid? => true, :label= => nil
     c2 = stub 'c2', :valid? => false, :label= => nil
 
-    Puppet::Provider::Confine.test(:true).expects(:new).returns(c1)
-    Puppet::Provider::Confine.test(:false).expects(:new).returns(c2)
+    Puppet::Confine.test(:true).expects(:new).returns(c1)
+    Puppet::Confine.test(:false).expects(:new).returns(c2)
 
-    confiner = Puppet::Provider::ConfineCollection.new("label")
+    confiner = Puppet::ConfineCollection.new("label")
     confiner.confine :true => :bar, :false => :bee
 
     confiner.should_not be_valid
@@ -87,7 +87,7 @@ describe Puppet::Provider::ConfineCollection do
 
   describe "when providing a summary" do
     before do
-      @confiner = Puppet::Provider::ConfineCollection.new("label")
+      @confiner = Puppet::ConfineCollection.new("label")
     end
 
     it "should return a hash" do
@@ -100,32 +100,32 @@ describe Puppet::Provider::ConfineCollection do
 
     it "should add each test type's summary to the hash" do
       @confiner.confine :true => :bar, :false => :bee
-      Puppet::Provider::Confine.test(:true).expects(:summarize).returns :tsumm
-      Puppet::Provider::Confine.test(:false).expects(:summarize).returns :fsumm
+      Puppet::Confine.test(:true).expects(:summarize).returns :tsumm
+      Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
 
       @confiner.summary.should == {:true => :tsumm, :false => :fsumm}
     end
 
     it "should not include tests that return 0" do
       @confiner.confine :true => :bar, :false => :bee
-      Puppet::Provider::Confine.test(:true).expects(:summarize).returns 0
-      Puppet::Provider::Confine.test(:false).expects(:summarize).returns :fsumm
+      Puppet::Confine.test(:true).expects(:summarize).returns 0
+      Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
 
       @confiner.summary.should == {:false => :fsumm}
     end
 
     it "should not include tests that return empty arrays" do
       @confiner.confine :true => :bar, :false => :bee
-      Puppet::Provider::Confine.test(:true).expects(:summarize).returns []
-      Puppet::Provider::Confine.test(:false).expects(:summarize).returns :fsumm
+      Puppet::Confine.test(:true).expects(:summarize).returns []
+      Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
 
       @confiner.summary.should == {:false => :fsumm}
     end
 
     it "should not include tests that return empty hashes" do
       @confiner.confine :true => :bar, :false => :bee
-      Puppet::Provider::Confine.test(:true).expects(:summarize).returns({})
-      Puppet::Provider::Confine.test(:false).expects(:summarize).returns :fsumm
+      Puppet::Confine.test(:true).expects(:summarize).returns({})
+      Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
 
       @confiner.summary.should == {:false => :fsumm}
     end