chef 12.7.2 → 12.8.1

data/spec/integration/recipes/recipe_dsl_spec.rb

@@ -1,1519 +1,1519 @@
-require "support/shared/integration/integration_helper"
-
-describe "Recipe DSL methods" do
-  include IntegrationSupport
-
-  module Namer
-    extend self
-    attr_accessor :current_index
-  end
-
-  before(:all) { Namer.current_index = 1 }
-  before { Namer.current_index += 1 }
-
-  context "with resource 'base_thingy' declared as BaseThingy" do
-    before(:context) {
-
-      class BaseThingy < Chef::Resource
-        resource_name "base_thingy"
-        default_action :create
-
-        class<<self
-          attr_accessor :created_name
-          attr_accessor :created_resource
-          attr_accessor :created_provider
-        end
-
-        def provider
-          Provider
-        end
-        class Provider < Chef::Provider
-          def load_current_resource
-          end
-
-          def action_create
-            BaseThingy.created_name = new_resource.name
-            BaseThingy.created_resource = new_resource.class
-            BaseThingy.created_provider = self.class
-          end
-        end
-      end
-
-      # Modules to put stuff in
-      module RecipeDSLSpecNamespace; end
-      module RecipeDSLSpecNamespace::Bar; end
-
-    }
-
-    before :each do
-      BaseThingy.created_resource = nil
-      BaseThingy.created_provider = nil
-    end
-
-    it "creates base_thingy when you call base_thingy in a recipe" do
-      recipe = converge {
-        base_thingy "blah" do; end
-      }
-      expect(recipe.logged_warnings).to eq ""
-      expect(BaseThingy.created_name).to eq "blah"
-      expect(BaseThingy.created_resource).to eq BaseThingy
-    end
-
-    it "errors out when you call base_thingy do ... end in a recipe" do
-      expect_converge {
-        base_thingy do; end
-      }.to raise_error(ArgumentError, "You must supply a name when declaring a base_thingy resource")
-    end
-
-    it "emits a warning when you call base_thingy 'foo', 'bar' do ... end in a recipe" do
-      Chef::Config[:treat_deprecation_warnings_as_errors] = false
-      recipe = converge {
-        base_thingy "foo", "bar" do
-        end
-      }
-      expect(recipe.logged_warnings).to match(/Cannot create resource base_thingy with more than one argument. All arguments except the name \("foo"\) will be ignored. This will cause an error in Chef 13. Arguments: \["foo", "bar"\]/)
-      expect(BaseThingy.created_name).to eq "foo"
-      expect(BaseThingy.created_resource).to eq BaseThingy
-    end
-
-    context "Deprecated automatic resource DSL" do
-      before do
-        Chef::Config[:treat_deprecation_warnings_as_errors] = false
-      end
-
-      context "with a resource 'backcompat_thingy' declared in Chef::Resource and Chef::Provider" do
-        before(:context) {
-
-          class Chef::Resource::BackcompatThingy < Chef::Resource
-            default_action :create
-          end
-          class Chef::Provider::BackcompatThingy < Chef::Provider
-            def load_current_resource
-            end
-
-            def action_create
-              BaseThingy.created_resource = new_resource.class
-              BaseThingy.created_provider = self.class
-            end
-          end
-
-        }
-
-        it "backcompat_thingy creates a Chef::Resource::BackcompatThingy" do
-          recipe = converge {
-            backcompat_thingy "blah" do; end
-          }
-          expect(BaseThingy.created_resource).to eq Chef::Resource::BackcompatThingy
-          expect(BaseThingy.created_provider).to eq Chef::Provider::BackcompatThingy
-        end
-
-        context "and another resource 'backcompat_thingy' in BackcompatThingy with 'provides'" do
-          before(:context) {
-
-            class RecipeDSLSpecNamespace::BackcompatThingy < BaseThingy
-              provides :backcompat_thingy
-              resource_name :backcompat_thingy
-            end
-
-          }
-
-          it "backcompat_thingy creates a BackcompatThingy" do
-            recipe = converge {
-              backcompat_thingy "blah" do; end
-            }
-            expect(recipe.logged_warnings).to match(/Class Chef::Provider::BackcompatThingy does not declare 'provides :backcompat_thingy'./)
-            expect(BaseThingy.created_resource).not_to be_nil
-          end
-        end
-      end
-
-      context "with a resource named RecipeDSLSpecNamespace::Bar::BarThingy" do
-        before(:context) {
-
-          class RecipeDSLSpecNamespace::Bar::BarThingy < BaseThingy
-          end
-
-        }
-
-        it "bar_thingy does not work" do
-          expect_converge {
-            bar_thingy "blah" do; end
-          }.to raise_error(NoMethodError)
-        end
-      end
-
-      context "with a resource named Chef::Resource::NoNameThingy with resource_name nil" do
-        before(:context) {
-
-          class Chef::Resource::NoNameThingy < BaseThingy
-            resource_name nil
-          end
-
-        }
-
-        it "no_name_thingy does not work" do
-          expect_converge {
-            no_name_thingy "blah" do; end
-          }.to raise_error(NoMethodError)
-        end
-      end
-
-      context "with a resource named AnotherNoNameThingy with resource_name :another_thingy_name" do
-        before(:context) {
-
-          class AnotherNoNameThingy < BaseThingy
-            resource_name :another_thingy_name
-          end
-
-        }
-
-        it "another_no_name_thingy does not work" do
-          expect_converge {
-            another_no_name_thingy "blah" do; end
-          }.to raise_error(NoMethodError)
-        end
-
-        it "another_thingy_name works" do
-          recipe = converge {
-            another_thingy_name "blah" do; end
-          }
-          expect(recipe.logged_warnings).to eq ""
-          expect(BaseThingy.created_resource).to eq(AnotherNoNameThingy)
-        end
-      end
-
-      context "with a resource named AnotherNoNameThingy2 with resource_name :another_thingy_name2; resource_name :another_thingy_name3" do
-        before(:context) {
-
-          class AnotherNoNameThingy2 < BaseThingy
-            resource_name :another_thingy_name2
-            resource_name :another_thingy_name3
-          end
-
-        }
-
-        it "another_no_name_thingy does not work" do
-          expect_converge {
-            another_no_name_thingy2 "blah" do; end
-          }.to raise_error(NoMethodError)
-        end
-
-        it "another_thingy_name2 does not work" do
-          expect_converge {
-            another_thingy_name2 "blah" do; end
-          }.to raise_error(NoMethodError)
-        end
-
-        it "yet_another_thingy_name3 works" do
-          recipe = converge {
-            another_thingy_name3 "blah" do; end
-          }
-          expect(recipe.logged_warnings).to eq ""
-          expect(BaseThingy.created_resource).to eq(AnotherNoNameThingy2)
-        end
-      end
-
-      context "provides overriding resource_name" do
-        context "with a resource named AnotherNoNameThingy3 with provides :another_no_name_thingy3, os: 'blarghle'" do
-          before(:context) {
-
-            class AnotherNoNameThingy3 < BaseThingy
-              resource_name :another_no_name_thingy_3
-              provides :another_no_name_thingy3, os: "blarghle"
-            end
-
-          }
-
-          it "and os = linux, another_no_name_thingy3 does not work" do
-            expect_converge {
-              # TODO this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "linux"
-              another_no_name_thingy3 "blah" do; end
-            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
-          end
-
-          it "and os = blarghle, another_no_name_thingy3 works" do
-            recipe = converge {
-              # TODO this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "blarghle"
-              another_no_name_thingy3 "blah" do; end
-            }
-            expect(recipe.logged_warnings).to eq ""
-            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy3)
-          end
-        end
-
-        context "with a resource named AnotherNoNameThingy4 with two provides" do
-          before(:context) {
-
-            class AnotherNoNameThingy4 < BaseThingy
-              resource_name :another_no_name_thingy_4
-              provides :another_no_name_thingy4, os: "blarghle"
-              provides :another_no_name_thingy4, platform_family: "foo"
-            end
-
-          }
-
-          it "and os = linux, another_no_name_thingy4 does not work" do
-            expect_converge {
-              # TODO this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "linux"
-              another_no_name_thingy4 "blah" do; end
-            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
-          end
-
-          it "and os = blarghle, another_no_name_thingy4 works" do
-            recipe = converge {
-              # TODO this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "blarghle"
-              another_no_name_thingy4 "blah" do; end
-            }
-            expect(recipe.logged_warnings).to eq ""
-            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy4)
-          end
-
-          it "and platform_family = foo, another_no_name_thingy4 works" do
-            recipe = converge {
-              # TODO this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:platform_family] = "foo"
-              another_no_name_thingy4 "blah" do; end
-            }
-            expect(recipe.logged_warnings).to eq ""
-            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy4)
-          end
-        end
-
-        context "with a resource named AnotherNoNameThingy5, a different resource_name, and a provides with the original resource_name" do
-          before(:context) {
-
-            class AnotherNoNameThingy5 < BaseThingy
-              resource_name :another_thingy_name_for_another_no_name_thingy5
-              provides :another_no_name_thingy5, os: "blarghle"
-            end
-
-          }
-
-          it "and os = linux, another_no_name_thingy5 does not work" do
-            expect_converge {
-              # this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "linux"
-              another_no_name_thingy5 "blah" do; end
-            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
-          end
-
-          it "and os = blarghle, another_no_name_thingy5 works" do
-            recipe = converge {
-              # this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "blarghle"
-              another_no_name_thingy5 "blah" do; end
-            }
-            expect(recipe.logged_warnings).to eq ""
-            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy5)
-          end
-
-          it "the new resource name can be used in a recipe" do
-            recipe = converge {
-              another_thingy_name_for_another_no_name_thingy5 "blah" do; end
-            }
-            expect(recipe.logged_warnings).to eq ""
-            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy5)
-          end
-        end
-
-        context "with a resource named AnotherNoNameThingy6, a provides with the original resource name, and a different resource_name" do
-          before(:context) {
-
-            class AnotherNoNameThingy6 < BaseThingy
-              provides :another_no_name_thingy6, os: "blarghle"
-              resource_name :another_thingy_name_for_another_no_name_thingy6
-            end
-
-          }
-
-          it "and os = linux, another_no_name_thingy6 does not work" do
-            expect_converge {
-              # this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "linux"
-              another_no_name_thingy6 "blah" do; end
-            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
-          end
-
-          it "and os = blarghle, another_no_name_thingy6 works" do
-            recipe = converge {
-              # this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "blarghle"
-              another_no_name_thingy6 "blah" do; end
-            }
-            expect(recipe.logged_warnings).to eq ""
-            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy6)
-          end
-
-          it "the new resource name can be used in a recipe" do
-            recipe = converge {
-              another_thingy_name_for_another_no_name_thingy6 "blah" do; end
-            }
-            expect(recipe.logged_warnings).to eq ""
-            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy6)
-          end
-        end
-
-        context "with a resource named AnotherNoNameThingy7, a new resource_name, and provides with that new resource name" do
-          before(:context) {
-
-            class AnotherNoNameThingy7 < BaseThingy
-              resource_name :another_thingy_name_for_another_no_name_thingy7
-              provides :another_thingy_name_for_another_no_name_thingy7, os: "blarghle"
-            end
-
-          }
-
-          it "and os = linux, another_thingy_name_for_another_no_name_thingy7 does not work" do
-            expect_converge {
-              # this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "linux"
-              another_thingy_name_for_another_no_name_thingy7 "blah" do; end
-            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
-          end
-
-          it "and os = blarghle, another_thingy_name_for_another_no_name_thingy7 works" do
-            recipe = converge {
-              # this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "blarghle"
-              another_thingy_name_for_another_no_name_thingy7 "blah" do; end
-            }
-            expect(recipe.logged_warnings).to eq ""
-            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy7)
-          end
-
-          it "the old resource name does not work" do
-            expect_converge {
-              # this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "linux"
-              another_no_name_thingy_7 "blah" do; end
-            }.to raise_error(NoMethodError)
-          end
-        end
-
-        # opposite order from the previous test (provides, then resource_name)
-        context "with a resource named AnotherNoNameThingy8, a provides with a new resource name, and resource_name with that new resource name" do
-          before(:context) {
-
-            class AnotherNoNameThingy8 < BaseThingy
-              provides :another_thingy_name_for_another_no_name_thingy8, os: "blarghle"
-              resource_name :another_thingy_name_for_another_no_name_thingy8
-            end
-
-          }
-
-          it "and os = linux, another_thingy_name_for_another_no_name_thingy8 does not work" do
-            expect_converge {
-              # this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "linux"
-              another_thingy_name_for_another_no_name_thingy8 "blah" do; end
-            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
-          end
-
-          it "and os = blarghle, another_thingy_name_for_another_no_name_thingy8 works" do
-            recipe = converge {
-              # this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "blarghle"
-              another_thingy_name_for_another_no_name_thingy8 "blah" do; end
-            }
-            expect(recipe.logged_warnings).to eq ""
-            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy8)
-          end
-
-          it "the old resource name does not work" do
-            expect_converge {
-              # this is an ugly way to test, make Cheffish expose node attrs
-              run_context.node.automatic[:os] = "linux"
-              another_thingy_name8 "blah" do; end
-            }.to raise_error(NoMethodError)
-          end
-        end
-      end
-    end
-
-    context "provides" do
-      context "when MySupplier provides :hemlock" do
-        before(:context) {
-
-          class RecipeDSLSpecNamespace::MySupplier < BaseThingy
-            resource_name :hemlock
-          end
-
-        }
-
-        it "my_supplier does not work in a recipe" do
-          expect_converge {
-            my_supplier "blah" do; end
-          }.to raise_error(NoMethodError)
-        end
-
-        it "hemlock works in a recipe" do
-          expect_recipe {
-            hemlock "blah" do; end
-          }.to emit_no_warnings_or_errors
-          expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::MySupplier
-        end
-      end
-
-      context "when Thingy3 has resource_name :thingy3" do
-        before(:context) {
-
-          class RecipeDSLSpecNamespace::Thingy3 < BaseThingy
-            resource_name :thingy3
-          end
-
-        }
-
-        it "thingy3 works in a recipe" do
-          expect_recipe {
-            thingy3 "blah" do; end
-          }.to emit_no_warnings_or_errors
-          expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy3
-        end
-
-        context "and Thingy4 has resource_name :thingy3" do
-          before(:context) {
-
-            class RecipeDSLSpecNamespace::Thingy4 < BaseThingy
-              resource_name :thingy3
-            end
-
-          }
-
-          it "thingy3 works in a recipe and yields Thingy3 (the alphabetical one)" do
-            recipe = converge {
-              thingy3 "blah" do; end
-            }
-            expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy3
-          end
-
-          it "thingy4 does not work in a recipe" do
-            expect_converge {
-              thingy4 "blah" do; end
-            }.to raise_error(NoMethodError)
-          end
-
-          it "resource_matching_short_name returns Thingy4" do
-            expect(Chef::Resource.resource_matching_short_name(:thingy3)).to eq RecipeDSLSpecNamespace::Thingy3
-          end
-        end
-      end
-
-      context "when Thingy5 has resource_name :thingy5 and provides :thingy5reverse, :thingy5_2 and :thingy5_2reverse" do
-        before(:context) {
-
-          class RecipeDSLSpecNamespace::Thingy5 < BaseThingy
-            resource_name :thingy5
-            provides :thingy5reverse
-            provides :thingy5_2
-            provides :thingy5_2reverse
-          end
-
-        }
-
-        it "thingy5 works in a recipe" do
-          expect_recipe {
-            thingy5 "blah" do; end
-          }.to emit_no_warnings_or_errors
-          expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy5
-        end
-
-        context "and Thingy6 provides :thingy5" do
-          before(:context) {
-
-            class RecipeDSLSpecNamespace::Thingy6 < BaseThingy
-              resource_name :thingy6
-              provides :thingy5
-            end
-
-          }
-
-          it "thingy6 works in a recipe and yields Thingy6" do
-            recipe = converge {
-              thingy6 "blah" do; end
-            }
-            expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy6
-          end
-
-          it "thingy5 works in a recipe and yields Foo::Thingy5 (the alphabetical one)" do
-            recipe = converge {
-              thingy5 "blah" do; end
-            }
-            expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy5
-          end
-
-          it "resource_matching_short_name returns Thingy5" do
-            expect(Chef::Resource.resource_matching_short_name(:thingy5)).to eq RecipeDSLSpecNamespace::Thingy5
-          end
-
-          context "and AThingy5 provides :thingy5reverse" do
-            before(:context) {
-
-              class RecipeDSLSpecNamespace::AThingy5 < BaseThingy
-                resource_name :thingy5reverse
-              end
-
-            }
-
-            it "thingy5reverse works in a recipe and yields AThingy5 (the alphabetical one)" do
-              recipe = converge {
-                thingy5reverse "blah" do; end
-              }
-              expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::AThingy5
-            end
-          end
-
-          context "and ZRecipeDSLSpecNamespace::Thingy5 provides :thingy5_2" do
-            before(:context) {
-
-              module ZRecipeDSLSpecNamespace
-                class Thingy5 < BaseThingy
-                  resource_name :thingy5_2
-                end
-              end
-
-            }
-
-            it "thingy5_2 works in a recipe and yields the RecipeDSLSpaceNamespace one (the alphabetical one)" do
-              recipe = converge {
-                thingy5_2 "blah" do; end
-              }
-              expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy5
-            end
-          end
-
-          context "and ARecipeDSLSpecNamespace::Thingy5 provides :thingy5_2" do
-            before(:context) {
-
-              module ARecipeDSLSpecNamespace
-                class Thingy5 < BaseThingy
-                  resource_name :thingy5_2reverse
-                end
-              end
-
-            }
-
-            it "thingy5_2reverse works in a recipe and yields the ARecipeDSLSpaceNamespace one (the alphabetical one)" do
-              recipe = converge {
-                thingy5_2reverse "blah" do; end
-              }
-              expect(BaseThingy.created_resource).to eq ARecipeDSLSpecNamespace::Thingy5
-            end
-          end
-        end
-
-        context "when Thingy3 has resource_name :thingy3" do
-          before(:context) {
-
-            class RecipeDSLSpecNamespace::Thingy3 < BaseThingy
-              resource_name :thingy3
-            end
-
-          }
-
-          it "thingy3 works in a recipe" do
-            expect_recipe {
-              thingy3 "blah" do; end
-            }.to emit_no_warnings_or_errors
-            expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy3
-          end
-
-          context "and Thingy4 has resource_name :thingy3" do
-            before(:context) {
-
-              class RecipeDSLSpecNamespace::Thingy4 < BaseThingy
-                resource_name :thingy3
-              end
-
-            }
-
-            it "thingy3 works in a recipe and yields Thingy3 (the alphabetical one)" do
-              recipe = converge {
-                thingy3 "blah" do; end
-              }
-              expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy3
-            end
-
-            it "thingy4 does not work in a recipe" do
-              expect_converge {
-                thingy4 "blah" do; end
-              }.to raise_error(NoMethodError)
-            end
-
-            it "resource_matching_short_name returns Thingy4" do
-              expect(Chef::Resource.resource_matching_short_name(:thingy3)).to eq RecipeDSLSpecNamespace::Thingy3
-            end
-          end
-
-          context "and Thingy4 has resource_name :thingy3" do
-            before(:context) {
-
-              class RecipeDSLSpecNamespace::Thingy4 < BaseThingy
-                resource_name :thingy3
-              end
-
-            }
-
-            it "thingy3 works in a recipe and yields Thingy3 (the alphabetical one)" do
-              recipe = converge {
-                thingy3 "blah" do; end
-              }
-              expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy3
-            end
-
-            it "thingy4 does not work in a recipe" do
-              expect_converge {
-                thingy4 "blah" do; end
-              }.to raise_error(NoMethodError)
-            end
-
-            it "resource_matching_short_name returns Thingy4" do
-              expect(Chef::Resource.resource_matching_short_name(:thingy3)).to eq RecipeDSLSpecNamespace::Thingy3
-            end
-          end
-        end
-
-      end
-
-      context "when Thingy7 provides :thingy8" do
-        before(:context) {
-
-          class RecipeDSLSpecNamespace::Thingy7 < BaseThingy
-            resource_name :thingy7
-            provides :thingy8
-          end
-
-        }
-
-        context "and Thingy8 has resource_name :thingy8" do
-          before(:context) {
-
-            class RecipeDSLSpecNamespace::Thingy8 < BaseThingy
-              resource_name :thingy8
-            end
-
-          }
-
-          it "thingy7 works in a recipe and yields Thingy7" do
-            recipe = converge {
-              thingy7 "blah" do; end
-            }
-            expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy7
-          end
-
-          it "thingy8 works in a recipe and yields Thingy7 (alphabetical)" do
-            recipe = converge {
-              thingy8 "blah" do; end
-            }
-            expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy7
-          end
-
-          it "resource_matching_short_name returns Thingy8" do
-            expect(Chef::Resource.resource_matching_short_name(:thingy8)).to eq RecipeDSLSpecNamespace::Thingy8
-          end
-        end
-      end
-
-      context "when Thingy12 provides :thingy12, :twizzle and :twizzle2" do
-        before(:context) {
-
-          class RecipeDSLSpecNamespace::Thingy12 < BaseThingy
-            resource_name :thingy12
-            provides :twizzle
-            provides :twizzle2
-          end
-
-        }
-
-        it "thingy12 works in a recipe and yields Thingy12" do
-          expect_recipe {
-            thingy12 "blah" do; end
-          }.to emit_no_warnings_or_errors
-          expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy12
-        end
-
-        it "twizzle works in a recipe and yields Thingy12" do
-          expect_recipe {
-            twizzle "blah" do; end
-          }.to emit_no_warnings_or_errors
-          expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy12
-        end
-
-        it "twizzle2 works in a recipe and yields Thingy12" do
-          expect_recipe {
-            twizzle2 "blah" do; end
-          }.to emit_no_warnings_or_errors
-          expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy12
-        end
-      end
-
-      context "with platform-specific resources 'my_super_thingy_foo' and 'my_super_thingy_bar'" do
-        before(:context) {
-          class MySuperThingyFoo < BaseThingy
-            resource_name :my_super_thingy_foo
-            provides :my_super_thingy, platform: "foo"
-          end
-
-          class MySuperThingyBar < BaseThingy
-            resource_name :my_super_thingy_bar
-            provides :my_super_thingy, platform: "bar"
-          end
-        }
-
-        it "A run with platform 'foo' uses MySuperThingyFoo" do
-          r = Cheffish::ChefRun.new(chef_config)
-          r.client.run_context.node.automatic["platform"] = "foo"
-          r.compile_recipe {
-            my_super_thingy "blah" do; end
-          }
-          r.converge
-          expect(r).to emit_no_warnings_or_errors
-          expect(BaseThingy.created_resource).to eq MySuperThingyFoo
-        end
-
-        it "A run with platform 'bar' uses MySuperThingyBar" do
-          r = Cheffish::ChefRun.new(chef_config)
-          r.client.run_context.node.automatic["platform"] = "bar"
-          r.compile_recipe {
-            my_super_thingy "blah" do; end
-          }
-          r.converge
-          expect(r).to emit_no_warnings_or_errors
-          expect(BaseThingy.created_resource).to eq MySuperThingyBar
-        end
-
-        it "A run with platform 'x' reports that my_super_thingy is not supported" do
-          r = Cheffish::ChefRun.new(chef_config)
-          r.client.run_context.node.automatic["platform"] = "x"
-          expect {
-            r.compile_recipe {
-              my_super_thingy "blah" do; end
-            }
-          }.to raise_error(Chef::Exceptions::NoSuchResourceType)
-        end
-      end
-
-      context "when Thingy10 provides :thingy10" do
-        before(:context) {
-          class RecipeDSLSpecNamespace::Thingy10 < BaseThingy
-            resource_name :thingy10
-          end
-        }
-
-        it "declaring a resource providing the same :thingy10 with override: true does not produce a warning" do
-          expect(Chef::Log).not_to receive(:warn)
-          class RecipeDSLSpecNamespace::Thingy10AlternateProvider < BaseThingy
-            provides :thingy10, override: true
-          end
-        end
-      end
-
-      context "when Thingy11 provides :thingy11" do
-        before(:context) {
-          class RecipeDSLSpecNamespace::Thingy11 < BaseThingy
-            resource_name :thingy10
-          end
-        }
-
-        it "declaring a resource providing the same :thingy11 with os: 'linux' does not produce a warning" do
-          expect(Chef::Log).not_to receive(:warn)
-          class RecipeDSLSpecNamespace::Thingy11AlternateProvider < BaseThingy
-            provides :thingy11, os: "linux"
-          end
-        end
-      end
-    end
-
-    context "with a resource named 'B' with resource name :two_classes_one_dsl" do
-      let(:two_classes_one_dsl) { :"two_classes_one_dsl#{Namer.current_index}" }
-      let(:resource_class) {
-        result = Class.new(BaseThingy) do
-          def self.name
-            "B"
-          end
-
-          def self.to_s; name; end
-
-          def self.inspect; name.inspect; end
-        end
-        result.resource_name two_classes_one_dsl
-        result
-      }
-      before { resource_class } # pull on it so it gets defined before the recipe runs
-
-      context "and another resource named 'A' with resource_name :two_classes_one_dsl" do
-        let(:resource_class_a) {
-          result = Class.new(BaseThingy) do
-            def self.name
-              "A"
-            end
-
-            def self.to_s; name; end
-
-            def self.inspect; name.inspect; end
-          end
-          result.resource_name two_classes_one_dsl
-          result
-        }
-        before { resource_class_a } # pull on it so it gets defined before the recipe runs
-
-        it "two_classes_one_dsl resolves to A (alphabetically earliest)" do
-          two_classes_one_dsl = self.two_classes_one_dsl
-          recipe = converge {
-            instance_eval("#{two_classes_one_dsl} 'blah'")
-          }
-          expect(recipe.logged_warnings).to eq ""
-          expect(BaseThingy.created_resource).to eq resource_class_a
-        end
-
-        it "resource_matching_short_name returns B" do
-          expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class_a
-        end
-      end
-
-      context "and another resource named 'Z' with resource_name :two_classes_one_dsl" do
-        let(:resource_class_z) {
-          result = Class.new(BaseThingy) do
-            def self.name
-              "Z"
-            end
-
-            def self.to_s; name; end
-
-            def self.inspect; name.inspect; end
-          end
-          result.resource_name two_classes_one_dsl
-          result
-        }
-        before { resource_class_z } # pull on it so it gets defined before the recipe runs
-
-        it "two_classes_one_dsl resolves to B (alphabetically earliest)" do
-          two_classes_one_dsl = self.two_classes_one_dsl
-          recipe = converge {
-            instance_eval("#{two_classes_one_dsl} 'blah'")
-          }
-          expect(recipe.logged_warnings).to eq ""
-          expect(BaseThingy.created_resource).to eq resource_class
-        end
-
-        it "resource_matching_short_name returns B" do
-          expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class
-        end
-
-        context "and a priority array [ Z, B ]" do
-          before do
-            Chef.set_resource_priority_array(two_classes_one_dsl, [ resource_class_z, resource_class ])
-          end
-
-          it "two_classes_one_dsl resolves to Z (respects the priority array)" do
-            two_classes_one_dsl = self.two_classes_one_dsl
-            recipe = converge {
-              instance_eval("#{two_classes_one_dsl} 'blah'")
-            }
-            expect(recipe.logged_warnings).to eq ""
-            expect(BaseThingy.created_resource).to eq resource_class_z
-          end
-
-          it "resource_matching_short_name returns B" do
-            expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class
-          end
-
-          context "when Z provides(:two_classes_one_dsl) { false }" do
-            before do
-              resource_class_z.provides(two_classes_one_dsl) { false }
-            end
-
-            it "two_classes_one_dsl resolves to B (picks the next thing in the priority array)" do
-              two_classes_one_dsl = self.two_classes_one_dsl
-              recipe = converge {
-                instance_eval("#{two_classes_one_dsl} 'blah'")
-              }
-              expect(recipe.logged_warnings).to eq ""
-              expect(BaseThingy.created_resource).to eq resource_class
-            end
-
-            it "resource_matching_short_name returns B" do
-              expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class
-            end
-          end
-        end
-
-        context "and priority arrays [ B ] and [ Z ]" do
-          before do
-            Chef.set_resource_priority_array(two_classes_one_dsl, [ resource_class ])
-            Chef.set_resource_priority_array(two_classes_one_dsl, [ resource_class_z ])
-          end
-
-          it "two_classes_one_dsl resolves to Z (respects the most recent priority array)" do
-            two_classes_one_dsl = self.two_classes_one_dsl
-            recipe = converge {
-              instance_eval("#{two_classes_one_dsl} 'blah'")
-            }
-            expect(recipe.logged_warnings).to eq ""
-            expect(BaseThingy.created_resource).to eq resource_class_z
-          end
-
-          it "resource_matching_short_name returns B" do
-            expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class
-          end
-
-          context "when Z provides(:two_classes_one_dsl) { false }" do
-            before do
-              resource_class_z.provides(two_classes_one_dsl) { false }
-            end
-
-            it "two_classes_one_dsl resolves to B (picks the first match from the other priority array)" do
-              two_classes_one_dsl = self.two_classes_one_dsl
-              recipe = converge {
-                instance_eval("#{two_classes_one_dsl} 'blah'")
-              }
-              expect(recipe.logged_warnings).to eq ""
-              expect(BaseThingy.created_resource).to eq resource_class
-            end
-
-            it "resource_matching_short_name returns B" do
-              expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class
-            end
-          end
-        end
-
-        context "and a priority array [ Z ]" do
-          before do
-            Chef.set_resource_priority_array(two_classes_one_dsl, [ resource_class_z ])
-          end
-
-          context "when Z provides(:two_classes_one_dsl) { false }" do
-            before do
-              resource_class_z.provides(two_classes_one_dsl) { false }
-            end
-
-            it "two_classes_one_dsl resolves to B (picks the first match outside the priority array)" do
-              two_classes_one_dsl = self.two_classes_one_dsl
-              recipe = converge {
-                instance_eval("#{two_classes_one_dsl} 'blah'")
-              }
-              expect(recipe.logged_warnings).to eq ""
-              expect(BaseThingy.created_resource).to eq resource_class
-            end
-
-            it "resource_matching_short_name returns B" do
-              expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class
-            end
-          end
-        end
-
-      end
-
-      context "and a provider named 'B' which provides :two_classes_one_dsl" do
-        before do
-          resource_class.send(:define_method, :provider) { nil }
-        end
-
-        let(:provider_class) {
-          result = Class.new(BaseThingy::Provider) do
-            def self.name
-              "B"
-            end
-
-            def self.to_s; name; end
-
-            def self.inspect; name.inspect; end
-          end
-          result.provides two_classes_one_dsl
-          result
-        }
-        before { provider_class } # pull on it so it gets defined before the recipe runs
-
-        context "and another provider named 'A'" do
-          let(:provider_class_a) {
-            result = Class.new(BaseThingy::Provider) do
-              def self.name
-                "A"
-              end
-
-              def self.to_s; name; end
-
-              def self.inspect; name.inspect; end
-            end
-            result
-          }
-          context "which provides :two_classes_one_dsl" do
-            before { provider_class_a.provides two_classes_one_dsl }
-
-            it "two_classes_one_dsl resolves to A (alphabetically earliest)" do
-              two_classes_one_dsl = self.two_classes_one_dsl
-              recipe = converge {
-                instance_eval("#{two_classes_one_dsl} 'blah'")
-              }
-              expect(recipe.logged_warnings).to eq ""
-              expect(BaseThingy.created_provider).to eq provider_class_a
-            end
-          end
-          context "which provides(:two_classes_one_dsl) { false }" do
-            before { provider_class_a.provides(two_classes_one_dsl) { false } }
-
-            it "two_classes_one_dsl resolves to B (since A declined)" do
-              two_classes_one_dsl = self.two_classes_one_dsl
-              recipe = converge {
-                instance_eval("#{two_classes_one_dsl} 'blah'")
-              }
-              expect(recipe.logged_warnings).to eq ""
-              expect(BaseThingy.created_provider).to eq provider_class
-            end
-          end
-        end
-
-        context "and another provider named 'Z'" do
-          let(:provider_class_z) {
-            result = Class.new(BaseThingy::Provider) do
-              def self.name
-                "Z"
-              end
-
-              def self.to_s; name; end
-
-              def self.inspect; name.inspect; end
-            end
-            result
-          }
-          before { provider_class_z } # pull on it so it gets defined before the recipe runs
-
-          context "which provides :two_classes_one_dsl" do
-            before { provider_class_z.provides two_classes_one_dsl }
-
-            it "two_classes_one_dsl resolves to B (alphabetically earliest)" do
-              two_classes_one_dsl = self.two_classes_one_dsl
-              recipe = converge {
-                instance_eval("#{two_classes_one_dsl} 'blah'")
-              }
-              expect(recipe.logged_warnings).to eq ""
-              expect(BaseThingy.created_provider).to eq provider_class
-            end
-
-            context "with a priority array [ Z, B ]" do
-              before { Chef.set_provider_priority_array two_classes_one_dsl, [ provider_class_z, provider_class ] }
-
-              it "two_classes_one_dsl resolves to Z (respects the priority map)" do
-                two_classes_one_dsl = self.two_classes_one_dsl
-                recipe = converge {
-                  instance_eval("#{two_classes_one_dsl} 'blah'")
-                }
-                expect(recipe.logged_warnings).to eq ""
-                expect(BaseThingy.created_provider).to eq provider_class_z
-              end
-            end
-          end
-
-          context "which provides(:two_classes_one_dsl) { false }" do
-            before { provider_class_z.provides(two_classes_one_dsl) { false } }
-
-            context "with a priority array [ Z, B ]" do
-              before { Chef.set_provider_priority_array two_classes_one_dsl, [ provider_class_z, provider_class ] }
-
-              it "two_classes_one_dsl resolves to B (the next one in the priority map)" do
-                two_classes_one_dsl = self.two_classes_one_dsl
-                recipe = converge {
-                  instance_eval("#{two_classes_one_dsl} 'blah'")
-                }
-                expect(recipe.logged_warnings).to eq ""
-                expect(BaseThingy.created_provider).to eq provider_class
-              end
-            end
-
-            context "with priority arrays [ B ] and [ Z ]" do
-              before { Chef.set_provider_priority_array two_classes_one_dsl, [ provider_class_z ] }
-              before { Chef.set_provider_priority_array two_classes_one_dsl, [ provider_class ] }
-
-              it "two_classes_one_dsl resolves to B (the one in the next priority map)" do
-                two_classes_one_dsl = self.two_classes_one_dsl
-                recipe = converge {
-                  instance_eval("#{two_classes_one_dsl} 'blah'")
-                }
-                expect(recipe.logged_warnings).to eq ""
-                expect(BaseThingy.created_provider).to eq provider_class
-              end
-            end
-          end
-        end
-      end
-
-      context "and another resource Blarghle with provides :two_classes_one_dsl, os: 'blarghle'" do
-        let(:resource_class_blarghle) {
-          result = Class.new(BaseThingy) do
-            def self.name
-              "Blarghle"
-            end
-
-            def self.to_s; name; end
-
-            def self.inspect; name.inspect; end
-          end
-          result.resource_name two_classes_one_dsl
-          result.provides two_classes_one_dsl, os: "blarghle"
-          result
-        }
-        before { resource_class_blarghle } # pull on it so it gets defined before the recipe runs
-
-        it "on os = blarghle, two_classes_one_dsl resolves to Blarghle" do
-          two_classes_one_dsl = self.two_classes_one_dsl
-          recipe = converge {
-            # this is an ugly way to test, make Cheffish expose node attrs
-            run_context.node.automatic[:os] = "blarghle"
-            instance_eval("#{two_classes_one_dsl} 'blah' do; end")
-          }
-          expect(recipe.logged_warnings).to eq ""
-          expect(BaseThingy.created_resource).to eq resource_class_blarghle
-        end
-
-        it "on os = linux, two_classes_one_dsl resolves to B" do
-          two_classes_one_dsl = self.two_classes_one_dsl
-          recipe = converge {
-            # this is an ugly way to test, make Cheffish expose node attrs
-            run_context.node.automatic[:os] = "linux"
-            instance_eval("#{two_classes_one_dsl} 'blah' do; end")
-          }
-          expect(recipe.logged_warnings).to eq ""
-          expect(BaseThingy.created_resource).to eq resource_class
-        end
-      end
-    end
-
-    context "with a resource MyResource" do
-      let(:resource_class) { Class.new(BaseThingy) do
-        def self.called_provides
-          @called_provides
-        end
-
-        def to_s
-          "MyResource"
-        end
-      end }
-      let(:my_resource) { :"my_resource#{Namer.current_index}" }
-      let(:blarghle_blarghle_little_star) { :"blarghle_blarghle_little_star#{Namer.current_index}" }
-
-      context "with resource_name :my_resource" do
-        before {
-          resource_class.resource_name my_resource
-        }
-
-        context "with provides? returning true to my_resource" do
-          before {
-            my_resource = self.my_resource
-            resource_class.define_singleton_method(:provides?) do |node, resource_name|
-              @called_provides = true
-              resource_name == my_resource
-            end
-          }
-
-          it "my_resource returns the resource and calls provides?, but does not emit a warning" do
-            dsl_name = self.my_resource
-            recipe = converge {
-              instance_eval("#{dsl_name} 'foo'")
-            }
-            expect(recipe.logged_warnings).to eq ""
-            expect(BaseThingy.created_resource).to eq resource_class
-            expect(resource_class.called_provides).to be_truthy
-          end
-        end
-
-        context "with provides? returning true to blarghle_blarghle_little_star and not resource_name" do
-          before do
-            blarghle_blarghle_little_star = self.blarghle_blarghle_little_star
-            resource_class.define_singleton_method(:provides?) do |node, resource_name|
-              @called_provides = true
-              resource_name == blarghle_blarghle_little_star
-            end
-          end
-
-          it "my_resource does not return the resource" do
-            dsl_name = self.my_resource
-            expect_converge {
-              instance_eval("#{dsl_name} 'foo'")
-            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
-            expect(resource_class.called_provides).to be_truthy
-          end
-
-          it "blarghle_blarghle_little_star 'foo' returns the resource and emits a warning" do
-            Chef::Config[:treat_deprecation_warnings_as_errors] = false
-            dsl_name = self.blarghle_blarghle_little_star
-            recipe = converge {
-              instance_eval("#{dsl_name} 'foo'")
-            }
-            expect(recipe.logged_warnings).to include "WARN: #{resource_class}.provides? returned true when asked if it provides DSL #{dsl_name}, but provides :#{dsl_name} was never called!"
-            expect(BaseThingy.created_resource).to eq resource_class
-            expect(resource_class.called_provides).to be_truthy
-          end
-        end
-
-        context "and a provider" do
-          let(:provider_class) do
-            Class.new(BaseThingy::Provider) do
-              def self.name
-                "MyProvider"
-              end
-
-              def self.to_s; name; end
-
-              def self.inspect; name.inspect; end
-
-              def self.called_provides
-                @called_provides
-              end
-            end
-          end
-
-          before do
-            resource_class.send(:define_method, :provider) { nil }
-          end
-
-          context "that provides :my_resource" do
-            before do
-              provider_class.provides my_resource
-            end
-
-            context "with supports? returning true" do
-              before do
-                provider_class.define_singleton_method(:supports?) { |resource, action| true }
-              end
-
-              it "my_resource runs the provider and does not emit a warning" do
-                my_resource = self.my_resource
-                recipe = converge {
-                  instance_eval("#{my_resource} 'foo'")
-                }
-                expect(recipe.logged_warnings).to eq ""
-                expect(BaseThingy.created_provider).to eq provider_class
-              end
-
-              context "and another provider supporting :my_resource with supports? false" do
-                let(:provider_class2) do
-                  Class.new(BaseThingy::Provider) do
-                    def self.name
-                      "MyProvider2"
-                    end
-
-                    def self.to_s; name; end
-
-                    def self.inspect; name.inspect; end
-
-                    def self.called_provides
-                      @called_provides
-                    end
-                    provides my_resource
-                    def self.supports?(resource, action)
-                      false
-                    end
-                  end
-                end
-
-                it "my_resource runs the first provider" do
-                  my_resource = self.my_resource
-                  recipe = converge {
-                    instance_eval("#{my_resource} 'foo'")
-                  }
-                  expect(recipe.logged_warnings).to eq ""
-                  expect(BaseThingy.created_provider).to eq provider_class
-                end
-              end
-            end
-
-            context "with supports? returning false" do
-              before do
-                provider_class.define_singleton_method(:supports?) { |resource, action| false }
-              end
-
-              # TODO no warning? ick
-              it "my_resource runs the provider anyway" do
-                my_resource = self.my_resource
-                recipe = converge {
-                  instance_eval("#{my_resource} 'foo'")
-                }
-                expect(recipe.logged_warnings).to eq ""
-                expect(BaseThingy.created_provider).to eq provider_class
-              end
-
-              context "and another provider supporting :my_resource with supports? true" do
-                let(:provider_class2) do
-                  my_resource = self.my_resource
-                  Class.new(BaseThingy::Provider) do
-                    def self.name
-                      "MyProvider2"
-                    end
-
-                    def self.to_s; name; end
-
-                    def self.inspect; name.inspect; end
-
-                    def self.called_provides
-                      @called_provides
-                    end
-                    provides my_resource
-                    def self.supports?(resource, action)
-                      true
-                    end
-                  end
-                end
-                before { provider_class2 } # make sure the provider class shows up
-
-                it "my_resource runs the other provider" do
-                  my_resource = self.my_resource
-                  recipe = converge {
-                    instance_eval("#{my_resource} 'foo'")
-                  }
-                  expect(recipe.logged_warnings).to eq ""
-                  expect(BaseThingy.created_provider).to eq provider_class2
-                end
-              end
-            end
-          end
-
-          context "with provides? returning true" do
-            before {
-              my_resource = self.my_resource
-              provider_class.define_singleton_method(:provides?) do |node, resource|
-                @called_provides = true
-                resource.declared_type == my_resource
-              end
-            }
-
-            context "that provides :my_resource" do
-              before {
-                provider_class.provides my_resource
-              }
-
-              it "my_resource calls the provider (and calls provides?), but does not emit a warning" do
-                my_resource = self.my_resource
-                recipe = converge {
-                  instance_eval("#{my_resource} 'foo'")
-                }
-                expect(recipe.logged_warnings).to eq ""
-                expect(BaseThingy.created_provider).to eq provider_class
-                expect(provider_class.called_provides).to be_truthy
-              end
-            end
-
-            context "that does not call provides :my_resource" do
-              it "my_resource calls the provider (and calls provides?), and emits a warning" do
-                Chef::Config[:treat_deprecation_warnings_as_errors] = false
-                my_resource = self.my_resource
-                recipe = converge {
-                  instance_eval("#{my_resource} 'foo'")
-                }
-                expect(recipe.logged_warnings).to include("WARN: #{provider_class}.provides? returned true when asked if it provides DSL #{my_resource}, but provides :#{my_resource} was never called!")
-                expect(BaseThingy.created_provider).to eq provider_class
-                expect(provider_class.called_provides).to be_truthy
-              end
-            end
-          end
-
-          context "with provides? returning false to my_resource" do
-            before {
-              my_resource = self.my_resource
-              provider_class.define_singleton_method(:provides?) do |node, resource|
-                @called_provides = true
-                false
-              end
-            }
-
-            context "that provides :my_resource" do
-              before {
-                provider_class.provides my_resource
-              }
-
-              it "my_resource fails to find a provider (and calls provides)" do
-                my_resource = self.my_resource
-                expect_converge {
-                  instance_eval("#{my_resource} 'foo'")
-                }.to raise_error(Chef::Exceptions::ProviderNotFound)
-                expect(provider_class.called_provides).to be_truthy
-              end
-            end
-
-            context "that does not provide :my_resource" do
-              it "my_resource fails to find a provider (and calls provides)" do
-                my_resource = self.my_resource
-                expect_converge {
-                  instance_eval("#{my_resource} 'foo'")
-                }.to raise_error(Chef::Exceptions::ProviderNotFound)
-                expect(provider_class.called_provides).to be_truthy
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  before(:all) { Namer.current_index = 0 }
-  before { Namer.current_index += 1 }
-
-  context "with an LWRP that declares actions" do
-    let(:resource_class) {
-      Class.new(Chef::Resource::LWRPBase) do
-        provides :"recipe_dsl_spec#{Namer.current_index}"
-        actions :create
-      end
-    }
-    let(:resource) {
-      resource_class.new("blah", run_context)
-    }
-    it "The actions are part of actions along with :nothing" do
-      expect(resource_class.actions).to eq [ :nothing, :create ]
-    end
-    it "The actions are part of allowed_actions along with :nothing" do
-      expect(resource.allowed_actions).to eq [ :nothing, :create ]
-    end
-
-    context "and a subclass that declares more actions" do
-      let(:subresource_class) {
-        Class.new(Chef::Resource::LWRPBase) do
-          provides :"recipe_dsl_spec_sub#{Namer.current_index}"
-          actions :delete
-        end
-      }
-      let(:subresource) {
-        subresource_class.new("subblah", run_context)
-      }
-
-      it "The parent class actions are not part of actions" do
-        expect(subresource_class.actions).to eq [ :nothing, :delete ]
-      end
-      it "The parent class actions are not part of allowed_actions" do
-        expect(subresource.allowed_actions).to eq [ :nothing, :delete ]
-      end
-      it "The parent class actions do not change" do
-        expect(resource_class.actions).to eq [ :nothing, :create ]
-        expect(resource.allowed_actions).to eq [ :nothing, :create ]
-      end
-    end
-  end
-
-  context "with a dynamically defined resource and regular provider" do
-    before(:context) do
-      Class.new(Chef::Resource) do
-        resource_name :lw_resource_with_hw_provider_test_case
-        default_action :create
-        attr_accessor :created_provider
-      end
-      class Chef::Provider::LwResourceWithHwProviderTestCase < Chef::Provider
-        def load_current_resource
-        end
-
-        def action_create
-          new_resource.created_provider = self.class
-        end
-      end
-    end
-
-    it "looks up the provider in Chef::Provider converting the resource name from snake case to camel case" do
-      resource = nil
-      recipe = converge {
-        resource = lw_resource_with_hw_provider_test_case "blah" do; end
-      }
-      expect(resource.created_provider).to eq(Chef::Provider::LwResourceWithHwProviderTestCase)
-    end
-  end
-end
+require "support/shared/integration/integration_helper"
+
+describe "Recipe DSL methods" do
+  include IntegrationSupport
+
+  module Namer
+    extend self
+    attr_accessor :current_index
+  end
+
+  before(:all) { Namer.current_index = 1 }
+  before { Namer.current_index += 1 }
+
+  context "with resource 'base_thingy' declared as BaseThingy" do
+    before(:context) {
+
+      class BaseThingy < Chef::Resource
+        resource_name "base_thingy"
+        default_action :create
+
+        class<<self
+          attr_accessor :created_name
+          attr_accessor :created_resource
+          attr_accessor :created_provider
+        end
+
+        def provider
+          Provider
+        end
+        class Provider < Chef::Provider
+          def load_current_resource
+          end
+
+          def action_create
+            BaseThingy.created_name = new_resource.name
+            BaseThingy.created_resource = new_resource.class
+            BaseThingy.created_provider = self.class
+          end
+        end
+      end
+
+      # Modules to put stuff in
+      module RecipeDSLSpecNamespace; end
+      module RecipeDSLSpecNamespace::Bar; end
+
+    }
+
+    before :each do
+      BaseThingy.created_resource = nil
+      BaseThingy.created_provider = nil
+    end
+
+    it "creates base_thingy when you call base_thingy in a recipe" do
+      recipe = converge {
+        base_thingy "blah" do; end
+      }
+      expect(recipe.logged_warnings).to eq ""
+      expect(BaseThingy.created_name).to eq "blah"
+      expect(BaseThingy.created_resource).to eq BaseThingy
+    end
+
+    it "errors out when you call base_thingy do ... end in a recipe" do
+      expect_converge {
+        base_thingy do; end
+      }.to raise_error(ArgumentError, "You must supply a name when declaring a base_thingy resource")
+    end
+
+    it "emits a warning when you call base_thingy 'foo', 'bar' do ... end in a recipe" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
+      recipe = converge {
+        base_thingy "foo", "bar" do
+        end
+      }
+      expect(recipe.logged_warnings).to match(/Cannot create resource base_thingy with more than one argument. All arguments except the name \("foo"\) will be ignored. This will cause an error in Chef 13. Arguments: \["foo", "bar"\]/)
+      expect(BaseThingy.created_name).to eq "foo"
+      expect(BaseThingy.created_resource).to eq BaseThingy
+    end
+
+    context "Deprecated automatic resource DSL" do
+      before do
+        Chef::Config[:treat_deprecation_warnings_as_errors] = false
+      end
+
+      context "with a resource 'backcompat_thingy' declared in Chef::Resource and Chef::Provider" do
+        before(:context) {
+
+          class Chef::Resource::BackcompatThingy < Chef::Resource
+            default_action :create
+          end
+          class Chef::Provider::BackcompatThingy < Chef::Provider
+            def load_current_resource
+            end
+
+            def action_create
+              BaseThingy.created_resource = new_resource.class
+              BaseThingy.created_provider = self.class
+            end
+          end
+
+        }
+
+        it "backcompat_thingy creates a Chef::Resource::BackcompatThingy" do
+          recipe = converge {
+            backcompat_thingy "blah" do; end
+          }
+          expect(BaseThingy.created_resource).to eq Chef::Resource::BackcompatThingy
+          expect(BaseThingy.created_provider).to eq Chef::Provider::BackcompatThingy
+        end
+
+        context "and another resource 'backcompat_thingy' in BackcompatThingy with 'provides'" do
+          before(:context) {
+
+            class RecipeDSLSpecNamespace::BackcompatThingy < BaseThingy
+              provides :backcompat_thingy
+              resource_name :backcompat_thingy
+            end
+
+          }
+
+          it "backcompat_thingy creates a BackcompatThingy" do
+            recipe = converge {
+              backcompat_thingy "blah" do; end
+            }
+            expect(recipe.logged_warnings).to match(/Class Chef::Provider::BackcompatThingy does not declare 'provides :backcompat_thingy'./)
+            expect(BaseThingy.created_resource).not_to be_nil
+          end
+        end
+      end
+
+      context "with a resource named RecipeDSLSpecNamespace::Bar::BarThingy" do
+        before(:context) {
+
+          class RecipeDSLSpecNamespace::Bar::BarThingy < BaseThingy
+          end
+
+        }
+
+        it "bar_thingy does not work" do
+          expect_converge {
+            bar_thingy "blah" do; end
+          }.to raise_error(NoMethodError)
+        end
+      end
+
+      context "with a resource named Chef::Resource::NoNameThingy with resource_name nil" do
+        before(:context) {
+
+          class Chef::Resource::NoNameThingy < BaseThingy
+            resource_name nil
+          end
+
+        }
+
+        it "no_name_thingy does not work" do
+          expect_converge {
+            no_name_thingy "blah" do; end
+          }.to raise_error(NoMethodError)
+        end
+      end
+
+      context "with a resource named AnotherNoNameThingy with resource_name :another_thingy_name" do
+        before(:context) {
+
+          class AnotherNoNameThingy < BaseThingy
+            resource_name :another_thingy_name
+          end
+
+        }
+
+        it "another_no_name_thingy does not work" do
+          expect_converge {
+            another_no_name_thingy "blah" do; end
+          }.to raise_error(NoMethodError)
+        end
+
+        it "another_thingy_name works" do
+          recipe = converge {
+            another_thingy_name "blah" do; end
+          }
+          expect(recipe.logged_warnings).to eq ""
+          expect(BaseThingy.created_resource).to eq(AnotherNoNameThingy)
+        end
+      end
+
+      context "with a resource named AnotherNoNameThingy2 with resource_name :another_thingy_name2; resource_name :another_thingy_name3" do
+        before(:context) {
+
+          class AnotherNoNameThingy2 < BaseThingy
+            resource_name :another_thingy_name2
+            resource_name :another_thingy_name3
+          end
+
+        }
+
+        it "another_no_name_thingy does not work" do
+          expect_converge {
+            another_no_name_thingy2 "blah" do; end
+          }.to raise_error(NoMethodError)
+        end
+
+        it "another_thingy_name2 does not work" do
+          expect_converge {
+            another_thingy_name2 "blah" do; end
+          }.to raise_error(NoMethodError)
+        end
+
+        it "yet_another_thingy_name3 works" do
+          recipe = converge {
+            another_thingy_name3 "blah" do; end
+          }
+          expect(recipe.logged_warnings).to eq ""
+          expect(BaseThingy.created_resource).to eq(AnotherNoNameThingy2)
+        end
+      end
+
+      context "provides overriding resource_name" do
+        context "with a resource named AnotherNoNameThingy3 with provides :another_no_name_thingy3, os: 'blarghle'" do
+          before(:context) {
+
+            class AnotherNoNameThingy3 < BaseThingy
+              resource_name :another_no_name_thingy_3
+              provides :another_no_name_thingy3, os: "blarghle"
+            end
+
+          }
+
+          it "and os = linux, another_no_name_thingy3 does not work" do
+            expect_converge {
+              # TODO this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "linux"
+              another_no_name_thingy3 "blah" do; end
+            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
+          end
+
+          it "and os = blarghle, another_no_name_thingy3 works" do
+            recipe = converge {
+              # TODO this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "blarghle"
+              another_no_name_thingy3 "blah" do; end
+            }
+            expect(recipe.logged_warnings).to eq ""
+            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy3)
+          end
+        end
+
+        context "with a resource named AnotherNoNameThingy4 with two provides" do
+          before(:context) {
+
+            class AnotherNoNameThingy4 < BaseThingy
+              resource_name :another_no_name_thingy_4
+              provides :another_no_name_thingy4, os: "blarghle"
+              provides :another_no_name_thingy4, platform_family: "foo"
+            end
+
+          }
+
+          it "and os = linux, another_no_name_thingy4 does not work" do
+            expect_converge {
+              # TODO this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "linux"
+              another_no_name_thingy4 "blah" do; end
+            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
+          end
+
+          it "and os = blarghle, another_no_name_thingy4 works" do
+            recipe = converge {
+              # TODO this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "blarghle"
+              another_no_name_thingy4 "blah" do; end
+            }
+            expect(recipe.logged_warnings).to eq ""
+            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy4)
+          end
+
+          it "and platform_family = foo, another_no_name_thingy4 works" do
+            recipe = converge {
+              # TODO this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:platform_family] = "foo"
+              another_no_name_thingy4 "blah" do; end
+            }
+            expect(recipe.logged_warnings).to eq ""
+            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy4)
+          end
+        end
+
+        context "with a resource named AnotherNoNameThingy5, a different resource_name, and a provides with the original resource_name" do
+          before(:context) {
+
+            class AnotherNoNameThingy5 < BaseThingy
+              resource_name :another_thingy_name_for_another_no_name_thingy5
+              provides :another_no_name_thingy5, os: "blarghle"
+            end
+
+          }
+
+          it "and os = linux, another_no_name_thingy5 does not work" do
+            expect_converge {
+              # this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "linux"
+              another_no_name_thingy5 "blah" do; end
+            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
+          end
+
+          it "and os = blarghle, another_no_name_thingy5 works" do
+            recipe = converge {
+              # this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "blarghle"
+              another_no_name_thingy5 "blah" do; end
+            }
+            expect(recipe.logged_warnings).to eq ""
+            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy5)
+          end
+
+          it "the new resource name can be used in a recipe" do
+            recipe = converge {
+              another_thingy_name_for_another_no_name_thingy5 "blah" do; end
+            }
+            expect(recipe.logged_warnings).to eq ""
+            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy5)
+          end
+        end
+
+        context "with a resource named AnotherNoNameThingy6, a provides with the original resource name, and a different resource_name" do
+          before(:context) {
+
+            class AnotherNoNameThingy6 < BaseThingy
+              provides :another_no_name_thingy6, os: "blarghle"
+              resource_name :another_thingy_name_for_another_no_name_thingy6
+            end
+
+          }
+
+          it "and os = linux, another_no_name_thingy6 does not work" do
+            expect_converge {
+              # this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "linux"
+              another_no_name_thingy6 "blah" do; end
+            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
+          end
+
+          it "and os = blarghle, another_no_name_thingy6 works" do
+            recipe = converge {
+              # this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "blarghle"
+              another_no_name_thingy6 "blah" do; end
+            }
+            expect(recipe.logged_warnings).to eq ""
+            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy6)
+          end
+
+          it "the new resource name can be used in a recipe" do
+            recipe = converge {
+              another_thingy_name_for_another_no_name_thingy6 "blah" do; end
+            }
+            expect(recipe.logged_warnings).to eq ""
+            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy6)
+          end
+        end
+
+        context "with a resource named AnotherNoNameThingy7, a new resource_name, and provides with that new resource name" do
+          before(:context) {
+
+            class AnotherNoNameThingy7 < BaseThingy
+              resource_name :another_thingy_name_for_another_no_name_thingy7
+              provides :another_thingy_name_for_another_no_name_thingy7, os: "blarghle"
+            end
+
+          }
+
+          it "and os = linux, another_thingy_name_for_another_no_name_thingy7 does not work" do
+            expect_converge {
+              # this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "linux"
+              another_thingy_name_for_another_no_name_thingy7 "blah" do; end
+            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
+          end
+
+          it "and os = blarghle, another_thingy_name_for_another_no_name_thingy7 works" do
+            recipe = converge {
+              # this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "blarghle"
+              another_thingy_name_for_another_no_name_thingy7 "blah" do; end
+            }
+            expect(recipe.logged_warnings).to eq ""
+            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy7)
+          end
+
+          it "the old resource name does not work" do
+            expect_converge {
+              # this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "linux"
+              another_no_name_thingy_7 "blah" do; end
+            }.to raise_error(NoMethodError)
+          end
+        end
+
+        # opposite order from the previous test (provides, then resource_name)
+        context "with a resource named AnotherNoNameThingy8, a provides with a new resource name, and resource_name with that new resource name" do
+          before(:context) {
+
+            class AnotherNoNameThingy8 < BaseThingy
+              provides :another_thingy_name_for_another_no_name_thingy8, os: "blarghle"
+              resource_name :another_thingy_name_for_another_no_name_thingy8
+            end
+
+          }
+
+          it "and os = linux, another_thingy_name_for_another_no_name_thingy8 does not work" do
+            expect_converge {
+              # this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "linux"
+              another_thingy_name_for_another_no_name_thingy8 "blah" do; end
+            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
+          end
+
+          it "and os = blarghle, another_thingy_name_for_another_no_name_thingy8 works" do
+            recipe = converge {
+              # this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "blarghle"
+              another_thingy_name_for_another_no_name_thingy8 "blah" do; end
+            }
+            expect(recipe.logged_warnings).to eq ""
+            expect(BaseThingy.created_resource).to eq (AnotherNoNameThingy8)
+          end
+
+          it "the old resource name does not work" do
+            expect_converge {
+              # this is an ugly way to test, make Cheffish expose node attrs
+              run_context.node.automatic[:os] = "linux"
+              another_thingy_name8 "blah" do; end
+            }.to raise_error(NoMethodError)
+          end
+        end
+      end
+    end
+
+    context "provides" do
+      context "when MySupplier provides :hemlock" do
+        before(:context) {
+
+          class RecipeDSLSpecNamespace::MySupplier < BaseThingy
+            resource_name :hemlock
+          end
+
+        }
+
+        it "my_supplier does not work in a recipe" do
+          expect_converge {
+            my_supplier "blah" do; end
+          }.to raise_error(NoMethodError)
+        end
+
+        it "hemlock works in a recipe" do
+          expect_recipe {
+            hemlock "blah" do; end
+          }.to emit_no_warnings_or_errors
+          expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::MySupplier
+        end
+      end
+
+      context "when Thingy3 has resource_name :thingy3" do
+        before(:context) {
+
+          class RecipeDSLSpecNamespace::Thingy3 < BaseThingy
+            resource_name :thingy3
+          end
+
+        }
+
+        it "thingy3 works in a recipe" do
+          expect_recipe {
+            thingy3 "blah" do; end
+          }.to emit_no_warnings_or_errors
+          expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy3
+        end
+
+        context "and Thingy4 has resource_name :thingy3" do
+          before(:context) {
+
+            class RecipeDSLSpecNamespace::Thingy4 < BaseThingy
+              resource_name :thingy3
+            end
+
+          }
+
+          it "thingy3 works in a recipe and yields Thingy3 (the alphabetical one)" do
+            recipe = converge {
+              thingy3 "blah" do; end
+            }
+            expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy3
+          end
+
+          it "thingy4 does not work in a recipe" do
+            expect_converge {
+              thingy4 "blah" do; end
+            }.to raise_error(NoMethodError)
+          end
+
+          it "resource_matching_short_name returns Thingy4" do
+            expect(Chef::Resource.resource_matching_short_name(:thingy3)).to eq RecipeDSLSpecNamespace::Thingy3
+          end
+        end
+      end
+
+      context "when Thingy5 has resource_name :thingy5 and provides :thingy5reverse, :thingy5_2 and :thingy5_2reverse" do
+        before(:context) {
+
+          class RecipeDSLSpecNamespace::Thingy5 < BaseThingy
+            resource_name :thingy5
+            provides :thingy5reverse
+            provides :thingy5_2
+            provides :thingy5_2reverse
+          end
+
+        }
+
+        it "thingy5 works in a recipe" do
+          expect_recipe {
+            thingy5 "blah" do; end
+          }.to emit_no_warnings_or_errors
+          expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy5
+        end
+
+        context "and Thingy6 provides :thingy5" do
+          before(:context) {
+
+            class RecipeDSLSpecNamespace::Thingy6 < BaseThingy
+              resource_name :thingy6
+              provides :thingy5
+            end
+
+          }
+
+          it "thingy6 works in a recipe and yields Thingy6" do
+            recipe = converge {
+              thingy6 "blah" do; end
+            }
+            expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy6
+          end
+
+          it "thingy5 works in a recipe and yields Foo::Thingy5 (the alphabetical one)" do
+            recipe = converge {
+              thingy5 "blah" do; end
+            }
+            expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy5
+          end
+
+          it "resource_matching_short_name returns Thingy5" do
+            expect(Chef::Resource.resource_matching_short_name(:thingy5)).to eq RecipeDSLSpecNamespace::Thingy5
+          end
+
+          context "and AThingy5 provides :thingy5reverse" do
+            before(:context) {
+
+              class RecipeDSLSpecNamespace::AThingy5 < BaseThingy
+                resource_name :thingy5reverse
+              end
+
+            }
+
+            it "thingy5reverse works in a recipe and yields AThingy5 (the alphabetical one)" do
+              recipe = converge {
+                thingy5reverse "blah" do; end
+              }
+              expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::AThingy5
+            end
+          end
+
+          context "and ZRecipeDSLSpecNamespace::Thingy5 provides :thingy5_2" do
+            before(:context) {
+
+              module ZRecipeDSLSpecNamespace
+                class Thingy5 < BaseThingy
+                  resource_name :thingy5_2
+                end
+              end
+
+            }
+
+            it "thingy5_2 works in a recipe and yields the RecipeDSLSpaceNamespace one (the alphabetical one)" do
+              recipe = converge {
+                thingy5_2 "blah" do; end
+              }
+              expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy5
+            end
+          end
+
+          context "and ARecipeDSLSpecNamespace::Thingy5 provides :thingy5_2" do
+            before(:context) {
+
+              module ARecipeDSLSpecNamespace
+                class Thingy5 < BaseThingy
+                  resource_name :thingy5_2reverse
+                end
+              end
+
+            }
+
+            it "thingy5_2reverse works in a recipe and yields the ARecipeDSLSpaceNamespace one (the alphabetical one)" do
+              recipe = converge {
+                thingy5_2reverse "blah" do; end
+              }
+              expect(BaseThingy.created_resource).to eq ARecipeDSLSpecNamespace::Thingy5
+            end
+          end
+        end
+
+        context "when Thingy3 has resource_name :thingy3" do
+          before(:context) {
+
+            class RecipeDSLSpecNamespace::Thingy3 < BaseThingy
+              resource_name :thingy3
+            end
+
+          }
+
+          it "thingy3 works in a recipe" do
+            expect_recipe {
+              thingy3 "blah" do; end
+            }.to emit_no_warnings_or_errors
+            expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy3
+          end
+
+          context "and Thingy4 has resource_name :thingy3" do
+            before(:context) {
+
+              class RecipeDSLSpecNamespace::Thingy4 < BaseThingy
+                resource_name :thingy3
+              end
+
+            }
+
+            it "thingy3 works in a recipe and yields Thingy3 (the alphabetical one)" do
+              recipe = converge {
+                thingy3 "blah" do; end
+              }
+              expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy3
+            end
+
+            it "thingy4 does not work in a recipe" do
+              expect_converge {
+                thingy4 "blah" do; end
+              }.to raise_error(NoMethodError)
+            end
+
+            it "resource_matching_short_name returns Thingy4" do
+              expect(Chef::Resource.resource_matching_short_name(:thingy3)).to eq RecipeDSLSpecNamespace::Thingy3
+            end
+          end
+
+          context "and Thingy4 has resource_name :thingy3" do
+            before(:context) {
+
+              class RecipeDSLSpecNamespace::Thingy4 < BaseThingy
+                resource_name :thingy3
+              end
+
+            }
+
+            it "thingy3 works in a recipe and yields Thingy3 (the alphabetical one)" do
+              recipe = converge {
+                thingy3 "blah" do; end
+              }
+              expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy3
+            end
+
+            it "thingy4 does not work in a recipe" do
+              expect_converge {
+                thingy4 "blah" do; end
+              }.to raise_error(NoMethodError)
+            end
+
+            it "resource_matching_short_name returns Thingy4" do
+              expect(Chef::Resource.resource_matching_short_name(:thingy3)).to eq RecipeDSLSpecNamespace::Thingy3
+            end
+          end
+        end
+
+      end
+
+      context "when Thingy7 provides :thingy8" do
+        before(:context) {
+
+          class RecipeDSLSpecNamespace::Thingy7 < BaseThingy
+            resource_name :thingy7
+            provides :thingy8
+          end
+
+        }
+
+        context "and Thingy8 has resource_name :thingy8" do
+          before(:context) {
+
+            class RecipeDSLSpecNamespace::Thingy8 < BaseThingy
+              resource_name :thingy8
+            end
+
+          }
+
+          it "thingy7 works in a recipe and yields Thingy7" do
+            recipe = converge {
+              thingy7 "blah" do; end
+            }
+            expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy7
+          end
+
+          it "thingy8 works in a recipe and yields Thingy7 (alphabetical)" do
+            recipe = converge {
+              thingy8 "blah" do; end
+            }
+            expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy7
+          end
+
+          it "resource_matching_short_name returns Thingy8" do
+            expect(Chef::Resource.resource_matching_short_name(:thingy8)).to eq RecipeDSLSpecNamespace::Thingy8
+          end
+        end
+      end
+
+      context "when Thingy12 provides :thingy12, :twizzle and :twizzle2" do
+        before(:context) {
+
+          class RecipeDSLSpecNamespace::Thingy12 < BaseThingy
+            resource_name :thingy12
+            provides :twizzle
+            provides :twizzle2
+          end
+
+        }
+
+        it "thingy12 works in a recipe and yields Thingy12" do
+          expect_recipe {
+            thingy12 "blah" do; end
+          }.to emit_no_warnings_or_errors
+          expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy12
+        end
+
+        it "twizzle works in a recipe and yields Thingy12" do
+          expect_recipe {
+            twizzle "blah" do; end
+          }.to emit_no_warnings_or_errors
+          expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy12
+        end
+
+        it "twizzle2 works in a recipe and yields Thingy12" do
+          expect_recipe {
+            twizzle2 "blah" do; end
+          }.to emit_no_warnings_or_errors
+          expect(BaseThingy.created_resource).to eq RecipeDSLSpecNamespace::Thingy12
+        end
+      end
+
+      context "with platform-specific resources 'my_super_thingy_foo' and 'my_super_thingy_bar'" do
+        before(:context) {
+          class MySuperThingyFoo < BaseThingy
+            resource_name :my_super_thingy_foo
+            provides :my_super_thingy, platform: "foo"
+          end
+
+          class MySuperThingyBar < BaseThingy
+            resource_name :my_super_thingy_bar
+            provides :my_super_thingy, platform: "bar"
+          end
+        }
+
+        it "A run with platform 'foo' uses MySuperThingyFoo" do
+          r = Cheffish::ChefRun.new(chef_config)
+          r.client.run_context.node.automatic["platform"] = "foo"
+          r.compile_recipe {
+            my_super_thingy "blah" do; end
+          }
+          r.converge
+          expect(r).to emit_no_warnings_or_errors
+          expect(BaseThingy.created_resource).to eq MySuperThingyFoo
+        end
+
+        it "A run with platform 'bar' uses MySuperThingyBar" do
+          r = Cheffish::ChefRun.new(chef_config)
+          r.client.run_context.node.automatic["platform"] = "bar"
+          r.compile_recipe {
+            my_super_thingy "blah" do; end
+          }
+          r.converge
+          expect(r).to emit_no_warnings_or_errors
+          expect(BaseThingy.created_resource).to eq MySuperThingyBar
+        end
+
+        it "A run with platform 'x' reports that my_super_thingy is not supported" do
+          r = Cheffish::ChefRun.new(chef_config)
+          r.client.run_context.node.automatic["platform"] = "x"
+          expect {
+            r.compile_recipe {
+              my_super_thingy "blah" do; end
+            }
+          }.to raise_error(Chef::Exceptions::NoSuchResourceType)
+        end
+      end
+
+      context "when Thingy10 provides :thingy10" do
+        before(:context) {
+          class RecipeDSLSpecNamespace::Thingy10 < BaseThingy
+            resource_name :thingy10
+          end
+        }
+
+        it "declaring a resource providing the same :thingy10 with override: true does not produce a warning" do
+          expect(Chef::Log).not_to receive(:warn)
+          class RecipeDSLSpecNamespace::Thingy10AlternateProvider < BaseThingy
+            provides :thingy10, override: true
+          end
+        end
+      end
+
+      context "when Thingy11 provides :thingy11" do
+        before(:context) {
+          class RecipeDSLSpecNamespace::Thingy11 < BaseThingy
+            resource_name :thingy10
+          end
+        }
+
+        it "declaring a resource providing the same :thingy11 with os: 'linux' does not produce a warning" do
+          expect(Chef::Log).not_to receive(:warn)
+          class RecipeDSLSpecNamespace::Thingy11AlternateProvider < BaseThingy
+            provides :thingy11, os: "linux"
+          end
+        end
+      end
+    end
+
+    context "with a resource named 'B' with resource name :two_classes_one_dsl" do
+      let(:two_classes_one_dsl) { :"two_classes_one_dsl#{Namer.current_index}" }
+      let(:resource_class) {
+        result = Class.new(BaseThingy) do
+          def self.name
+            "B"
+          end
+
+          def self.to_s; name; end
+
+          def self.inspect; name.inspect; end
+        end
+        result.resource_name two_classes_one_dsl
+        result
+      }
+      before { resource_class } # pull on it so it gets defined before the recipe runs
+
+      context "and another resource named 'A' with resource_name :two_classes_one_dsl" do
+        let(:resource_class_a) {
+          result = Class.new(BaseThingy) do
+            def self.name
+              "A"
+            end
+
+            def self.to_s; name; end
+
+            def self.inspect; name.inspect; end
+          end
+          result.resource_name two_classes_one_dsl
+          result
+        }
+        before { resource_class_a } # pull on it so it gets defined before the recipe runs
+
+        it "two_classes_one_dsl resolves to A (alphabetically earliest)" do
+          two_classes_one_dsl = self.two_classes_one_dsl
+          recipe = converge {
+            instance_eval("#{two_classes_one_dsl} 'blah'")
+          }
+          expect(recipe.logged_warnings).to eq ""
+          expect(BaseThingy.created_resource).to eq resource_class_a
+        end
+
+        it "resource_matching_short_name returns B" do
+          expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class_a
+        end
+      end
+
+      context "and another resource named 'Z' with resource_name :two_classes_one_dsl" do
+        let(:resource_class_z) {
+          result = Class.new(BaseThingy) do
+            def self.name
+              "Z"
+            end
+
+            def self.to_s; name; end
+
+            def self.inspect; name.inspect; end
+          end
+          result.resource_name two_classes_one_dsl
+          result
+        }
+        before { resource_class_z } # pull on it so it gets defined before the recipe runs
+
+        it "two_classes_one_dsl resolves to B (alphabetically earliest)" do
+          two_classes_one_dsl = self.two_classes_one_dsl
+          recipe = converge {
+            instance_eval("#{two_classes_one_dsl} 'blah'")
+          }
+          expect(recipe.logged_warnings).to eq ""
+          expect(BaseThingy.created_resource).to eq resource_class
+        end
+
+        it "resource_matching_short_name returns B" do
+          expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class
+        end
+
+        context "and a priority array [ Z, B ]" do
+          before do
+            Chef.set_resource_priority_array(two_classes_one_dsl, [ resource_class_z, resource_class ])
+          end
+
+          it "two_classes_one_dsl resolves to Z (respects the priority array)" do
+            two_classes_one_dsl = self.two_classes_one_dsl
+            recipe = converge {
+              instance_eval("#{two_classes_one_dsl} 'blah'")
+            }
+            expect(recipe.logged_warnings).to eq ""
+            expect(BaseThingy.created_resource).to eq resource_class_z
+          end
+
+          it "resource_matching_short_name returns B" do
+            expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class
+          end
+
+          context "when Z provides(:two_classes_one_dsl) { false }" do
+            before do
+              resource_class_z.provides(two_classes_one_dsl) { false }
+            end
+
+            it "two_classes_one_dsl resolves to B (picks the next thing in the priority array)" do
+              two_classes_one_dsl = self.two_classes_one_dsl
+              recipe = converge {
+                instance_eval("#{two_classes_one_dsl} 'blah'")
+              }
+              expect(recipe.logged_warnings).to eq ""
+              expect(BaseThingy.created_resource).to eq resource_class
+            end
+
+            it "resource_matching_short_name returns B" do
+              expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class
+            end
+          end
+        end
+
+        context "and priority arrays [ B ] and [ Z ]" do
+          before do
+            Chef.set_resource_priority_array(two_classes_one_dsl, [ resource_class ])
+            Chef.set_resource_priority_array(two_classes_one_dsl, [ resource_class_z ])
+          end
+
+          it "two_classes_one_dsl resolves to Z (respects the most recent priority array)" do
+            two_classes_one_dsl = self.two_classes_one_dsl
+            recipe = converge {
+              instance_eval("#{two_classes_one_dsl} 'blah'")
+            }
+            expect(recipe.logged_warnings).to eq ""
+            expect(BaseThingy.created_resource).to eq resource_class_z
+          end
+
+          it "resource_matching_short_name returns B" do
+            expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class
+          end
+
+          context "when Z provides(:two_classes_one_dsl) { false }" do
+            before do
+              resource_class_z.provides(two_classes_one_dsl) { false }
+            end
+
+            it "two_classes_one_dsl resolves to B (picks the first match from the other priority array)" do
+              two_classes_one_dsl = self.two_classes_one_dsl
+              recipe = converge {
+                instance_eval("#{two_classes_one_dsl} 'blah'")
+              }
+              expect(recipe.logged_warnings).to eq ""
+              expect(BaseThingy.created_resource).to eq resource_class
+            end
+
+            it "resource_matching_short_name returns B" do
+              expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class
+            end
+          end
+        end
+
+        context "and a priority array [ Z ]" do
+          before do
+            Chef.set_resource_priority_array(two_classes_one_dsl, [ resource_class_z ])
+          end
+
+          context "when Z provides(:two_classes_one_dsl) { false }" do
+            before do
+              resource_class_z.provides(two_classes_one_dsl) { false }
+            end
+
+            it "two_classes_one_dsl resolves to B (picks the first match outside the priority array)" do
+              two_classes_one_dsl = self.two_classes_one_dsl
+              recipe = converge {
+                instance_eval("#{two_classes_one_dsl} 'blah'")
+              }
+              expect(recipe.logged_warnings).to eq ""
+              expect(BaseThingy.created_resource).to eq resource_class
+            end
+
+            it "resource_matching_short_name returns B" do
+              expect(Chef::Resource.resource_matching_short_name(two_classes_one_dsl)).to eq resource_class
+            end
+          end
+        end
+
+      end
+
+      context "and a provider named 'B' which provides :two_classes_one_dsl" do
+        before do
+          resource_class.send(:define_method, :provider) { nil }
+        end
+
+        let(:provider_class) {
+          result = Class.new(BaseThingy::Provider) do
+            def self.name
+              "B"
+            end
+
+            def self.to_s; name; end
+
+            def self.inspect; name.inspect; end
+          end
+          result.provides two_classes_one_dsl
+          result
+        }
+        before { provider_class } # pull on it so it gets defined before the recipe runs
+
+        context "and another provider named 'A'" do
+          let(:provider_class_a) {
+            result = Class.new(BaseThingy::Provider) do
+              def self.name
+                "A"
+              end
+
+              def self.to_s; name; end
+
+              def self.inspect; name.inspect; end
+            end
+            result
+          }
+          context "which provides :two_classes_one_dsl" do
+            before { provider_class_a.provides two_classes_one_dsl }
+
+            it "two_classes_one_dsl resolves to A (alphabetically earliest)" do
+              two_classes_one_dsl = self.two_classes_one_dsl
+              recipe = converge {
+                instance_eval("#{two_classes_one_dsl} 'blah'")
+              }
+              expect(recipe.logged_warnings).to eq ""
+              expect(BaseThingy.created_provider).to eq provider_class_a
+            end
+          end
+          context "which provides(:two_classes_one_dsl) { false }" do
+            before { provider_class_a.provides(two_classes_one_dsl) { false } }
+
+            it "two_classes_one_dsl resolves to B (since A declined)" do
+              two_classes_one_dsl = self.two_classes_one_dsl
+              recipe = converge {
+                instance_eval("#{two_classes_one_dsl} 'blah'")
+              }
+              expect(recipe.logged_warnings).to eq ""
+              expect(BaseThingy.created_provider).to eq provider_class
+            end
+          end
+        end
+
+        context "and another provider named 'Z'" do
+          let(:provider_class_z) {
+            result = Class.new(BaseThingy::Provider) do
+              def self.name
+                "Z"
+              end
+
+              def self.to_s; name; end
+
+              def self.inspect; name.inspect; end
+            end
+            result
+          }
+          before { provider_class_z } # pull on it so it gets defined before the recipe runs
+
+          context "which provides :two_classes_one_dsl" do
+            before { provider_class_z.provides two_classes_one_dsl }
+
+            it "two_classes_one_dsl resolves to B (alphabetically earliest)" do
+              two_classes_one_dsl = self.two_classes_one_dsl
+              recipe = converge {
+                instance_eval("#{two_classes_one_dsl} 'blah'")
+              }
+              expect(recipe.logged_warnings).to eq ""
+              expect(BaseThingy.created_provider).to eq provider_class
+            end
+
+            context "with a priority array [ Z, B ]" do
+              before { Chef.set_provider_priority_array two_classes_one_dsl, [ provider_class_z, provider_class ] }
+
+              it "two_classes_one_dsl resolves to Z (respects the priority map)" do
+                two_classes_one_dsl = self.two_classes_one_dsl
+                recipe = converge {
+                  instance_eval("#{two_classes_one_dsl} 'blah'")
+                }
+                expect(recipe.logged_warnings).to eq ""
+                expect(BaseThingy.created_provider).to eq provider_class_z
+              end
+            end
+          end
+
+          context "which provides(:two_classes_one_dsl) { false }" do
+            before { provider_class_z.provides(two_classes_one_dsl) { false } }
+
+            context "with a priority array [ Z, B ]" do
+              before { Chef.set_provider_priority_array two_classes_one_dsl, [ provider_class_z, provider_class ] }
+
+              it "two_classes_one_dsl resolves to B (the next one in the priority map)" do
+                two_classes_one_dsl = self.two_classes_one_dsl
+                recipe = converge {
+                  instance_eval("#{two_classes_one_dsl} 'blah'")
+                }
+                expect(recipe.logged_warnings).to eq ""
+                expect(BaseThingy.created_provider).to eq provider_class
+              end
+            end
+
+            context "with priority arrays [ B ] and [ Z ]" do
+              before { Chef.set_provider_priority_array two_classes_one_dsl, [ provider_class_z ] }
+              before { Chef.set_provider_priority_array two_classes_one_dsl, [ provider_class ] }
+
+              it "two_classes_one_dsl resolves to B (the one in the next priority map)" do
+                two_classes_one_dsl = self.two_classes_one_dsl
+                recipe = converge {
+                  instance_eval("#{two_classes_one_dsl} 'blah'")
+                }
+                expect(recipe.logged_warnings).to eq ""
+                expect(BaseThingy.created_provider).to eq provider_class
+              end
+            end
+          end
+        end
+      end
+
+      context "and another resource Blarghle with provides :two_classes_one_dsl, os: 'blarghle'" do
+        let(:resource_class_blarghle) {
+          result = Class.new(BaseThingy) do
+            def self.name
+              "Blarghle"
+            end
+
+            def self.to_s; name; end
+
+            def self.inspect; name.inspect; end
+          end
+          result.resource_name two_classes_one_dsl
+          result.provides two_classes_one_dsl, os: "blarghle"
+          result
+        }
+        before { resource_class_blarghle } # pull on it so it gets defined before the recipe runs
+
+        it "on os = blarghle, two_classes_one_dsl resolves to Blarghle" do
+          two_classes_one_dsl = self.two_classes_one_dsl
+          recipe = converge {
+            # this is an ugly way to test, make Cheffish expose node attrs
+            run_context.node.automatic[:os] = "blarghle"
+            instance_eval("#{two_classes_one_dsl} 'blah' do; end")
+          }
+          expect(recipe.logged_warnings).to eq ""
+          expect(BaseThingy.created_resource).to eq resource_class_blarghle
+        end
+
+        it "on os = linux, two_classes_one_dsl resolves to B" do
+          two_classes_one_dsl = self.two_classes_one_dsl
+          recipe = converge {
+            # this is an ugly way to test, make Cheffish expose node attrs
+            run_context.node.automatic[:os] = "linux"
+            instance_eval("#{two_classes_one_dsl} 'blah' do; end")
+          }
+          expect(recipe.logged_warnings).to eq ""
+          expect(BaseThingy.created_resource).to eq resource_class
+        end
+      end
+    end
+
+    context "with a resource MyResource" do
+      let(:resource_class) { Class.new(BaseThingy) do
+        def self.called_provides
+          @called_provides
+        end
+
+        def to_s
+          "MyResource"
+        end
+      end }
+      let(:my_resource) { :"my_resource#{Namer.current_index}" }
+      let(:blarghle_blarghle_little_star) { :"blarghle_blarghle_little_star#{Namer.current_index}" }
+
+      context "with resource_name :my_resource" do
+        before {
+          resource_class.resource_name my_resource
+        }
+
+        context "with provides? returning true to my_resource" do
+          before {
+            my_resource = self.my_resource
+            resource_class.define_singleton_method(:provides?) do |node, resource_name|
+              @called_provides = true
+              resource_name == my_resource
+            end
+          }
+
+          it "my_resource returns the resource and calls provides?, but does not emit a warning" do
+            dsl_name = self.my_resource
+            recipe = converge {
+              instance_eval("#{dsl_name} 'foo'")
+            }
+            expect(recipe.logged_warnings).to eq ""
+            expect(BaseThingy.created_resource).to eq resource_class
+            expect(resource_class.called_provides).to be_truthy
+          end
+        end
+
+        context "with provides? returning true to blarghle_blarghle_little_star and not resource_name" do
+          before do
+            blarghle_blarghle_little_star = self.blarghle_blarghle_little_star
+            resource_class.define_singleton_method(:provides?) do |node, resource_name|
+              @called_provides = true
+              resource_name == blarghle_blarghle_little_star
+            end
+          end
+
+          it "my_resource does not return the resource" do
+            dsl_name = self.my_resource
+            expect_converge {
+              instance_eval("#{dsl_name} 'foo'")
+            }.to raise_error(Chef::Exceptions::NoSuchResourceType)
+            expect(resource_class.called_provides).to be_truthy
+          end
+
+          it "blarghle_blarghle_little_star 'foo' returns the resource and emits a warning" do
+            Chef::Config[:treat_deprecation_warnings_as_errors] = false
+            dsl_name = self.blarghle_blarghle_little_star
+            recipe = converge {
+              instance_eval("#{dsl_name} 'foo'")
+            }
+            expect(recipe.logged_warnings).to include "WARN: #{resource_class}.provides? returned true when asked if it provides DSL #{dsl_name}, but provides :#{dsl_name} was never called!"
+            expect(BaseThingy.created_resource).to eq resource_class
+            expect(resource_class.called_provides).to be_truthy
+          end
+        end
+
+        context "and a provider" do
+          let(:provider_class) do
+            Class.new(BaseThingy::Provider) do
+              def self.name
+                "MyProvider"
+              end
+
+              def self.to_s; name; end
+
+              def self.inspect; name.inspect; end
+
+              def self.called_provides
+                @called_provides
+              end
+            end
+          end
+
+          before do
+            resource_class.send(:define_method, :provider) { nil }
+          end
+
+          context "that provides :my_resource" do
+            before do
+              provider_class.provides my_resource
+            end
+
+            context "with supports? returning true" do
+              before do
+                provider_class.define_singleton_method(:supports?) { |resource, action| true }
+              end
+
+              it "my_resource runs the provider and does not emit a warning" do
+                my_resource = self.my_resource
+                recipe = converge {
+                  instance_eval("#{my_resource} 'foo'")
+                }
+                expect(recipe.logged_warnings).to eq ""
+                expect(BaseThingy.created_provider).to eq provider_class
+              end
+
+              context "and another provider supporting :my_resource with supports? false" do
+                let(:provider_class2) do
+                  Class.new(BaseThingy::Provider) do
+                    def self.name
+                      "MyProvider2"
+                    end
+
+                    def self.to_s; name; end
+
+                    def self.inspect; name.inspect; end
+
+                    def self.called_provides
+                      @called_provides
+                    end
+                    provides my_resource
+                    def self.supports?(resource, action)
+                      false
+                    end
+                  end
+                end
+
+                it "my_resource runs the first provider" do
+                  my_resource = self.my_resource
+                  recipe = converge {
+                    instance_eval("#{my_resource} 'foo'")
+                  }
+                  expect(recipe.logged_warnings).to eq ""
+                  expect(BaseThingy.created_provider).to eq provider_class
+                end
+              end
+            end
+
+            context "with supports? returning false" do
+              before do
+                provider_class.define_singleton_method(:supports?) { |resource, action| false }
+              end
+
+              # TODO no warning? ick
+              it "my_resource runs the provider anyway" do
+                my_resource = self.my_resource
+                recipe = converge {
+                  instance_eval("#{my_resource} 'foo'")
+                }
+                expect(recipe.logged_warnings).to eq ""
+                expect(BaseThingy.created_provider).to eq provider_class
+              end
+
+              context "and another provider supporting :my_resource with supports? true" do
+                let(:provider_class2) do
+                  my_resource = self.my_resource
+                  Class.new(BaseThingy::Provider) do
+                    def self.name
+                      "MyProvider2"
+                    end
+
+                    def self.to_s; name; end
+
+                    def self.inspect; name.inspect; end
+
+                    def self.called_provides
+                      @called_provides
+                    end
+                    provides my_resource
+                    def self.supports?(resource, action)
+                      true
+                    end
+                  end
+                end
+                before { provider_class2 } # make sure the provider class shows up
+
+                it "my_resource runs the other provider" do
+                  my_resource = self.my_resource
+                  recipe = converge {
+                    instance_eval("#{my_resource} 'foo'")
+                  }
+                  expect(recipe.logged_warnings).to eq ""
+                  expect(BaseThingy.created_provider).to eq provider_class2
+                end
+              end
+            end
+          end
+
+          context "with provides? returning true" do
+            before {
+              my_resource = self.my_resource
+              provider_class.define_singleton_method(:provides?) do |node, resource|
+                @called_provides = true
+                resource.declared_type == my_resource
+              end
+            }
+
+            context "that provides :my_resource" do
+              before {
+                provider_class.provides my_resource
+              }
+
+              it "my_resource calls the provider (and calls provides?), but does not emit a warning" do
+                my_resource = self.my_resource
+                recipe = converge {
+                  instance_eval("#{my_resource} 'foo'")
+                }
+                expect(recipe.logged_warnings).to eq ""
+                expect(BaseThingy.created_provider).to eq provider_class
+                expect(provider_class.called_provides).to be_truthy
+              end
+            end
+
+            context "that does not call provides :my_resource" do
+              it "my_resource calls the provider (and calls provides?), and emits a warning" do
+                Chef::Config[:treat_deprecation_warnings_as_errors] = false
+                my_resource = self.my_resource
+                recipe = converge {
+                  instance_eval("#{my_resource} 'foo'")
+                }
+                expect(recipe.logged_warnings).to include("WARN: #{provider_class}.provides? returned true when asked if it provides DSL #{my_resource}, but provides :#{my_resource} was never called!")
+                expect(BaseThingy.created_provider).to eq provider_class
+                expect(provider_class.called_provides).to be_truthy
+              end
+            end
+          end
+
+          context "with provides? returning false to my_resource" do
+            before {
+              my_resource = self.my_resource
+              provider_class.define_singleton_method(:provides?) do |node, resource|
+                @called_provides = true
+                false
+              end
+            }
+
+            context "that provides :my_resource" do
+              before {
+                provider_class.provides my_resource
+              }
+
+              it "my_resource fails to find a provider (and calls provides)" do
+                my_resource = self.my_resource
+                expect_converge {
+                  instance_eval("#{my_resource} 'foo'")
+                }.to raise_error(Chef::Exceptions::ProviderNotFound)
+                expect(provider_class.called_provides).to be_truthy
+              end
+            end
+
+            context "that does not provide :my_resource" do
+              it "my_resource fails to find a provider (and calls provides)" do
+                my_resource = self.my_resource
+                expect_converge {
+                  instance_eval("#{my_resource} 'foo'")
+                }.to raise_error(Chef::Exceptions::ProviderNotFound)
+                expect(provider_class.called_provides).to be_truthy
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  before(:all) { Namer.current_index = 0 }
+  before { Namer.current_index += 1 }
+
+  context "with an LWRP that declares actions" do
+    let(:resource_class) {
+      Class.new(Chef::Resource::LWRPBase) do
+        provides :"recipe_dsl_spec#{Namer.current_index}"
+        actions :create
+      end
+    }
+    let(:resource) {
+      resource_class.new("blah", run_context)
+    }
+    it "The actions are part of actions along with :nothing" do
+      expect(resource_class.actions).to eq [ :nothing, :create ]
+    end
+    it "The actions are part of allowed_actions along with :nothing" do
+      expect(resource.allowed_actions).to eq [ :nothing, :create ]
+    end
+
+    context "and a subclass that declares more actions" do
+      let(:subresource_class) {
+        Class.new(Chef::Resource::LWRPBase) do
+          provides :"recipe_dsl_spec_sub#{Namer.current_index}"
+          actions :delete
+        end
+      }
+      let(:subresource) {
+        subresource_class.new("subblah", run_context)
+      }
+
+      it "The parent class actions are not part of actions" do
+        expect(subresource_class.actions).to eq [ :nothing, :delete ]
+      end
+      it "The parent class actions are not part of allowed_actions" do
+        expect(subresource.allowed_actions).to eq [ :nothing, :delete ]
+      end
+      it "The parent class actions do not change" do
+        expect(resource_class.actions).to eq [ :nothing, :create ]
+        expect(resource.allowed_actions).to eq [ :nothing, :create ]
+      end
+    end
+  end
+
+  context "with a dynamically defined resource and regular provider" do
+    before(:context) do
+      Class.new(Chef::Resource) do
+        resource_name :lw_resource_with_hw_provider_test_case
+        default_action :create
+        attr_accessor :created_provider
+      end
+      class Chef::Provider::LwResourceWithHwProviderTestCase < Chef::Provider
+        def load_current_resource
+        end
+
+        def action_create
+          new_resource.created_provider = self.class
+        end
+      end
+    end
+
+    it "looks up the provider in Chef::Provider converting the resource name from snake case to camel case" do
+      resource = nil
+      recipe = converge {
+        resource = lw_resource_with_hw_provider_test_case "blah" do; end
+      }
+      expect(resource.created_provider).to eq(Chef::Provider::LwResourceWithHwProviderTestCase)
+    end
+  end
+end