diff options
Diffstat (limited to 'spec/integration/recipes')
-rw-r--r-- | spec/integration/recipes/resource_load_spec.rb | 178 |
1 files changed, 178 insertions, 0 deletions
diff --git a/spec/integration/recipes/resource_load_spec.rb b/spec/integration/recipes/resource_load_spec.rb new file mode 100644 index 0000000000..f91039abb4 --- /dev/null +++ b/spec/integration/recipes/resource_load_spec.rb @@ -0,0 +1,178 @@ +require 'support/shared/integration/integration_helper' + +describe "Resource.load_current_value" 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 } + + let(:resource_name) { :"load_current_value_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 :x, default: lazy { "default #{Namer.incrementing_value}" } + action :create do + end + default_action :nothing + end + result.resource_name resource_name + result + } + + # Pull on resource_class to initialize it + before { resource_class } + + context "with a resource with load_current_value" do + before :each do + resource_class.load_current_value do + x "loaded #{Namer.incrementing_value} (#{self.class.properties.sort_by { |name,p| name }. + select { |name,p| p.is_set?(self) }. + map { |name,p| "#{name}=#{p.get(self)}" }. + join(", ") })" + end + end + + let(:resource) do + e = self + r = nil + converge { + r = public_send(e.resource_name, 'blah') do + x 'desired' + end + } + r + end + + it "current_resource is passed name but not x" do + expect(resource.current_resource.x).to eq 'loaded 1 (name=blah)' + end + + it "resource.current_resource returns a different resource" do + expect(resource.current_resource.x).to eq 'loaded 1 (name=blah)' + expect(resource.x).to eq 'desired' + end + + it "resource.current_resource constructs the resource anew each time" do + expect(resource.current_resource.x).to eq 'loaded 1 (name=blah)' + expect(resource.current_resource.x).to eq 'loaded 2 (name=blah)' + end + + context "and identity: :i and :d with desired_state: false" do + before { + resource_class.class_eval do + property :i, identity: true + property :d, desired_state: false + end + } + + before { + resource.i 'desired_i' + resource.d 'desired_d' + } + + it "i, name and d are passed to load_current_value, but not x" do + expect(resource.current_resource.x).to eq 'loaded 1 (d=desired_d, i=desired_i, name=blah)' + end + end + + context "and name_property: :i and :d with desired_state: false" do + before { + resource_class.class_eval do + property :i, name_property: true + property :d, desired_state: false + end + } + + before { + resource.i 'desired_i' + resource.d 'desired_d' + } + + it "i, name and d are passed to load_current_value, but not x" do + expect(resource.current_resource.x).to eq 'loaded 1 (d=desired_d, i=desired_i, name=blah)' + end + end + + let (:subresource_name) { + :"load_current_value_subresource_dsl#{Namer.current_index}" + } + let (:subresource_class) { + r = Class.new(resource_class) do + property :y, default: lazy { "default_y #{Namer.incrementing_value}" } + end + r.resource_name subresource_name + r + } + + # Pull on subresource_class to initialize it + before { subresource_class } + + let(:subresource) do + e = self + r = nil + converge { + r = public_send(e.subresource_name, 'blah') do + x 'desired' + end + } + r + end + + context "and a child resource class with no load_current_value" do + it "the parent load_current_value is used" do + expect(subresource.current_resource.x).to eq 'loaded 1 (name=blah)' + end + it "load_current_value yields a copy of the child class" do + expect(subresource.current_resource).to be_kind_of(subresource_class) + end + end + + context "And a child resource class with load_current_value" do + before { + subresource_class.load_current_value do + y "loaded_y #{Namer.incrementing_value} (#{self.class.properties.sort_by { |name,p| name }. + select { |name,p| p.is_set?(self) }. + map { |name,p| "#{name}=#{p.get(self)}" }. + join(", ") })" + end + } + + it "the overridden load_current_value is used" do + current_resource = subresource.current_resource + expect(current_resource.x).to eq 'default 2' + expect(current_resource.y).to eq 'loaded_y 1 (name=blah)' + end + end + + context "and a child resource class with load_current_value calling super()" do + before { + subresource_class.load_current_value do + super() + y "loaded_y #{Namer.incrementing_value} (#{self.class.properties.sort_by { |name,p| name }. + select { |name,p| p.is_set?(self) }. + map { |name,p| "#{name}=#{p.get(self)}" }. + join(", ") })" + end + } + + it "the original load_current_value is called as well as the child one" do + current_resource = subresource.current_resource + expect(current_resource.x).to eq 'loaded 1 (name=blah)' + expect(current_resource.y).to eq 'loaded_y 2 (name=blah, x=loaded 1 (name=blah))' + end + end + end + +end |