puppet 2.6.18 → 2.7.1

data/spec/unit/indirector/yaml_spec.rb

@@ -1,18 +1,18 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/indirector/yaml'
 
 describe Puppet::Indirector::Yaml, " when choosing file location" do
-  before :each do
+  before :all 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
+    Puppet::Indirector::Indirection.expects(:instance).with(:my_yaml).returns(@indirection)
+    module MyYaml; end
+    @store_class = class MyYaml::MyType < Puppet::Indirector::Yaml
+      self
     end
+  end
+  before :each do
     @store = @store_class.new
 
     @subject = Object.new
@@ -63,20 +63,6 @@ describe Puppet::Indirector::Yaml, " when choosing file location" do
     it "should use the object's name to determine the file name" do
       @store.path(:me).should =~ %r{me.yaml$}
     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 { @store.path(input) }.to raise_error
-      end
-    end
   end
 
   describe Puppet::Indirector::Yaml, " when storing objects as YAML" do

data/spec/unit/indirector_spec.rb

@@ -1,10 +1,68 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/defaults'
 require 'puppet/indirector'
 
+describe Puppet::Indirector, "when configuring routes" do
+  before :each do
+    Puppet::Node.indirection.reset_terminus_class
+    Puppet::Node.indirection.cache_class = nil
+  end
+
+  after :each do
+    Puppet::Node.indirection.reset_terminus_class
+    Puppet::Node.indirection.cache_class = nil
+  end
+
+  it "should configure routes as requested" do
+    routes = {
+      "node" => {
+        "terminus" => "exec",
+        "cache"    => "plain"
+      }
+    }
+
+    Puppet::Indirector.configure_routes(routes)
+
+    Puppet::Node.indirection.terminus_class.should == "exec"
+    Puppet::Node.indirection.cache_class.should    == "plain"
+  end
+
+  it "should fail when given an invalid indirection" do
+    routes = {
+      "fake_indirection" => {
+        "terminus" => "exec",
+        "cache"    => "plain"
+      }
+    }
+
+    expect { Puppet::Indirector.configure_routes(routes) }.should raise_error(/fake_indirection does not exist/)
+  end
+
+  it "should fail when given an invalid terminus" do
+    routes = {
+      "node" => {
+        "terminus" => "fake_terminus",
+        "cache"    => "plain"
+      }
+    }
+
+    expect { Puppet::Indirector.configure_routes(routes) }.should raise_error(/Could not find terminus fake_terminus/)
+  end
+
+  it "should fail when given an invalid cache" do
+    routes = {
+      "node" => {
+        "terminus" => "exec",
+        "cache"    => "fake_cache"
+      }
+    }
+
+    expect { Puppet::Indirector.configure_routes(routes) }.should raise_error(/Could not find terminus fake_cache/)
+  end
+end
+
 describe Puppet::Indirector, " when available to a model" do
   before do
     @thingie = Class.new do
@@ -64,24 +122,6 @@ describe Puppet::Indirector, "when registering an indirection" do
   end
 end
 
-shared_examples_for "Delegated Indirection Method" do
-  it "should delegate to the indirection" do
-    @indirection.expects(@method)
-    @thingie.send(@method, "me")
-  end
-
-  it "should pass all of the passed arguments directly to the indirection instance" do
-    @indirection.expects(@method).with("me", :one => :two)
-    @thingie.send(@method, "me", :one => :two)
-  end
-
-  it "should return the results of the delegation as its result" do
-    request = mock 'request'
-    @indirection.expects(@method).returns "yay"
-    @thingie.send(@method, "me").should == "yay"
-  end
-end
-
 describe Puppet::Indirector, "when redirecting a model" do
   before do
     @thingie = Class.new do
@@ -98,64 +138,6 @@ describe Puppet::Indirector, "when redirecting a model" do
     @thingie.ancestors.should be_include(Puppet::Indirector::Envelope)
   end
 
-  describe "when finding instances via the model" do
-    before { @method = :find }
-    it_should_behave_like "Delegated Indirection Method"
-  end
-
-  describe "when destroying instances via the model" do
-    before { @method = :destroy }
-    it_should_behave_like "Delegated Indirection Method"
-  end
-
-  describe "when searching for instances via the model" do
-    before { @method = :search }
-    it_should_behave_like "Delegated Indirection Method"
-  end
-
-  describe "when expiring instances via the model" do
-    before { @method = :expire }
-    it_should_behave_like "Delegated Indirection Method"
-  end
-
-  describe "when performing a head request" do
-    before { @method = :head }
-    it_should_behave_like "Delegated Indirection Method"
-  end
-
-  # This is an instance method, so it behaves a bit differently.
-  describe "when saving instances via the model" do
-    before do
-      @instance = @thingie.new("me")
-    end
-
-    it "should delegate to the indirection" do
-      @indirection.expects(:save)
-      @instance.save
-    end
-
-    it "should pass the instance and an optional key to the indirection's :save method" do
-      @indirection.expects(:save).with("key", @instance)
-      @instance.save "key"
-    end
-
-    it "should return the results of the delegation as its result" do
-      request = mock 'request'
-      @indirection.expects(:save).returns "yay"
-      @instance.save.should == "yay"
-    end
-  end
-
-  it "should give the model the ability to set the indirection terminus class" do
-    @indirection.expects(:terminus_class=).with(:myterm)
-    @thingie.terminus_class = :myterm
-  end
-
-  it "should give the model the ability to set the indirection cache class" do
-    @indirection.expects(:cache_class=).with(:mycache)
-    @thingie.cache_class = :mycache
-  end
-
   after do
     @indirection.delete
   end

data/spec/unit/interface/action_builder_spec.rb

@@ -0,0 +1,214 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet/interface/action_builder'
+require 'puppet/network/format_handler'
+
+describe Puppet::Interface::ActionBuilder do
+  let :face do Puppet::Interface.new(:puppet_interface_actionbuilder, '0.0.1') end
+
+  it "should build an action" do
+    action = Puppet::Interface::ActionBuilder.build(face, :foo) do
+      when_invoked do |options| true end
+    end
+    action.should be_a(Puppet::Interface::Action)
+    action.name.should == :foo
+  end
+
+  it "should define a method on the face which invokes the action" do
+    face = Puppet::Interface.new(:action_builder_test_interface, '0.0.1') do
+      action(:foo) { when_invoked { |options| "invoked the method" } }
+    end
+
+    face.foo.should == "invoked the method"
+  end
+
+  it "should require a block" do
+    expect { Puppet::Interface::ActionBuilder.build(nil, :foo) }.
+      should raise_error("Action :foo must specify a block")
+  end
+
+  it "should require an invocation block" do
+    expect {
+      Puppet::Interface::ActionBuilder.build(face, :foo) {}
+    }.to raise_error(/actions need to know what to do when_invoked; please add the block/)
+  end
+
+  describe "when handling options" do
+    it "should have a #option DSL function" do
+      method = nil
+      Puppet::Interface::ActionBuilder.build(face, :foo) do
+        when_invoked do |options| true end
+        method = self.method(:option)
+      end
+      method.should be_an_instance_of Method
+    end
+
+    it "should define an option without a block" do
+      action = Puppet::Interface::ActionBuilder.build(face, :foo) do
+        when_invoked do |options| true end
+        option "--bar"
+      end
+      action.should be_option :bar
+    end
+
+    it "should accept an empty block" do
+      action = Puppet::Interface::ActionBuilder.build(face, :foo) do
+        when_invoked do |options| true end
+        option "--bar" do
+          # This space left deliberately blank.
+        end
+      end
+      action.should be_option :bar
+    end
+  end
+
+  context "inline documentation" do
+    it "should set the summary" do
+      action = Puppet::Interface::ActionBuilder.build(face, :foo) do
+        when_invoked do |options| true end
+        summary "this is some text"
+      end
+      action.summary.should == "this is some text"
+    end
+  end
+
+  context "action defaulting" do
+    it "should set the default to true" do
+      action = Puppet::Interface::ActionBuilder.build(face, :foo) do
+        when_invoked do |options| true end
+        default
+      end
+      action.default.should be_true
+    end
+
+    it "should not be default by, er, default. *cough*" do
+      action = Puppet::Interface::ActionBuilder.build(face, :foo) do
+        when_invoked do |options| true end
+      end
+      action.default.should be_false
+    end
+  end
+
+  context "#when_rendering" do
+    it "should fail if no rendering format is given" do
+      expect {
+        Puppet::Interface::ActionBuilder.build(face, :foo) do
+          when_invoked do |options| true end
+          when_rendering do true end
+        end
+      }.to raise_error ArgumentError, /must give a rendering format to when_rendering/
+    end
+
+    it "should fail if no block is given" do
+      expect {
+        Puppet::Interface::ActionBuilder.build(face, :foo) do
+          when_invoked do |options| true end
+          when_rendering :json
+        end
+      }.to raise_error ArgumentError, /must give a block to when_rendering/
+    end
+
+    it "should fail if the block takes no arguments" do
+      expect {
+        Puppet::Interface::ActionBuilder.build(face, :foo) do
+          when_invoked do |options| true end
+          when_rendering :json do true end
+        end
+      }.to raise_error ArgumentError, /when_rendering methods take one argument, the result, not/
+    end
+
+    it "should fail if the block takes more than one argument" do
+      expect {
+        Puppet::Interface::ActionBuilder.build(face, :foo) do
+          when_invoked do |options| true end
+          when_rendering :json do |a, b, c| true end
+        end
+      }.to raise_error ArgumentError, /when_rendering methods take one argument, the result, not/
+    end
+
+    it "should fail if the block takes a variable number of arguments" do
+      expect {
+        Puppet::Interface::ActionBuilder.build(face, :foo) do
+          when_invoked do |options| true end
+          when_rendering :json do |*args| true end
+        end
+      }.to raise_error(ArgumentError,
+                       /when_rendering methods take one argument, the result, not/)
+    end
+
+    it "should stash a rendering block" do
+      action = Puppet::Interface::ActionBuilder.build(face, :foo) do
+        when_invoked do |options| true end
+        when_rendering :json do |a| true end
+      end
+      action.when_rendering(:json).should be_an_instance_of Method
+    end
+
+    it "should fail if you try to set the same rendering twice" do
+      expect {
+        Puppet::Interface::ActionBuilder.build(face, :foo) do
+          when_invoked do |options| true end
+          when_rendering :json do |a| true end
+          when_rendering :json do |a| true end
+        end
+      }.to raise_error ArgumentError, /You can't define a rendering method for json twice/
+    end
+
+    it "should work if you set two different renderings" do
+      action = Puppet::Interface::ActionBuilder.build(face, :foo) do
+        when_invoked do |options| true end
+        when_rendering :json do |a| true end
+        when_rendering :yaml do |a| true end
+      end
+      action.when_rendering(:json).should be_an_instance_of Method
+      action.when_rendering(:yaml).should be_an_instance_of Method
+    end
+
+    it "should be bound to the face when called" do
+      action = Puppet::Interface::ActionBuilder.build(face, :foo) do
+        when_invoked do |options| true end
+        when_rendering :json do |a| self end
+      end
+      action.when_rendering(:json).call(true).should == face
+    end
+  end
+
+  context "#render_as" do
+    it "should default to nil (eg: based on context)" do
+      action = Puppet::Interface::ActionBuilder.build(face, :foo) do
+        when_invoked do |options| true end
+      end
+      action.render_as.should be_nil
+    end
+
+    it "should fail if not rendering format is given" do
+      expect {
+        Puppet::Interface::ActionBuilder.build(face, :foo) do
+          when_invoked do |options| true end
+          render_as
+        end
+      }.to raise_error ArgumentError, /must give a rendering format to render_as/
+    end
+
+    Puppet::Network::FormatHandler.formats.each do |name|
+      it "should accept #{name.inspect} format" do
+        action = Puppet::Interface::ActionBuilder.build(face, :foo) do
+          when_invoked do |options| true end
+          render_as name
+        end
+        action.render_as.should == name
+      end
+    end
+
+    [:if_you_define_this_format_you_frighten_me, "json", 12].each do |input|
+      it "should fail if given #{input.inspect}" do
+        expect {
+          Puppet::Interface::ActionBuilder.build(face, :foo) do
+            when_invoked do |options| true end
+            render_as input
+          end
+        }.to raise_error ArgumentError, /#{input.inspect} is not a valid rendering format/
+      end
+    end
+  end
+end

data/spec/unit/interface/action_manager_spec.rb

@@ -0,0 +1,282 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+# This is entirely an internal class for Interface, so we have to load it instead of our class.
+require 'puppet/interface'
+require 'puppet/face'
+
+class ActionManagerTester
+  include Puppet::Interface::ActionManager
+end
+
+describe Puppet::Interface::ActionManager do
+  subject { ActionManagerTester.new }
+
+  describe "when included in a class" do
+    it "should be able to define an action" do
+      subject.action(:foo) do
+        when_invoked { |options| "something "}
+      end
+    end
+
+    it "should be able to define a 'script' style action" do
+      subject.script :bar do |options|
+        "a bar is where beer is found"
+      end
+    end
+
+    it "should be able to list defined actions" do
+      subject.action(:foo) do
+        when_invoked { |options| "something" }
+      end
+      subject.action(:bar) do
+        when_invoked { |options| "something" }
+      end
+
+      subject.actions.should =~ [:foo, :bar]
+    end
+
+    it "should list 'script' actions" do
+      subject.script :foo do |options| "foo" end
+      subject.actions.should =~ [:foo]
+    end
+
+    it "should list both script and normal actions" do
+      subject.action :foo do
+        when_invoked do |options| "foo" end
+      end
+      subject.script :bar do |options| "a bar is where beer is found" end
+
+      subject.actions.should =~ [:foo, :bar]
+    end
+
+    it "should be able to indicate when an action is defined" do
+      subject.action(:foo) do
+        when_invoked { |options| "something" }
+      end
+
+      subject.should be_action(:foo)
+    end
+
+    it "should indicate an action is defined for script actions" do
+      subject.script :foo do |options| "foo" end
+      subject.should be_action :foo
+    end
+
+    it "should correctly treat action names specified as strings" do
+      subject.action(:foo) do
+        when_invoked { |options| "something" }
+      end
+
+      subject.should be_action("foo")
+    end
+  end
+
+  describe "when used to extend a class" do
+    subject { Class.new.extend(Puppet::Interface::ActionManager) }
+
+    it "should be able to define an action" do
+      subject.action(:foo) do
+        when_invoked { |options| "something "}
+      end
+    end
+
+    it "should be able to list defined actions" do
+      subject.action(:foo) do
+        when_invoked { |options| "something" }
+      end
+      subject.action(:bar) do
+        when_invoked { |options| "something" }
+      end
+
+      subject.actions.should include(:bar)
+      subject.actions.should include(:foo)
+    end
+
+    it "should be able to indicate when an action is defined" do
+      subject.action(:foo) { when_invoked do |options| true end }
+      subject.should be_action(:foo)
+    end
+  end
+
+  describe "when used both at the class and instance level" do
+    before do
+      @klass = Class.new do
+        include Puppet::Interface::ActionManager
+        extend Puppet::Interface::ActionManager
+        def __invoke_decorations(*args) true end
+        def options() [] end
+      end
+      @instance = @klass.new
+    end
+
+    it "should be able to define an action at the class level" do
+      @klass.action(:foo) do
+        when_invoked { |options| "something "}
+      end
+    end
+
+    it "should create an instance method when an action is defined at the class level" do
+      @klass.action(:foo) do
+        when_invoked { |options| "something" }
+      end
+      @instance.foo.should == "something"
+    end
+
+    it "should be able to define an action at the instance level" do
+      @instance.action(:foo) do
+        when_invoked { |options| "something "}
+      end
+    end
+
+    it "should create an instance method when an action is defined at the instance level" do
+      @instance.action(:foo) do
+        when_invoked { |options| "something" }
+      end
+      @instance.foo.should == "something"
+    end
+
+    it "should be able to list actions defined at the class level" do
+      @klass.action(:foo) do
+        when_invoked { |options| "something" }
+      end
+      @klass.action(:bar) do
+        when_invoked { |options| "something" }
+      end
+
+      @klass.actions.should include(:bar)
+      @klass.actions.should include(:foo)
+    end
+
+    it "should be able to list actions defined at the instance level" do
+      @instance.action(:foo) do
+        when_invoked { |options| "something" }
+      end
+      @instance.action(:bar) do
+        when_invoked { |options| "something" }
+      end
+
+      @instance.actions.should include(:bar)
+      @instance.actions.should include(:foo)
+    end
+
+    it "should be able to list actions defined at both instance and class level" do
+      @klass.action(:foo) do
+        when_invoked { |options| "something" }
+      end
+      @instance.action(:bar) do
+        when_invoked { |options| "something" }
+      end
+
+      @instance.actions.should include(:bar)
+      @instance.actions.should include(:foo)
+    end
+
+    it "should be able to indicate when an action is defined at the class level" do
+      @klass.action(:foo) do
+        when_invoked { |options| "something" }
+      end
+      @instance.should be_action(:foo)
+    end
+
+    it "should be able to indicate when an action is defined at the instance level" do
+      @klass.action(:foo) do
+        when_invoked { |options| "something" }
+      end
+      @instance.should be_action(:foo)
+    end
+
+    context "with actions defined in superclass" do
+      before :each do
+        @subclass = Class.new(@klass)
+        @instance = @subclass.new
+
+        @klass.action(:parent) do
+          when_invoked { |options| "a" }
+        end
+        @subclass.action(:sub) do
+          when_invoked { |options| "a" }
+        end
+        @instance.action(:instance) do
+          when_invoked { |options| "a" }
+        end
+      end
+
+      it "should list actions defined in superclasses" do
+        @instance.should be_action(:parent)
+        @instance.should be_action(:sub)
+        @instance.should be_action(:instance)
+      end
+
+      it "should list inherited actions" do
+        @instance.actions.should =~ [:instance, :parent, :sub]
+      end
+
+      it "should not duplicate instance actions after fetching them (#7699)" do
+        @instance.actions.should =~ [:instance, :parent, :sub]
+        @instance.get_action(:instance)
+        @instance.actions.should =~ [:instance, :parent, :sub]
+      end
+
+      it "should not duplicate subclass actions after fetching them (#7699)" do
+        @instance.actions.should =~ [:instance, :parent, :sub]
+        @instance.get_action(:sub)
+        @instance.actions.should =~ [:instance, :parent, :sub]
+      end
+
+      it "should not duplicate superclass actions after fetching them (#7699)" do
+        @instance.actions.should =~ [:instance, :parent, :sub]
+        @instance.get_action(:parent)
+        @instance.actions.should =~ [:instance, :parent, :sub]
+      end
+    end
+
+    it "should create an instance method when an action is defined in a superclass" do
+      @subclass = Class.new(@klass)
+      @instance = @subclass.new
+
+      @klass.action(:foo) do
+        when_invoked { |options| "something" }
+      end
+      @instance.foo.should == "something"
+    end
+  end
+
+  describe "#action" do
+    it 'should add an action' do
+      subject.action(:foo) { when_invoked do |options| true end }
+      subject.get_action(:foo).should be_a Puppet::Interface::Action
+    end
+
+    it 'should support default actions' do
+      subject.action(:foo) { when_invoked do |options| true end; default }
+      subject.get_default_action.should == subject.get_action(:foo)
+    end
+
+    it 'should not support more than one default action' do
+      subject.action(:foo) { when_invoked do |options| true end; default }
+      expect { subject.action(:bar) {
+          when_invoked do |options| true end
+          default
+        }
+      }.should raise_error /cannot both be default/
+    end
+  end
+
+  describe "#get_action" do
+    let :parent_class do
+      parent_class = Class.new(Puppet::Interface)
+      parent_class.action(:foo) { when_invoked do |options| true end }
+      parent_class
+    end
+
+    it "should check that we can find inherited actions when we are a class" do
+      Class.new(parent_class).get_action(:foo).name.should == :foo
+    end
+
+    it "should check that we can find inherited actions when we are an instance" do
+      instance = parent_class.new(:foo, '0.0.0')
+      instance.get_action(:foo).name.should == :foo
+    end
+  end
+end