puppet 2.7.9 → 2.7.11

data/spec/unit/face/instrumentation_data.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:instrumentation_data, '0.0.1'] do
+  it_should_behave_like "an indirector face"
+end

data/spec/unit/face/instrumentation_listener.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:instrumentation_listener, '0.0.1'] do
+  it_should_behave_like "an indirector face"
+
+  [:enable, :disable].each do |m|
+    describe "when running ##{m}" do
+      before(:each) do
+        @listener = stub_everything 'listener'
+        Puppet::Face[:instrumentation_listener, '0.0.1'].stubs(:find).returns(@listener)
+        Puppet::Face[:instrumentation_listener, '0.0.1'].stubs(:save)
+        Puppet::Util::Instrumentation::Listener.indirection.stubs(:terminus_class=)
+      end
+
+      it "should force the REST terminus" do
+        Puppet::Util::Instrumentation::Listener.indirection.expects(:terminus_class=).with(:rest)
+        subject.send(m, "dummy")
+      end
+
+      it "should find the named listener" do
+        Puppet::Face[:instrumentation_listener, '0.0.1'].expects(:find).with("dummy").returns(@listener)
+        subject.send(m, "dummy")
+      end
+
+      it "should #{m} the named listener" do
+        @listener.expects(:enabled=).with( m == :enable )
+        subject.send(m, "dummy")
+      end
+
+      it "should save finally the listener" do
+        Puppet::Face[:instrumentation_listener, '0.0.1'].expects(:save).with(@listener)
+        subject.send(m, "dummy")
+      end
+    end
+  end
+end

data/spec/unit/face/instrumentation_probe.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:instrumentation_probe, '0.0.1'] do
+  it_should_behave_like "an indirector face"
+
+  describe 'when running #enable' do
+    it 'should invoke #save' do
+      subject.expects(:save).with(nil)
+      subject.enable('hostname')
+    end
+  end
+
+  describe 'when running #disable' do
+    it 'should invoke #destroy' do
+      subject.expects(:destroy).with(nil)
+      subject.disable('hostname')
+    end
+  end
+end

data/spec/unit/face/node_spec.rb

@@ -14,9 +14,7 @@ describe Puppet::Face[:node, '0.0.1'] do
         "cached_facts" => ['hostname'],
         "cached_node"  => ['hostname'],
         "reports"      => ['hostname'],
-
-        # Support for cleaning storeconfigs has been temporarily suspended.
-        # "storeconfigs" => ['hostname', :unexport]
+        "storeconfigs" => ['hostname', :unexport]
       }.each { |k, v| subject.expects("clean_#{k}".to_sym).with(*v) }
       subject.cleanup('hostname', :unexport)
     end
@@ -158,114 +156,116 @@ describe Puppet::Face[:node, '0.0.1'] do
         end
       end
 
-      # describe "when cleaning storeconfigs entries for host", :if => Puppet.features.rails? do
-      #   before :each do
-      #     # Stub this so we don't need access to the DB
-      #     require 'puppet/rails/host'
-      #
-      #     Puppet.stubs(:[]).with(:storeconfigs).returns(true)
-      #
-      #     Puppet::Rails.stubs(:connect)
-      #     @rails_node = stub_everything 'rails_node'
-      #     Puppet::Rails::Host.stubs(:find_by_name).returns(@rails_node)
-      #   end
-      #
-      #   it "should connect to the database" do
-      #     Puppet::Rails.expects(:connect)
-      #     subject.clean_storeconfigs(@host, false)
-      #   end
-      #
-      #   it "should find the right host entry" do
-      #     Puppet::Rails::Host.expects(:find_by_name).with(@host).returns(@rails_node)
-      #     subject.clean_storeconfigs(@host, false)
-      #   end
-      #
-      #   describe "without unexport" do
-      #     it "should remove the host and it's content" do
-      #       @rails_node.expects(:destroy)
-      #       subject.clean_storeconfigs(@host, false)
-      #     end
-      #   end
-      #
-      #   describe "with unexport" do
-      #     before :each do
-      #       @rails_node.stubs(:id).returns(1234)
-      #
-      #       @type = stub_everything 'type'
-      #       @type.stubs(:validattr?).with(:ensure).returns(true)
-      #
-      #       @ensure_name = stub_everything 'ensure_name', :id => 23453
-      #       Puppet::Rails::ParamName.stubs(:find_or_create_by_name).returns(@ensure_name)
-      #
-      #       @param_values = stub_everything 'param_values'
-      #       @resource = stub_everything 'resource', :param_values => @param_values, :restype => "File"
-      #       Puppet::Rails::Resource.stubs(:find).returns([@resource])
-      #     end
-      #
-      #     it "should find all resources" do
-      #       Puppet::Rails::Resource.expects(:find).with(:all, {:include => {:param_values => :param_name}, :conditions => ["exported=? AND host_id=?", true, 1234]}).returns([])
-      #
-      #       subject.clean_storeconfigs(@host, true)
-      #     end
-      #
-      #     describe "with an exported native type" do
-      #       before :each do
-      #         Puppet::Type.stubs(:type).returns(@type)
-      #         @type.expects(:validattr?).with(:ensure).returns(true)
-      #       end
-      #
-      #       it "should test a native type for ensure as an attribute" do
-      #         subject.clean_storeconfigs(@host, true)
-      #       end
-      #
-      #       it "should delete the old ensure parameter" do
-      #         ensure_param = stub 'ensure_param', :id => 12345, :line => 12
-      #         @param_values.stubs(:find).returns(ensure_param)
-      #         Puppet::Rails::ParamValue.expects(:delete).with(12345);
-      #         subject.clean_storeconfigs(@host, true)
-      #       end
-      #
-      #       it "should add an ensure => absent parameter" do
-      #         @param_values.expects(:create).with(:value => "absent",
-      #                                             :line => 0,
-      #                                             :param_name => @ensure_name)
-      #         subject.clean_storeconfigs(@host, true)
-      #       end
-      #     end
-      #
-      #     describe "with an exported definition" do
-      #       it "should try to lookup a definition and test it for the ensure argument" do
-      #         Puppet::Type.stubs(:type).returns(nil)
-      #         definition = stub_everything 'definition', :arguments => { 'ensure' => 'present' }
-      #         Puppet::Resource::TypeCollection.any_instance.expects(:find_definition).with('', "File").returns(definition)
-      #         subject.clean_storeconfigs(@host, true)
-      #       end
-      #     end
-      #
-      #     it "should not unexport the resource of an unknown type" do
-      #       Puppet::Type.stubs(:type).returns(nil)
-      #       Puppet::Resource::TypeCollection.any_instance.expects(:find_definition).with('', "File").returns(nil)
-      #       Puppet::Rails::ParamName.expects(:find_or_create_by_name).never
-      #       subject.clean_storeconfigs(@host)
-      #     end
-      #
-      #     it "should not unexport the resource of a not ensurable native type" do
-      #       Puppet::Type.stubs(:type).returns(@type)
-      #       @type.expects(:validattr?).with(:ensure).returns(false)
-      #       Puppet::Resource::TypeCollection.any_instance.expects(:find_definition).with('', "File").returns(nil)
-      #       Puppet::Rails::ParamName.expects(:find_or_create_by_name).never
-      #       subject.clean_storeconfigs(@host, true)
-      #     end
-      #
-      #     it "should not unexport the resource of a not ensurable definition" do
-      #       Puppet::Type.stubs(:type).returns(nil)
-      #       definition = stub_everything 'definition', :arguments => { 'foobar' => 'someValue' }
-      #       Puppet::Resource::TypeCollection.any_instance.expects(:find_definition).with('', "File").returns(definition)
-      #       Puppet::Rails::ParamName.expects(:find_or_create_by_name).never
-      #       subject.clean_storeconfigs(@host, true)
-      #     end
-      #   end
-      # end
+      describe "when cleaning storeconfigs entries for host", :if => Puppet.features.rails? do
+        before :each do
+          # Stub this so we don't need access to the DB
+          require 'puppet/rails/host'
+
+          Puppet.stubs(:[]).with(:storeconfigs).returns(true)
+
+          Puppet::Rails.stubs(:connect)
+          @rails_node = stub_everything 'rails_node'
+          Puppet::Rails::Host.stubs(:find_by_name).returns(@rails_node)
+        end
+
+        it "should connect to the database" do
+          Puppet::Rails.expects(:connect)
+          subject.clean_storeconfigs(@host, false)
+        end
+
+        it "should find the right host entry" do
+          Puppet::Rails::Host.expects(:find_by_name).with(@host).returns(@rails_node)
+
+          subject.clean_storeconfigs(@host, false)
+        end
+
+        describe "without unexport" do
+          it "should remove the host and it's content" do
+            @rails_node.expects(:destroy)
+
+           subject.clean_storeconfigs(@host, false)
+          end
+        end
+
+        describe "with unexport" do
+          before :each do
+            @rails_node.stubs(:id).returns(1234)
+
+            @type = stub_everything 'type'
+            @type.stubs(:validattr?).with(:ensure).returns(true)
+
+            @ensure_name = stub_everything 'ensure_name', :id => 23453
+            Puppet::Rails::ParamName.stubs(:find_or_create_by_name).returns(@ensure_name)
+
+            @param_values = stub_everything 'param_values'
+            @resource = stub_everything 'resource', :param_values => @param_values, :restype => "File"
+            Puppet::Rails::Resource.stubs(:find).returns([@resource])
+          end
+
+          it "should find all resources" do
+            Puppet::Rails::Resource.expects(:find).with(:all, {:include => {:param_values => :param_name}, :conditions => ["exported=? AND host_id=?", true, 1234]}).returns([])
+
+            subject.clean_storeconfigs(@host, true)
+          end
+
+          describe "with an exported native type" do
+            before :each do
+              Puppet::Type.stubs(:type).returns(@type)
+              @type.expects(:validattr?).with(:ensure).returns(true)
+            end
+
+            it "should test a native type for ensure as an attribute" do
+              subject.clean_storeconfigs(@host, true)
+            end
+
+            it "should delete the old ensure parameter" do
+              ensure_param = stub 'ensure_param', :id => 12345, :line => 12
+              @param_values.stubs(:find).returns(ensure_param)
+              Puppet::Rails::ParamValue.expects(:delete).with(12345);
+              subject.clean_storeconfigs(@host, true)
+            end
+
+            it "should add an ensure => absent parameter" do
+              @param_values.expects(:create).with(:value => "absent",
+                                                       :line => 0,
+                                                       :param_name => @ensure_name)
+              subject.clean_storeconfigs(@host, true)
+            end
+          end
+
+          describe "with an exported definition" do
+            it "should try to lookup a definition and test it for the ensure argument" do
+              Puppet::Type.stubs(:type).returns(nil)
+              definition = stub_everything 'definition', :arguments => { 'ensure' => 'present' }
+              Puppet::Resource::TypeCollection.any_instance.expects(:find_definition).with('', "File").returns(definition)
+              subject.clean_storeconfigs(@host, true)
+            end
+          end
+
+          it "should not unexport the resource of an unkown type" do
+            Puppet::Type.stubs(:type).returns(nil)
+            Puppet::Resource::TypeCollection.any_instance.expects(:find_definition).with('', "File").returns(nil)
+            Puppet::Rails::ParamName.expects(:find_or_create_by_name).never
+            subject.clean_storeconfigs(@host, true)
+          end
+
+          it "should not unexport the resource of a not ensurable native type" do
+            Puppet::Type.stubs(:type).returns(@type)
+            @type.expects(:validattr?).with(:ensure).returns(false)
+            Puppet::Resource::TypeCollection.any_instance.expects(:find_definition).with('', "File").returns(nil)
+            Puppet::Rails::ParamName.expects(:find_or_create_by_name).never
+            subject.clean_storeconfigs(@host, true)
+          end
+
+          it "should not unexport the resource of a not ensurable definition" do
+            Puppet::Type.stubs(:type).returns(nil)
+            definition = stub_everything 'definition', :arguments => { 'foobar' => 'someValue' }
+            Puppet::Resource::TypeCollection.any_instance.expects(:find_definition).with('', "File").returns(definition)
+            Puppet::Rails::ParamName.expects(:find_or_create_by_name).never
+            subject.clean_storeconfigs(@host, true)
+          end
+        end
+      end
     end
   end
 end

data/spec/unit/file_serving/content_spec.rb

@@ -102,13 +102,13 @@ describe Puppet::FileServing::Content, "when returning the contents" do
 
   it "should return the contents of the path if the file exists" do
     File.expects(:stat).with(@path).returns stub("stat", :ftype => "file")
-    File.expects(:read).with(@path).returns(:mycontent)
+    Puppet::Util.expects(:binread).with(@path).returns(:mycontent)
     @content.content.should == :mycontent
   end
 
   it "should cache the returned contents" do
     File.expects(:stat).with(@path).returns stub("stat", :ftype => "file")
-    File.expects(:read).with(@path).returns(:mycontent)
+    Puppet::Util.expects(:binread).with(@path).returns(:mycontent)
     @content.content
 
     # The second run would throw a failure if the content weren't being cached.

data/spec/unit/indirector/facts/facter_spec.rb

@@ -21,14 +21,29 @@ describe Puppet::Node::Facts::Facter do
     Puppet::Node::Facts::Facter.name.should == :facter
   end
 
-  it "should load facts on initialization" do
-    Puppet::Node::Facts::Facter.expects(:load_fact_plugins)
-    Puppet::Node::Facts::Facter.new
+  describe "when reloading Facter" do
+    before do
+      @facter_class = Puppet::Node::Facts::Facter
+      Facter.stubs(:clear)
+      Facter.stubs(:load)
+      Facter.stubs(:loadfacts)
+    end
+
+    it "should clear Facter" do
+      Facter.expects(:clear)
+      @facter_class.reload_facter
+    end
+
+    it "should load all Facter facts" do
+      Facter.expects(:loadfacts)
+      @facter_class.reload_facter
+    end
   end
 end
 
 describe Puppet::Node::Facts::Facter do
   before :each do
+    Puppet::Node::Facts::Facter.stubs(:reload_facter)
     @facter = Puppet::Node::Facts::Facter.new
     Facter.stubs(:to_hash).returns({})
     @name = "me"
@@ -36,6 +51,13 @@ describe Puppet::Node::Facts::Facter do
   end
 
   describe Puppet::Node::Facts::Facter, " when finding facts" do
+    it "should reset and load facts" do
+      clear = sequence 'clear'
+      Puppet::Node::Facts::Facter.expects(:reload_facter).in_sequence(clear)
+      Puppet::Node::Facts::Facter.expects(:load_fact_plugins).in_sequence(clear)
+      @facter.find(@request)
+    end
+
     it "should return a Facts instance" do
       @facter.find(@request).should be_instance_of(Puppet::Node::Facts)
     end

data/spec/unit/indirector/facts/inventory_active_record_spec.rb

@@ -38,10 +38,22 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
   end
 
   describe "#save" do
+    let(:node) {
+      Puppet::Rails::InventoryNode.new(:name => "foo", :timestamp => Time.now)
+    }
+
+    let(:facts) {
+      Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin")
+    }
+
+    it "should retry on ActiveRecord error" do
+      Puppet::Rails::InventoryNode.expects(:create).twice.raises(ActiveRecord::StatementInvalid).returns node
+
+      Puppet::Node::Facts.indirection.save(facts)
+    end
+
     it "should use an existing node if possible" do
-      node = Puppet::Rails::InventoryNode.new(:name => "foo", :timestamp => Time.now)
       node.save
-      facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin")
       Puppet::Node::Facts.indirection.save(facts)
 
       Puppet::Rails::InventoryNode.count.should == 1
@@ -52,7 +64,6 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
       # This test isn't valid if there are nodes to begin with
       Puppet::Rails::InventoryNode.count.should == 0
 
-      facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin")
       Puppet::Node::Facts.indirection.save(facts)
 
       Puppet::Rails::InventoryNode.count.should == 1
@@ -60,7 +71,6 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
     end
 
     it "should save the facts" do
-      facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin")
       Puppet::Node::Facts.indirection.save(facts)
 
       Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should =~ [["uptime_days","60"],["kernel","Darwin"]]

data/spec/unit/indirector/instrumentation_data/local_spec.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'puppet/util/instrumentation/listener'
+require 'puppet/indirector/instrumentation_data/local'
+
+describe Puppet::Indirector::InstrumentationData::Local do
+  it "should be a subclass of the Code terminus" do
+    Puppet::Indirector::InstrumentationData::Local.superclass.should equal(Puppet::Indirector::Code)
+  end
+
+  it "should be registered with the configuration store indirection" do
+    indirection = Puppet::Indirector::Indirection.instance(:instrumentation_data)
+    Puppet::Indirector::InstrumentationData::Local.indirection.should equal(indirection)
+  end
+
+  it "should have its name set to :local" do
+    Puppet::Indirector::InstrumentationData::Local.name.should == :local
+  end
+end
+
+describe Puppet::Indirector::InstrumentationData::Local do
+  before :each do
+    Puppet::Util::Instrumentation.stubs(:listener)
+    @data = Puppet::Indirector::InstrumentationData::Local.new
+    @name = "me"
+    @request = stub 'request', :key => @name
+  end
+
+  describe "when finding instrumentation data" do
+    it "should return a Instrumentation Data instance matching the key" do
+    end
+  end
+
+  describe "when searching listeners" do
+    it "should raise an error" do
+      lambda { @data.search(@request) }.should raise_error(Puppet::DevError)
+    end
+  end
+
+  describe "when saving listeners" do
+    it "should raise an error" do
+      lambda { @data.save(@request) }.should raise_error(Puppet::DevError)
+    end
+  end
+
+  describe "when destroying listeners" do
+    it "should raise an error" do
+      lambda { @data.destroy(@reques) }.should raise_error(Puppet::DevError)
+    end
+  end
+end