puppet 3.5.0.rc1-x86-mingw32

data/spec/unit/indirector/certificate_status/rest_spec.rb

@@ -0,0 +1,18 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/ssl/host'
+require 'puppet/indirector/certificate_status'
+
+describe "Puppet::CertificateStatus::Rest" do
+  before do
+    @terminus = Puppet::SSL::Host.indirection.terminus(:rest)
+  end
+
+  it "should be a terminus on Puppet::SSL::Host" do
+    @terminus.should be_instance_of(Puppet::Indirector::CertificateStatus::Rest)
+  end
+
+  it "should use the :ca SRV service" do
+    Puppet::Indirector::CertificateStatus::Rest.srv_service.should == :ca
+  end
+end

data/spec/unit/indirector/code_spec.rb

@@ -0,0 +1,31 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/indirector/code'
+
+describe Puppet::Indirector::Code do
+  before :all 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)
+
+    module Testing; end
+    @code_class = class Testing::MyCode < Puppet::Indirector::Code
+      self
+    end
+
+    @searcher = @code_class.new
+  end
+
+  it "should not have a find() method defined" do
+    @searcher.should_not respond_to(:find)
+  end
+
+  it "should not have a save() method defined" do
+    @searcher.should_not respond_to(:save)
+  end
+
+  it "should not have a destroy() method defined" do
+    @searcher.should_not respond_to(:destroy)
+  end
+end

data/spec/unit/indirector/data_binding/hiera_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'puppet/indirector/data_binding/hiera'
+
+describe Puppet::DataBinding::Hiera do
+  include PuppetSpec::Files
+
+  def write_hiera_config(config_file, datadir)
+    File.open(config_file, 'w') do |f|
+      f.write("---
+        :yaml:
+          :datadir: #{datadir}
+        :hierarchy: ['global', 'invalid']
+        :logger: 'noop'
+        :backends: ['yaml']
+      ")
+    end
+  end
+
+  def request(key)
+    Puppet::Indirector::Request.new(:hiera, :find, key, nil)
+  end
+
+  before do
+    hiera_config_file = tmpfile("hiera.yaml")
+    Puppet.settings[:hiera_config] = hiera_config_file
+    write_hiera_config(hiera_config_file, my_fixture_dir)
+  end
+
+  after do
+    Puppet::DataBinding::Hiera.instance_variable_set(:@hiera, nil)
+  end
+
+  it "should have documentation" do
+    Puppet::DataBinding::Hiera.doc.should_not be_nil
+  end
+
+  it "should be registered with the data_binding indirection" do
+    indirection = Puppet::Indirector::Indirection.instance(:data_binding)
+    Puppet::DataBinding::Hiera.indirection.should equal(indirection)
+  end
+
+  it "should have its name set to :hiera" do
+    Puppet::DataBinding::Hiera.name.should == :hiera
+  end
+  it "should be the default data_binding terminus" do
+    Puppet.settings[:data_binding_terminus].should == :hiera
+  end
+
+  it "should raise an error if we don't have the hiera feature" do
+    Puppet.features.expects(:hiera?).returns(false)
+    lambda { Puppet::DataBinding::Hiera.new }.should raise_error RuntimeError,
+      "Hiera terminus not supported without hiera library"
+  end
+
+  describe "the behavior of the hiera_config method", :if => Puppet.features.hiera? do
+    it "should override the logger and set it to puppet" do
+      Puppet::DataBinding::Hiera.hiera_config[:logger].should == "puppet"
+    end
+
+    context "when the Hiera configuration file does not exist" do
+      let(:path) { File.expand_path('/doesnotexist') }
+
+      before do
+        Puppet.settings[:hiera_config] = path
+      end
+
+      it "should log a warning" do
+        Puppet.expects(:warning).with(
+         "Config file #{path} not found, using Hiera defaults")
+        Puppet::DataBinding::Hiera.hiera_config
+      end
+
+      it "should only configure the logger and set it to puppet" do
+        Puppet.expects(:warning).with(
+         "Config file #{path} not found, using Hiera defaults")
+        Puppet::DataBinding::Hiera.hiera_config.should == { :logger => 'puppet' }
+      end
+    end
+  end
+
+  describe "the behavior of the find method", :if => Puppet.features.hiera? do
+
+    let(:data_binder) { Puppet::DataBinding::Hiera.new }
+
+    it "should support looking up an integer" do
+      data_binder.find(request("integer")).should == 3000
+    end
+
+    it "should support looking up a string" do
+      data_binder.find(request("string")).should == 'apache'
+    end
+
+    it "should support looking up an array" do
+      data_binder.find(request("array")).should == [
+        '0.ntp.puppetlabs.com',
+        '1.ntp.puppetlabs.com',
+      ]
+    end
+
+    it "should support looking up a hash" do
+      data_binder.find(request("hash")).should == {
+        'user'  => 'Hightower',
+        'group' => 'admin',
+        'mode'  => '0644'
+      }
+    end
+
+    it "raises a data binding error if hiera cannot parse the yaml data" do
+      expect do
+        data_binder.find(request('invalid'))
+      end.to raise_error(Puppet::DataBinding::LookupError)
+    end
+  end
+end

data/spec/unit/indirector/data_binding/none_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'puppet/indirector/data_binding/none'
+
+describe Puppet::DataBinding::None do
+  it "should be a subclass of the None terminus" do
+    Puppet::DataBinding::None.superclass.should equal(Puppet::Indirector::None)
+  end
+
+  it "should have documentation" do
+    Puppet::DataBinding::None.doc.should_not be_nil
+  end
+
+  it "should be registered with the data_binding indirection" do
+    indirection = Puppet::Indirector::Indirection.instance(:data_binding)
+    Puppet::DataBinding::None.indirection.should equal(indirection)
+  end
+
+  it "should have its name set to :none" do
+    Puppet::DataBinding::None.name.should == :none
+  end
+
+  describe "the behavior of the find method" do
+    it "should just return nil" do
+      data_binding = Puppet::DataBinding::None.new
+      data_binding.find('fake_request').should be_nil
+    end
+  end
+end

data/spec/unit/indirector/direct_file_server_spec.rb

@@ -0,0 +1,80 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/indirector/direct_file_server'
+
+describe Puppet::Indirector::DirectFileServer do
+  before :all 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)
+
+    module Testing; end
+    @direct_file_class = class Testing::Mytype < Puppet::Indirector::DirectFileServer
+      self
+    end
+
+    @server = @direct_file_class.new
+
+    @path = File.expand_path('/my/local')
+    @uri = Puppet::Util.path_to_uri(@path).to_s
+
+    @request = Puppet::Indirector::Request.new(:mytype, :find, @uri, nil)
+  end
+
+  describe Puppet::Indirector::DirectFileServer, "when finding a single file" do
+
+    it "should return nil if the file does not exist" do
+      Puppet::FileSystem.expects(:exist?).with(@path).returns false
+      @server.find(@request).should be_nil
+    end
+
+    it "should return a Content instance created with the full path to the file if the file exists" do
+      Puppet::FileSystem.expects(:exist?).with(@path).returns true
+      @model.expects(:new).returns(:mycontent)
+      @server.find(@request).should == :mycontent
+    end
+  end
+
+  describe Puppet::Indirector::DirectFileServer, "when creating the instance for a single found file" do
+
+    before do
+      @data = mock 'content'
+      @data.stubs(:collect)
+      Puppet::FileSystem.expects(:exist?).with(@path).returns true
+    end
+
+    it "should pass the full path to the instance" do
+      @model.expects(:new).with { |key, options| key == @path }.returns(@data)
+      @server.find(@request)
+    end
+
+    it "should pass the :links setting on to the created Content instance if the file exists and there is a value for :links" do
+      @model.expects(:new).returns(@data)
+      @data.expects(:links=).with(:manage)
+
+      @request.stubs(:options).returns(:links => :manage)
+      @server.find(@request)
+    end
+  end
+
+  describe Puppet::Indirector::DirectFileServer, "when searching for multiple files" do
+    it "should return nil if the file does not exist" do
+      Puppet::FileSystem.expects(:exist?).with(@path).returns false
+      @server.find(@request).should be_nil
+    end
+
+    it "should use :path2instances from the terminus_helper to return instances if the file exists" do
+      Puppet::FileSystem.expects(:exist?).with(@path).returns true
+      @server.expects(:path2instances)
+      @server.search(@request)
+    end
+
+    it "should pass the original request to :path2instances" do
+      Puppet::FileSystem.expects(:exist?).with(@path).returns true
+      @server.expects(:path2instances).with(@request, @path)
+      @server.search(@request)
+    end
+  end
+end

data/spec/unit/indirector/envelope_spec.rb

@@ -0,0 +1,33 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/indirector/envelope'
+
+describe Puppet::Indirector::Envelope do
+  before do
+    @instance = Object.new
+    @instance.extend(Puppet::Indirector::Envelope)
+  end
+
+  describe "when testing if it is expired" do
+    it "should return false if there is no expiration set" do
+      @instance.should_not be_expired
+    end
+
+    it "should return true if the current date is after the expiration date" do
+      @instance.expiration = Time.now - 10
+      @instance.should be_expired
+    end
+
+    it "should return false if the current date is prior to the expiration date" do
+      @instance.expiration = Time.now + 10
+      @instance.should_not be_expired
+    end
+
+    it "should return false if the current date is equal to the expiration date" do
+      now = Time.now
+      Time.stubs(:now).returns(now)
+      @instance.expiration = now
+      @instance.should_not be_expired
+    end
+  end
+end

data/spec/unit/indirector/exec_spec.rb

@@ -0,0 +1,58 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/indirector/exec'
+
+describe Puppet::Indirector::Exec do
+  before :all do
+    @indirection = stub 'indirection', :name => :testing
+    Puppet::Indirector::Indirection.expects(:instance).with(:testing).returns(@indirection)
+    module Testing; end
+    @exec_class = class Testing::MyTesting < Puppet::Indirector::Exec
+      attr_accessor :command
+      self
+    end
+  end
+
+  let(:path) { File.expand_path('/echo') }
+  let(:arguments) { {:failonfail => true, :combine => false } }
+
+  before :each do
+    @searcher = @exec_class.new
+    @searcher.command = [path]
+
+    @request = stub 'request', :key => "foo"
+  end
+
+  it "should throw an exception if the command is not an array" do
+    @searcher.command = path
+    proc { @searcher.find(@request) }.should raise_error(Puppet::DevError)
+  end
+
+  it "should throw an exception if the command is not fully qualified" do
+    @searcher.command = ["mycommand"]
+    proc { @searcher.find(@request) }.should raise_error(ArgumentError)
+  end
+
+  it "should execute the command with the object name as the only argument" do
+    @searcher.expects(:execute).with([path, 'foo'], arguments)
+    @searcher.find(@request)
+  end
+
+  it "should return the output of the script" do
+    @searcher.expects(:execute).with([path, 'foo'], arguments).returns("whatever")
+    @searcher.find(@request).should == "whatever"
+  end
+
+  it "should return nil when the command produces no output" do
+    @searcher.expects(:execute).with([path, 'foo'], arguments).returns(nil)
+    @searcher.find(@request).should be_nil
+  end
+
+  it "should raise an exception if there's an execution failure" do
+    @searcher.expects(:execute).with([path, 'foo'], arguments).raises(Puppet::ExecutionFailure.new("message"))
+    expect {
+      @searcher.find(@request)
+    }.to raise_exception(Puppet::Error, 'Failed to find foo via exec: message')
+  end
+end

data/spec/unit/indirector/face_spec.rb

@@ -0,0 +1,70 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/indirector/face'
+
+describe Puppet::Indirector::Face do
+  subject do
+    instance = Puppet::Indirector::Face.new(:test, '0.0.1')
+    indirection = stub('indirection',
+                       :name => :stub_indirection,
+                       :reset_terminus_class => nil)
+    instance.stubs(:indirection).returns indirection
+    instance
+  end
+
+  it { should be_option :extra }
+
+  it "should be able to return a list of indirections" do
+    Puppet::Indirector::Face.indirections.should be_include("catalog")
+  end
+
+  it "should return the sorted to_s list of terminus classes" do
+    Puppet::Indirector::Terminus.expects(:terminus_classes).returns([
+      :yaml,
+      :compiler,
+      :rest
+   ])
+    Puppet::Indirector::Face.terminus_classes(:catalog).should == [
+      'compiler',
+      'rest',
+      'yaml'
+    ]
+  end
+
+  describe "as an instance" do
+    it "should be able to determine its indirection" do
+      # Loading actions here can get, um, complicated
+      Puppet::Face.stubs(:load_actions)
+      Puppet::Indirector::Face.new(:catalog, '0.0.1').indirection.should equal(Puppet::Resource::Catalog.indirection)
+    end
+  end
+
+  [:find, :search, :save, :destroy].each do |method|
+    it "should define a '#{method}' action" do
+      Puppet::Indirector::Face.should be_action(method)
+    end
+
+    it "should call the indirection method with options when the '#{method}' action is invoked" do
+      subject.indirection.expects(method).with(:test, {})
+      subject.send(method, :test)
+    end
+    it "should forward passed options" do
+      subject.indirection.expects(method).with(:test, {'one'=>'1'})
+      subject.send(method, :test, :extra => {'one'=>'1'})
+    end
+  end
+
+  it "should be able to override its indirection name" do
+    subject.set_indirection_name :foo
+    subject.indirection_name.should == :foo
+  end
+
+  it "should be able to set its terminus class" do
+    subject.indirection.expects(:terminus_class=).with(:myterm)
+    subject.set_terminus(:myterm)
+  end
+
+  it "should define a class-level 'info' action" do
+    Puppet::Indirector::Face.should be_action(:info)
+  end
+end

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

@@ -0,0 +1,113 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/rails'
+require 'puppet/node/facts'
+
+describe "Puppet::Node::Facts::ActiveRecord", :if => Puppet.features.rails? do
+  before do
+    require 'puppet/indirector/facts/active_record'
+    Puppet.features.stubs(:rails?).returns true
+    Puppet::Rails.stubs(:init)
+  end
+
+  let :terminus do
+    Puppet::Node::Facts::ActiveRecord.new
+  end
+
+  it "should issue a deprecation warning" do
+    Puppet.expects(:deprecation_warning).with() { |msg| msg =~ /ActiveRecord-based storeconfigs and inventory are deprecated/ }
+    terminus
+  end
+
+  it "should be a subclass of the ActiveRecord terminus class" do
+    Puppet::Node::Facts::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
+  end
+
+  it "should use Puppet::Rails::Host as its ActiveRecord model" do
+    Puppet::Node::Facts::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
+  end
+
+  describe "when finding an instance" do
+    let :request do
+      stub 'request', :key => "foo"
+    end
+
+    it "should use the Hosts ActiveRecord class to find the host" do
+      Puppet::Rails::Host.expects(:find_by_name).with { |key, args| key == "foo" }
+      terminus.find(request)
+    end
+
+    it "should include the fact names and values when finding the host" do
+      Puppet::Rails::Host.expects(:find_by_name).with { |key, args| args[:include] == {:fact_values => :fact_name} }
+      terminus.find(request)
+    end
+
+    it "should return nil if no host instance can be found" do
+      Puppet::Rails::Host.expects(:find_by_name).returns nil
+      terminus.find(request).should be_nil
+    end
+
+    it "should convert the node's parameters into a Facts instance if a host instance is found" do
+      host = stub 'host', :name => "foo"
+      host.expects(:get_facts_hash).returns("one" => [mock("two_value", :value => "two")], "three" => [mock("three_value", :value => "four")])
+
+      Puppet::Rails::Host.expects(:find_by_name).returns host
+
+      result = terminus.find(request)
+
+      result.should be_instance_of(Puppet::Node::Facts)
+      result.name.should == "foo"
+      result.values.should == {"one" => "two", "three" => "four"}
+    end
+
+    it "should convert all single-member arrays into non-arrays" do
+      host = stub 'host', :name => "foo"
+      host.expects(:get_facts_hash).returns("one" => [mock("two_value", :value => "two")])
+
+      Puppet::Rails::Host.expects(:find_by_name).returns host
+
+      terminus.find(request).values["one"].should == "two"
+    end
+  end
+
+  describe "when saving an instance" do
+    let :facts do
+      Puppet::Node::Facts.new("foo", "one" => "two", "three" => "four")
+    end
+
+    let :request do
+      stub 'request', :key => "foo", :instance => facts
+    end
+
+    let :host do
+      stub 'host', :name => "foo", :save => nil, :merge_facts => nil
+    end
+
+    before do
+      Puppet::Rails::Host.stubs(:find_by_name).returns host
+    end
+
+    it "should find the Rails host with the same name" do
+      Puppet::Rails::Host.expects(:find_by_name).with("foo").returns host
+      terminus.save(request)
+    end
+
+    it "should create a new Rails host if none can be found" do
+      Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
+      Puppet::Rails::Host.expects(:create).with(:name => "foo").returns host
+      terminus.save(request)
+    end
+
+    it "should set the facts as facts on the Rails host instance" do
+      # There is other stuff added to the hash.
+      host.expects(:merge_facts).with { |args| args["one"] == "two" and args["three"] == "four" }
+      terminus.save(request)
+    end
+
+    it "should save the Rails host instance" do
+      host.expects(:save)
+      terminus.save(request)
+    end
+  end
+end