chef 12.4.3-universal-mingw32 → 12.5.1-universal-mingw32

data/spec/integration/recipes/resource_action_spec.rb

@@ -0,0 +1,363 @@
+require 'support/shared/integration/integration_helper'
+
+describe "Resource.action" do
+  include IntegrationSupport
+
+  shared_context "ActionJackson" do
+    it "the default action is the first declared action" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_recipe_dsl
+      expect(ActionJackson.succeeded).to eq true
+    end
+
+    it "the action can access recipe DSL" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_recipe_dsl
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_recipe_dsl
+      expect(ActionJackson.succeeded).to eq true
+    end
+
+    it "the action can access attributes" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_attribute
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_attribute
+      expect(ActionJackson.succeeded).to eq 'foo!'
+    end
+
+    it "the action can access public methods" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_method
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_method
+      expect(ActionJackson.succeeded).to eq 'foo_public!'
+    end
+
+    it "the action can access protected methods" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_protected_method
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_protected_method
+      expect(ActionJackson.succeeded).to eq 'foo_protected!'
+    end
+
+    it "the action cannot access private methods" do
+      expect {
+        converge(<<-EOM, __FILE__, __LINE__+1)
+          #{resource_dsl} 'hi' do
+            foo 'foo!'
+            action :access_private_method
+          end
+        EOM
+      }.to raise_error(NameError)
+      expect(ActionJackson.ran_action).to eq :access_private_method
+    end
+
+    it "the action cannot access resource instance variables" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_instance_variable
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_instance_variable
+      expect(ActionJackson.succeeded).to be_nil
+    end
+
+    it "the action does not compile until the prior resource has converged" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        ruby_block 'wow' do
+          block do
+            ActionJackson.ruby_block_converged = 'ruby_block_converged!'
+          end
+        end
+
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_class_method
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_class_method
+      expect(ActionJackson.succeeded).to eq 'ruby_block_converged!'
+    end
+
+    it "the action's resources converge before the next resource converges" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_attribute
+        end
+
+        ruby_block 'wow' do
+          block do
+            ActionJackson.ruby_block_converged = ActionJackson.succeeded
+          end
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_attribute
+      expect(ActionJackson.succeeded).to eq 'foo!'
+      expect(ActionJackson.ruby_block_converged).to eq 'foo!'
+    end
+  end
+
+  context "With resource 'action_jackson'" do
+    before(:context) {
+      class ActionJackson < Chef::Resource
+        use_automatic_resource_name
+        def foo(value=nil)
+          @foo = value if value
+          @foo
+        end
+        def blarghle(value=nil)
+          @blarghle = value if value
+          @blarghle
+        end
+
+        class <<self
+          attr_accessor :ran_action
+          attr_accessor :succeeded
+          attr_accessor :ruby_block_converged
+        end
+
+        public
+        def foo_public
+          'foo_public!'
+        end
+        protected
+        def foo_protected
+          'foo_protected!'
+        end
+        private
+        def foo_private
+          'foo_private!'
+        end
+
+        public
+        action :access_recipe_dsl do
+          ActionJackson.ran_action = :access_recipe_dsl
+          ruby_block 'hi there' do
+            block do
+              ActionJackson.succeeded = true
+            end
+          end
+        end
+        action :access_attribute do
+          ActionJackson.ran_action = :access_attribute
+          ActionJackson.succeeded = foo
+          ActionJackson.succeeded += " #{blarghle}" if blarghle
+          ActionJackson.succeeded += " #{bar}" if respond_to?(:bar)
+        end
+        action :access_attribute2 do
+          ActionJackson.ran_action = :access_attribute2
+          ActionJackson.succeeded = foo
+          ActionJackson.succeeded += " #{blarghle}" if blarghle
+          ActionJackson.succeeded += " #{bar}" if respond_to?(:bar)
+        end
+        action :access_method do
+          ActionJackson.ran_action = :access_method
+          ActionJackson.succeeded = foo_public
+        end
+        action :access_protected_method do
+          ActionJackson.ran_action = :access_protected_method
+          ActionJackson.succeeded = foo_protected
+        end
+        action :access_private_method do
+          ActionJackson.ran_action = :access_private_method
+          ActionJackson.succeeded = foo_private
+        end
+        action :access_instance_variable do
+          ActionJackson.ran_action = :access_instance_variable
+          ActionJackson.succeeded = @foo
+        end
+        action :access_class_method do
+          ActionJackson.ran_action = :access_class_method
+          ActionJackson.succeeded = ActionJackson.ruby_block_converged
+        end
+      end
+    }
+    before(:each) {
+      ActionJackson.ran_action = :error
+      ActionJackson.succeeded = :error
+      ActionJackson.ruby_block_converged = :error
+    }
+
+    it_behaves_like "ActionJackson" do
+      let(:resource_dsl) { :action_jackson }
+    end
+
+    it "Can retrieve ancestors of action class without crashing" do
+      converge { action_jackson 'hi' }
+      expect { ActionJackson.action_class.ancestors.join(",") }.not_to raise_error
+    end
+
+    context "And 'action_jackgrandson' inheriting from ActionJackson and changing nothing" do
+      before(:context) {
+        class ActionJackgrandson < ActionJackson
+          use_automatic_resource_name
+        end
+      }
+
+      it_behaves_like "ActionJackson" do
+        let(:resource_dsl) { :action_jackgrandson }
+      end
+    end
+
+    context "And 'action_jackalope' inheriting from ActionJackson with an extra attribute, action and custom method" do
+      before(:context) {
+        class ActionJackalope < ActionJackson
+          use_automatic_resource_name
+
+          def foo(value=nil)
+            @foo = "#{value}alope" if value
+            @foo
+          end
+          def bar(value=nil)
+            @bar = "#{value}alope" if value
+            @bar
+          end
+          class <<self
+            attr_accessor :load_current_resource_ran
+            attr_accessor :jackalope_ran
+          end
+          action :access_jackalope do
+            ActionJackalope.jackalope_ran = :access_jackalope
+            ActionJackalope.succeeded = "#{foo} #{blarghle} #{bar}"
+          end
+          action :access_attribute do
+            super()
+            ActionJackalope.jackalope_ran = :access_attribute
+            ActionJackalope.succeeded = ActionJackson.succeeded
+          end
+        end
+      }
+      before do
+        ActionJackalope.jackalope_ran = nil
+        ActionJackalope.load_current_resource_ran = nil
+      end
+
+      context "action_jackson still behaves the same" do
+        it_behaves_like "ActionJackson" do
+          let(:resource_dsl) { :action_jackson }
+        end
+      end
+
+      it "the default action remains the same even though new actions were specified first" do
+        converge {
+          action_jackalope 'hi' do
+            foo 'foo!'
+            bar 'bar!'
+          end
+        }
+        expect(ActionJackson.ran_action).to eq :access_recipe_dsl
+        expect(ActionJackson.succeeded).to eq true
+      end
+
+      it "new actions run, and can access overridden, new, and overridden attributes" do
+        converge {
+          action_jackalope 'hi' do
+            foo 'foo!'
+            bar 'bar!'
+            blarghle 'blarghle!'
+            action :access_jackalope
+          end
+        }
+        expect(ActionJackalope.jackalope_ran).to eq :access_jackalope
+        expect(ActionJackalope.succeeded).to eq "foo!alope blarghle! bar!alope"
+      end
+
+      it "overridden actions run, call super, and can access overridden, new, and overridden attributes" do
+        converge {
+          action_jackalope 'hi' do
+            foo 'foo!'
+            bar 'bar!'
+            blarghle 'blarghle!'
+            action :access_attribute
+          end
+        }
+        expect(ActionJackson.ran_action).to eq :access_attribute
+        expect(ActionJackson.succeeded).to eq "foo!alope blarghle! bar!alope"
+        expect(ActionJackalope.jackalope_ran).to eq :access_attribute
+        expect(ActionJackalope.succeeded).to eq "foo!alope blarghle! bar!alope"
+      end
+
+      it "non-overridden actions run and can access overridden and non-overridden variables (but not necessarily new ones)" do
+        converge {
+          action_jackalope 'hi' do
+            foo 'foo!'
+            bar 'bar!'
+            blarghle 'blarghle!'
+            action :access_attribute2
+          end
+        }
+        expect(ActionJackson.ran_action).to eq :access_attribute2
+        expect(ActionJackson.succeeded).to eq("foo!alope blarghle! bar!alope").or(eq("foo!alope blarghle!"))
+      end
+    end
+  end
+
+  context "With a resource with no actions" do
+    before(:context) {
+      class NoActionJackson < Chef::Resource
+        use_automatic_resource_name
+
+        def foo(value=nil)
+          @foo = value if value
+          @foo
+        end
+
+        class <<self
+          attr_accessor :action_was
+        end
+      end
+    }
+    it "the default action is :nothing" do
+      converge {
+        no_action_jackson 'hi' do
+          foo 'foo!'
+          NoActionJackson.action_was = action
+        end
+      }
+      expect(NoActionJackson.action_was).to eq [:nothing]
+    end
+  end
+
+  context "With a resource with action a-b-c d" do
+    before(:context) {
+      class WeirdActionJackson < Chef::Resource
+        use_automatic_resource_name
+
+        class <<self
+          attr_accessor :action_was
+        end
+
+        action "a-b-c d" do
+          WeirdActionJackson.action_was = action
+        end
+      end
+    }
+
+    it "Running the action works" do
+      expect_recipe {
+        weird_action_jackson 'hi'
+      }.to be_up_to_date
+      expect(WeirdActionJackson.action_was).to eq :"a-b-c d"
+    end
+  end
+end

data/spec/integration/recipes/resource_converge_if_changed_spec.rb

@@ -0,0 +1,423 @@
+require 'support/shared/integration/integration_helper'
+
+describe "Resource::ActionClass#converge_if_changed" do
+  include IntegrationSupport
+
+  module Namer
+    extend self
+    attr_accessor :current_index
+    def incrementing_value
+      @incrementing_value += 1
+      @incrementing_value
+    end
+    attr_writer :incrementing_value
+  end
+
+  before(:all) { Namer.current_index = 1 }
+  before { Namer.current_index += 1 }
+  before { Namer.incrementing_value = 0 }
+
+  context "when the resource has identity, state and control properties" do
+    let(:resource_name) { :"converge_if_changed_dsl#{Namer.current_index}" }
+    let(:resource_class) {
+      result = Class.new(Chef::Resource) do
+        def self.to_s; resource_name; end
+        def self.inspect; resource_name.inspect; end
+        property :identity1, identity: true, default: 'default_identity1'
+        property :control1, desired_state: false, default: 'default_control1'
+        property :state1, default: 'default_state1'
+        property :state2, default: 'default_state2'
+        attr_accessor :converged
+        def initialize(*args)
+          super
+          @converged = 0
+        end
+      end
+      result.resource_name resource_name
+      result
+    }
+    let(:converged_recipe) { converge(converge_recipe) }
+    let(:resource) { converged_recipe.resources.first }
+
+    context "and converge_if_changed with no parameters" do
+      before :each do
+        resource_class.action :create do
+          converge_if_changed do
+            new_resource.converged += 1
+          end
+        end
+      end
+
+      context "and current_resource with state1=current, state2=current" do
+        before :each do
+          resource_class.load_current_value do
+            state1 'current_state1'
+            state2 'current_state2'
+          end
+        end
+
+        context "and nothing is set" do
+          let(:converge_recipe) { "#{resource_name} 'blah'" }
+
+          it "the resource updates nothing" do
+            expect(resource.converged).to eq 0
+            expect(resource.updated?).to  be_falsey
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create (up to date)
+            EOM
+          end
+        end
+
+        context "and state1 is set to a new value" do
+          let(:converge_recipe) {
+            <<-EOM
+              #{resource_name} 'blah' do
+                state1 'new_state1'
+              end
+            EOM
+          }
+
+          it "the resource updates state1" do
+            expect(resource.converged).to eq 1
+            expect(resource.updated?).to  be_truthy
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create
+  - update default_identity1
+  -   set state1 to "new_state1" (was "current_state1")
+              EOM
+          end
+        end
+
+        context "and state1 and state2 are set to new values" do
+          let(:converge_recipe) {
+            <<-EOM
+              #{resource_name} 'blah' do
+                state1 'new_state1'
+                state2 'new_state2'
+              end
+            EOM
+          }
+
+          it "the resource updates state1 and state2" do
+            expect(resource.converged).to eq 1
+            expect(resource.updated?).to  be_truthy
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create
+  - update default_identity1
+  -   set state1 to "new_state1" (was "current_state1")
+  -   set state2 to "new_state2" (was "current_state2")
+EOM
+          end
+        end
+
+        context "and state1 is set to its current value but state2 is set to a new value" do
+          let(:converge_recipe) {
+            <<-EOM
+              #{resource_name} 'blah' do
+                state1 'current_state1'
+                state2 'new_state2'
+              end
+            EOM
+          }
+
+          it "the resource updates state2" do
+            expect(resource.converged).to eq 1
+            expect(resource.updated?).to  be_truthy
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create
+  - update default_identity1
+  -   set state2 to "new_state2" (was "current_state2")
+EOM
+          end
+        end
+
+        context "and state1 and state2 are set to their current values" do
+          let(:converge_recipe) {
+            <<-EOM
+              #{resource_name} 'blah' do
+                state1 'current_state1'
+                state2 'current_state2'
+              end
+            EOM
+          }
+
+          it "the resource updates nothing" do
+            expect(resource.converged).to eq 0
+            expect(resource.updated?).to  be_falsey
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create (up to date)
+EOM
+          end
+        end
+
+        context "and identity1 and control1 are set to new values" do
+          let(:converge_recipe) {
+            <<-EOM
+              #{resource_name} 'blah' do
+                identity1 'new_identity1'
+                control1 'new_control1'
+              end
+            EOM
+          }
+
+          # Because the identity value is copied over to the new resource, by
+          # default they do not register as "changed"
+          it "the resource updates nothing" do
+            expect(resource.converged).to eq 0
+            expect(resource.updated?).to  be_falsey
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create (up to date)
+EOM
+          end
+        end
+      end
+
+      context "and current_resource with identity1=current, control1=current" do
+        before :each do
+          resource_class.load_current_value do
+            identity1 'current_identity1'
+            control1 'current_control1'
+          end
+        end
+
+        context "and identity1 and control1 are set to new values" do
+          let(:converge_recipe) {
+            <<-EOM
+              #{resource_name} 'blah' do
+                identity1 'new_identity1'
+                control1 'new_control1'
+              end
+            EOM
+          }
+
+          # Control values are not desired state and are therefore not considered
+          # a reason for converging.
+          it "the resource updates identity1" do
+            expect(resource.converged).to eq 1
+            expect(resource.updated?).to  be_truthy
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create
+  - update current_identity1
+  -   set identity1 to "new_identity1" (was "current_identity1")
+            EOM
+          end
+        end
+      end
+
+      context "and has no current_resource" do
+        before :each do
+          resource_class.load_current_value do
+            current_value_does_not_exist!
+          end
+        end
+
+        context "and nothing is set" do
+          let(:converge_recipe) { "#{resource_name} 'blah'" }
+
+          it "the resource is created" do
+            expect(resource.converged).to eq 1
+            expect(resource.updated?).to  be_truthy
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create
+  - create default_identity1
+  -   set identity1 to "default_identity1" (default value)
+  -   set state1    to "default_state1" (default value)
+  -   set state2    to "default_state2" (default value)
+EOM
+          end
+        end
+
+        context "and state1 and state2 are set" do
+          let(:converge_recipe) {
+            <<-EOM
+              #{resource_name} 'blah' do
+                state1 'new_state1'
+                state2 'new_state2'
+              end
+            EOM
+          }
+
+          it "the resource is created" do
+            expect(resource.converged).to eq 1
+            expect(resource.updated?).to  be_truthy
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create
+  - create default_identity1
+  -   set identity1 to "default_identity1" (default value)
+  -   set state1    to "new_state1"
+  -   set state2    to "new_state2"
+EOM
+          end
+        end
+      end
+    end
+
+    context "and separate converge_if_changed :state1 and converge_if_changed :state2" do
+      before :each do
+        resource_class.action :create do
+          converge_if_changed :state1 do
+            new_resource.converged += 1
+          end
+          converge_if_changed :state2 do
+            new_resource.converged += 1
+          end
+        end
+      end
+
+      context "and current_resource with state1=current, state2=current" do
+        before :each do
+          resource_class.load_current_value do
+            state1 'current_state1'
+            state2 'current_state2'
+          end
+        end
+
+        context "and nothing is set" do
+          let(:converge_recipe) { "#{resource_name} 'blah'" }
+
+          it "the resource updates nothing" do
+            expect(resource.converged).to eq 0
+            expect(resource.updated?).to  be_falsey
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create (up to date)
+EOM
+          end
+        end
+
+        context "and state1 is set to a new value" do
+
+          let(:converge_recipe) {
+            <<-EOM
+              #{resource_name} 'blah' do
+                state1 'new_state1'
+              end
+            EOM
+          }
+
+          it "the resource updates state1" do
+            expect(resource.converged).to eq 1
+            expect(resource.updated?).to  be_truthy
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create
+  - update default_identity1
+  -   set state1 to "new_state1" (was "current_state1")
+EOM
+          end
+        end
+
+        context "and state1 and state2 are set to new values" do
+          let(:converge_recipe) {
+            <<-EOM
+              #{resource_name} 'blah' do
+                state1 'new_state1'
+                state2 'new_state2'
+              end
+            EOM
+          }
+
+          it "the resource updates state1 and state2" do
+            expect(resource.converged).to eq 2
+            expect(resource.updated?).to  be_truthy
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create
+  - update default_identity1
+  -   set state1 to "new_state1" (was "current_state1")
+  - update default_identity1
+  -   set state2 to "new_state2" (was "current_state2")
+EOM
+          end
+        end
+
+        context "and state1 is set to its current value but state2 is set to a new value" do
+          let(:converge_recipe) {
+            <<-EOM
+              #{resource_name} 'blah' do
+                state1 'current_state1'
+                state2 'new_state2'
+              end
+            EOM
+          }
+
+          it "the resource updates state2" do
+            expect(resource.converged).to eq 1
+            expect(resource.updated?).to  be_truthy
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create
+  - update default_identity1
+  -   set state2 to "new_state2" (was "current_state2")
+EOM
+          end
+        end
+
+        context "and state1 and state2 are set to their current values" do
+          let(:converge_recipe) {
+            <<-EOM
+              #{resource_name} 'blah' do
+                state1 'current_state1'
+                state2 'current_state2'
+              end
+            EOM
+          }
+
+          it "the resource updates nothing" do
+            expect(resource.converged).to eq 0
+            expect(resource.updated?).to  be_falsey
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create (up to date)
+EOM
+          end
+        end
+      end
+
+      context "and no current_resource" do
+        before :each do
+          resource_class.load_current_value do
+            current_value_does_not_exist!
+          end
+        end
+
+        context "and nothing is set" do
+          let(:converge_recipe) {
+            "#{resource_name} 'blah'"
+          }
+
+          it "the resource is created" do
+            expect(resource.converged).to eq 2
+            expect(resource.updated?).to  be_truthy
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create
+  - create default_identity1
+  -   set state1 to "default_state1" (default value)
+  - create default_identity1
+  -   set state2 to "default_state2" (default value)
+EOM
+          end
+        end
+
+        context "and state1 and state2 are set to new values" do
+          let(:converge_recipe) {
+            <<-EOM
+              #{resource_name} 'blah' do
+                state1 'new_state1'
+                state2 'new_state2'
+              end
+            EOM
+          }
+
+          it "the resource is created" do
+            expect(resource.converged).to eq 2
+            expect(resource.updated?).to  be_truthy
+            expect(converged_recipe.stdout).to eq <<-EOM
+* #{resource_name}[blah] action create
+  - create default_identity1
+  -   set state1 to "new_state1"
+  - create default_identity1
+  -   set state2 to "new_state2"
+EOM
+          end
+        end
+      end
+    end
+
+  end
+end