puppet 0.24.6 → 0.24.7

data/spec/unit/indirector/ssl_rsa/file.rb

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-9-22.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/sslcertificates/monkey_patch'
+require 'puppet/indirector/ssl_rsa/file'
+
+
+describe Puppet::Indirector::SslRsa::File do
+
+    it "should be a subclass of the File terminus class" do
+        Puppet::Indirector::SslRsa::File.superclass.should equal(Puppet::Indirector::File)
+    end
+    
+    it "should have documentation" do
+        Puppet::Indirector::SslRsa::File.doc.should be_instance_of(String)
+    end
+end
+
+describe Puppet::Indirector::SslRsa::File, " when choosing a path for a ca key" do
+    before do
+        @file = Puppet::Indirector::SslRsa::File.new
+        @name = :ca
+    end
+
+    it "should use the cadir" do
+        Puppet.settings.stubs(:value).with(:cadir).returns("/dir")
+        @file.path(@name).should =~ /^\/dir/
+    end
+
+    it "should use 'ca_key.pem' as the file name" do
+        @file.path(@name).should =~ /ca_key\.pem$/
+    end
+end
+
+describe Puppet::Indirector::SslRsa::File, " when choosing a path for a non-ca key" do
+    before do
+        @file = Puppet::Indirector::SslRsa::File.new
+        @name = :publickey
+    end
+
+    it "should use the publickeydir" do
+        Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
+        @file.path(@name).should =~ /^\/dir/
+    end
+
+    it "should use the key name with the pem file extension" do
+        @file.path(@name).should =~ /#{@name}\.pem$/
+    end
+end
+
+describe Puppet::Indirector::SslRsa::File, " when saving" do
+    before do
+        @file = Puppet::Indirector::SslRsa::File.new
+
+        Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
+        @key = stub "key", :name => "foo"
+    end
+
+    it "should store the rsa key to disk in pem format" do
+        @key.expects(:to_pem).returns(:data)
+        @path = "/dir/foo.pem"
+        filehandle = mock "filehandle"
+        File.expects(:open).with(@path, "w").yields(filehandle)
+        filehandle.expects(:print).with(:data)
+        @file.save(@key)
+    end
+end
+
+describe Puppet::Indirector::SslRsa::File, " when finding a key by name" do
+    before do
+        @file = Puppet::Indirector::SslRsa::File.new
+
+        Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
+        @name = "foo"
+    end
+
+    it "should return the key as a key object on success" do
+        @path = "/dir/foo.pem"
+        FileTest.stubs(:exists?).with(@path).returns(true)
+        File.stubs(:read).with(@path).returns(:data)
+        OpenSSL::PKey::RSA.expects(:new).with(:data).returns(:mykey)
+        @file.find(@name).should == :mykey
+    end
+
+    it "should return 'nil' on failure" do
+        @path = "/dir/foo.pem"
+        FileTest.stubs(:exists?).with(@path).returns(false)
+        @file.find(@name).should == nil
+    end
+end
+
+describe Puppet::Indirector::SslRsa::File, " when removing a key" do
+    before do
+        @file = Puppet::Indirector::SslRsa::File.new
+
+        Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
+        @name = "foo"
+    end
+
+    it "should remove the key from disk and return true" do
+        @path = "/dir/foo.pem"
+        FileTest.stubs(:exists?).with(@path).returns(true)
+        File.stubs(:unlink).with(@path).returns(true)
+        @file.destroy(@name).should == true
+    end
+
+    it "should return an exception on failure" do
+        @path = "/dir/foo.pem"
+        FileTest.stubs(:exists?).with(@path).returns(false)
+        @file.destroy(@name).should == nil
+    end
+end

data/spec/unit/indirector/terminus.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
+

data/spec/unit/indirector/yaml.rb

@@ -0,0 +1,145 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/indirector/yaml'
+
+describe Puppet::Indirector::Yaml, " when choosing file location" do
+    before :each do
+        @indirection = stub 'indirection', :name => :my_yaml, :register_terminus_type => nil
+        Puppet::Indirector::Indirection.stubs(:instance).with(:my_yaml).returns(@indirection)
+        @store_class = Class.new(Puppet::Indirector::Yaml) do
+            def self.to_s
+                "MyYaml::MyType"
+            end
+        end
+        @store = @store_class.new
+
+        @subject = Object.new
+        @subject.metaclass.send(:attr_accessor, :name)
+        @subject.name = :me
+
+        @dir = "/what/ever"
+        Puppet.settings.stubs(:value).returns("fakesettingdata")
+        Puppet.settings.stubs(:value).with(:clientyamldir).returns(@dir)
+
+        @request = stub 'request', :key => :me, :instance => @subject
+    end
+
+    describe Puppet::Indirector::Yaml, " when choosing file location" do
+        it "should use the yamldir if the process name is 'puppetmasterd'" do
+            Puppet.settings.expects(:value).with(:name).returns "puppetmasterd"
+            Puppet.settings.expects(:value).with(:yamldir).returns "/main/yaml/dir"
+            @store.path(:me).should =~ %r{^/main/yaml/dir}
+        end
+
+        it "should use the client yamldir if the process name is not 'puppetmasterd'" do
+            Puppet.settings.expects(:value).with(:name).returns "cient"
+            Puppet.settings.expects(:value).with(:clientyamldir).returns "/client/yaml/dir"
+            @store.path(:me).should =~ %r{^/client/yaml/dir}
+        end
+
+        it "should store all files in a single file root set in the Puppet defaults" do
+            @store.path(:me).should =~ %r{^#{@dir}}
+        end
+
+        it "should use the terminus name for choosing the subdirectory" do
+            @store.path(:me).should =~ %r{^#{@dir}/my_yaml}
+        end
+
+        it "should use the object's name to determine the file name" do
+            @store.path(:me).should =~ %r{me.yaml$}
+        end
+    end
+
+    describe Puppet::Indirector::Yaml, " when storing objects as YAML" do
+        it "should only store objects that respond to :name" do
+            @request.stubs(:instance).returns Object.new
+            proc { @store.save(@request) }.should raise_error(ArgumentError)
+        end
+
+        it "should convert Ruby objects to YAML and write them to disk using a write lock" do
+            yaml = @subject.to_yaml
+            file = mock 'file'
+            path = @store.send(:path, @subject.name)
+            FileTest.expects(:exist?).with(File.dirname(path)).returns(true)
+            @store.expects(:writelock).with(path, 0660).yields(file)
+            file.expects(:print).with(yaml)
+
+            @store.save(@request)
+        end
+
+        it "should create the indirection subdirectory if it does not exist" do
+            yaml = @subject.to_yaml
+            file = mock 'file'
+            path = @store.send(:path, @subject.name)
+            dir = File.dirname(path)
+
+            FileTest.expects(:exist?).with(dir).returns(false)
+            Dir.expects(:mkdir).with(dir)
+
+            @store.expects(:writelock).yields(file)
+            file.expects(:print).with(yaml)
+
+            @store.save(@request)
+        end
+    end
+
+    describe Puppet::Indirector::Yaml, " when retrieving YAML" do
+        it "should read YAML in from disk using a read lock and convert it to Ruby objects" do
+            path = @store.send(:path, @subject.name)
+
+            yaml = @subject.to_yaml
+            FileTest.expects(:exist?).with(path).returns(true)
+
+            fh = mock 'filehandle'
+            @store.expects(:readlock).with(path).yields fh
+            fh.expects(:read).returns yaml
+
+            @store.find(@request).instance_variable_get("@name").should == :me
+        end
+
+        it "should fail coherently when the stored YAML is invalid" do
+            path = @store.send(:path, @subject.name)
+            FileTest.expects(:exist?).with(path).returns(true)
+
+            # Something that will fail in yaml
+            yaml = "--- !ruby/object:Hash"
+
+            fh = mock 'filehandle'
+            @store.expects(:readlock).yields fh
+            fh.expects(:read).returns yaml
+
+            proc { @store.find(@request) }.should raise_error(Puppet::Error)
+        end
+    end
+
+    describe Puppet::Indirector::Yaml, " when searching" do
+      it "should return an array of fact instances with one instance for each file when globbing *" do
+        @request = stub 'request', :key => "*", :instance => @subject
+        @one = mock 'one'
+        @two = mock 'two'
+        @store.expects(:base).returns "/my/yaml/dir"
+        Dir.expects(:glob).with(File.join("/my/yaml/dir", @store.class.indirection_name.to_s, @request.key)).returns(%w{one.yaml two.yaml})
+        YAML.expects(:load_file).with("one.yaml").returns @one;
+        YAML.expects(:load_file).with("two.yaml").returns @two;
+        @store.search(@request).should == [@one, @two]
+      end
+
+      it "should return an array containing a single instance of fact when globbing 'one*'" do
+        @request = stub 'request', :key => "one*", :instance => @subject
+        @one = mock 'one'
+        @store.expects(:base).returns "/my/yaml/dir"
+        Dir.expects(:glob).with(File.join("/my/yaml/dir", @store.class.indirection_name.to_s, @request.key)).returns(%w{one.yaml})
+        YAML.expects(:load_file).with("one.yaml").returns @one;
+        @store.search(@request).should == [@one]
+      end
+
+      it "should return an empty array when the glob doesn't match anything" do
+        @request = stub 'request', :key => "f*ilglobcanfail*", :instance => @subject
+        @store.expects(:base).returns "/my/yaml/dir"
+        Dir.expects(:glob).with(File.join("/my/yaml/dir", @store.class.indirection_name.to_s, @request.key)).returns([])
+        @store.search(@request).should == []
+      end
+    end
+end