puppet 7.28.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/interface/action_builder_spec.rb

@@ -1,216 +0,0 @@
-require 'spec_helper'
-require 'puppet/interface'
-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
-    expect(action).to be_a(Puppet::Interface::Action)
-    expect(action.name).to eq(: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
-
-    expect(face.foo).to eq("invoked the method")
-  end
-
-  it "should require a block" do
-    expect {
-      Puppet::Interface::ActionBuilder.build(nil, :foo)
-    }.to 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
-      expect(method).to 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
-      expect(action).to 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
-      expect(action).to 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
-      expect(action.summary).to eq("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
-      expect(action.default).to be_truthy
-    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
-      expect(action.default).to be_falsey
-    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,
-        /the puppet_interface_actionbuilder face foo action takes .* not/
-    end
-
-    it "should fail if the when_rendering block takes a different number of arguments than when_invoked" 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,
-        /the puppet_interface_actionbuilder face foo action takes .* not 3/
-    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,
-        /the puppet_interface_actionbuilder face foo action takes .* 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
-      expect(action.when_rendering(:json)).to 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
-      expect(action.when_rendering(:json)).to be_an_instance_of Method
-      expect(action.when_rendering(:yaml)).to 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
-      expect(action.when_rendering(:json).call(true)).to eq(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
-      expect(action.render_as).to 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
-        expect(action.render_as).to eq(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

@@ -1,254 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/interface'
-
-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 list defined actions" do
-      subject.action(:foo) do
-        when_invoked { |options| "something" }
-      end
-      subject.action(:bar) do
-        when_invoked { |options| "something" }
-      end
-
-      expect(subject.actions).to match_array([:foo, :bar])
-    end
-
-    it "should be able to indicate when an action is defined" do
-      subject.action(:foo) do
-        when_invoked { |options| "something" }
-      end
-
-      expect(subject).to be_action(:foo)
-    end
-
-    it "should correctly treat action names specified as strings" do
-      subject.action(:foo) do
-        when_invoked { |options| "something" }
-      end
-
-      expect(subject).to 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
-
-      expect(subject.actions).to include(:bar)
-      expect(subject.actions).to include(:foo)
-    end
-
-    it "should be able to indicate when an action is defined" do
-      subject.action(:foo) { when_invoked do |options| true end }
-      expect(subject).to 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
-      expect(@instance.foo).to eq("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
-      expect(@instance.foo).to eq("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
-
-      expect(@klass.actions).to include(:bar)
-      expect(@klass.actions).to 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
-
-      expect(@instance.actions).to include(:bar)
-      expect(@instance.actions).to 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
-
-      expect(@instance.actions).to include(:bar)
-      expect(@instance.actions).to 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
-      expect(@instance).to 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
-      expect(@instance).to 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
-        expect(@instance).to be_action(:parent)
-        expect(@instance).to be_action(:sub)
-        expect(@instance).to be_action(:instance)
-      end
-
-      it "should list inherited actions" do
-        expect(@instance.actions).to match_array([:instance, :parent, :sub])
-      end
-
-      it "should not duplicate instance actions after fetching them (#7699)" do
-        expect(@instance.actions).to match_array([:instance, :parent, :sub])
-        @instance.get_action(:instance)
-        expect(@instance.actions).to match_array([:instance, :parent, :sub])
-      end
-
-      it "should not duplicate subclass actions after fetching them (#7699)" do
-        expect(@instance.actions).to match_array([:instance, :parent, :sub])
-        @instance.get_action(:sub)
-        expect(@instance.actions).to match_array([:instance, :parent, :sub])
-      end
-
-      it "should not duplicate superclass actions after fetching them (#7699)" do
-        expect(@instance.actions).to match_array([:instance, :parent, :sub])
-        @instance.get_action(:parent)
-        expect(@instance.actions).to match_array([: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
-      expect(@instance.foo).to eq("something")
-    end
-  end
-
-  describe "#action" do
-    it 'should add an action' do
-      subject.action(:foo) { when_invoked do |options| true end }
-      expect(subject.get_action(:foo)).to be_a Puppet::Interface::Action
-    end
-
-    it 'should support default actions' do
-      subject.action(:foo) { when_invoked do |options| true end; default }
-      expect(subject.get_default_action).to eq(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
-        }
-      }.to 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
-      expect(Class.new(parent_class).get_action(:foo).name).to eq(: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')
-      expect(instance.get_action(:foo).name).to eq(:foo)
-    end
-  end
-end