puppet 2.6.18 → 2.7.1

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

@@ -0,0 +1,187 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet/ssl/host'
+require 'puppet/indirector/certificate_status'
+require 'tempfile'
+
+describe "Puppet::Indirector::CertificateStatus::File" do
+  include PuppetSpec::Files
+
+  before do
+    Puppet::SSL::CertificateAuthority.stubs(:ca?).returns true
+    @terminus = Puppet::SSL::Host.indirection.terminus(:file)
+
+    @tmpdir = tmpdir("certificate_status_ca_testing")
+    Puppet[:confdir] = @tmpdir
+    Puppet[:vardir] = @tmpdir
+
+    # localcacert is where each client stores the CA certificate
+    # cacert is where the master stores the CA certificate
+    # Since we need to play the role of both for testing we need them to be the same and exist
+    Puppet[:cacert] = Puppet[:localcacert]
+  end
+
+  def generate_csr(host)
+    host.generate_key
+    csr = Puppet::SSL::CertificateRequest.new(host.name)
+    csr.generate(host.key.content)
+    Puppet::SSL::CertificateRequest.indirection.save(csr)
+  end
+
+  def sign_csr(host)
+    host.desired_state = "signed"
+    @terminus.save(Puppet::Indirector::Request.new(:certificate_status, :save, host.name, host))
+  end
+
+  def generate_signed_cert(host)
+    generate_csr(host)
+    sign_csr(host)
+
+    @terminus.find(Puppet::Indirector::Request.new(:certificate_status, :find, host.name, host))
+  end
+
+  def generate_revoked_cert(host)
+    generate_signed_cert(host)
+
+    host.desired_state = "revoked"
+
+    @terminus.save(Puppet::Indirector::Request.new(:certificate_status, :save, host.name, host))
+  end
+
+  it "should be a terminus on SSL::Host" do
+    @terminus.should be_instance_of(Puppet::Indirector::CertificateStatus::File)
+  end
+
+  it "should create a CA instance if none is present" do
+    @terminus.ca.should be_instance_of(Puppet::SSL::CertificateAuthority)
+  end
+
+  describe "when creating the CA" do
+    it "should fail if it is not a valid CA" do
+      Puppet::SSL::CertificateAuthority.expects(:ca?).returns false
+      lambda { @terminus.ca }.should raise_error(ArgumentError, "This process is not configured as a certificate authority")
+    end
+  end
+
+  it "should be indirected with the name 'certificate_status'" do
+    Puppet::SSL::Host.indirection.name.should == :certificate_status
+  end
+
+  describe "when finding" do
+    before do
+      @host = Puppet::SSL::Host.new("foo")
+      Puppet.settings.use(:main)
+    end
+
+    it "should return the Puppet::SSL::Host when a CSR exists for the host" do
+      generate_csr(@host)
+      request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
+
+      retrieved_host = @terminus.find(request)
+
+      retrieved_host.name.should == @host.name
+      retrieved_host.certificate_request.content.to_s.chomp.should == @host.certificate_request.content.to_s.chomp
+    end
+
+    it "should return the Puppet::SSL::Host when a public key exist for the host" do
+      generate_signed_cert(@host)
+      request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
+
+      retrieved_host = @terminus.find(request)
+
+      retrieved_host.name.should == @host.name
+      retrieved_host.certificate.content.to_s.chomp.should == @host.certificate.content.to_s.chomp
+    end
+
+    it "should return nil when neither a CSR nor public key exist for the host" do
+      request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
+      @terminus.find(request).should == nil
+    end
+  end
+
+  describe "when saving" do
+    before do
+      @host = Puppet::SSL::Host.new("foobar")
+      Puppet.settings.use(:main)
+    end
+
+    describe "when signing a cert" do
+      before do
+        @host.desired_state = "signed"
+        @request = Puppet::Indirector::Request.new(:certificate_status, :save, "foobar", @host)
+      end
+
+      it "should fail if no CSR is on disk" do
+        lambda { @terminus.save(@request) }.should raise_error(Puppet::Error, /certificate request/)
+      end
+
+      it "should sign the on-disk CSR when it is present" do
+        signed_host = generate_signed_cert(@host)
+
+        signed_host.state.should == "signed"
+        Puppet::SSL::Certificate.indirection.find("foobar").should be_instance_of(Puppet::SSL::Certificate)
+      end
+    end
+
+    describe "when revoking a cert" do
+      before do
+        @request = Puppet::Indirector::Request.new(:certificate_status, :save, "foobar", @host)
+      end
+
+      it "should fail if no certificate is on disk" do
+        @host.desired_state = "revoked"
+        lambda { @terminus.save(@request) }.should raise_error(Puppet::Error, /Cannot revoke/)
+      end
+
+      it "should revoke the certificate when it is present" do
+        generate_revoked_cert(@host)
+
+        @host.state.should == 'revoked'
+      end
+    end
+  end
+
+  describe "when deleting" do
+    before do
+      Puppet.settings.use(:main)
+    end
+
+    it "should not delete anything if no certificate, request, or key is on disk" do
+      host = Puppet::SSL::Host.new("clean_me")
+      request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_me", host)
+      @terminus.destroy(request).should == "Nothing was deleted"
+    end
+
+    it "should clean certs, cert requests, keys" do
+      signed_host = Puppet::SSL::Host.new("clean_signed_cert")
+      generate_signed_cert(signed_host)
+      signed_request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_signed_cert", signed_host)
+      @terminus.destroy(signed_request).should == "Deleted for clean_signed_cert: Puppet::SSL::Certificate, Puppet::SSL::Key"
+
+      requested_host = Puppet::SSL::Host.new("clean_csr")
+      generate_csr(requested_host)
+      csr_request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_csr", requested_host)
+      @terminus.destroy(csr_request).should == "Deleted for clean_csr: Puppet::SSL::CertificateRequest, Puppet::SSL::Key"
+    end
+  end
+
+  describe "when searching" do
+    it "should return a list of all hosts with certificate requests, signed certs, or revoked certs" do
+      Puppet.settings.use(:main)
+
+      signed_host = Puppet::SSL::Host.new("signed_host")
+      generate_signed_cert(signed_host)
+
+      requested_host = Puppet::SSL::Host.new("requested_host")
+      generate_csr(requested_host)
+
+      revoked_host = Puppet::SSL::Host.new("revoked_host")
+      generate_revoked_cert(revoked_host)
+
+      retrieved_hosts = @terminus.search(Puppet::Indirector::Request.new(:certificate_status, :search, "all", signed_host))
+
+      results = retrieved_hosts.map {|h| [h.name, h.state]}.sort{ |h,i| h[0] <=> i[0] }
+      results.should == [["ca","signed"],["requested_host","requested"],["revoked_host","revoked"],["signed_host","signed"]]
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+#!/usr/bin/env rspec
+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
+end

data/spec/unit/indirector/code_spec.rb

@@ -1,19 +1,17 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 require 'puppet/indirector/code'
 
 describe Puppet::Indirector::Code do
-  before 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)
 
-    @code_class = Class.new(Puppet::Indirector::Code) do
-      def self.to_s
-        "Mystuff::Testing"
-      end
+    module Testing; end
+    @code_class = class Testing::MyCode < Puppet::Indirector::Code
+      self
     end
 
     @searcher = @code_class.new

data/spec/unit/indirector/direct_file_server_spec.rb

@@ -1,23 +1,22 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env rspec
 #
 #  Created by Luke Kanies on 2007-10-24.
 #  Copyright (c) 2007. All rights reserved.
 
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 require 'puppet/indirector/direct_file_server'
 
 describe Puppet::Indirector::DirectFileServer do
-  before :each 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)
 
-    @direct_file_class = Class.new(Puppet::Indirector::DirectFileServer) do
-      def self.to_s
-        "Testing::Mytype"
-      end
+    module Testing; end
+    @direct_file_class = class Testing::Mytype < Puppet::Indirector::DirectFileServer
+      self
     end
 
     @server = @direct_file_class.new

data/spec/unit/indirector/envelope_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 require 'puppet/indirector/envelope'
 
 describe Puppet::Indirector::Envelope do

data/spec/unit/indirector/exec_spec.rb

@@ -1,21 +1,20 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/indirector/exec'
 
 describe Puppet::Indirector::Exec do
-  before do
+  before :all do
     @indirection = stub 'indirection', :name => :testing
     Puppet::Indirector::Indirection.expects(:instance).with(:testing).returns(@indirection)
-    @exec_class = Class.new(Puppet::Indirector::Exec) do
-      def self.to_s
-        "Testing::Mytype"
-      end
-
+    module Testing; end
+    @exec_class = class Testing::MyTesting < Puppet::Indirector::Exec
       attr_accessor :command
+      self
     end
+  end
 
+  before :each do
     @searcher = @exec_class.new
     @searcher.command = ["/echo"]
 
@@ -33,22 +32,22 @@ describe Puppet::Indirector::Exec do
   end
 
   it "should execute the command with the object name as the only argument" do
-    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false)
+    @searcher.expects(:execute).with(%w{/echo foo})
     @searcher.find(@request)
   end
 
   it "should return the output of the script" do
-    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false).returns("whatever")
+    @searcher.expects(:execute).with(%w{/echo foo}).returns("whatever")
     @searcher.find(@request).should == "whatever"
   end
 
   it "should return nil when the command produces no output" do
-    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false).returns(nil)
+    @searcher.expects(:execute).with(%w{/echo foo}).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(%w{/echo foo}, :combine => false).raises(Puppet::ExecutionFailure.new("message"))
+    @searcher.expects(:execute).with(%w{/echo foo}).raises(Puppet::ExecutionFailure.new("message"))
 
     lambda {@searcher.find(@request)}.should raise_exception(Puppet::Error, 'Failed to find foo via exec: message')
   end

data/spec/unit/indirector/face_spec.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env rspec
+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 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 an 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, {'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

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/rails'
 require 'puppet/node/facts'

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

@@ -1,97 +1,102 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/node/facts'
+require 'puppet/indirector/facts/couch'
 
-describe "Puppet::Node::Facts::Couch", :if => Puppet.features.couchdb? do
-  require 'puppet/indirector/facts/couch' if Puppet.features.couchdb?
-
-  before do
-    @mock_db = mock('couch db')
-    mock_document = CouchRest::Document.new(:_id => fake_request.key, :facts => fake_request.values)
-    mock_document.stubs(:database).returns(@mock_db)
-    @mock_db.stubs(:get).with(fake_request.key).returns(mock_document)
-    Puppet::Node::Facts::Couch.stubs(:db).returns(@mock_db)
+describe "Puppet::Node::Facts::Couch" do
+  describe "when couchdb is not available", :unless => Puppet.features.couchdb? do
+    it "should fail to initialize", :'fails_in_ruby_1.9.2' => true do
+      lambda { Puppet::Node::Facts::Couch.new }.should raise_error
+    end
   end
 
-  subject { Puppet::Node::Facts::Couch }
-
-  describe "#find" do
-    describe "when the node document exists" do
-      it "should find the request by key" do
-        @mock_db.expects(:get).with(fake_request.key).returns({'_id' => fake_request.key, 'facts' => fake_request.instance.values})
-        subject.new.find(fake_request).should == fake_request.instance
-      end
+  describe "when couchdb is available", :if => Puppet.features.couchdb?, :'fails_on_ruby_1.9.2' => true do
+    before do
+      @mock_db = mock('couch db')
+      mock_document = CouchRest::Document.new(:_id => fake_request.key, :facts => fake_request.values)
+      mock_document.stubs(:database).returns(@mock_db)
+      @mock_db.stubs(:get).with(fake_request.key).returns(mock_document)
+      Puppet::Node::Facts::Couch.stubs(:db).returns(@mock_db)
     end
 
-    describe "when the node document does not exist" do
-      before do
-        @mock_db.expects(:get).
-          with(fake_request.key).
-          raises(RestClient::ResourceNotFound)
-      end
+    subject { Puppet::Node::Facts::Couch }
 
-      it "should return nil" do
-        subject.new.find(fake_request).should be_nil
+    describe "#find" do
+      describe "when the node document exists" do
+        it "should find the request by key" do
+          @mock_db.expects(:get).with(fake_request.key).returns({'_id' => fake_request.key, 'facts' => fake_request.instance.values})
+          subject.new.find(fake_request).should == fake_request.instance
+        end
       end
 
-      it "should send Puppet a debug message" do
-        Puppet.expects(:debug).with("No couchdb document with id: test.local")
-        subject.new.find(fake_request).should be_nil
-      end
+      describe "when the node document does not exist" do
+        before do
+          @mock_db.expects(:get).
+            with(fake_request.key).
+            raises(RestClient::ResourceNotFound)
+        end
 
-    end
-  end
+        it "should return nil" do
+          subject.new.find(fake_request).should be_nil
+        end
 
-  describe "#save" do
-    describe "with options" do
-      subject do
-        lambda { Puppet::Node::Facts::Couch.new.save(fake_request([1])) }
-      end
+        it "should send Puppet a debug message" do
+          Puppet.expects(:debug).with("No couchdb document with id: test.local")
+          subject.new.find(fake_request).should be_nil
+        end
 
-      it { should raise_error(ArgumentError, "PUT does not accept options") }
+      end
     end
 
-    it "should save the json to the CouchDB database" do
-      @mock_db.expects(:save_doc).at_least_once.returns({'ok' => true })
-      subject.new.save(fake_request)
-    end
+    describe "#save" do
+      describe "with options" do
+        subject do
+          lambda { Puppet::Node::Facts::Couch.new.save(fake_request([1])) }
+        end
 
-    describe "when the document exists" do
-      before do
-        @doc = CouchRest::Document.new(:_id => fake_request.key, :facts => fake_request.instance.values)
-        @mock_db.expects(:get).with(fake_request.key).returns(@doc)
+        it { should raise_error(ArgumentError, "PUT does not accept options") }
       end
 
-      it "saves the document" do
-        @doc.expects(:save)
+      it "should save the json to the CouchDB database" do
+        @mock_db.expects(:save_doc).at_least_once.returns({'ok' => true })
         subject.new.save(fake_request)
       end
 
-    end
+      describe "when the document exists" do
+        before do
+          @doc = CouchRest::Document.new(:_id => fake_request.key, :facts => fake_request.instance.values)
+          @mock_db.expects(:get).with(fake_request.key).returns(@doc)
+        end
+
+        it "saves the document" do
+          @doc.expects(:save)
+          subject.new.save(fake_request)
+        end
 
-    describe "when the document does not exist" do
-      before do
-        @mock_db.expects(:get).
-          with(fake_request.key).
-          raises(RestClient::ResourceNotFound)
       end
 
-      it "saves the document" do
-        @mock_db.expects(:save_doc)
-        subject.new.save(fake_request)
+      describe "when the document does not exist" do
+        before do
+          @mock_db.expects(:get).
+            with(fake_request.key).
+            raises(RestClient::ResourceNotFound)
+        end
+
+        it "saves the document" do
+          @mock_db.expects(:save_doc)
+          subject.new.save(fake_request)
+        end
+
       end
 
     end
 
+    def fake_request(options={})
+      facts = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml', 'test.local.yaml'))
+      Struct.new(:instance, :key, :options).new(facts, facts.name, options)
+    end
+    private :fake_request
   end
-
-  def fake_request(options={})
-    facts = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml', 'test.local.yaml'))
-    Struct.new(:instance, :key, :options).new(facts, facts.name, options)
-  end
-  private :fake_request
-
 end