chef-resource 0.2.2

data/files/lib/chef_resource/types.rb

@@ -0,0 +1,4 @@
+module ChefResource
+  module Types
+  end
+end

data/files/lib/chef_resource/types/boolean.rb

@@ -0,0 +1,16 @@
+require 'chef_resource/type'
+
+module ChefResource
+  module Types
+    class Boolean
+      extend Type
+
+      must_be_kind_of TrueClass, FalseClass
+    end
+  end
+end
+
+#
+# Put Boolean, Interval and Path into the top level namespace so they can be used
+#
+::Boolean = ChefResource::Types::Boolean

data/files/lib/chef_resource/types/byte_size.rb

@@ -0,0 +1,10 @@
+require 'chef_resource/type'
+
+module ChefResource
+  module Types
+    class ByteSize
+      extend Type
+      must_be_kind_of Integer
+    end
+  end
+end

data/files/lib/chef_resource/types/date_time_type.rb

@@ -0,0 +1,18 @@
+require 'chef_resource/type'
+
+module ChefResource
+  module Types
+    #
+    # Represents a DateTime.  Will always be in DateTime format.
+    #
+    # Accepts a number (# of seconds since 1970), a Date, a DateTime, or a
+    # string ("now", "2 hours from now", "second thursday in 1970", "2045/10/27").
+    # Has methods to denote the default date format for printing and disambiguation.
+    #
+    class DateTimeType
+      extend Type
+
+      must_be_kind_of DateTime
+    end
+  end
+end

data/files/lib/chef_resource/types/date_type.rb

@@ -0,0 +1,18 @@
+require 'chef_resource/type'
+
+module ChefResource
+  module Types
+    #
+    # Represents a Date.  Will always be a Date object.
+    #
+    # Accepts a number (# of seconds since 1970), a Date, a DateTime, or a
+    # string ("now", "2 days from now", "second thursday in 1970", "2045/10/27").
+    # Has methods to denote the default date format for printing and disambiguation.
+    #
+    class DateTimeType
+      extend Type
+
+      must_be_kind_of Date
+    end
+  end
+end

data/files/lib/chef_resource/types/float_type.rb

@@ -0,0 +1,28 @@
+require 'chef_resource/type'
+
+module ChefResource
+  module Types
+    #
+    # Handles Float types.
+    #
+    # Supports strings and number types.
+    #
+    class FloatType
+      extend Type
+
+      must_be_kind_of Float
+
+      def self.coerce(parent, value)
+        if value.is_a?(String)
+          if value !~ /^[+-]?(\d+(\.\d+)?|.\d+)(e[+-]?\d+)?$/i
+            raise ValidationError.new("not a valid floating point string", value)
+          end
+          value = value.to_f
+        elsif value.is_a?(Numeric)
+          value = value.to_f
+        end
+        super
+      end
+    end
+  end
+end

data/files/lib/chef_resource/types/integer_type.rb

@@ -0,0 +1,53 @@
+require 'chef_resource/type'
+
+module ChefResource
+  module Types
+    #
+    # Handles Integer types.
+    #
+    # Supports parse / to_s in bases other than 10.
+    #
+    class IntegerType
+      extend Type
+
+      must_be_kind_of Integer
+
+      def self.coerce(parent, value)
+        if value.is_a?(String)
+          if !base_regexp.match(value)
+            raise ValidationError.new("must be a base #{base||10} string", value)
+          end
+
+          if base
+            value = value.to_i(base)
+          else
+            value = value.to_i
+          end
+        end
+        super
+      end
+
+      def self.value_to_s(value)
+        str = base ? value.to_s(base) : value.to_s
+        str
+      end
+
+      def self.base_regexp
+        base = self.base || 10
+        if base <= 10
+          /^[-+]?[0-#{base-1}]+$/
+        elsif base <= 36
+          top_char = ('a'.ord + base-11).chr
+          /^[-+]?[0-9a-#{top_char}]+$/i
+        else
+          raise "Base #{base} strings not supported: nothing bigger than 36!"
+        end
+      end
+
+      class <<self
+        extend SimpleStruct
+        property :base
+      end
+    end
+  end
+end

data/files/lib/chef_resource/types/interval.rb

@@ -0,0 +1,21 @@
+require 'chef_resource/type'
+
+module ChefResource
+  module Types
+    #
+    # Represents a time interval ("3 seconds", "1 day", etc.).
+    #
+    # Stored as an Interval object (no standard representation can accurately
+    # record this, because things like seconds per day and even the length of a
+    # second can vary depending on the exact date and time).
+    #
+    class Interval
+      extend Type
+    end
+  end
+end
+
+#
+# Put Boolean, Interval and Path into the top level namespace so they can be used
+#
+::Interval = ChefResource::Types::Interval

data/files/lib/chef_resource/types/path.rb

@@ -0,0 +1,39 @@
+require 'chef_resource/types/pathname_type'
+
+module ChefResource
+  module Types
+    #
+    # Type for Paths.  Always stored as String.
+    #
+    # Allows paths to be specified as Pathname or as String.  Can handle
+    # absolutizing relative URLs with #relative_to.
+    #
+    class Path
+      extend Type
+
+      must_be_kind_of String
+
+      class <<self
+        extend SimpleStruct
+        property :relative_to, coerced: "value.is_a?(Pathname) ? value.to_s : value"
+      end
+
+      def self.coerce(parent, path)
+        if path
+          rel = relative_to(parent: parent)
+          if rel
+            path = (Pathname.new(rel) + path).to_s
+          else
+            path = path.to_s if path.is_a?(Pathname)
+          end
+        end
+        super
+      end
+    end
+  end
+end
+
+#
+# Put Boolean, Interval and Path into the top level namespace so they can be used
+#
+::Path = ChefResource::Types::Path

data/files/lib/chef_resource/types/pathname_type.rb

@@ -0,0 +1,34 @@
+require 'chef_resource/type'
+require 'chef_resource/simple_struct'
+require 'pathname'
+
+module ChefResource
+  module Types
+    #
+    # Type for Paths.  Always stored as Pathname
+    #
+    # Can handle absolutizing relative URLs with #relative_to.
+    #
+    class PathnameType
+      extend Type
+      must_be_kind_of Pathname
+
+      class <<self
+        extend SimpleStruct
+        property :relative_to, coerced: "value.is_a?(String) ? Pathname.new(value) : value"
+      end
+
+      def self.coerce(parent, path)
+        if path
+          rel = relative_to(parent: parent)
+          if rel
+            path = rel + path if rel
+          else
+            path = Pathname.new(path) if path.is_a?(String)
+          end
+        end
+        super
+      end
+    end
+  end
+end

data/files/lib/chef_resource/types/string_type.rb

@@ -0,0 +1,16 @@
+require 'chef_resource/type'
+
+module ChefResource
+  module Types
+    class StringType
+      extend Type
+
+      must_be_kind_of String
+
+      def self.coerce(parent, value)
+        value = value.to_s unless value.nil?
+        super
+      end
+    end
+  end
+end

data/files/lib/chef_resource/types/symbol_type.rb

@@ -0,0 +1,18 @@
+require 'chef_resource/type'
+
+module ChefResource
+  module Types
+    class SymbolType
+      extend Type
+
+      must_be_kind_of Symbol
+
+      def self.coerce(parent, value)
+        if value.respond_to?(:to_sym)
+          value = value.to_sym
+        end
+        super
+      end
+    end
+  end
+end

data/files/lib/chef_resource/types/uri_type.rb

@@ -0,0 +1,37 @@
+require 'chef_resource/type'
+require 'chef_resource/simple_struct'
+require 'uri'
+
+module ChefResource
+  module Types
+    #
+    # Type for URIs.
+    #
+    # Allows URIs to be specified as URI or as String.  Can also handle absolutizing
+    # relative URLs with #relative_to.
+    #
+    class URIType
+      extend Type
+      extend SimpleStruct
+
+      must_be_kind_of URI
+
+      def self.coerce(parent, uri)
+        if uri
+          rel = relative_to(parent: parent)
+          if rel
+            uri = rel + uri
+          else
+            uri = URI.parse(uri) if uri.is_a?(String)
+          end
+        end
+        super
+      end
+
+      class <<self
+        extend SimpleStruct
+        property :relative_to, coerced: "value.is_a?(String) ? URI.parse(value) : value"
+      end
+    end
+  end
+end

data/files/lib/chef_resource/version.rb

@@ -0,0 +1,3 @@
+module ChefResource
+  VERSION = '0.2.2'
+end

data/spec/integration/chef.rb

@@ -0,0 +1,81 @@
+require 'cheffish/basic_chef_client'
+require 'chef_resource/chef'
+require 'tempfile'
+
+module Cheffish
+  class BasicChefClient
+    prepend ChefResource::ChefDSL::ChefRecipeDSLExtensions
+  end
+end
+
+Chef.resource :simple_resource do
+  property :hi
+  attr_reader :did_it
+  recipe do
+    @did_it = true
+  end
+end
+
+Chef.resource :compound_resource do
+  property :lo
+  attr_reader :did_it
+  attr_reader :f
+  recipe do
+    @f = Tempfile.new('foo')
+    file @f.path do
+      content 'hi'
+    end
+    simple_resource do
+      hi 10
+    end
+    @did_it = true
+  end
+end
+
+Chef.resource :resource_with_error do
+  property :lo
+  recipe do
+    blarghfile 'wow.txt' do
+      content 'hi'
+    end
+  end
+end
+
+
+describe 'Chef integration' do
+  context "When simple_resource is a ChefResource resource" do
+    it "a recipe can run the resource" do
+      x = nil
+      Cheffish::BasicChefClient.converge_block do
+        x = simple_resource do
+          hi 10
+        end
+      end
+      expect(x.did_it).to be_truthy
+    end
+  end
+  context "When compound_resource has a file and a simple_resource in it" do
+    it "a recipe can run the resource and both sub-resources run" do
+      x = nil
+      Cheffish::BasicChefClient.converge_block do
+        x = compound_resource do
+          lo 100
+        end
+      end
+      expect(x.did_it).to be_truthy
+      expect(IO.read(x.f.path)).to eq 'hi'
+    end
+  end
+  context "When resource_with_error has a misspelled resource name" do
+    it "a recipe can run the resource and both sub-resources run" do
+      expect do
+        Cheffish::BasicChefClient.converge_block do
+          resource_with_error do
+            lo 100
+          end
+        end
+      end.to raise_error(NoMethodError)
+    end
+  end
+  # notifications and subscribes, both directions
+end

data/spec/integration/struct_spec.rb

@@ -0,0 +1,611 @@
+require 'support/spec_support'
+require 'chef_resource/resource/struct_resource_base'
+
+describe ChefResource::Resource::StructResource do
+  def self.with_struct(name, &block)
+    before :each do
+      Object.send(:remove_const, name) if Object.const_defined?(name, false)
+      eval "class ::#{name} < ChefResource::Resource::StructResourceBase; end"
+      Object.const_get(name).class_eval(&block)
+    end
+    after :each do
+    end
+  end
+
+  describe :inheritance do
+    context "When A < B, and A has x and B has y" do
+      class A < ChefResource::Resource::StructResourceBase
+        property :x, identity: true do
+          default { y*2 }
+        end
+      end
+      class B < A
+        property :y, identity: true do
+          default { x*2 }
+        end
+      end
+
+      it "A.open(x: 1).y raises an error" do
+        expect { A.open(x: 1).y }.to raise_error
+      end
+      it "B.open(x: 1).y yields 2" do
+        expect(B.open(x: 1).y).to eq 2
+      end
+      it "B.open(y: 1).x yields 2" do
+        expect(B.open(y: 1).x).to eq 2
+      end
+    end
+  end
+
+  describe :reset do
+    context "When MyResource has both a set and not-set property" do
+      with_struct(:MyResource) do
+        property :identity_set, identity: true
+        property :normal_set, default: 20
+        property :normal_not_set, default: 30
+      end
+      let(:r) { r = MyResource.open(1); r.normal_set = 2; r }
+      it "explicit_property_values is missing values" do
+        expect(r.to_h(:only_explicit)).to eq({ identity_set: 1, normal_set: 2 })
+        expect(r.normal_set).to eq 2
+        expect(r.normal_not_set).to eq 30
+      end
+      it "reset(:normal_set) succeeds" do
+        r.reset(:normal_set)
+        expect(r.to_h(:only_explicit)).to eq({ identity_set: 1 })
+        expect(r.normal_set).to eq 20
+        expect(r.normal_not_set).to eq 30
+      end
+      it "reset(:normal_not_set) succeeds" do
+        r.reset(:normal_not_set)
+        expect(r.to_h(:only_explicit)).to eq({ identity_set: 1, normal_set: 2 })
+        expect(r.normal_set).to eq 2
+        expect(r.normal_not_set).to eq 30
+      end
+      it "reset(:normal_set) succeeds" do
+        r.reset(:normal_set)
+        expect(r.to_h(:only_explicit)).to eq({ identity_set: 1 })
+        expect(r.normal_set).to eq 20
+        expect(r.normal_not_set).to eq 30
+      end
+      it "reset() resets normal but not identity properties" do
+        r.reset
+        expect(r.to_h(:only_explicit)).to eq({ identity_set: 1 })
+        expect(r.normal_set).to eq 20
+        expect(r.normal_not_set).to eq 30
+      end
+      it "reset() twice in a row succeeds (but second reset does nothing)" do
+        r.reset
+        expect(r.to_h(:only_explicit)).to eq({ identity_set: 1 })
+        expect(r.normal_set).to eq 20
+        expect(r.normal_not_set).to eq 30
+        r.reset
+        expect(r.to_h(:only_explicit)).to eq({ identity_set: 1 })
+        expect(r.normal_set).to eq 20
+        expect(r.normal_not_set).to eq 30
+      end
+    end
+  end
+
+  describe :property do
+    context "When MyResource is a ResourceStruct with two properties" do
+      with_struct(:MyResource) do
+        property :x
+        property :y
+      end
+      it "You can create a new MyResource" do
+        expect(MyResource.open).to be_kind_of(MyResource)
+      end
+      it "You can set and get properties" do
+        r = MyResource.open
+        expect(r.x).to be_nil
+        expect(r.y).to be_nil
+        expect(r.x = 10).to eq 10
+        expect(r.y = 20).to eq 20
+        expect(r.x).to eq 10
+        expect(r.y).to eq 20
+      end
+    end
+
+    describe :type do
+      context "When MyResource is a ResourceStruct with property :x, ResourceStruct (resource struct reference)" do
+        with_struct(:MyResource) do
+          property :x, MyResource
+          property :y
+        end
+        it "x and y can be set to a resource" do
+          r = MyResource.open
+          r.y = 10
+          expect(r.x).to be_nil
+          r2 = MyResource.open
+          expect(r2.x = r).to eq r
+          r2.y = 20
+          expect(r2.x).to eq r
+          expect(r2.x.y).to eq 10
+        end
+      end
+    end
+
+    describe :identity do
+      context "When MyResource has property :x, identity: true" do
+        with_struct(:MyResource) do
+          property :x, identity: true
+          property :y
+        end
+        it "open() fails with 'x is required'" do
+          expect { MyResource.open() }.to raise_error ArgumentError
+        end
+        it "open(1) creates a MyResource where x = 1" do
+          expect(r = MyResource.open(1)).to be_kind_of(MyResource)
+          expect(r.x).to eq 1
+          expect(r.y).to be_nil
+        end
+        it "open(x: 1) creates a MyResource where x = 1" do
+          expect(r = MyResource.open(x: 1)).to be_kind_of(MyResource)
+          expect(r.x).to eq 1
+          expect(r.y).to be_nil
+        end
+        it "open(1, 2) fails with too many arguments" do
+          expect { MyResource.open(1, 2) }.to raise_error ArgumentError
+        end
+      end
+
+      context "When MyResource has property :x, identity: true, default: 10" do
+        with_struct(:MyResource) do
+          property :x, identity: true, default: 10
+          property :y
+        end
+        it "open() succeeds with x = 10" do
+          expect(r = MyResource.open()).to be_kind_of(MyResource)
+          expect(r.x).to eq 10
+          expect(r.y).to be_nil
+        end
+        it "open(1) fails due to non-required argument" do
+          expect { MyResource.open(1) }.to raise_error ArgumentError
+        end
+        it "open(x: 1) creates a MyResource where x = 1" do
+          expect(r = MyResource.open(x: 1)).to be_kind_of(MyResource)
+          expect(r.x).to eq 1
+          expect(r.y).to be_nil
+        end
+        it "open(1, 2) fails with too many arguments" do
+          expect { MyResource.open(1, 2) }.to raise_error ArgumentError
+        end
+      end
+
+      context "When MyResource has property :x, identity: true, required: false" do
+        with_struct(:MyResource) do
+          property :x, identity: true, required: false
+          property :y
+        end
+        it "open() creates a MyResource where x = nil" do
+          expect(r = MyResource.open()).to be_kind_of(MyResource)
+          expect(r.x).to be_nil
+          expect(r.y).to be_nil
+        end
+        it "open(1) fails with 'too many arguments'" do
+          expect { MyResource.open(1) }.to raise_error ArgumentError
+        end
+        it "open(x: 1) creates a MyResource where x = 1" do
+          expect(r = MyResource.open(x: 1)).to be_kind_of(MyResource)
+          expect(r.x).to eq 1
+          expect(r.y).to be_nil
+        end
+      end
+
+      context "When MyResource has property :x and :y, identity: true" do
+        with_struct(:MyResource) do
+          property :x, identity: true
+          property :y, identity: true
+          property :z
+        end
+        it "open() fails with 'x is required'" do
+          expect { MyResource.open() }.to raise_error ArgumentError
+        end
+        it "open(1) fails with 'y is required'" do
+          expect { MyResource.open(1) }.to raise_error ArgumentError
+        end
+        it "open(y: 1) fails with 'x is required'" do
+          expect { MyResource.open(y: 1) }.to raise_error ArgumentError
+        end
+        it "open(1, 2) creates a MyResource where x = 1 and y = 2" do
+          expect(r = MyResource.open(1, 2)).to be_kind_of(MyResource)
+          expect(r.x).to eq 1
+          expect(r.y).to eq 2
+          expect(r.z).to be_nil
+        end
+        it "open(1, 2, 3) fails with too many arguments" do
+          expect { MyResource.open(1, 2, 3) }.to raise_error ArgumentError
+        end
+        it "open(x: 1, y: 2) creates MyResource.x = 1, y = 2" do
+          expect(r = MyResource.open(x: 1, y: 2)).to be_kind_of(MyResource)
+          expect(r.x).to eq 1
+          expect(r.y).to eq 2
+          expect(r.z).to be_nil
+        end
+        it "open(3, 4, x: 1, y: 2) creates MyResource.x = 3, y = 4" do
+          expect { MyResource.open(3, 4, x: 1, y: 2) }.to raise_error ArgumentError
+        end
+      end
+
+      context "When MyResource has identity properties x and y, and x is not required" do
+        with_struct(:MyResource) do
+          property :x, identity: true, required: false
+          property :y, identity: true
+        end
+        it "open() fails with y is required" do
+          expect { MyResource.open() }.to raise_error ArgumentError
+        end
+        it "open(1) creates a MyResource where x = nil and y = 1" do
+          expect(r = MyResource.open(1)).to be_kind_of(MyResource)
+          expect(r.x).to be_nil
+          expect(r.y).to eq 1
+        end
+        it "open(1, 2) fails with 'too many arguments'" do
+          expect { MyResource.open(1, 2) }.to raise_error ArgumentError
+        end
+        it "open(y: 1) creates a MyResource where x = nil and y = 1" do
+          expect(r = MyResource.open(y: 1)).to be_kind_of(MyResource)
+          expect(r.x).to be_nil
+          expect(r.y).to eq 1
+        end
+      end
+    end
+
+    describe :override_block do
+      context "property overrides" do
+        context "When MyResource has a primitive property that overrides coerce" do
+          with_struct(:MyResource) do
+            property :x, String do
+              def self.coerce(parent, value)
+                "#{value} is awesome"
+              end
+            end
+          end
+          it "MyResource.coerce(nil, { x: 1 }) yields { x: '1 is awesome' }" do
+            expect(MyResource.coerce(nil, { x: 1 }).to_h(:only_explicit)).to eq({ x: "1 is awesome" })
+          end
+        end
+
+        context "When MyResource has an untyped property that overrides coerce" do
+          with_struct(:MyResource) do
+            property :x do
+              def self.coerce(parent, value)
+                "#{value} is awesome"
+              end
+            end
+          end
+          it "MyResource.coerce(nil, { x: 1 }) yields { x: '1 is awesome' }" do
+            expect(MyResource.coerce(nil, { x: 1 }).to_h(:only_explicit)).to eq({ x: "1 is awesome" })
+          end
+        end
+
+        context "When MyResource has a resource typed property that overrides coerce" do
+          with_struct(:MyResource) do
+            property :x, MyResource do
+              def self.coerce(parent, value)
+                if value.is_a?(Integer)
+                  x = value
+                  value = MyResource.open
+                  value.x "#{x} is awesome"
+                end
+                super
+              end
+            end
+          end
+          it "MyResource.coerce(nil, { x: 1 }) yields MyResource{ x: '1 is awesome' }" do
+            r = MyResource.coerce(nil, { x: 1 })
+            expect(r.x).to be_kind_of(MyResource)
+            expect(r.x.to_h(:only_explicit)).to eq({ x: "1 is awesome" })
+          end
+        end
+
+        context "When MyResource has an override that sets must(be between 0 and 10)" do
+          with_struct(:MyResource) do
+            property :x, Integer, nullable: true do
+              def self.run_count
+                @run_count ||= 0
+              end
+              def self.run_count=(value)
+                @run_count = value
+              end
+              must("be between 0 and 10") do
+                MyResource::X.run_count += 1
+                self >= 0 && self <= 10
+              end
+            end
+            property :run_count, Integer, default: 0
+          end
+          it "MyResource.coerce(nil, {x: 1}) succeeds" do
+            expect(MyResource.coerce(nil, { x: 1 }).to_h(:only_explicit)).to eq({ x: 1 })
+            expect(MyResource::X.run_count).to eq 1
+          end
+          it "MyResource.coerce(nil, {x: nil}) succeeds" do
+            expect(MyResource.coerce(nil, { x: nil }).to_h(:only_explicit)).to eq({ x: nil })
+            expect(MyResource::X.run_count).to eq 0
+          end
+          it "MyResource.coerce(nil, {x: 11}) fails" do
+            expect { MyResource.coerce(nil, { x: 11 }).to_h(:all) }.to raise_error(ChefResource::ValidationError)
+          end
+          it "MyResource.coerce(nil, {}) never runs it" do
+            expect(MyResource.coerce(nil, {}).to_h(:only_explicit)).to eq({})
+            expect(MyResource::X.run_count).to eq 0
+          end
+        end
+      end
+    end
+
+    describe :default do
+      context "When MyResource is a ResourceStruct with property :x, default: 15" do
+        with_struct(:MyResource) do
+          property :x, default: 15
+        end
+        it "x returns the default if not set" do
+          r = MyResource.open
+          expect(r.x).to eq 15
+        end
+        it "x returns the new value if it is set" do
+          r = MyResource.open
+          expect(r.x).to eq 15
+          expect(r.x = 20).to eq 20
+          expect(r.x).to eq 20
+        end
+      end
+
+      context "When MyResource is a ResourceStruct with property :x, 15 and property :y { x*2 } (default block)" do
+        with_struct(:MyResource) do
+          property :x, default: 15
+          property :y, default: ChefResource::LazyProc.new { x*2 }
+        end
+        it "x and y return the default if not set" do
+          r = MyResource.open
+          expect(r.x).to eq 15
+          expect(r.y).to eq 30
+        end
+        it "y returns the new value if it is set" do
+          r = MyResource.open
+          expect(r.y).to eq 30
+          expect(r.y = 20).to eq 20
+          expect(r.y).to eq 20
+        end
+        it "y returns a value based on x if x is set" do
+          r = MyResource.open
+          expect(r.y).to eq 30
+          expect(r.x = 20).to eq 20
+          expect(r.y).to eq 40
+        end
+      end
+    end
+  end
+
+  describe :coerce do
+    context "With a struct with x, y and z" do
+      with_struct(:MyResource) do
+        property :a, identity: true
+        property :b, identity: true
+        property :c, nullable: :validate
+        property :d, nullable: :validate
+        nullable :validate
+      end
+
+      context "multi-arg form" do
+        it "coerce(nil, 1, 2) yields a=1,b=2" do
+          expect(MyResource.coerce(nil, 1, 2).to_h(:only_explicit)).to eq({ a: 1, b: 2 })
+        end
+        it "coerce(nil, 1, 2, c: 3, d: 4) yields a=1, b=2, c=3, d=4" do
+          expect(MyResource.coerce(nil, 1, 2, c: 3, d: 4).to_h(:only_explicit)).to eq({ a: 1, b: 2, c: 3, d: 4 })
+        end
+      end
+      context "hash form" do
+        it "coerce(nil, a: 1, b: 2) yields a=1, b=2" do
+          expect(MyResource.coerce(nil, a: 1, b: 2).to_h(:only_explicit)).to eq({ a: 1, b: 2 })
+        end
+        it "coerce(nil, a: 1, b: 2, c: 3, d: 4) yields a=1, b=2, c=3, d=4" do
+          expect(MyResource.coerce(nil, a: 1, b: 2, c: 3, d: 4).to_h(:only_explicit)).to eq({ a: 1, b: 2, c: 3, d: 4 })
+        end
+        it "coerce(nil, c: 3, d: 4) fails" do
+          expect { MyResource.coerce(nil, c: 3, d: 4) }.to raise_error(ArgumentError)
+        end
+      end
+      it "coerce(nil, another resource) yields that resource" do
+        x = MyResource.open(1,2)
+        expect(MyResource.coerce(nil, x).object_id).to eq x.object_id
+      end
+      it "coerce(nil, nil) yields nil" do
+        expect(MyResource.coerce(nil, nil)).to be_nil
+      end
+    end
+  end
+
+  describe :load do
+    context "When load sets y to x*2 and z to x*3" do
+      with_struct(:MyResource) do
+        property :x, identity: true
+        property :y
+        property :z
+        property :num_loads
+        def load
+          y x*2
+          z x*3
+          self.num_loads ||= 0
+          self.num_loads += 1
+        end
+      end
+
+      it "MyResource.open(1).y == 2 and .z == 3" do
+        r = MyResource.open(1)
+        expect(r.x).to eq 1
+        expect(r.y).to eq 2
+        expect(r.z).to eq 3
+      end
+
+      it "load is only called once" do
+        r = MyResource.open(1)
+        expect(r.x).to eq 1
+        expect(r.y).to eq 2
+        expect(r.z).to eq 3
+        expect(r.x).to eq 1
+        expect(r.y).to eq 2
+        expect(r.z).to eq 3
+        expect(r.num_loads).to eq 1
+      end
+    end
+
+    context "When load sets y to x*2 and z has its own load_value that does x*3" do
+      with_struct(:MyResource) do
+        property :x, identity: true
+        property :y
+        property :z, load_value: ChefResource::LazyProc.new { self.num_loads += 1; x*3 }
+        property :num_loads, default: 0
+        def load
+          y x*2
+          self.num_loads += 1
+        end
+      end
+
+      it "MyResource.open(1).y == 2 and .z == 3" do
+        r = MyResource.open(1)
+        expect(r.x).to eq 1
+        expect(r.y).to eq 2
+        expect(r.z).to eq 3
+      end
+
+      it "current_resource.z yields x*3" do
+        r = MyResource.open(1)
+        expect(r.current_resource.z).to eq 3
+      end
+
+      it "load is only called twice" do
+        r = MyResource.open(1)
+        expect(r.x).to eq 1
+        expect(r.y).to eq 2
+        expect(r.z).to eq 3
+        expect(r.x).to eq 1
+        expect(r.y).to eq 2
+        expect(r.z).to eq 3
+        expect(r.num_loads).to eq 2
+      end
+    end
+
+    context "Primitive values" do
+      context "With a struct with Integers and Strings" do
+        with_struct(:MyResource) do
+          property :s1, String, identity: true, nullable: :validate
+          property :n1, Integer, identity: true, nullable: :validate
+          property :s2, String, nullable: :validate
+          property :n2, Integer, nullable: :validate
+        end
+
+        it "coerce(nil, s1: 'hi', n1: 1, s2: 'lo', n2: 2) succeeds" do
+          expect(MyResource.coerce(nil, s1: 'hi', n1: 1, s2: 'lo', n2: 2).to_h(:only_explicit)).to eq(s1: 'hi', n1: 1, s2: 'lo', n2: 2)
+        end
+
+        it "coerce(nil, s1: nil, n1: nil, s2: nil, n2: nil) succeeds" do
+          expect(MyResource.coerce(nil, s1: nil, n1: nil, s2: nil, n2: nil).to_h(:only_explicit)).to eq(s1: nil, n1: nil, s2: nil, n2: nil)
+        end
+
+        it "coerce(nil, s1: 'hi', n1: 1) succeeds" do
+          expect(MyResource.coerce(nil, s1: 'hi', n1: 1).to_h(:only_explicit)).to eq(s1: 'hi', n1: 1)
+        end
+
+        it "coerce(nil, s1: 'hi', n1: 'lo') fails" do
+          expect { MyResource.coerce(nil, s1: 'hi', n1: 'lo') }.to raise_error(ChefResource::ValidationError)
+        end
+
+        it "coerce(nil, s1: 'hi', n1: 'lo') fails" do
+          expect { MyResource.coerce(nil, s1: 'hi', n1: 'lo') }.to raise_error(ChefResource::ValidationError)
+        end
+      end
+    end
+
+    context "Lazy values" do
+      context "With a struct with x and some default values with instance_eval in various states" do
+        with_struct(:MyResource) do
+          def self.x
+            "outside.x"
+          end
+          property :x, default: "instance.x" do
+            def self.coerce(parent, value)
+              "coerce(#{value})"
+            end
+          end
+          property :default_no_params, default: ChefResource::LazyProc.new { "#{x} lazy_default" } do
+            def self.coerce(parent, value)
+              "coerce(#{value})"
+            end
+          end
+          property :default_instance_eval_symbol, default: ChefResource::LazyProc.new(:should_instance_eval) { "#{x} lazy_default" } do
+            def self.coerce(parent, value)
+              "coerce(#{value})"
+            end
+          end
+          property :default_instance_eval_true, default: ChefResource::LazyProc.new(should_instance_eval: true) { "#{x} lazy_default" } do
+            def self.coerce(parent, value)
+              "coerce(#{value})"
+            end
+          end
+          property :default_instance_eval_false, default: ChefResource::LazyProc.new(should_instance_eval: false) { "#{x} lazy_default" } do
+            def self.coerce(parent, value)
+              "coerce(#{value})"
+            end
+          end
+          property :default_block do
+            default { "#{x} lazy_default" }
+            def self.coerce(parent, value)
+              "coerce(#{value})"
+            end
+          end
+
+          property :z, default: "instance.z"
+        end
+
+        it "lazy default does instance_eval and coerces" do
+          r = MyResource.open
+          expect(r.default_no_params).to eq "coerce(coerce(instance.x) lazy_default)"
+        end
+        it "lazy default with :should_instance_eval does instance_eval and coerces" do
+          r = MyResource.open
+          expect(r.default_instance_eval_symbol).to eq "coerce(coerce(instance.x) lazy_default)"
+        end
+        it "lazy default with should_instance_eval: true does instance_eval and coerces" do
+          r = MyResource.open
+          expect(r.default_instance_eval_true).to eq "coerce(coerce(instance.x) lazy_default)"
+        end
+        it "lazy default with should_instance_eval: false does not do instance_eval, and coerces" do
+          r = MyResource.open
+          expect(r.default_instance_eval_false).to eq "coerce(outside.x lazy_default)"
+        end
+        it "default block does instance_eval and coerces" do
+          r = MyResource.open
+          expect(r.default_block).to eq "coerce(coerce(instance.x) lazy_default)"
+        end
+
+        def z
+          "outside.z"
+        end
+
+        it "lazy on x does not do instance_eval but coerces" do
+          r = MyResource.open
+          r.x ChefResource::LazyProc.new { "#{z} set_lazy" }
+          expect(r.x).to eq "coerce(outside.z set_lazy)"
+        end
+        it "lazy on x with :should_instance_eval does instance_eval and coerces" do
+          r = MyResource.open
+          r.x ChefResource::LazyProc.new(:should_instance_eval) { "#{z} set_lazy" }
+          expect(r.x).to eq "coerce(instance.z set_lazy)"
+        end
+        it "lazy on x should_instance_eval: true does instance_eval and coerces" do
+          r = MyResource.open
+          r.x ChefResource::LazyProc.new(:should_instance_eval) { "#{z} set_lazy" }
+          expect(r.x).to eq "coerce(instance.z set_lazy)"
+        end
+        it "lazy on x with should_instance_eval: false does instance_eval and coerces" do
+          r = MyResource.open
+          r.x ChefResource::LazyProc.new(should_instance_eval: false) { "#{z} set_lazy" }
+          expect(r.x).to eq "coerce(outside.z set_lazy)"
+        end
+
+      end
+    end
+  end
+end