puppet 2.6.18 → 2.7.1

data/spec/unit/indirector/run/local_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/run/local'
 

data/spec/unit/indirector/run/rest_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/run/rest'
 

data/spec/unit/indirector/ssl_file_spec.rb

@@ -1,22 +1,23 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env rspec
 #
 #  Created by Luke Kanies on 2008-3-10.
 #  Copyright (c) 2007. All rights reserved.
 
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 require 'puppet/indirector/ssl_file'
 
 describe Puppet::Indirector::SslFile do
-  before do
-    @model = mock 'model'
+  before :all do
     @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
+    module Testing; end
+    @file_class = class Testing::MyType < Puppet::Indirector::SslFile
+      self
     end
+  end
+  before :each do
+    @model = mock 'model'
 
     @setting = :certdir
     @file_class.store_in @setting
@@ -87,25 +88,6 @@ describe Puppet::Indirector::SslFile do
       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
-
-      ['../foo', '..\\foo', './../foo', '.\\..\\foo',
-       '/foo', '//foo', '\\foo', '\\\\goo',
-       "test\0/../bar", "test\0\\..\\bar",
-       "..\\/bar", "/tmp/bar", "/tmp\\bar", "tmp\\bar",
-       " / bar", " /../ bar", " \\..\\ bar",
-       "c:\\foo", "c:/foo", "\\\\?\\UNC\\bar", "\\\\foo\\bar",
-       "\\\\?\\c:\\foo", "//?/UNC/bar", "//foo/bar",
-       "//?/c:/foo",
-      ].each do |input|
-        it "should resist directory traversal attacks (#{input.inspect})" do
-          expect { @searcher.path(input) }.to raise_error
-        end
-      end
-
-      # REVISIT: Should probably test MS-DOS reserved names here, too, since
-      # they would represent a vulnerability on a Win32 system, should we ever
-      # support that path.  Don't forget that 'CON.foo' == 'CON'
-      # --daniel 2011-09-24
     end
 
     describe "when finding certificates on disk" do

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

@@ -1,6 +1,5 @@
-#!/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") }
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/indirector/status/rest'
 

data/spec/unit/indirector/terminus_spec.rb

@@ -1,257 +1,250 @@
-#! /usr/bin/env ruby
+#!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/defaults'
 require 'puppet/indirector'
-require 'puppet/indirector/memory'
-
-describe Puppet::Indirector::Terminus do
-  before :all do
-    class Puppet::AbstractConcept
-      extend Puppet::Indirector
-      indirects :abstract_concept
-      attr_accessor :name
-      def initialize(name = "name")
-        @name = name
+require 'puppet/indirector/file'
+
+describe Puppet::Indirector::Terminus, :'fails_on_ruby_1.9.2' => true 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
-
-    class Puppet::AbstractConcept::Freedom < Puppet::Indirector::Code
+    @terminus_class = Class.new(@abstract_terminus) do
+      def self.to_s
+        "MyStuff::TermType"
+      end
     end
+    @terminus = @terminus_class.new
   end
 
-  after :all do
-    # Remove the class, unlinking it from the rest of the system.
-    Puppet.send(:remove_const, :AbstractConcept)
-  end
+  describe Puppet::Indirector::Terminus do
 
-  let :terminus_class do Puppet::AbstractConcept::Freedom end
-  let :terminus       do terminus_class.new end
-  let :indirection    do Puppet::AbstractConcept.indirection end
-  let :model          do Puppet::AbstractConcept end
-
-  it "should provide a method for setting terminus class documentation" do
-    terminus_class.should respond_to(:desc)
-  end
+    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 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 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 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 support a class-level model attribute" do
+      @terminus_class.should respond_to(:model)
+    end
 
-  it "should accept indirection instances as its indirection" do
-    # The test is that this shouldn't raise, and should preserve the object
-    # instance exactly, hence "equal", not just "==".
-    terminus_class.indirection = indirection
-    terminus_class.indirection.should equal indirection
-  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
-    terminus_class.indirection = :abstract_concept
-    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
-    expect {
-      terminus_class.indirection = :exploding_whales
-    }.to raise_error(ArgumentError, /Could not find indirection instance/)
+    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)
 
-    # We should still have the default indirection.
-    terminus_class.indirection.should equal indirection
+      # It shouldn't overwrite our existing one (or, more normally, it shouldn't set
+      # anything).
+      @terminus_class.indirection.should equal(@indirection)
+    end
   end
 
-  describe "when a terminus instance" do
-    it "should return the class's name as its name" do
-      terminus.name.should == :freedom
+  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 return the class's indirection as its indirection" do
-      terminus.indirection.should equal indirection
+    it "should set the subclass's type to the abstract terminus name" do
+      @terminus.terminus_type.should == :abstract
     end
 
-    it "should set the instances's type to the abstract terminus type's name" do
-      terminus.terminus_type.should == :code
+    it "should set the subclass's name to the indirection name" do
+      @terminus.name.should == :term_type
     end
 
-    it "should set the instances's model to the indirection's model" do
-      terminus.model.should equal indirection.model
+    it "should set the subclass's model to the indirection model" do
+      @indirection.expects(:model).returns :yay
+      @terminus.model.should == :yay
     end
   end
 
-  describe "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
+  describe Puppet::Indirector::Terminus, " when a terminus instance" do
 
-    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)
+    it "should return the class's name as its name" do
+      @terminus.name.should == :term_type
     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)
+    it "should return the class's indirection as its indirection" do
+      @terminus.indirection.should equal(@indirection)
     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)
+    it "should set the instances's type to the abstract terminus type's name" do
+      @terminus.terminus_type.should == :abstract
     end
 
-    it "should fail when no indirection can be found" do
-      Puppet::Indirector::Indirection.expects(:instance).with(:abstract_concept).returns(nil)
-      expect {
-        class Puppet::AbstractConcept::Physics < Puppet::Indirector::Code
-        end
-      }.to raise_error(ArgumentError, /Could not find indirection instance/)
+    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
 
-    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 == :abstract_concept and type.name == :intellect
-      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
 
-      begin
-        class Puppet::AbstractConcept::Intellect < Puppet::Indirector::Code
-        end
-      ensure
-        Puppet::AbstractConcept.send(:remove_const, :Intellect) rescue nil
-      end
-    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
 
-  describe "when parsing class constants for indirection and terminus names" do
-    before :each do
-      Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-    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
 
-    let :subclass do
-      subclass = mock 'subclass'
-      subclass.stubs(:to_s).returns("TestInd::OneTwo")
-      subclass.stubs(:mark_as_abstract_terminus)
-      subclass
-    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"
 
-    it "should fail when anonymous classes are used" do
-      expect {
-        Puppet::Indirector::Terminus.inherited(Class.new)
-      }.to raise_error(Puppet::DevError, /Terminus subclasses must have associated constants/)
-    end
+    Puppet::Indirector::Terminus.instance_loader(:test1).expects(:load).with(:yay)
+    Puppet::Indirector::Terminus.terminus_class(:test1, :yay)
+  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 fail when no indirection can be found", :'fails_on_ruby_1.9.2' => true do
+    Puppet::Indirector::Indirection.expects(:instance).with(:my_indirection).returns(nil)
 
-    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)
+    @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 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::Memory.inherited(subclass)
+  it "should register the terminus class with the terminus base class", :'fails_on_ruby_1.9.2' => true 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)
 
-    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::Memory.inherited(subclass)
+    @abstract_terminus = Class.new(Puppet::Indirector::Terminus) do
+      def self.to_s
+        "Abstract"
+      end
     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)
+    @terminus = Class.new(@abstract_terminus) do
+      def self.to_s
+        "MyIndirection::TestTerminus"
+      end
     end
   end
+end
 
-  describe "when creating terminus class types" do
-    before :all do
-      Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-
-      class Puppet::Indirector::Terminus::TestTerminusType < Puppet::Indirector::Terminus
-      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
 
-    after :all do
-      Puppet::Indirector::Terminus.send(:remove_const, :TestTerminusType)
-    end
+  it "should fail when anonymous classes are used" do
+    proc { Puppet::Indirector::Terminus.inherited(Class.new) }.should raise_error(Puppet::DevError)
+  end
 
-    let :subclass do
-      Puppet::Indirector::Terminus::TestTerminusType
-    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 set the name of the abstract subclass to be its class constant" do
-      subclass.name.should == :test_terminus_type
-    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 mark abstract terminus types as such" do
-      subclass.should be_abstract_terminus
-    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 not allow instances of abstract subclasses to be created" do
-      expect { subclass.new }.to raise_error(Puppet::DevError)
-    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
 
-  describe "when validating a request" do
-    let :request do
-      Puppet::Indirector::Request.new(indirection.name, :find, "the_key", instance)
-    end
+  it "should convert camel case to lower case with underscores as word separators" do
+    @subclass.expects(:name=).with(:one_two)
+    @subclass.stubs(:indirection=)
 
-    describe "`instance.name` does not match the key in the request" do
-      let(:instance) { model.new("wrong_key") }
+    Puppet::Indirector::Terminus.inherited(@subclass)
+  end
+end
 
-      it "raises an error " do
-        expect {
-          terminus.validate(request)
-        }.to raise_error(
-          Puppet::Indirector::ValidationError,
-          /Instance name .* does not match requested key/
-        )
+describe Puppet::Indirector::Terminus, " when creating terminus class types", :'fails_on_ruby_1.9.2' => true 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
 
-    describe "`instance` is not an instance of the model class" do
-      let(:instance) { mock "instance" }
+  it "should set the name of the abstract subclass to be its class constant" do
+    @subclass.name.should equal(:my_term_type)
+  end
 
-      it "raises an error" do
-        expect {
-          terminus.validate(request)
-        }.to raise_error(
-          Puppet::Indirector::ValidationError,
-          /Invalid instance type/
-        )
-      end
-    end
+  it "should mark abstract terminus types as such" do
+    @subclass.should be_abstract_terminus
+  end
 
-    describe "the instance key and class match the request key and model class" do
-      let(:instance) { model.new("the_key") }
+  it "should not allow instances of abstract subclasses to be created" do
+    proc { @subclass.new }.should raise_error(Puppet::DevError)
+  end
+end
 
-      it "passes" do
-        terminus.validate(request)
-      end
-    end
+describe Puppet::Indirector::Terminus, " when listing terminus classes" do
+  it "should list the terminus files available to load" do
+    Puppet::Util::Autoload.any_instance.stubs(:files_to_load).returns ["/foo/bar/baz", "/max/runs/marathon"]
+    Puppet::Indirector::Terminus.terminus_classes('my_stuff').should == [:baz, :marathon]
   end
 end