puppet 0.25.5 → 2.6.0

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

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/node/memory'
+
+require 'shared_behaviours/memory_terminus'
+
+describe Puppet::Node::Memory do
+  before do
+    @name = "me"
+    @searcher = Puppet::Node::Memory.new
+    @instance = stub 'instance', :name => @name
+
+    @request = stub 'request', :key => @name, :instance => @instance
+  end
+
+  it_should_behave_like "A Memory Terminus"
+end

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

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/node/plain'
+
+describe Puppet::Node::Plain do
+  before do
+    @searcher = Puppet::Node::Plain.new
+  end
+
+  it "should call node_merge() on the returned node" do
+    node = mock 'node'
+    Puppet::Node.expects(:new).with("mynode").returns(node)
+    node.expects(:fact_merge)
+    request = stub 'request', :key => "mynode"
+    @searcher.find(request)
+  end
+end

data/spec/unit/indirector/node/rest_spec.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_spec.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_spec.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/queue_spec.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/indirector/queue'
+
+class Puppet::Indirector::Queue::TestClient
+end
+
+class FooExampleData
+  attr_accessor :name
+
+  def self.pson_create(pson)
+    new(pson['data'].to_sym)
+  end
+
+  def initialize(name = nil)
+    @name = name if name
+  end
+
+  def render(format = :pson)
+    to_pson
+  end
+
+  def to_pson(*args)
+    {:type => self.class.to_s, :data => name}.to_pson(*args)
+  end
+end
+
+describe Puppet::Indirector::Queue do
+  confine "PSON library is missing; cannot test queueing" => Puppet.features.pson?
+
+  before :each do
+    @model = mock 'model'
+    @indirection = stub 'indirection', :name => :my_queue, :register_terminus_type => nil, :model => @model
+    Puppet::Indirector::Indirection.stubs(:instance).with(:my_queue).returns(@indirection)
+    @store_class = Class.new(Puppet::Indirector::Queue) do
+      def self.to_s
+        'MyQueue::MyType'
+      end
+    end
+    @store = @store_class.new
+
+    @subject_class = FooExampleData
+    @subject = @subject_class.new
+    @subject.name = :me
+
+    Puppet.settings.stubs(:value).returns("bogus setting data")
+    Puppet.settings.stubs(:value).with(:queue_type).returns(:test_client)
+    Puppet::Util::Queue.stubs(:queue_type_to_class).with(:test_client).returns(Puppet::Indirector::Queue::TestClient)
+
+    @request = stub 'request', :key => :me, :instance => @subject
+  end
+
+  it "should require PSON" do
+    Puppet.features.expects(:pson?).returns false
+
+    lambda { @store_class.new }.should raise_error(ArgumentError)
+  end
+
+  it 'should use the correct client type and queue' do
+    @store.queue.should == :my_queue
+    @store.client.should be_an_instance_of(Puppet::Indirector::Queue::TestClient)
+  end
+
+  describe "when saving" do
+    it 'should render the instance using pson' do
+      @subject.expects(:render).with(:pson)
+      @store.client.stubs(:send_message)
+      @store.save(@request)
+    end
+
+    it "should send the rendered message to the appropriate queue on the client" do
+      @subject.expects(:render).returns "mypson"
+
+      @store.client.expects(:send_message).with(:my_queue, "mypson")
+
+      @store.save(@request)
+    end
+
+    it "should catch any exceptions raised" do
+      @store.client.expects(:send_message).raises ArgumentError
+
+      lambda { @store.save(@request) }.should raise_error(Puppet::Error)
+    end
+  end
+
+  describe "when subscribing to the queue" do
+    before do
+      @store_class.stubs(:model).returns @model
+    end
+
+    it "should use the model's Format support to intern the message from pson" do
+      @model.expects(:convert_from).with(:pson, "mymessage")
+
+      @store_class.client.expects(:subscribe).yields("mymessage")
+      @store_class.subscribe {|o| o }
+    end
+
+    it "should yield each interned received message" do
+      @model.stubs(:convert_from).returns "something"
+
+      @subject_two = @subject_class.new
+      @subject_two.name = :too
+
+      @store_class.client.expects(:subscribe).with(:my_queue).multiple_yields(@subject, @subject_two)
+
+      received = []
+      @store_class.subscribe do |obj|
+        received.push(obj)
+      end
+
+      received.should == %w{something something}
+    end
+
+    it "should log but not propagate errors" do
+      @store_class.client.expects(:subscribe).yields("foo")
+      @store_class.expects(:intern).raises ArgumentError
+      Puppet.expects(:err)
+      @store_class.subscribe {|o| o }
+    end
+  end
+end
+

data/spec/unit/indirector/report/processor_spec.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/report/rest_spec.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/report/rest'
+
+describe Puppet::Transaction::Report::Rest do
+  it "should be a subclass of Puppet::Indirector::REST" do
+    Puppet::Transaction::Report::Rest.superclass.should equal(Puppet::Indirector::REST)
+  end
+
+  it "should use the :report_server setting in preference to :reportserver" do
+    Puppet.settings[:reportserver] = "reportserver"
+    Puppet.settings[:report_server] = "report_server"
+    Puppet::Transaction::Report::Rest.server.should == "report_server"
+  end
+
+  it "should use the :report_server setting in preference to :server" do
+    Puppet.settings[:server] = "server"
+    Puppet.settings[:report_server] = "report_server"
+    Puppet::Transaction::Report::Rest.server.should == "report_server"
+  end
+
+  it "should have a value for report_server and report_port" do
+    Puppet::Transaction::Report::Rest.server.should_not be_nil
+    Puppet::Transaction::Report::Rest.port.should_not be_nil
+  end
+end

data/spec/unit/indirector/request_spec.rb

@@ -0,0 +1,304 @@
+#!/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 always convert the indirection name to a symbol" do
+      Puppet::Indirector::Request.new("ind", :method, "mykey").indirection_name.should == :ind
+    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 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
+
+    it "should treat options other than :ip, :node, and :authenticated as options rather than attributes" do
+      Puppet::Indirector::Request.new(:ind, :method, :key, :server => "bar").options[:server].should == "bar"
+    end
+
+    it "should normalize options to use symbols as keys" do
+      Puppet::Indirector::Request.new(:ind, :method, :key, "foo" => "bar").options[:foo].should == "bar"
+    end
+
+    describe "and the request key is a URI" do
+      describe "and the URI is a 'file' URI" do
+        before do
+          @request = Puppet::Indirector::Request.new(:ind, :method, "file:///my/file with spaces")
+        end
+
+        it "should set the request key to the unescaped full file path" do
+          @request.key.should == "/my/file with spaces"
+        end
+
+        it "should not set the protocol" do
+          @request.protocol.should be_nil
+        end
+
+        it "should not set the port" do
+          @request.port.should be_nil
+        end
+
+        it "should not set the server" do
+          @request.server.should be_nil
+        end
+      end
+
+      it "should set the protocol to the URI scheme" do
+        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").protocol.should == "http"
+      end
+
+      it "should set the server if a server is provided" do
+        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").server.should == "host"
+      end
+
+      it "should set the server and port if both are provided" do
+        Puppet::Indirector::Request.new(:ind, :method, "http://host:543/stuff").port.should == 543
+      end
+
+      it "should default to the masterport if the URI scheme is 'puppet'" do
+        Puppet.settings.expects(:value).with(:masterport).returns "321"
+        Puppet::Indirector::Request.new(:ind, :method, "puppet://host/stuff").port.should == 321
+      end
+
+      it "should use the provided port if the URI scheme is not 'puppet'" do
+        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").port.should == 80
+      end
+
+      it "should set the request key to the unescaped key part path from the URI" do
+        Puppet::Indirector::Request.new(:ind, :method, "http://host/environment/terminus/stuff with spaces").key.should == "stuff with spaces"
+      end
+
+      it "should set the :uri attribute to the full URI" do
+        Puppet::Indirector::Request.new(:ind, :method, "http:///stuff").uri.should == "http:///stuff"
+      end
+    end
+
+    it "should allow indication that it should not read a cached instance" do
+      Puppet::Indirector::Request.new(:ind, :method, :key, :ignore_cache => true).should be_ignore_cache
+    end
+
+    it "should default to not ignoring the cache" do
+      Puppet::Indirector::Request.new(:ind, :method, :key).should_not be_ignore_cache
+    end
+
+    it "should allow indication that it should not not read an instance from the terminus" do
+      Puppet::Indirector::Request.new(:ind, :method, :key, :ignore_terminus => true).should be_ignore_terminus
+    end
+
+    it "should default to not ignoring the terminus" do
+      Puppet::Indirector::Request.new(:ind, :method, :key).should_not be_ignore_terminus
+    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
+
+  it "should use its indirection to look up the appropriate model" do
+    ind = mock 'indirection'
+    Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
+    request = Puppet::Indirector::Request.new(:myind, :method, :key)
+
+    ind.expects(:model).returns "mymodel"
+
+    request.model.should == "mymodel"
+  end
+
+  it "should fail intelligently when asked to find a model but the indirection cannot be found" do
+    Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns nil
+    request = Puppet::Indirector::Request.new(:myind, :method, :key)
+
+    lambda { request.model }.should raise_error(ArgumentError)
+  end
+
+  it "should have a method for determining if the request is plural or singular" do
+    Puppet::Indirector::Request.new(:myind, :method, :key).should respond_to(:plural?)
+  end
+
+  it "should be considered plural if the method is 'search'" do
+    Puppet::Indirector::Request.new(:myind, :search, :key).should be_plural
+  end
+
+  it "should not be considered plural if the method is not 'search'" do
+    Puppet::Indirector::Request.new(:myind, :find, :key).should_not be_plural
+  end
+
+  it "should use its uri, if it has one, as its string representation" do
+    Puppet::Indirector::Request.new(:myind, :find, "foo://bar/baz").to_s.should == "foo://bar/baz"
+  end
+
+  it "should use its indirection name and key, if it has no uri, as its string representation" do
+    Puppet::Indirector::Request.new(:myind, :find, "key") == "/myind/key"
+  end
+
+  it "should be able to return the URI-escaped key" do
+    Puppet::Indirector::Request.new(:myind, :find, "my key").escaped_key.should == URI.escape("my key")
+  end
+
+  it "should have an environment accessor" do
+    Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => "foo").should respond_to(:environment)
+  end
+
+  it "should set its environment to an environment instance when a string is specified as its environment" do
+    Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => "foo").environment.should == Puppet::Node::Environment.new("foo")
+  end
+
+  it "should use any passed in environment instances as its environment" do
+    env = Puppet::Node::Environment.new("foo")
+    Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => env).environment.should equal(env)
+  end
+
+  it "should use the default environment when none is provided" do
+    Puppet::Indirector::Request.new(:myind, :find, "my key" ).environment.should equal(Puppet::Node::Environment.new)
+  end
+
+  it "should support converting its options to a hash" do
+    Puppet::Indirector::Request.new(:myind, :find, "my key" ).should respond_to(:to_hash)
+  end
+
+  it "should include all of its attributes when its options are converted to a hash" do
+    Puppet::Indirector::Request.new(:myind, :find, "my key", :node => 'foo').to_hash[:node].should == 'foo'
+  end
+
+  describe "when building a query string from its options" do
+    before do
+      @request = Puppet::Indirector::Request.new(:myind, :find, "my key")
+    end
+
+    it "should return an empty query string if there are no options" do
+      @request.stubs(:options).returns nil
+      @request.query_string.should == ""
+    end
+
+    it "should return an empty query string if the options are empty" do
+      @request.stubs(:options).returns({})
+      @request.query_string.should == ""
+    end
+
+    it "should prefix the query string with '?'" do
+      @request.stubs(:options).returns(:one => "two")
+      @request.query_string.should =~ /^\?/
+    end
+
+    it "should include all options in the query string, separated by '&'" do
+      @request.stubs(:options).returns(:one => "two", :three => "four")
+      @request.query_string.sub(/^\?/, '').split("&").sort.should == %w{one=two three=four}.sort
+    end
+
+    it "should ignore nil options" do
+      @request.stubs(:options).returns(:one => "two", :three => nil)
+      @request.query_string.should_not be_include("three")
+    end
+
+    it "should convert 'true' option values into strings" do
+      @request.stubs(:options).returns(:one => true)
+      @request.query_string.should == "?one=true"
+    end
+
+    it "should convert 'false' option values into strings" do
+      @request.stubs(:options).returns(:one => false)
+      @request.query_string.should == "?one=false"
+    end
+
+    it "should convert to a string all option values that are integers" do
+      @request.stubs(:options).returns(:one => 50)
+      @request.query_string.should == "?one=50"
+    end
+
+    it "should convert to a string all option values that are floating point numbers" do
+      @request.stubs(:options).returns(:one => 1.2)
+      @request.query_string.should == "?one=1.2"
+    end
+
+    it "should CGI-escape all option values that are strings" do
+      escaping = CGI.escape("one two")
+      @request.stubs(:options).returns(:one => "one two")
+      @request.query_string.should == "?one=#{escaping}"
+    end
+
+    it "should YAML-dump and CGI-escape arrays" do
+      escaping = CGI.escape(YAML.dump(%w{one two}))
+      @request.stubs(:options).returns(:one => %w{one two})
+      @request.query_string.should == "?one=#{escaping}"
+    end
+
+    it "should convert to a string and CGI-escape all option values that are symbols" do
+      escaping = CGI.escape("sym bol")
+      @request.stubs(:options).returns(:one => :"sym bol")
+      @request.query_string.should == "?one=#{escaping}"
+    end
+
+    it "should fail if options other than booleans or strings are provided" do
+      @request.stubs(:options).returns(:one => {:one => :two})
+      lambda { @request.query_string }.should raise_error(ArgumentError)
+    end
+  end
+end