chef 12.6.0 → 12.7.2

data/spec/unit/property_spec.rb

@@ -1,4 +1,4 @@
-require 'support/shared/integration/integration_helper'
+require "support/shared/integration/integration_helper"
 
 describe "Chef::Resource.property" do
   include IntegrationSupport
@@ -8,12 +8,15 @@ describe "Chef::Resource.property" do
     def self.next_resource_name
       "chef_resource_property_spec_#{@i += 1}"
     end
+
     def self.reset_index
       @current_index = 0
     end
+
     def self.current_index
       @current_index
     end
+
     def self.next_index
       @current_index += 1
     end
@@ -46,15 +49,15 @@ describe "Chef::Resource.property" do
   end
 
   def self.english_join(values)
-    return '<nothing>' if values.size == 0
+    return "<nothing>" if values.size == 0
     return values[0].inspect if values.size == 1
     "#{values[0..-2].map { |v| v.inspect }.join(", ")} and #{values[-1].inspect}"
   end
 
   def self.with_property(*properties, &block)
-    tags_index = properties.find_index { |p| !p.is_a?(String)}
+    tags_index = properties.find_index { |p| !p.is_a?(String) }
     if tags_index
-      properties, tags = properties[0..tags_index-1], properties[tags_index..-1]
+      properties, tags = properties[0..tags_index - 1], properties[tags_index..-1]
     else
       tags = []
     end
@@ -74,7 +77,7 @@ describe "Chef::Resource.property" do
   end
 
   # Basic properties
-  with_property ':bare_property' do
+  with_property ":bare_property" do
     it "can be set" do
       expect(resource.bare_property 10).to eq 10
       expect(resource.bare_property).to eq 10
@@ -116,7 +119,7 @@ describe "Chef::Resource.property" do
         end
       end
       let(:subresource) do
-        subresource_class.new('blah')
+        subresource_class.new("blah")
       end
 
       context "with property :x on the subclass" do
@@ -127,7 +130,7 @@ describe "Chef::Resource.property" do
         end
 
         it "x is still name_property" do
-          expect(subresource.x).to eq 'blah'
+          expect(subresource.x).to eq "blah"
         end
       end
 
@@ -166,7 +169,7 @@ describe "Chef::Resource.property" do
         end
       end
       let(:subresource) do
-        subresource_class.new('blah')
+        subresource_class.new("blah")
       end
 
       it "x is inherited" do
@@ -178,7 +181,7 @@ describe "Chef::Resource.property" do
       end
 
       it "x's validation is inherited" do
-        expect { subresource.x 'ohno' }.to raise_error Chef::Exceptions::ValidationFailed
+        expect { subresource.x "ohno" }.to raise_error Chef::Exceptions::ValidationFailed
       end
 
       context "with property :y on the subclass" do
@@ -203,7 +206,7 @@ describe "Chef::Resource.property" do
           expect(subresource_class.properties[:y]).not_to be_nil
         end
         it "y is not on the superclass" do
-          expect { resource_class.y 10 }.to raise_error
+          expect { resource_class.y 10 }.to raise_error NoMethodError
           expect(resource_class.properties[:y]).to be_nil
         end
       end
@@ -225,7 +228,7 @@ describe "Chef::Resource.property" do
         end
 
         it "x's validation is inherited" do
-          expect { subresource.x 'ohno' }.to raise_error Chef::Exceptions::ValidationFailed
+          expect { subresource.x "ohno" }.to raise_error Chef::Exceptions::ValidationFailed
         end
       end
 
@@ -250,7 +253,7 @@ describe "Chef::Resource.property" do
         end
 
         it "x's validation is inherited" do
-          expect { subresource.x 'ohno' }.to raise_error Chef::Exceptions::ValidationFailed
+          expect { subresource.x "ohno" }.to raise_error Chef::Exceptions::ValidationFailed
         end
       end
 
@@ -272,12 +275,12 @@ describe "Chef::Resource.property" do
 
         it "x's validation is overwritten" do
           expect { subresource.x 10 }.to raise_error Chef::Exceptions::ValidationFailed
-          expect(subresource.x 'ohno').to eq 'ohno'
-          expect(subresource.x).to eq 'ohno'
+          expect(subresource.x "ohno").to eq "ohno"
+          expect(subresource.x).to eq "ohno"
         end
 
         it "the superclass's validation for x is still there" do
-          expect { resource.x 'ohno' }.to raise_error Chef::Exceptions::ValidationFailed
+          expect { resource.x "ohno" }.to raise_error Chef::Exceptions::ValidationFailed
           expect(resource.x 10).to eq 10
           expect(resource.x).to eq 10
         end
@@ -297,7 +300,7 @@ describe "Chef::Resource.property" do
       expect { resource.reset_property(:x) }.to raise_error(ArgumentError)
     end
 
-    with_property ':x' do
+    with_property ":x" do
       it "when the resource is newly created, reset_property(:x) does nothing" do
         expect(resource.property_is_set?(:x)).to be_falsey
         resource.reset_property(:x)
@@ -313,7 +316,7 @@ describe "Chef::Resource.property" do
       end
     end
 
-    with_property ':x, Integer' do
+    with_property ":x, Integer" do
       it "when the resource is newly created, reset_property(:x) does nothing" do
         expect(resource.property_is_set?(:x)).to be_falsey
         resource.reset_property(:x)
@@ -329,7 +332,7 @@ describe "Chef::Resource.property" do
       end
     end
 
-    with_property ':x, default: 10' do
+    with_property ":x, default: 10" do
       it "when the resource is newly created, reset_property(:x) does nothing" do
         expect(resource.property_is_set?(:x)).to be_falsey
         resource.reset_property(:x)
@@ -344,7 +347,7 @@ describe "Chef::Resource.property" do
       end
     end
 
-    with_property ':x, default: lazy { 10 }' do
+    with_property ":x, default: lazy { 10 }" do
       it "when the resource is newly created, reset_property(:x) does nothing" do
         expect(resource.property_is_set?(:x)).to be_falsey
         resource.reset_property(:x)
@@ -369,7 +372,7 @@ describe "Chef::Resource.property" do
       expect { resource.property_is_set?(:x) }.to raise_error(ArgumentError)
     end
 
-    with_property ':x' do
+    with_property ":x" do
       it "when the resource is newly created, property_is_set?(:x) is false" do
         expect(resource.property_is_set?(:x)).to be_falsey
       end
@@ -391,7 +394,7 @@ describe "Chef::Resource.property" do
       end
     end
 
-    with_property ':x, default: 10' do
+    with_property ":x, default: 10" do
       it "when the resource is newly created, property_is_set?(:x) is false" do
         expect(resource.property_is_set?(:x)).to be_falsey
       end
@@ -413,7 +416,7 @@ describe "Chef::Resource.property" do
       end
     end
 
-    with_property ':x, default: nil' do
+    with_property ":x, default: nil" do
       it "when the resource is newly created, property_is_set?(:x) is false" do
         expect(resource.property_is_set?(:x)).to be_falsey
       end
@@ -435,7 +438,7 @@ describe "Chef::Resource.property" do
       end
     end
 
-    with_property ':x, default: lazy { 10 }' do
+    with_property ":x, default: lazy { 10 }" do
       it "when the resource is newly created, property_is_set?(:x) is false" do
         expect(resource.property_is_set?(:x)).to be_falsey
       end
@@ -455,7 +458,7 @@ describe "Chef::Resource.property" do
   end
 
   context "Chef::Resource::Property#default" do
-    with_property ':x, default: 10' do
+    with_property ":x, default: 10" do
       it "when x is set, it returns its value" do
         expect(resource.x 20).to eq 20
         expect(resource.property_is_set?(:x)).to be_truthy
@@ -479,33 +482,33 @@ describe "Chef::Resource.property" do
             resource_name new_resource_name
           end
         end
-        let(:subresource) { subresource_class.new('blah') }
+        let(:subresource) { subresource_class.new("blah") }
         it "The default is inherited" do
           expect(subresource.x).to eq 10
         end
       end
     end
 
-    with_property ':x, default: 10, identity: true' do
+    with_property ":x, default: 10, identity: true" do
       it "when x is not set, it is included in identity" do
         expect(resource.identity).to eq(10)
       end
     end
 
-    with_property ':x, default: 1, identity: true', ':y, default: 2, identity: true' do
+    with_property ":x, default: 1, identity: true", ":y, default: 2, identity: true" do
       it "when x is not set, it is still included in identity" do
         resource.y 20
         expect(resource.identity).to eq(x: 1, y: 20)
       end
     end
 
-    with_property ':x, default: nil' do
+    with_property ":x, default: nil" do
       it "when x is not set, it returns nil" do
         expect(resource.x).to be_nil
       end
     end
 
-    with_property ':x' do
+    with_property ":x" do
       it "when x is not set, it returns nil" do
         expect(resource.x).to be_nil
       end
@@ -515,7 +518,7 @@ describe "Chef::Resource.property" do
       context "(deprecations allowed)" do
         before { Chef::Config[:treat_deprecation_warnings_as_errors] = false }
 
-        with_property ':x, default: {}' do
+        with_property ":x, default: {}" do
           it "when x is not set, it returns {}" do
             expect(resource.x).to eq({})
           end
@@ -525,12 +528,12 @@ describe "Chef::Resource.property" do
             expect(resource.x.object_id).to eq(value.object_id)
           end
           it "Multiple instances of x receive the exact same value" do
-            expect(resource.x.object_id).to eq(resource_class.new('blah2').x.object_id)
+            expect(resource.x.object_id).to eq(resource_class.new("blah2").x.object_id)
           end
         end
       end
 
-      with_property ':x, default: lazy { {} }' do
+      with_property ":x, default: lazy { {} }" do
         it "when x is not set, it returns {}" do
           expect(resource.x).to eq({})
         end
@@ -540,7 +543,7 @@ describe "Chef::Resource.property" do
         #   expect(resource.x.object_id).not_to eq(value.object_id)
         # end
         it "Multiple instances of x receive different values" do
-          expect(resource.x.object_id).not_to eq(resource_class.new('blah2').x.object_id)
+          expect(resource.x.object_id).not_to eq(resource_class.new("blah2").x.object_id)
         end
       end
     end
@@ -549,21 +552,22 @@ describe "Chef::Resource.property" do
       before do
         resource_class.class_eval do
           def self.blah
-            'class'
+            "class"
           end
+
           def blah
             "#{name}#{next_index}"
           end
         end
       end
 
-      with_property ':x, default: lazy { blah }' do
+      with_property ":x, default: lazy { blah }" do
         it "x is run in context of the instance" do
           expect(resource.x).to eq "blah1"
         end
         it "x is run in the context of each instance it is run in" do
           expect(resource.x).to eq "blah1"
-          expect(resource_class.new('another').x).to eq "another2"
+          expect(resource_class.new("another").x).to eq "another2"
           # expect(resource.x).to eq "blah3"
         end
       end
@@ -574,27 +578,31 @@ describe "Chef::Resource.property" do
         end
         it "x is passed the value of each instance it is run in" do
           expect(resource.x).to eq "classblah1"
-          expect(resource_class.new('another').x).to eq "classanother2"
+          expect(resource_class.new("another").x).to eq "classanother2"
           # expect(resource.x).to eq "classblah3"
         end
       end
     end
 
     context "validation of defaults" do
-      with_property ':x, String, default: 10' do
-        it "when the resource is created, no error is raised" do
-          resource
+      it "When a class is declared with property :x, String, default: 10, a warning is emitted" do
+        expect { resource_class.class_eval { property :x, String, default: 10 } }.to raise_error Chef::Exceptions::DeprecatedFeatureError,
+          /Default value 10 is invalid for property x of resource chef_resource_property_spec_(\d+). In Chef 13 this will become an error: Property x must be one of: String!  You passed 10./
+      end
+      context "With property :x, String, default: 10" do
+        before do
+          Chef::Config[:treat_deprecation_warnings_as_errors] = false
+          resource_class.class_eval { property :x, String, default: 10 }
+          Chef::Config[:treat_deprecation_warnings_as_errors] = true
         end
+
         it "when x is set, no error is raised" do
-          expect(resource.x 'hi').to eq 'hi'
-          expect(resource.x).to eq 'hi'
+          expect(resource.x "hi").to eq "hi"
+          expect(resource.x).to eq "hi"
         end
         it "when x is retrieved, no validation error is raised" do
           expect(resource.x).to eq 10
         end
-        # it "when x is retrieved, a validation error is raised" do
-        #   expect { resource.x }.to raise_error Chef::Exceptions::ValidationFailed
-        # end
       end
 
       with_property ":x, String, default: lazy { Namer.next_index }" do
@@ -602,43 +610,34 @@ describe "Chef::Resource.property" do
           resource
         end
         it "when x is set, no error is raised" do
-          expect(resource.x 'hi').to eq 'hi'
-          expect(resource.x).to eq 'hi'
+          expect(resource.x "hi").to eq "hi"
+          expect(resource.x).to eq "hi"
         end
-        it "when x is retrieved, no validation error is raised" do
-          expect(resource.x).to eq 1
+        it "when x is retrieved, an invalid default warning is emitted and the value is returned" do
+          expect { resource.x }.to raise_error Chef::Exceptions::DeprecatedFeatureError,
+            /Default value 1 is invalid for property x of resource chef_resource_property_spec_(\d+). In Chef 13 this will become an error: Property x must be one of: String!  You passed 1./
           expect(Namer.current_index).to eq 1
+          Chef::Config[:treat_deprecation_warnings_as_errors] = false
+          expect(resource.x).to eq 2
         end
-        # it "when x is retrieved, a validation error is raised" do
-        #   expect { resource.x }.to raise_error Chef::Exceptions::ValidationFailed
-        #   expect(Namer.current_index).to eq 1
-        # end
       end
 
       with_property ":x, default: lazy { Namer.next_index.to_s }, is: proc { |v| Namer.next_index; true }" do
-        it "validation is not run at all on the default value" do
-          expect(resource.x).to eq '1'
-          expect(Namer.current_index).to eq 1
+        it "coercion and validation is only run the first time" do
+          expect(resource.x).to eq "1"
+          expect(Namer.current_index).to eq 2
+          expect(resource.x).to eq "1"
+          expect(Namer.current_index).to eq 2
         end
-        # it "validation is run each time" do
-        #   expect(resource.x).to eq '1'
-        #   expect(Namer.current_index).to eq 2
-        #   expect(resource.x).to eq '1'
-        #   expect(Namer.current_index).to eq 2
-        # end
       end
 
       with_property ":x, default: lazy { Namer.next_index.to_s.freeze }, is: proc { |v| Namer.next_index; true }" do
-        it "validation is not run at all on the default value" do
-          expect(resource.x).to eq '1'
-          expect(Namer.current_index).to eq 1
+        it "coercion and validation is run each time" do
+          expect(resource.x).to eq "1"
+          expect(Namer.current_index).to eq 2
+          expect(resource.x).to eq "3"
+          expect(Namer.current_index).to eq 4
         end
-        # it "validation is only run the first time" do
-        #   expect(resource.x).to eq '1'
-        #   expect(Namer.current_index).to eq 2
-        #   expect(resource.x).to eq '1'
-        #   expect(Namer.current_index).to eq 2
-        # end
       end
     end
 
@@ -650,13 +649,13 @@ describe "Chef::Resource.property" do
           expect(Namer.current_index).to eq 0
         end
         it "when x is set, coercion is run" do
-          expect(resource.x 'hi').to eq 'hi1'
-          expect(resource.x).to eq 'hi1'
+          expect(resource.x "hi").to eq "hi1"
+          expect(resource.x).to eq "hi1"
           expect(Namer.current_index).to eq 1
         end
         it "when x is retrieved, coercion is run exactly once" do
-          expect(resource.x).to eq '101'
-          expect(resource.x).to eq '101'
+          expect(resource.x).to eq "101"
+          expect(resource.x).to eq "101"
           expect(Namer.current_index).to eq 1
         end
       end
@@ -668,13 +667,13 @@ describe "Chef::Resource.property" do
           expect(Namer.current_index).to eq 0
         end
         it "when x is set, coercion is run" do
-          expect(resource.x 'hi').to eq 'hi1'
-          expect(resource.x).to eq 'hi1'
+          expect(resource.x "hi").to eq "hi1"
+          expect(resource.x).to eq "hi1"
           expect(Namer.current_index).to eq 1
         end
         it "when x is retrieved, coercion is run each time" do
-          expect(resource.x).to eq '101'
-          expect(resource.x).to eq '102'
+          expect(resource.x).to eq "101"
+          expect(resource.x).to eq "102"
           expect(Namer.current_index).to eq 2
         end
       end
@@ -686,13 +685,13 @@ describe "Chef::Resource.property" do
           expect(Namer.current_index).to eq 0
         end
         it "when x is set, coercion is run" do
-          expect(resource.x 'hi').to eq 'hi1'
-          expect(resource.x).to eq 'hi1'
+          expect(resource.x "hi").to eq "hi1"
+          expect(resource.x).to eq "hi1"
           expect(Namer.current_index).to eq 1
         end
         it "when x is retrieved, coercion is run exactly once" do
-          expect(resource.x).to eq '101'
-          expect(resource.x).to eq '101'
+          expect(resource.x).to eq "101"
+          expect(resource.x).to eq "101"
           expect(Namer.current_index).to eq 1
         end
       end
@@ -704,61 +703,61 @@ describe "Chef::Resource.property" do
           expect(Namer.current_index).to eq 0
         end
         it "when x is set, coercion is run" do
-          expect(resource.x 'hi').to eq 'hi1'
-          expect(resource.x).to eq 'hi1'
+          expect(resource.x "hi").to eq "hi1"
+          expect(resource.x).to eq "hi1"
           expect(Namer.current_index).to eq 1
         end
         it "when x is retrieved, coercion is run each time" do
-          expect(resource.x).to eq '101'
-          expect(resource.x).to eq '102'
+          expect(resource.x).to eq "101"
+          expect(resource.x).to eq "102"
           expect(Namer.current_index).to eq 2
         end
       end
 
       with_property ':x, proc { |v| Namer.next_index; true }, coerce: proc { |v| "#{v}#{next_index}" }, default: lazy { 10 }' do
-        it "coercion is only run the first time x is retrieved, and validation is not run" do
+        it "coercion and validation is only run the first time x is retrieved" do
           expect(Namer.current_index).to eq 0
-          expect(resource.x).to eq '101'
-          expect(Namer.current_index).to eq 1
-          expect(resource.x).to eq '101'
-          expect(Namer.current_index).to eq 1
+          expect(resource.x).to eq "101"
+          expect(Namer.current_index).to eq 2
+          expect(resource.x).to eq "101"
+          expect(Namer.current_index).to eq 2
         end
       end
 
       context "validation and coercion of defaults" do
         with_property ':x, String, coerce: proc { |v| "#{v}#{next_index}" }, default: 10' do
           it "when x is retrieved, it is coerced before validating and passes" do
-            expect(resource.x).to eq '101'
+            expect(resource.x).to eq "101"
           end
         end
         with_property ':x, Integer, coerce: proc { |v| "#{v}#{next_index}" }, default: 10' do
-          it "when x is retrieved, it is coerced and not validated" do
-            expect(resource.x).to eq '101'
+          it "when x is retrieved, it is coerced and emits an invalid default warning, but still returns the value" do
+            expect { resource.x }.to raise_error Chef::Exceptions::DeprecatedFeatureError,
+              /Default value 10 is invalid for property x of resource chef_resource_property_spec_(\d+). In Chef 13 this will become an error: Property x must be one of: Integer!  You passed "101"./
+            Chef::Config[:treat_deprecation_warnings_as_errors] = false
+            expect(resource.x).to eq "102"
           end
-          # it "when x is retrieved, it is coerced before validating and fails" do
-          #   expect { resource.x }.to raise_error Chef::Exceptions::ValidationFailed
-          # end
         end
         with_property ':x, String, coerce: proc { |v| "#{v}#{next_index}" }, default: lazy { 10 }' do
           it "when x is retrieved, it is coerced before validating and passes" do
-            expect(resource.x).to eq '101'
+            expect(resource.x).to eq "101"
           end
         end
         with_property ':x, Integer, coerce: proc { |v| "#{v}#{next_index}" }, default: lazy { 10 }' do
-          it "when x is retrieved, it is coerced and not validated" do
-            expect(resource.x).to eq '101'
+          it "when x is retrieved, it is coerced and emits an invalid default warning; the value is still returned." do
+            expect { resource.x }.to raise_error Chef::Exceptions::DeprecatedFeatureError,
+              /Default value 10 is invalid for property x of resource chef_resource_property_spec_(\d+). In Chef 13 this will become an error: Property x must be one of: Integer!  You passed "101"./
+            Chef::Config[:treat_deprecation_warnings_as_errors] = false
+            expect(resource.x).to eq "102"
           end
-          # it "when x is retrieved, it is coerced before validating and fails" do
-          #   expect { resource.x }.to raise_error Chef::Exceptions::ValidationFailed
-          # end
         end
         with_property ':x, proc { |v| Namer.next_index; true }, coerce: proc { |v| "#{v}#{next_index}" }, default: lazy { 10 }' do
-          it "coercion is only run the first time x is retrieved, and validation is not run" do
+          it "coercion is only run the first time x is retrieved, and validation is run" do
             expect(Namer.current_index).to eq 0
-            expect(resource.x).to eq '101'
-            expect(Namer.current_index).to eq 1
-            expect(resource.x).to eq '101'
-            expect(Namer.current_index).to eq 1
+            expect(resource.x).to eq "101"
+            expect(Namer.current_index).to eq 2
+            expect(resource.x).to eq "101"
+            expect(Namer.current_index).to eq 2
           end
         end
       end
@@ -766,7 +765,7 @@ describe "Chef::Resource.property" do
   end
 
   context "Chef::Resource#lazy" do
-    with_property ':x' do
+    with_property ":x" do
       it "setting x to a lazy value does not run it immediately" do
         resource.x lazy { Namer.next_index }
         expect(Namer.current_index).to eq 0
@@ -805,6 +804,7 @@ describe "Chef::Resource.property" do
             def self.blah
               "class"
             end
+
             def blah
               "#{name}#{Namer.next_index}"
             end
@@ -861,7 +861,7 @@ describe "Chef::Resource.property" do
       end
     end
 
-    with_property ':x, String' do
+    with_property ":x, String" do
       it "lazy values are not validated on set" do
         resource.x lazy { Namer.next_index }
         expect(Namer.current_index).to eq 0
@@ -873,7 +873,7 @@ describe "Chef::Resource.property" do
       end
     end
 
-    with_property ':x, is: proc { |v| Namer.next_index; true }' do
+    with_property ":x, is: proc { |v| Namer.next_index; true }" do
       it "lazy values are validated on each access" do
         resource.x lazy { Namer.next_index }
         expect(resource.x).to eq 1
@@ -922,7 +922,8 @@ describe "Chef::Resource.property" do
         expect(Namer.current_index).to eq 1
       end
       it "does not emit a deprecation warning if set to nil" do
-        expect(resource.x nil).to eq "1"
+        # nil is never coerced
+        expect(resource.x nil).to be_nil
       end
       it "coercion sets the value (and coercion does not run on get)" do
         expect(resource.x 10).to eq "101"
@@ -936,7 +937,7 @@ describe "Chef::Resource.property" do
         expect(Namer.current_index).to eq 2
       end
     end
-    with_property ':x, coerce: proc { |x| x }' do
+    with_property ":x, coerce: proc { |x| x }" do
       it "does not emit a deprecation warning if set to nil" do
         expect(resource.x nil).to be_nil
       end
@@ -946,19 +947,19 @@ describe "Chef::Resource.property" do
         resource.x 20
         expect(resource.x).to eq 20
         expect(Namer.current_index).to eq 2
-        expect { resource.x 10 }.to raise_error 'hi'
+        expect { resource.x 10 }.to raise_error "hi"
         expect(resource.x).to eq 20
         expect(Namer.current_index).to eq 3
       end
       it "validation does not run if coercion fails" do
-        expect { resource.x 10 }.to raise_error 'hi'
+        expect { resource.x 10 }.to raise_error "hi"
         expect(Namer.current_index).to eq 1
       end
     end
   end
 
   context "Chef::Resource::Property validation" do
-    with_property ':x, is: proc { |v| Namer.next_index; v.is_a?(Integer) }' do
+    with_property ":x, is: proc { |v| Namer.next_index; v.is_a?(Integer) }" do
       it "validation runs on set" do
         expect(resource.x 10).to eq 10
         expect(Namer.current_index).to eq 1
@@ -977,31 +978,31 @@ describe "Chef::Resource.property" do
       it "failed validation fails to set the value" do
         expect(resource.x 10).to eq 10
         expect(Namer.current_index).to eq 1
-        expect { resource.x 'blah' }.to raise_error Chef::Exceptions::ValidationFailed
+        expect { resource.x "blah" }.to raise_error Chef::Exceptions::ValidationFailed
         expect(resource.x).to eq 10
         expect(Namer.current_index).to eq 2
       end
     end
   end
 
-  [ 'name_attribute', 'name_property' ].each do |name|
+  [ "name_attribute", "name_property" ].each do |name|
     context "Chef::Resource::Property##{name}" do
       with_property ":x, #{name}: true" do
         it "defaults x to resource.name" do
-          expect(resource.x).to eq 'blah'
+          expect(resource.x).to eq "blah"
         end
         it "does not pick up resource.name if set" do
           expect(resource.x 10).to eq 10
           expect(resource.x).to eq 10
         end
         it "binds to the latest resource.name when run" do
-          resource.name 'foo'
-          expect(resource.x).to eq 'foo'
+          resource.name "foo"
+          expect(resource.x).to eq "foo"
         end
         it "caches resource.name" do
-          expect(resource.x).to eq 'blah'
-          resource.name 'foo'
-          expect(resource.x).to eq 'blah'
+          expect(resource.x).to eq "blah"
+          resource.name "foo"
+          expect(resource.x).to eq "blah"
         end
       end
 
@@ -1045,17 +1046,17 @@ describe "Chef::Resource.property" do
         end
         with_property ":x, default: nil, #{name}: true" do
           it "chooses #{name} over default" do
-            expect(resource.x).to eq 'blah'
+            expect(resource.x).to eq "blah"
           end
         end
         with_property ":x, #{name}: true, default: 10" do
           it "chooses #{name} over default" do
-            expect(resource.x).to eq 'blah'
+            expect(resource.x).to eq "blah"
           end
         end
         with_property ":x, #{name}: true, default: nil" do
           it "chooses #{name} over default" do
-            expect(resource.x).to eq 'blah'
+            expect(resource.x).to eq "blah"
           end
         end
       end
@@ -1100,6 +1101,82 @@ describe "Chef::Resource.property" do
       /Cannot specify both name_property and name_attribute together on property x of resource chef_resource_property_spec_(\d+)./
   end
 
+  context "property_type" do
+    it "property_types validate their defaults" do
+      expect {
+        module ::PropertySpecPropertyTypes
+          include Chef::Mixin::Properties
+          property_type(is: [:a, :b], default: :c)
+        end
+      }.to raise_error(Chef::Exceptions::DeprecatedFeatureError, /Default value :c is invalid for property <property type>./)
+      expect {
+        module ::PropertySpecPropertyTypes
+          include Chef::Mixin::Properties
+          property_type(is: [:a, :b], default: :b)
+        end
+      }.not_to raise_error
+    end
+
+    context "With property_type ABType (is: [:a, :b]) and CDType (is: [:c, :d])" do
+      before :all do
+        module ::PropertySpecPropertyTypes
+          include Chef::Mixin::Properties
+          ABType = property_type(is: [:a, :b])
+          CDType = property_type(is: [:c, :d])
+        end
+      end
+
+      with_property ":x, [PropertySpecPropertyTypes::ABType, nil, PropertySpecPropertyTypes::CDType]" do
+        it "The property can be set to nil without triggering a warning" do
+          expect(resource.x nil).to be_nil
+          expect(resource.x).to be_nil
+        end
+        it "The property can be set to :a" do
+          expect(resource.x :a).to eq(:a)
+          expect(resource.x).to eq(:a)
+        end
+        it "The property can be set to :c" do
+          expect(resource.x :c).to eq(:c)
+          expect(resource.x).to eq(:c)
+        end
+        it "The property cannot be set to :z" do
+          expect { resource.x :z }.to raise_error(Chef::Exceptions::ValidationFailed, /Property x must be one of/)
+        end
+      end
+
+      with_property ":x, [nil, PropertySpecPropertyTypes::ABType, PropertySpecPropertyTypes::CDType]" do
+        it "The property can be set to nil without triggering a warning" do
+          expect(resource.x nil).to be_nil
+          expect(resource.x).to be_nil
+        end
+        it "The property can be set to :a" do
+          expect(resource.x :a).to eq(:a)
+          expect(resource.x).to eq(:a)
+        end
+        it "The property can be set to :c" do
+          expect(resource.x :c).to eq(:c)
+          expect(resource.x).to eq(:c)
+        end
+        it "The property cannot be set to :z" do
+          expect { resource.x :z }.to raise_error(Chef::Exceptions::ValidationFailed, /Property x must be one of/)
+        end
+      end
+
+      with_property ":x, [PropertySpecPropertyTypes::ABType, nil], default: nil" do
+        it "The value defaults to nil" do
+          expect(resource.x).to be_nil
+        end
+      end
+
+      with_property ":x, [PropertySpecPropertyTypes::ABType, nil], default: lazy { nil }" do
+        it "The value defaults to nil" do
+          expect(resource.x).to be_nil
+        end
+      end
+    end
+
+  end
+
   context "with a custom property type" do
     class CustomPropertyType < Chef::Property
     end
@@ -1117,7 +1194,7 @@ describe "Chef::Resource.property" do
           end
         end
         let(:subresource) do
-          subresource_class.new('blah')
+          subresource_class.new("blah")
         end
 
         context "with property :x, default: 10 on the subclass" do