puppet 0.25.5 → 2.6.0

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

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/run/local'
+
+describe Puppet::Run::Local do
+  it "should be a sublcass of Puppet::Indirector::Code" do
+    Puppet::Run::Local.superclass.should equal(Puppet::Indirector::Code)
+  end
+
+  it "should call runner.run on save and return the runner" do
+    runner  = Puppet::Run.new
+    runner.stubs(:run).returns(runner)
+
+    request = Puppet::Indirector::Request.new(:indirection, :save, "anything")
+    request.instance = runner = Puppet::Run.new
+    Puppet::Run::Local.new.save(request).should == runner
+  end
+end

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

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/run/rest'
+
+describe Puppet::Run::Rest do
+  it "should be a sublcass of Puppet::Indirector::REST" do
+    Puppet::Run::Rest.superclass.should equal(Puppet::Indirector::REST)
+  end
+end

data/spec/unit/indirector/ssl_file_spec.rb

@@ -0,0 +1,281 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-3-10.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/indirector/ssl_file'
+
+describe Puppet::Indirector::SslFile do
+  before do
+    @model = mock 'model'
+    @indirection = stub 'indirection', :name => :testing, :model => @model
+    Puppet::Indirector::Indirection.expects(:instance).with(:testing).returns(@indirection)
+    @file_class = Class.new(Puppet::Indirector::SslFile) do
+      def self.to_s
+        "Testing::Mytype"
+      end
+    end
+
+    @setting = :mydir
+    @file_class.store_in @setting
+    @path = "/my/directory"
+    Puppet.settings.stubs(:value).with(:noop).returns(false)
+    Puppet.settings.stubs(:value).with(@setting).returns(@path)
+    Puppet.settings.stubs(:value).with(:trace).returns(false)
+  end
+
+  it "should use :main and :ssl upon initialization" do
+    Puppet.settings.expects(:use).with(:main, :ssl)
+    @file_class.new
+  end
+
+  it "should return a nil collection directory if no directory setting has been provided" do
+    @file_class.store_in nil
+    @file_class.collection_directory.should be_nil
+  end
+
+  it "should return a nil file location if no location has been provided" do
+    @file_class.store_at nil
+    @file_class.file_location.should be_nil
+  end
+
+  it "should fail if no store directory or file location has been set" do
+    @file_class.store_in nil
+    @file_class.store_at nil
+    lambda { @file_class.new }.should raise_error(Puppet::DevError)
+  end
+
+  describe "when managing ssl files" do
+    before do
+      Puppet.settings.stubs(:use)
+      @searcher = @file_class.new
+
+      @cert = stub 'certificate', :name => "myname"
+      @certpath = File.join(@path, "myname.pem")
+
+      @request = stub 'request', :key => @cert.name, :instance => @cert
+    end
+
+    it "should consider the file a ca file if the name is equal to what the SSL::Host class says is the CA name" do
+      Puppet::SSL::Host.expects(:ca_name).returns "amaca"
+      @searcher.should be_ca("amaca")
+    end
+
+    describe "when choosing the location for certificates" do
+      it "should set them at the ca setting's path if a ca setting is available and the name resolves to the CA name" do
+        @file_class.store_in nil
+        @file_class.store_at :mysetting
+        @file_class.store_ca_at :casetting
+
+        Puppet.settings.stubs(:value).with(:casetting).returns "/ca/file"
+
+        @searcher.expects(:ca?).with(@cert.name).returns true
+        @searcher.path(@cert.name).should == "/ca/file"
+      end
+
+      it "should set them at the file location if a file setting is available" do
+        @file_class.store_in nil
+        @file_class.store_at :mysetting
+
+        Puppet.settings.stubs(:value).with(:mysetting).returns "/some/file"
+
+        @searcher.path(@cert.name).should == "/some/file"
+      end
+
+      it "should set them in the setting directory, with the certificate name plus '.pem', if a directory setting is available" do
+        @searcher.path(@cert.name).should == @certpath
+      end
+    end
+
+    describe "when finding certificates on disk" do
+      describe "and no certificate is present" do
+        before do
+          # Stub things so the case management bits work.
+          FileTest.stubs(:exist?).with(File.dirname(@certpath)).returns false
+          FileTest.expects(:exist?).with(@certpath).returns false
+        end
+
+        it "should return nil" do
+          @searcher.find(@request).should be_nil
+        end
+      end
+
+      describe "and a certificate is present" do
+        before do
+          FileTest.expects(:exist?).with(@certpath).returns true
+        end
+
+        it "should return an instance of the model, which it should use to read the certificate" do
+          cert = mock 'cert'
+          model = mock 'model'
+          @file_class.stubs(:model).returns model
+
+          model.expects(:new).with("myname").returns cert
+          cert.expects(:read).with(@certpath)
+          @searcher.find(@request).should equal(cert)
+        end
+      end
+
+      describe "and a certificate is present but has uppercase letters" do
+        before do
+          @request = stub 'request', :key => "myhost"
+        end
+
+        # This is kind of more an integration test; it's for #1382, until
+        # the support for upper-case certs can be removed around mid-2009.
+        it "should rename the existing file to the lower-case path" do
+          @path = @searcher.path("myhost")
+          FileTest.expects(:exist?).with(@path).returns(false)
+          dir, file = File.split(@path)
+          FileTest.expects(:exist?).with(dir).returns true
+          Dir.expects(:entries).with(dir).returns [".", "..", "something.pem", file.upcase]
+
+          File.expects(:rename).with(File.join(dir, file.upcase), @path)
+
+          cert = mock 'cert'
+          model = mock 'model'
+          @searcher.stubs(:model).returns model
+          @searcher.model.expects(:new).with("myhost").returns cert
+          cert.expects(:read).with(@path)
+
+          @searcher.find(@request)
+        end
+      end
+    end
+
+    describe "when saving certificates to disk" do
+      before do
+        FileTest.stubs(:directory?).returns true
+        FileTest.stubs(:writable?).returns true
+      end
+
+      it "should fail if the directory is absent" do
+        FileTest.expects(:directory?).with(File.dirname(@certpath)).returns false
+        lambda { @searcher.save(@request) }.should raise_error(Puppet::Error)
+      end
+
+      it "should fail if the directory is not writeable" do
+        FileTest.stubs(:directory?).returns true
+        FileTest.expects(:writable?).with(File.dirname(@certpath)).returns false
+        lambda { @searcher.save(@request) }.should raise_error(Puppet::Error)
+      end
+
+      it "should save to the path the output of converting the certificate to a string" do
+        fh = mock 'filehandle'
+        fh.expects(:print).with("mycert")
+
+        @searcher.stubs(:write).yields fh
+        @cert.expects(:to_s).returns "mycert"
+
+        @searcher.save(@request)
+      end
+
+      describe "and a directory setting is set" do
+        it "should use the Settings class to write the file" do
+          @searcher.class.store_in @setting
+          fh = mock 'filehandle'
+          fh.stubs :print
+          Puppet.settings.expects(:writesub).with(@setting, @certpath).yields fh
+
+          @searcher.save(@request)
+        end
+      end
+
+      describe "and a file location is set" do
+        it "should use the filehandle provided by the Settings" do
+          @searcher.class.store_at @setting
+
+          fh = mock 'filehandle'
+          fh.stubs :print
+          Puppet.settings.expects(:write).with(@setting).yields fh
+          @searcher.save(@request)
+        end
+      end
+
+      describe "and the name is the CA name and a ca setting is set" do
+        it "should use the filehandle provided by the Settings" do
+          @searcher.class.store_at @setting
+          @searcher.class.store_ca_at :castuff
+          Puppet.settings.stubs(:value).with(:castuff).returns "castuff stub"
+
+          fh = mock 'filehandle'
+          fh.stubs :print
+          Puppet.settings.expects(:write).with(:castuff).yields fh
+          @searcher.stubs(:ca?).returns true
+          @searcher.save(@request)
+        end
+      end
+    end
+
+    describe "when destroying certificates" do
+      describe "that do not exist" do
+        before do
+          FileTest.expects(:exist?).with(@certpath).returns false
+        end
+
+        it "should return false" do
+          @searcher.destroy(@request).should be_false
+        end
+      end
+
+      describe "that exist" do
+        before do
+          FileTest.expects(:exist?).with(@certpath).returns true
+        end
+
+        it "should unlink the certificate file" do
+          File.expects(:unlink).with(@certpath)
+          @searcher.destroy(@request)
+        end
+
+        it "should log that is removing the file" do
+          File.stubs(:exist?).returns true
+          File.stubs(:unlink)
+          Puppet.expects(:notice)
+          @searcher.destroy(@request)
+        end
+      end
+    end
+
+    describe "when searching for certificates" do
+      before do
+        @model = mock 'model'
+        @file_class.stubs(:model).returns @model
+      end
+      it "should return a certificate instance for all files that exist" do
+        Dir.expects(:entries).with(@path).returns %w{one.pem two.pem}
+
+        one = stub 'one', :read => nil
+        two = stub 'two', :read => nil
+
+        @model.expects(:new).with("one").returns one
+        @model.expects(:new).with("two").returns two
+
+        @searcher.search(@request).should == [one, two]
+      end
+
+      it "should read each certificate in using the model's :read method" do
+        Dir.expects(:entries).with(@path).returns %w{one.pem}
+
+        one = stub 'one'
+        one.expects(:read).with(File.join(@path, "one.pem"))
+
+        @model.expects(:new).with("one").returns one
+
+        @searcher.search(@request)
+      end
+
+      it "should skip any files that do not match /\.pem$/" do
+        Dir.expects(:entries).with(@path).returns %w{. .. one.pem}
+
+        one = stub 'one', :read => nil
+
+        @model.expects(:new).with("one").returns one
+
+        @searcher.search(@request)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+require 'puppet/indirector/status/rest'
+
+describe Puppet::Indirector::Status::Rest do
+  it "should be a sublcass of Puppet::Indirector::REST" do
+    Puppet::Indirector::Status::Rest.superclass.should equal(Puppet::Indirector::REST)
+  end
+end

data/spec/unit/indirector/terminus_spec.rb

@@ -0,0 +1,245 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/defaults'
+require 'puppet/indirector'
+require 'puppet/indirector/file'
+
+describe Puppet::Indirector::Terminus do
+  before :each do
+    Puppet::Indirector::Terminus.stubs(:register_terminus_class)
+    @indirection = stub 'indirection', :name => :my_stuff, :register_terminus_type => nil
+    Puppet::Indirector::Indirection.stubs(:instance).with(:my_stuff).returns(@indirection)
+    @abstract_terminus = Class.new(Puppet::Indirector::Terminus) do
+      def self.to_s
+        "Testing::Abstract"
+      end
+    end
+    @terminus_class = Class.new(@abstract_terminus) do
+      def self.to_s
+        "MyStuff::TermType"
+      end
+    end
+    @terminus = @terminus_class.new
+  end
+
+  describe Puppet::Indirector::Terminus do
+
+    it "should provide a method for setting terminus class documentation" do
+      @terminus_class.should respond_to(:desc)
+    end
+
+    it "should support a class-level name attribute" do
+      @terminus_class.should respond_to(:name)
+    end
+
+    it "should support a class-level indirection attribute" do
+      @terminus_class.should respond_to(:indirection)
+    end
+
+    it "should support a class-level terminus-type attribute" do
+      @terminus_class.should respond_to(:terminus_type)
+    end
+
+    it "should support a class-level model attribute" do
+      @terminus_class.should respond_to(:model)
+    end
+
+    it "should accept indirection instances as its indirection" do
+      indirection = stub 'indirection', :is_a? => true, :register_terminus_type => nil
+      proc { @terminus_class.indirection = indirection }.should_not raise_error
+      @terminus_class.indirection.should equal(indirection)
+    end
+
+    it "should look up indirection instances when only a name has been provided" do
+      indirection = mock 'indirection'
+      Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns(indirection)
+      @terminus_class.indirection = :myind
+      @terminus_class.indirection.should equal(indirection)
+    end
+
+    it "should fail when provided a name that does not resolve to an indirection" do
+      Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns(nil)
+      proc { @terminus_class.indirection = :myind }.should raise_error(ArgumentError)
+
+      # It shouldn't overwrite our existing one (or, more normally, it shouldn't set
+      # anything).
+      @terminus_class.indirection.should equal(@indirection)
+    end
+  end
+
+  describe Puppet::Indirector::Terminus, " when creating terminus classes" do
+    it "should associate the subclass with an indirection based on the subclass constant" do
+      @terminus.indirection.should equal(@indirection)
+    end
+
+    it "should set the subclass's type to the abstract terminus name" do
+      @terminus.terminus_type.should == :abstract
+    end
+
+    it "should set the subclass's name to the indirection name" do
+      @terminus.name.should == :term_type
+    end
+
+    it "should set the subclass's model to the indirection model" do
+      @indirection.expects(:model).returns :yay
+      @terminus.model.should == :yay
+    end
+  end
+
+  describe Puppet::Indirector::Terminus, " when a terminus instance" do
+
+    it "should return the class's name as its name" do
+      @terminus.name.should == :term_type
+    end
+
+    it "should return the class's indirection as its indirection" do
+      @terminus.indirection.should equal(@indirection)
+    end
+
+    it "should set the instances's type to the abstract terminus type's name" do
+      @terminus.terminus_type.should == :abstract
+    end
+
+    it "should set the instances's model to the indirection's model" do
+      @indirection.expects(:model).returns :yay
+      @terminus.model.should == :yay
+    end
+  end
+end
+
+# LAK: This could reasonably be in the Indirection instances, too.  It doesn't make
+# a whole heckuva lot of difference, except that with the instance loading in
+# the Terminus base class, we have to have a check to see if we're already
+# instance-loading a given terminus class type.
+describe Puppet::Indirector::Terminus, " when managing terminus classes" do
+  it "should provide a method for registering terminus classes" do
+    Puppet::Indirector::Terminus.should respond_to(:register_terminus_class)
+  end
+
+  it "should provide a method for returning terminus classes by name and type" do
+    terminus = stub 'terminus_type', :name => :abstract, :indirection_name => :whatever
+    Puppet::Indirector::Terminus.register_terminus_class(terminus)
+    Puppet::Indirector::Terminus.terminus_class(:whatever, :abstract).should equal(terminus)
+  end
+
+  it "should set up autoloading for any terminus class types requested" do
+    Puppet::Indirector::Terminus.expects(:instance_load).with(:test2, "puppet/indirector/test2")
+    Puppet::Indirector::Terminus.terminus_class(:test2, :whatever)
+  end
+
+  it "should load terminus classes that are not found" do
+    # Set up instance loading; it would normally happen automatically
+    Puppet::Indirector::Terminus.instance_load :test1, "puppet/indirector/test1"
+
+    Puppet::Indirector::Terminus.instance_loader(:test1).expects(:load).with(:yay)
+    Puppet::Indirector::Terminus.terminus_class(:test1, :yay)
+  end
+
+  it "should fail when no indirection can be found" do
+    Puppet::Indirector::Indirection.expects(:instance).with(:my_indirection).returns(nil)
+
+    @abstract_terminus = Class.new(Puppet::Indirector::Terminus) do
+      def self.to_s
+        "Abstract"
+      end
+    end
+    proc {
+      @terminus = Class.new(@abstract_terminus) do
+        def self.to_s
+          "MyIndirection::TestType"
+        end
+      end
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should register the terminus class with the terminus base class" do
+    Puppet::Indirector::Terminus.expects(:register_terminus_class).with do |type|
+      type.indirection_name == :my_indirection and type.name == :test_terminus
+    end
+    @indirection = stub 'indirection', :name => :my_indirection, :register_terminus_type => nil
+    Puppet::Indirector::Indirection.expects(:instance).with(:my_indirection).returns(@indirection)
+
+    @abstract_terminus = Class.new(Puppet::Indirector::Terminus) do
+      def self.to_s
+        "Abstract"
+      end
+    end
+
+    @terminus = Class.new(@abstract_terminus) do
+      def self.to_s
+        "MyIndirection::TestTerminus"
+      end
+    end
+  end
+end
+
+describe Puppet::Indirector::Terminus, " when parsing class constants for indirection and terminus names" do
+  before do
+    @subclass = mock 'subclass'
+    @subclass.stubs(:to_s).returns("TestInd::OneTwo")
+    @subclass.stubs(:mark_as_abstract_terminus)
+    Puppet::Indirector::Terminus.stubs(:register_terminus_class)
+  end
+
+  it "should fail when anonymous classes are used" do
+    proc { Puppet::Indirector::Terminus.inherited(Class.new) }.should raise_error(Puppet::DevError)
+  end
+
+  it "should use the last term in the constant for the terminus class name" do
+    @subclass.expects(:name=).with(:one_two)
+    @subclass.stubs(:indirection=)
+    Puppet::Indirector::Terminus.inherited(@subclass)
+  end
+
+  it "should convert the terminus name to a downcased symbol" do
+    @subclass.expects(:name=).with(:one_two)
+    @subclass.stubs(:indirection=)
+    Puppet::Indirector::Terminus.inherited(@subclass)
+  end
+
+  it "should use the second to last term in the constant for the indirection name" do
+    @subclass.expects(:indirection=).with(:test_ind)
+    @subclass.stubs(:name=)
+    @subclass.stubs(:terminus_type=)
+    Puppet::Indirector::File.inherited(@subclass)
+  end
+
+  it "should convert the indirection name to a downcased symbol" do
+    @subclass.expects(:indirection=).with(:test_ind)
+    @subclass.stubs(:name=)
+    @subclass.stubs(:terminus_type=)
+    Puppet::Indirector::File.inherited(@subclass)
+  end
+
+  it "should convert camel case to lower case with underscores as word separators" do
+    @subclass.expects(:name=).with(:one_two)
+    @subclass.stubs(:indirection=)
+
+    Puppet::Indirector::Terminus.inherited(@subclass)
+  end
+end
+
+describe Puppet::Indirector::Terminus, " when creating terminus class types" do
+  before do
+    Puppet::Indirector::Terminus.stubs(:register_terminus_class)
+    @subclass = Class.new(Puppet::Indirector::Terminus) do
+      def self.to_s
+        "Puppet::Indirector::Terminus::MyTermType"
+      end
+    end
+  end
+
+  it "should set the name of the abstract subclass to be its class constant" do
+    @subclass.name.should equal(:my_term_type)
+  end
+
+  it "should mark abstract terminus types as such" do
+    @subclass.should be_abstract_terminus
+  end
+
+  it "should not allow instances of abstract subclasses to be created" do
+    proc { @subclass.new }.should raise_error(Puppet::DevError)
+  end
+end
+