puppet 0.24.6 → 0.24.7

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

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/node/rest'
+
+describe Puppet::Node::Rest do
+    before do
+        @searcher = Puppet::Node::Rest.new
+    end
+    
+    
+end

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

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/node'
+require 'puppet/indirector/node/yaml'
+
+describe Puppet::Node::Yaml do
+    it "should be a subclass of the Yaml terminus" do
+        Puppet::Node::Yaml.superclass.should equal(Puppet::Indirector::Yaml)
+    end
+
+    it "should have documentation" do
+        Puppet::Node::Yaml.doc.should_not be_nil
+    end
+
+    it "should be registered with the configuration store indirection" do
+        indirection = Puppet::Indirector::Indirection.instance(:node)
+        Puppet::Node::Yaml.indirection.should equal(indirection)
+    end
+
+    it "should have its name set to :node" do
+        Puppet::Node::Yaml.name.should == :yaml
+    end
+end

data/spec/unit/indirector/plain.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/indirector/plain'
+
+describe Puppet::Indirector::Plain do
+    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)
+
+        @plain_class = Class.new(Puppet::Indirector::Plain) do
+            def self.to_s
+                "Mystuff::Testing"
+            end
+        end
+
+        @searcher = @plain_class.new
+
+        @request = stub 'request', :key => "yay"
+    end
+
+    it "should return return an instance of the indirected model" do
+        object = mock 'object'
+        @model.expects(:new).with(@request.key).returns object
+        @searcher.find(@request).should equal(object)
+    end
+end

data/spec/unit/indirector/report/processor.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-9-23.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/report/processor'
+
+describe Puppet::Transaction::Report::Processor do
+    before do
+        Puppet.settings.stubs(:use).returns(true)
+    end
+
+    it "should provide a method for saving reports" do
+        Puppet::Transaction::Report::Processor.new.should respond_to(:save)
+    end
+end
+
+describe Puppet::Transaction::Report::Processor, " when saving a report" do
+    before do
+        Puppet.settings.stubs(:use)
+        @reporter = Puppet::Transaction::Report::Processor.new
+    end
+
+    it "should not process the report if reports are set to 'none'" do
+        Puppet::Reports.expects(:report).never
+        Puppet.settings.expects(:value).with(:reports).returns("none")
+
+        request = stub 'request', :instance => mock("report")
+
+        @reporter.save(request)
+    end
+
+    it "should process the report with each configured report type" do
+        Puppet.settings.stubs(:value).with(:reports).returns("one,two")
+        @reporter.send(:reports).should == %w{one two}
+    end
+end
+
+describe Puppet::Transaction::Report::Processor, " when processing a report" do
+    before do
+        Puppet.settings.stubs(:value).with(:reports).returns("one")
+        Puppet.settings.stubs(:use)
+        @reporter = Puppet::Transaction::Report::Processor.new
+
+        @report_type = mock 'one'
+        @dup_report = mock 'dupe report'
+        @dup_report.stubs(:process)
+        @report = mock 'report'
+        @report.expects(:dup).returns(@dup_report)
+
+        @request = stub 'request', :instance => @report
+
+        Puppet::Reports.expects(:report).with("one").returns(@report_type)
+
+        @dup_report.expects(:extend).with(@report_type)
+    end
+
+    # LAK:NOTE This is stupid, because the code is so short it doesn't
+    # make sense to split it out, which means I just do the same test
+    # three times so the spec looks right.
+    it "should process a duplicate of the report, not the original" do
+        @reporter.save(@request)
+    end
+
+    it "should extend the report with the report type's module" do
+        @reporter.save(@request)
+    end
+
+    it "should call the report type's :process method" do
+        @dup_report.expects(:process)
+        @reporter.save(@request)
+    end
+
+    it "should not raise exceptions" do
+        Puppet.settings.stubs(:value).with(:trace).returns(false)
+        @dup_report.expects(:process).raises(ArgumentError)
+        proc { @reporter.save(@request) }.should_not raise_error
+    end
+end

data/spec/unit/indirector/request.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/indirector/request'
+
+describe Puppet::Indirector::Request do
+    describe "when initializing" do
+        it "should require an indirection name, a key, and a method" do
+            lambda { Puppet::Indirector::Request.new }.should raise_error(ArgumentError)
+        end
+
+        it "should use provided value as the key if it is a string" do
+            Puppet::Indirector::Request.new(:ind, :method, "mykey").key.should == "mykey"
+        end
+
+        it "should use provided value as the key if it is a symbol" do
+            Puppet::Indirector::Request.new(:ind, :method, :mykey).key.should == :mykey
+        end
+
+        it "should use the name of the provided instance as its key if an instance is provided as the key instead of a string" do
+            instance = mock 'instance', :name => "mykey"
+            request = Puppet::Indirector::Request.new(:ind, :method, instance)
+            request.key.should == "mykey"
+            request.instance.should equal(instance)
+        end
+
+        it "should support options specified as a hash" do
+            lambda { Puppet::Indirector::Request.new(:ind, :method, :key, :one => :two) }.should_not raise_error(ArgumentError)
+        end
+
+        it "should support nil options" do
+            lambda { Puppet::Indirector::Request.new(:ind, :method, :key, nil) }.should_not raise_error(ArgumentError)
+        end
+
+        it "should support unspecified options" do
+            lambda { Puppet::Indirector::Request.new(:ind, :method, :key) }.should_not raise_error(ArgumentError)
+        end
+
+        it "should fail if options are specified as anything other than nil or a hash" do
+            lambda { Puppet::Indirector::Request.new(:ind, :method, :key, [:one, :two]) }.should raise_error(ArgumentError)
+        end
+
+        it "should use an empty options hash if nil was provided" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, nil).options.should == {}
+        end
+
+        it "should default to a nil node" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, nil).node.should be_nil
+        end
+
+        it "should set its node attribute if provided in the options" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, :node => "foo.com").node.should == "foo.com"
+        end
+
+        it "should default to a nil ip" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, nil).ip.should be_nil
+        end
+
+        it "should set its ip attribute if provided in the options" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, :ip => "192.168.0.1").ip.should == "192.168.0.1"
+        end
+
+        it "should default to being unauthenticated" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_authenticated
+        end
+
+        it "should set be marked authenticated if configured in the options" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, :authenticated => "eh").should be_authenticated
+        end
+
+        it "should keep its options as a hash even if a node is specified" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, :node => "eh").options.should be_instance_of(Hash)
+        end
+
+        it "should keep its options as a hash even if another option is specified" do
+            Puppet::Indirector::Request.new(:ind, :method, :key, :foo => "bar").options.should be_instance_of(Hash)
+        end
+    end
+
+    it "should look use the Indirection class to return the appropriate indirection" do
+        ind = mock 'indirection'
+        Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
+        request = Puppet::Indirector::Request.new(:myind, :method, :key)
+
+        request.indirection.should equal(ind)
+    end
+end

data/spec/unit/indirector/rest.rb

@@ -0,0 +1,372 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/indirector/rest'
+
+describe Puppet::Indirector::REST do
+    before do
+        Puppet::Indirector::Terminus.stubs(:register_terminus_class)
+        @model = stub('model')
+        @instance = stub('model instance')
+        @indirection = stub('indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model)
+        Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
+
+        @rest_class = Class.new(Puppet::Indirector::REST) do
+            def self.to_s
+                "This::Is::A::Test::Class"
+            end
+        end
+
+        @searcher = @rest_class.new
+    end
+    
+    describe "when locating the REST connection" do
+      before do
+        Puppet.settings.stubs(:value).returns("whatever")
+      end
+
+      it "should return the :server setting as the host" do
+        Puppet.settings.expects(:value).with(:server).returns "myserver"
+        @searcher.rest_connection_details[:host].should == "myserver"
+      end
+      
+      it "should return the :masterport (as an Integer) as the port" do
+        Puppet.settings.expects(:value).with(:masterport).returns "1234"
+        @searcher.rest_connection_details[:port].should == 1234
+      end
+    end
+    
+    describe "when doing a network fetch" do
+      before :each do
+        Net::HTTP.stubs(:start).returns('result')
+        @details = { :host => '127.0.0.1', :port => 34343 }
+        @searcher.stubs(:rest_connection_details).returns(@details)
+      end
+      
+      it "should accept a path" do
+        lambda { @search.network_fetch('foo') }.should_not raise_error(ArgumentError)
+      end
+      
+      it "should require a path" do
+        lambda { @searcher.network_fetch }.should raise_error(ArgumentError)
+      end
+            
+      it "should look up connection details" do
+        @searcher.expects(:rest_connection_details).returns(@details)
+        @searcher.network_fetch('foo')
+      end
+      
+      it "should use the GET http method" do
+        @mock_result = stub('mock result', :body => 'result')
+        @mock_connection = mock('mock http connection', :get => @mock_result)
+        @searcher.stubs(:network).yields(@mock_connection)
+        @searcher.network_fetch('foo')
+      end
+      
+      it "should use the appropriate remote server" do
+        Net::HTTP.expects(:start).with {|host, port| host == @details[:host] }
+        @searcher.network_fetch('foo')
+      end
+      
+      it "should use the appropriate remote port" do
+        Net::HTTP.expects(:start).with {|host, port| port == @details[:port] }
+        @searcher.network_fetch('foo')
+      end
+      
+      it "should use the provided path" do
+        @mock_result = stub('mock result', :body => 'result')
+        @mock_connection = stub('mock http connection')
+        @mock_connection.expects(:get).with('/foo').returns(@mock_result)
+        @searcher.stubs(:network).yields(@mock_connection)
+        @searcher.network_fetch('foo')
+      end
+                
+      it "should return the results of the GET request" do
+        @searcher.network_fetch('foo').should == 'result'        
+      end
+    end
+
+    describe "when doing a network delete" do
+      before :each do
+        Net::HTTP.stubs(:start).returns('result')
+        @details = { :host => '127.0.0.1', :port => 34343 }
+        @searcher.stubs(:rest_connection_details).returns(@details)
+      end
+      
+      it "should accept a path" do
+        lambda { @search.network_delete('foo') }.should_not raise_error(ArgumentError)
+      end
+      
+      it "should require a path" do
+        lambda { @searcher.network_delete }.should raise_error(ArgumentError)
+      end
+            
+      it "should look up connection details" do
+        @searcher.expects(:rest_connection_details).returns(@details)
+        @searcher.network_delete('foo')
+      end
+      
+      it "should use the DELETE http method" do
+        @mock_result = stub('mock result', :body => 'result')
+        @mock_connection = mock('mock http connection', :delete => @mock_result)
+        @searcher.stubs(:network).yields(@mock_connection)
+        @searcher.network_delete('foo')
+      end
+      
+      it "should use the appropriate remote server" do
+        Net::HTTP.expects(:start).with {|host, port| host == @details[:host] }
+        @searcher.network_delete('foo')
+      end
+      
+      it "should use the appropriate remote port" do
+        Net::HTTP.expects(:start).with {|host, port| port == @details[:port] }
+        @searcher.network_delete('foo')
+      end
+      
+      it "should use the provided path" do
+        @mock_result = stub('mock result', :body => 'result')
+        @mock_connection = stub('mock http connection')
+        @mock_connection.expects(:delete).with('/foo').returns(@mock_result)
+        @searcher.stubs(:network).yields(@mock_connection)
+        @searcher.network_delete('foo')
+      end
+            
+      it "should return the results of the DELETE request" do
+        @searcher.network_delete('foo').should == 'result'        
+      end    
+    end
+    
+    describe "when doing a network put" do
+      before :each do
+        Net::HTTP.stubs(:start).returns('result')
+        @details = { :host => '127.0.0.1', :port => 34343 }
+        @data = { :foo => 'bar' }
+        @searcher.stubs(:rest_connection_details).returns(@details)
+      end
+      
+      it "should accept a path and data" do
+        lambda { @search.network_put('foo', @data) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "should require a path and data" do
+        lambda { @searcher.network_put('foo') }.should raise_error(ArgumentError)
+      end
+      
+      it "should look up connection details" do
+        @searcher.expects(:rest_connection_details).returns(@details)
+        @searcher.network_put('foo', @data)
+      end
+      
+      it "should use the appropriate remote server" do
+        Net::HTTP.expects(:start).with {|host, port| host == @details[:host] }
+        @searcher.network_put('foo', @data)
+      end
+      
+      it "should use the appropriate remote port" do
+        Net::HTTP.expects(:start).with {|host, port| port == @details[:port] }
+        @searcher.network_put('foo', @data)
+      end
+      
+      it "should use the PUT http method" do
+        @mock_result = stub('mock result', :body => 'result')
+        @mock_connection = mock('mock http connection', :put => @mock_result)
+        @searcher.stubs(:network).yields(@mock_connection)
+        @searcher.network_put('foo', @data)
+      end
+      
+      it "should use the provided path" do
+        @mock_result = stub('mock result', :body => 'result')
+        @mock_connection = stub('mock http connection')
+        @mock_connection.expects(:put).with {|path, data| path == '/foo' }.returns(@mock_result)
+        @searcher.stubs(:network).yields(@mock_connection)
+        @searcher.network_put('foo', @data)        
+      end
+      
+      it "should use the provided data" do
+        @mock_result = stub('mock result', :body => 'result')
+        @mock_connection = stub('mock http connection')
+        @mock_connection.expects(:put).with {|path, data| data == @data }.returns(@mock_result)
+        @searcher.stubs(:network).yields(@mock_connection)
+        @searcher.network_put('foo', @data)                
+      end
+      
+      it "should return the results of the PUT request" do
+        @searcher.network_put('foo', @data).should == 'result'        
+      end    
+    end
+
+    describe "when doing a find" do
+      before :each do
+        @result = { :foo => 'bar'}.to_yaml
+        @searcher.stubs(:network_fetch).returns(@result)  # neuter the network connection
+        @model.stubs(:from_yaml).returns(@instance)
+
+        @request = stub 'request', :key => 'foo'
+      end
+      
+      it "should look up the model instance over the network" do
+        @searcher.expects(:network_fetch).returns(@result)
+        @searcher.find(@request)
+      end
+      
+      it "should look up the model instance using the named indirection" do
+        @searcher.expects(:network_fetch).with {|path| path =~ %r{^#{@indirection.name.to_s}/} }.returns(@result)
+        @searcher.find(@request)
+      end
+      
+      it "should look up the model instance using the provided key" do
+        @searcher.expects(:network_fetch).with {|path| path =~ %r{/foo$} }.returns(@result)
+        @searcher.find(@request)
+      end
+      
+      it "should deserialize result data to a Model instance" do
+        @model.expects(:from_yaml)
+        @searcher.find(@request)
+      end
+      
+      it "should return the deserialized Model instance" do
+        @searcher.find(@request).should == @instance     
+      end
+      
+      it "should return nil when deserialized model instance is nil" do
+        @model.stubs(:from_yaml).returns(nil)
+        @searcher.find(@request).should be_nil
+      end
+      
+      it "should generate an error when result data deserializes improperly" do
+        @model.stubs(:from_yaml).raises(ArgumentError)
+        lambda { @searcher.find(@request) }.should raise_error(ArgumentError)
+      end
+      
+      it "should generate an error when result data specifies an error" do
+        @searcher.stubs(:network_fetch).returns(RuntimeError.new("bogus").to_yaml)
+        lambda { @searcher.find(@request) }.should raise_error(RuntimeError)        
+      end      
+    end
+
+    describe "when doing a search" do
+      before :each do
+        @result = [1, 2].to_yaml
+        @searcher.stubs(:network_fetch).returns(@result)
+        @model.stubs(:from_yaml).returns(@instance)
+
+        @request = stub 'request', :key => 'foo'
+      end
+      
+      it "should look up the model data over the network" do
+        @searcher.expects(:network_fetch).returns(@result)
+        @searcher.search(@request)
+      end
+      
+      it "should look up the model instance using the named indirection" do
+        @searcher.expects(:network_fetch).with {|path| path =~ %r{^#{@indirection.name.to_s}s/} }.returns(@result)
+        @searcher.search(@request)
+      end
+      
+      it "should look up the model instance using the provided key" do
+        @searcher.expects(:network_fetch).with {|path| path =~ %r{/foo$} }.returns(@result)
+        @searcher.search(@request)
+      end
+      
+      it "should deserialize result data into a list of Model instances" do
+        @model.expects(:from_yaml).at_least(2)
+        @searcher.search(@request)
+      end
+      
+      it "should generate an error when result data deserializes improperly" do
+        @model.stubs(:from_yaml).raises(ArgumentError)
+        lambda { @searcher.search(@request) }.should raise_error(ArgumentError)        
+      end
+      
+      it "should generate an error when result data specifies an error" do
+        @searcher.stubs(:network_fetch).returns(RuntimeError.new("bogus").to_yaml)
+        lambda { @searcher.search(@request) }.should raise_error(RuntimeError)        
+      end     
+    end    
+    
+    describe "when doing a destroy" do
+      before :each do
+        @result = true.to_yaml
+        @searcher.stubs(:network_delete).returns(@result)  # neuter the network connection
+        @model.stubs(:from_yaml).returns(@instance)
+
+        @request = stub 'request', :key => 'foo'
+      end
+      
+      it "should look up the model instance over the network" do
+        @searcher.expects(:network_delete).returns(@result)
+        @searcher.destroy(@request)
+      end
+      
+      it "should look up the model instance using the named indirection" do
+        @searcher.expects(:network_delete).with {|path| path =~ %r{^#{@indirection.name.to_s}/} }.returns(@result)
+        @searcher.destroy(@request)
+      end
+      
+      it "should look up the model instance using the provided key" do
+        @searcher.expects(:network_delete).with {|path| path =~ %r{/foo$} }.returns(@result)
+        @searcher.destroy(@request)
+      end
+      
+      it "should deserialize result data" do
+        YAML.expects(:load).with(@result)
+        @searcher.destroy(@request)
+      end
+      
+      it "should return deserialized result data" do
+        @searcher.destroy(@request).should == true
+      end
+      
+      it "should generate an error when result data specifies an error" do
+        @searcher.stubs(:network_delete).returns(RuntimeError.new("bogus").to_yaml)
+        lambda { @searcher.destroy(@request) }.should raise_error(RuntimeError)        
+      end      
+    end
+
+    describe "when doing a save" do
+      before :each do
+        @result = { :foo => 'bar'}.to_yaml
+        @searcher.stubs(:network_put).returns(@result)  # neuter the network connection
+        @model.stubs(:from_yaml).returns(@instance)
+
+        @request = stub 'request', :instance => @instance
+      end
+      
+      it "should save the model instance over the network" do
+        @searcher.expects(:network_put).returns(@result)
+        @searcher.save(@request)
+      end
+      
+      it "should save the model instance using the named indirection" do
+        @searcher.expects(:network_put).with do |path, data| 
+          path =~ %r{^#{@indirection.name.to_s}/} and 
+          data == @instance.to_yaml 
+        end.returns(@result)
+        @searcher.save(@request)
+      end
+      
+      it "should deserialize result data to a Model instance" do
+        @model.expects(:from_yaml)
+        @searcher.save(@request)
+      end
+      
+      it "should return the resulting deserialized Model instance" do
+        @searcher.save(@request).should == @instance     
+      end
+      
+      it "should return nil when deserialized model instance is nil" do
+        @model.stubs(:from_yaml).returns(nil)
+        @searcher.save(@request).should be_nil
+      end
+      
+      it "should generate an error when result data deserializes improperly" do
+        @model.stubs(:from_yaml).raises(ArgumentError)
+        lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
+      end
+      
+      it "should generate an error when result data specifies an error" do
+        @searcher.stubs(:network_put).returns(RuntimeError.new("bogus").to_yaml)
+        lambda { @searcher.save(@request) }.should raise_error(RuntimeError)        
+      end      
+    end
+end