chef 12.4.0.rc.0-universal-mingw32 → 12.4.0.rc.2-universal-mingw32

data/spec/unit/knife/user_delete_spec.rb

@@ -19,21 +19,47 @@
 require 'spec_helper'
 
 describe Chef::Knife::UserDelete do
+  let(:knife) { Chef::Knife::UserDelete.new }
+  let(:user) { double('user_object') }
+  let(:stdout) { StringIO.new }
+
   before(:each) do
     Chef::Knife::UserDelete.load_deps
-    @knife = Chef::Knife::UserDelete.new
-    @knife.name_args = [ 'my_user' ]
+    knife.name_args = [ 'my_user' ]
+    allow(Chef::User).to receive(:load).and_return(user)
+    allow(user).to receive(:username).and_return('my_user')
+    allow(knife.ui).to receive(:stderr).and_return(stdout)
+    allow(knife.ui).to receive(:stdout).and_return(stdout)
+  end
+
+  # delete this once OSC11 support is gone
+  context "when the username field is not supported by the server" do
+    before do
+      allow(knife).to receive(:run_osc_11_user_delete).and_raise(SystemExit)
+      allow(user).to receive(:username).and_return(nil)
+    end
+
+    it "displays the osc warning" do
+      expect(knife.ui).to receive(:warn).with(knife.osc_11_warning)
+      expect{ knife.run }.to raise_error(SystemExit)
+    end
+
+    it "forwards the command to knife osc_user edit" do
+      expect(knife).to receive(:run_osc_11_user_delete)
+      expect{ knife.run }.to raise_error(SystemExit)
+    end
   end
 
   it 'deletes the user' do
-    expect(@knife).to receive(:delete_object).with(Chef::User, 'my_user')
-    @knife.run
+    #expect(knife).to receive(:delete_object).with(Chef::User, 'my_user')
+    expect(knife).to receive(:delete_object).with('my_user')
+    knife.run
   end
 
   it 'prints usage and exits when a user name is not provided' do
-    @knife.name_args = []
-    expect(@knife).to receive(:show_usage)
-    expect(@knife.ui).to receive(:fatal)
-    expect { @knife.run }.to raise_error(SystemExit)
+    knife.name_args = []
+    expect(knife).to receive(:show_usage)
+    expect(knife.ui).to receive(:fatal)
+    expect { knife.run }.to raise_error(SystemExit)
   end
 end

data/spec/unit/knife/user_edit_spec.rb

@@ -19,29 +19,48 @@
 require 'spec_helper'
 
 describe Chef::Knife::UserEdit do
+  let(:knife) { Chef::Knife::UserEdit.new }
+
   before(:each) do
     @stderr = StringIO.new
     @stdout = StringIO.new
 
     Chef::Knife::UserEdit.load_deps
-    @knife = Chef::Knife::UserEdit.new
-    allow(@knife.ui).to receive(:stderr).and_return(@stderr)
-    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
-    @knife.name_args = [ 'my_user' ]
-    @knife.config[:disable_editing] = true
+    allow(knife.ui).to receive(:stderr).and_return(@stderr)
+    allow(knife.ui).to receive(:stdout).and_return(@stdout)
+    knife.name_args = [ 'my_user' ]
+    knife.config[:disable_editing] = true
+  end
+
+  # delete this once OSC11 support is gone
+  context "when the username field is not supported by the server" do
+    before do
+      allow(knife).to receive(:run_osc_11_user_edit).and_raise(SystemExit)
+      allow(Chef::User).to receive(:load).and_return({"username" => nil})
+    end
+
+    it "displays the osc warning" do
+      expect(knife.ui).to receive(:warn).with(knife.osc_11_warning)
+      expect{ knife.run }.to raise_error(SystemExit)
+    end
+
+    it "forwards the command to knife osc_user edit" do
+      expect(knife).to receive(:run_osc_11_user_edit)
+      expect{ knife.run }.to raise_error(SystemExit)
+    end
   end
 
   it 'loads and edits the user' do
-    data = { :name => "my_user" }
+    data = { "username" => "my_user" }
     allow(Chef::User).to receive(:load).with("my_user").and_return(data)
-    expect(@knife).to receive(:edit_data).with(data).and_return(data)
-    @knife.run
+    expect(knife).to receive(:edit_data).with(data).and_return(data)
+    knife.run
   end
 
   it 'prints usage and exits when a user name is not provided' do
-    @knife.name_args = []
-    expect(@knife).to receive(:show_usage)
-    expect(@knife.ui).to receive(:fatal)
-    expect { @knife.run }.to raise_error(SystemExit)
+    knife.name_args = []
+    expect(knife).to receive(:show_usage)
+    expect(knife.ui).to receive(:fatal)
+    expect { knife.run }.to raise_error(SystemExit)
   end
 end

data/spec/unit/knife/user_list_spec.rb

@@ -19,14 +19,18 @@
 require 'spec_helper'
 
 describe Chef::Knife::UserList do
+  let(:knife) { Chef::Knife::UserList.new }
+  let(:stdout) { StringIO.new }
+
   before(:each) do
     Chef::Knife::UserList.load_deps
-    @knife = Chef::Knife::UserList.new
+    allow(knife.ui).to receive(:stderr).and_return(stdout)
+    allow(knife.ui).to receive(:stdout).and_return(stdout)
   end
 
   it 'lists the users' do
     expect(Chef::User).to receive(:list)
-    expect(@knife).to receive(:format_list_for_display)
-    @knife.run
+    expect(knife).to receive(:format_list_for_display)
+    knife.run
   end
 end

data/spec/unit/knife/user_reregister_spec.rb

@@ -19,35 +19,56 @@
 require 'spec_helper'
 
 describe Chef::Knife::UserReregister do
-  before(:each) do
+  let(:knife) { Chef::Knife::UserReregister.new }
+  let(:user_mock) { double('user_mock', :private_key => "private_key") }
+  let(:stdout) { StringIO.new }
+
+  before do
     Chef::Knife::UserReregister.load_deps
-    @knife = Chef::Knife::UserReregister.new
-    @knife.name_args = [ 'a_user' ]
-    @user_mock = double('user_mock', :private_key => "private_key")
-    allow(Chef::User).to receive(:load).and_return(@user_mock)
-    @stdout = StringIO.new
-    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
+    knife.name_args = [ 'a_user' ]
+    allow(Chef::User).to receive(:load).and_return(user_mock)
+    allow(knife.ui).to receive(:stdout).and_return(stdout)
+    allow(knife.ui).to receive(:stderr).and_return(stdout)
+    allow(user_mock).to receive(:username).and_return('a_user')
+  end
+
+  # delete this once OSC11 support is gone
+  context "when the username field is not supported by the server" do
+    before do
+      allow(knife).to receive(:run_osc_11_user_reregister).and_raise(SystemExit)
+      allow(user_mock).to receive(:username).and_return(nil)
+    end
+
+    it "displays the osc warning" do
+      expect(knife.ui).to receive(:warn).with(knife.osc_11_warning)
+      expect{ knife.run }.to raise_error(SystemExit)
+    end
+
+    it "forwards the command to knife osc_user edit" do
+      expect(knife).to receive(:run_osc_11_user_reregister)
+      expect{ knife.run }.to raise_error(SystemExit)
+    end
   end
 
   it 'prints usage and exits when a user name is not provided' do
-    @knife.name_args = []
-    expect(@knife).to receive(:show_usage)
-    expect(@knife.ui).to receive(:fatal)
-    expect { @knife.run }.to raise_error(SystemExit)
+    knife.name_args = []
+    expect(knife).to receive(:show_usage)
+    expect(knife.ui).to receive(:fatal)
+    expect { knife.run }.to raise_error(SystemExit)
   end
 
   it 'reregisters the user and prints the key' do
-    expect(@user_mock).to receive(:reregister).and_return(@user_mock)
-    @knife.run
-    expect(@stdout.string).to match( /private_key/ )
+    expect(user_mock).to receive(:reregister).and_return(user_mock)
+    knife.run
+    expect(stdout.string).to match( /private_key/ )
   end
 
   it 'writes the private key to a file when --file is specified' do
-    expect(@user_mock).to receive(:reregister).and_return(@user_mock)
-    @knife.config[:file] = '/tmp/a_file'
+    expect(user_mock).to receive(:reregister).and_return(user_mock)
+    knife.config[:file] = '/tmp/a_file'
     filehandle = StringIO.new
     expect(File).to receive(:open).with('/tmp/a_file', 'w').and_yield(filehandle)
-    @knife.run
+    knife.run
     expect(filehandle.string).to eq("private_key")
   end
 end

data/spec/unit/knife/user_show_spec.rb

@@ -19,23 +19,47 @@
 require 'spec_helper'
 
 describe Chef::Knife::UserShow do
-  before(:each) do
+  let(:knife) { Chef::Knife::UserShow.new }
+  let(:user_mock) { double('user_mock') }
+  let(:stdout) { StringIO.new }
+
+  before do
     Chef::Knife::UserShow.load_deps
-    @knife = Chef::Knife::UserShow.new
-    @knife.name_args = [ 'my_user' ]
-    @user_mock = double('user_mock')
+    knife.name_args = [ 'my_user' ]
+    allow(user_mock).to receive(:username).and_return('my_user')
+    allow(knife.ui).to receive(:stderr).and_return(stdout)
+    allow(knife.ui).to receive(:stdout).and_return(stdout)
+  end
+
+  # delete this once OSC11 support is gone
+  context "when the username field is not supported by the server" do
+    before do
+      allow(knife).to receive(:run_osc_11_user_show).and_raise(SystemExit)
+      allow(Chef::User).to receive(:load).with('my_user').and_return(user_mock)
+      allow(user_mock).to receive(:username).and_return(nil)
+    end
+
+    it "displays the osc warning" do
+      expect(knife.ui).to receive(:warn).with(knife.osc_11_warning)
+      expect{ knife.run }.to raise_error(SystemExit)
+    end
+
+    it "forwards the command to knife osc_user edit" do
+      expect(knife).to receive(:run_osc_11_user_show)
+      expect{ knife.run }.to raise_error(SystemExit)
+    end
   end
 
   it 'loads and displays the user' do
-    expect(Chef::User).to receive(:load).with('my_user').and_return(@user_mock)
-    expect(@knife).to receive(:format_for_display).with(@user_mock)
-    @knife.run
+    expect(Chef::User).to receive(:load).with('my_user').and_return(user_mock)
+    expect(knife).to receive(:format_for_display).with(user_mock)
+    knife.run
   end
 
   it 'prints usage and exits when a user name is not provided' do
-    @knife.name_args = []
-    expect(@knife).to receive(:show_usage)
-    expect(@knife.ui).to receive(:fatal)
-    expect { @knife.run }.to raise_error(SystemExit)
+    knife.name_args = []
+    expect(knife).to receive(:show_usage)
+    expect(knife.ui).to receive(:fatal)
+    expect { knife.run }.to raise_error(SystemExit)
   end
 end

data/spec/unit/knife_spec.rb

@@ -140,7 +140,7 @@ describe Chef::Knife do
                     'X-Chef-Version' => Chef::VERSION,
                     "Host"=>"api.opscode.piab",
                     "X-REMOTE-REQUEST-ID"=>request_id,
-                    'X-Ops-Server-API-Version' => Chef::HTTP::Authenticator::SERVER_API_VERSION}}
+                    'X-Ops-Server-API-Version' => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION}}
 
     let(:request_id) {"1234"}
 
@@ -399,11 +399,17 @@ describe Chef::Knife do
     it "formats 406s (non-supported API version error) nicely" do
       response = Net::HTTPNotAcceptable.new("1.1", "406", "Not Acceptable")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "sad trombone", :min_version => "0", :max_version => "1"))
+
+      # set the header
+      response["x-ops-server-api-version"] = Chef::JSONCompat.to_json(:min_version => "0", :max_version => "1", :request_version => "10000000")
+
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "sad trombone"))
       allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("406 Not Acceptable", response))
+
       knife.run_with_pretty_exceptions
-      expect(stderr.string).to include('The version of Chef that Knife is using is not supported by the Chef server you sent this request to')
-      expect(stderr.string).to include("This version of Chef requires a server API version of #{Chef::HTTP::Authenticator::SERVER_API_VERSION}")
+      expect(stderr.string).to include('The request that Knife sent was using API version 10000000')
+      expect(stderr.string).to include('The Chef server you sent the request to supports a min API verson of 0 and a max API version of 1')
+      expect(stderr.string).to include('Please either update your Chef client or server to be a compatible set')
     end
 
     it "formats 500s nicely" do

data/spec/unit/lwrp_spec.rb

@@ -38,7 +38,7 @@ describe "LWRP" do
   end
 
   def get_lwrp(name)
-    Chef::Resource.resource_for_node(name, Chef::Node.new)
+    Chef::ResourceResolver.resolve(name)
   end
 
   def get_lwrp_provider(name)
@@ -122,6 +122,23 @@ describe "LWRP" do
 
   end
 
+  context "When an LWRP resource in cookbook l-w-r-p is loaded" do
+    before do
+      @tmpdir = Dir.mktmpdir("lwrp_test")
+      resource_path = File.join(@tmpdir, "foo.rb")
+      IO.write(resource_path, "default_action :create")
+      provider_path = File.join(@tmpdir, "foo.rb")
+      IO.write(provider_path, <<-EOM)
+        action :create do
+          raise "hi"
+        end
+      EOM
+    end
+
+    it "Can find the resource at l_w_r_p_foo" do
+    end
+  end
+
   context "When an LWRP resource lwrp_foo is loaded" do
     before do
       @tmpdir = Dir.mktmpdir("lwrp_test")
@@ -129,7 +146,7 @@ describe "LWRP" do
       content = IO.read(File.expand_path("../../data/lwrp/resources/foo.rb", __FILE__))
       IO.write(@lwrp_path, content)
       Chef::Resource::LWRPBase.build_from_file("lwrp", @lwrp_path, nil)
-      @original_resource = Chef::Resource.resource_for_node(:lwrp_foo, Chef::Node.new)
+      @original_resource = Chef::ResourceResolver.resolve(:lwrp_foo)
     end
 
     after do
@@ -144,9 +161,9 @@ describe "LWRP" do
       end
 
       it "Should load the old content, and not the new" do
-        resource = Chef::Resource.resource_for_node(:lwrp_foo, Chef::Node.new)
+        resource = Chef::ResourceResolver.resolve(:lwrp_foo)
         expect(resource).to eq @original_resource
-        expect(resource.default_action).to eq([:pass_buck])
+        expect(resource.default_action).to eq(:pass_buck)
         expect(Chef.method_defined?(:method_created_by_override_lwrp_foo)).to be_falsey
       end
     end
@@ -160,8 +177,8 @@ describe "LWRP" do
       end
     end
 
-    it "should load the resource into a properly-named class and emit a warning about deprecation when accessing it" do
-      expect { Chef::Resource::LwrpFoo }.to raise_error(Chef::Exceptions::DeprecatedFeatureError)
+    it "should load the resource into a properly-named class and emit a warning when it is initialized" do
+      expect { Chef::Resource::LwrpFoo.new('hi') }.to raise_error(Chef::Exceptions::DeprecatedFeatureError)
     end
 
     it "should be resolvable with Chef::ResourceResolver.resolve(:lwrp_foo)" do
@@ -185,7 +202,7 @@ describe "LWRP" do
     end
 
     it "should set the specified action as the default action" do
-      expect(get_lwrp(:lwrp_foo).new("blah").action).to eq([:pass_buck])
+      expect(get_lwrp(:lwrp_foo).new("blah").action).to eq(:pass_buck)
     end
 
     it "should create a method for each attribute" do
@@ -211,6 +228,127 @@ describe "LWRP" do
       expect(cls.node[:penguin_name]).to eql("jackass")
     end
 
+    context "resource class created" do
+      before do
+        @old_treat_deprecation_warnings_as_errors = Chef::Config[:treat_deprecation_warnings_as_errors]
+        Chef::Config[:treat_deprecation_warnings_as_errors] = false
+      end
+      after do
+        Chef::Config[:treat_deprecation_warnings_as_errors] = @old_treat_deprecation_warnings_as_errors
+      end
+
+      it "should load the resource into a properly-named class" do
+        expect(Chef::Resource::LwrpFoo).to be_kind_of(Class)
+        expect(Chef::Resource::LwrpFoo <= Chef::Resource::LWRPBase).to be_truthy
+      end
+
+      it "get_lwrp(:lwrp_foo).new is a Chef::Resource::LwrpFoo" do
+        lwrp = get_lwrp(:lwrp_foo).new('hi')
+        expect(lwrp.kind_of?(Chef::Resource::LwrpFoo)).to be_truthy
+        expect(lwrp.is_a?(Chef::Resource::LwrpFoo)).to be_truthy
+        expect(get_lwrp(:lwrp_foo) === lwrp).to be_truthy
+        expect(Chef::Resource::LwrpFoo === lwrp).to be_truthy
+      end
+
+      it "Chef::Resource::LwrpFoo.new is a get_lwrp(:lwrp_foo)" do
+        lwrp = Chef::Resource::LwrpFoo.new('hi')
+        expect(lwrp.kind_of?(get_lwrp(:lwrp_foo))).to be_truthy
+        expect(lwrp.is_a?(get_lwrp(:lwrp_foo))).to be_truthy
+        expect(get_lwrp(:lwrp_foo) === lwrp).to be_truthy
+        expect(Chef::Resource::LwrpFoo === lwrp).to be_truthy
+      end
+
+      it "works even if LwrpFoo exists in the top level" do
+        module ::LwrpFoo
+        end
+        expect(Chef::Resource::LwrpFoo).not_to eq(::LwrpFoo)
+      end
+
+      context "with a subclass of get_lwrp(:lwrp_foo)" do
+        let(:subclass) do
+          Class.new(get_lwrp(:lwrp_foo))
+        end
+
+        it "subclass.new is a subclass" do
+          lwrp = subclass.new('hi')
+          expect(lwrp.kind_of?(subclass)).to be_truthy
+          expect(lwrp.is_a?(subclass)).to be_truthy
+          expect(subclass === lwrp).to be_truthy
+          expect(lwrp.class === subclass)
+        end
+        it "subclass.new is a Chef::Resource::LwrpFoo" do
+          lwrp = subclass.new('hi')
+          expect(lwrp.kind_of?(Chef::Resource::LwrpFoo)).to be_truthy
+          expect(lwrp.is_a?(Chef::Resource::LwrpFoo)).to be_truthy
+          expect(Chef::Resource::LwrpFoo === lwrp).to be_truthy
+          expect(lwrp.class === Chef::Resource::LwrpFoo)
+        end
+        it "subclass.new is a get_lwrp(:lwrp_foo)" do
+          lwrp = subclass.new('hi')
+          expect(lwrp.kind_of?(get_lwrp(:lwrp_foo))).to be_truthy
+          expect(lwrp.is_a?(get_lwrp(:lwrp_foo))).to be_truthy
+          expect(get_lwrp(:lwrp_foo) === lwrp).to be_truthy
+          expect(lwrp.class === get_lwrp(:lwrp_foo))
+        end
+        it "Chef::Resource::LwrpFoo.new is *not* a subclass" do
+          lwrp = Chef::Resource::LwrpFoo.new('hi')
+          expect(lwrp.kind_of?(subclass)).to be_falsey
+          expect(lwrp.is_a?(subclass)).to be_falsey
+          expect(subclass === lwrp.class).to be_falsey
+          expect(subclass === Chef::Resource::LwrpFoo).to be_falsey
+        end
+        it "get_lwrp(:lwrp_foo).new is *not* a subclass" do
+          lwrp = get_lwrp(:lwrp_foo).new('hi')
+          expect(lwrp.kind_of?(subclass)).to be_falsey
+          expect(lwrp.is_a?(subclass)).to be_falsey
+          expect(subclass === lwrp.class).to be_falsey
+          expect(subclass === get_lwrp(:lwrp_foo)).to be_falsey
+        end
+      end
+
+      context "with a subclass of Chef::Resource::LwrpFoo" do
+        let(:subclass) do
+          Class.new(Chef::Resource::LwrpFoo)
+        end
+
+        it "subclass.new is a subclass" do
+          lwrp = subclass.new('hi')
+          expect(lwrp.kind_of?(subclass)).to be_truthy
+          expect(lwrp.is_a?(subclass)).to be_truthy
+          expect(subclass === lwrp).to be_truthy
+          expect(lwrp.class === subclass)
+        end
+        it "subclass.new is a Chef::Resource::LwrpFoo" do
+          lwrp = subclass.new('hi')
+          expect(lwrp.kind_of?(Chef::Resource::LwrpFoo)).to be_truthy
+          expect(lwrp.is_a?(Chef::Resource::LwrpFoo)).to be_truthy
+          expect(Chef::Resource::LwrpFoo === lwrp).to be_truthy
+          expect(lwrp.class === Chef::Resource::LwrpFoo)
+        end
+        it "subclass.new is a get_lwrp(:lwrp_foo)" do
+          lwrp = subclass.new('hi')
+          expect(lwrp.kind_of?(get_lwrp(:lwrp_foo))).to be_truthy
+          expect(lwrp.is_a?(get_lwrp(:lwrp_foo))).to be_truthy
+          expect(get_lwrp(:lwrp_foo) === lwrp).to be_truthy
+          expect(lwrp.class === get_lwrp(:lwrp_foo))
+        end
+        it "Chef::Resource::LwrpFoo.new is *not* a subclass" do
+          lwrp = Chef::Resource::LwrpFoo.new('hi')
+          expect(lwrp.kind_of?(subclass)).to be_falsey
+          expect(lwrp.is_a?(subclass)).to be_falsey
+          expect(subclass === lwrp.class).to be_falsey
+          expect(subclass === Chef::Resource::LwrpFoo).to be_falsey
+        end
+        it "get_lwrp(:lwrp_foo).new is *not* a subclass" do
+          lwrp = get_lwrp(:lwrp_foo).new('hi')
+          expect(lwrp.kind_of?(subclass)).to be_falsey
+          expect(lwrp.is_a?(subclass)).to be_falsey
+          expect(subclass === lwrp.class).to be_falsey
+          expect(subclass === get_lwrp(:lwrp_foo)).to be_falsey
+        end
+      end
+    end
+
     context "resource_name" do
       let(:klass) { Class.new(Chef::Resource::LWRPBase) }
 
@@ -229,14 +367,6 @@ describe "LWRP" do
         expect(klass.resource_name).to eq(:foo)
       end
 
-      context "when creating a new instance" do
-        it "raises an exception if resource_name is nil" do
-          expect {
-            klass.new('blah')
-          }.to raise_error(Chef::Exceptions::InvalidResourceSpecification)
-        end
-      end
-
       context "lazy default values" do
         let(:klass) do
           Class.new(Chef::Resource::LWRPBase) do
@@ -289,7 +419,7 @@ describe "LWRP" do
         end
 
         it "delegates #default_action to the parent" do
-          expect(child.default_action).to eq([:eat])
+          expect(child.default_action).to eq(:eat)
         end
       end
 
@@ -306,7 +436,7 @@ describe "LWRP" do
         end
 
         it "does not delegate #default_action to the parent" do
-          expect(child.default_action).to eq([:dont_eat])
+          expect(child.default_action).to eq(:dont_eat)
         end
       end
 
@@ -335,27 +465,38 @@ describe "LWRP" do
   end
 
   describe "Lightweight Chef::Provider" do
+
+    let(:node) do
+      Chef::Node.new.tap do |n|
+        n.automatic[:platform] = :ubuntu
+        n.automatic[:platform_version] = '8.10'
+      end
+    end
+
+    let(:events) { Chef::EventDispatch::Dispatcher.new }
+
+    let(:run_context) { Chef::RunContext.new(node, Chef::CookbookCollection.new({}), events) }
+
+    let(:runner) { Chef::Runner.new(run_context) }
+
+    let(:lwrp_cookbok_name) { "lwrp" }
+
     before do
-      @node = Chef::Node.new
-      @node.automatic[:platform] = :ubuntu
-      @node.automatic[:platform_version] = '8.10'
-      @events = Chef::EventDispatch::Dispatcher.new
-      @run_context = Chef::RunContext.new(@node, Chef::CookbookCollection.new({}), @events)
-      @runner = Chef::Runner.new(@run_context)
+      Chef::Provider::LWRPBase.class_eval { @loaded_lwrps = {} }
     end
 
     before(:each) do
       Dir[File.expand_path(File.expand_path("../../data/lwrp/resources/*", __FILE__))].each do |file|
-        Chef::Resource::LWRPBase.build_from_file("lwrp", file, @run_context)
+        Chef::Resource::LWRPBase.build_from_file(lwrp_cookbok_name, file, run_context)
       end
 
       Dir[File.expand_path(File.expand_path("../../data/lwrp/providers/*", __FILE__))].each do |file|
-        Chef::Provider::LWRPBase.build_from_file("lwrp", file, @run_context)
+        Chef::Provider::LWRPBase.build_from_file(lwrp_cookbok_name, file, run_context)
       end
     end
 
     it "should properly handle a new_resource reference" do
-      resource = get_lwrp(:lwrp_foo).new("morpheus", @run_context)
+      resource = get_lwrp(:lwrp_foo).new("morpheus", run_context)
       resource.monkey("bob")
       resource.provider(get_lwrp_provider(:lwrp_monkey_name_printer))
 
@@ -363,11 +504,12 @@ describe "LWRP" do
       provider.action_twiddle_thumbs
     end
 
-    context "resource class created" do
+    context "provider class created" do
       before do
         @old_treat_deprecation_warnings_as_errors = Chef::Config[:treat_deprecation_warnings_as_errors]
         Chef::Config[:treat_deprecation_warnings_as_errors] = false
       end
+
       after do
         Chef::Config[:treat_deprecation_warnings_as_errors] = @old_treat_deprecation_warnings_as_errors
       end
@@ -381,54 +523,86 @@ describe "LWRP" do
         expect(get_lwrp_provider(:lwrp_buck_passer).instance_methods).to include(:action_pass_buck)
         expect(get_lwrp_provider(:lwrp_thumb_twiddler).instance_methods).to include(:action_twiddle_thumbs)
       end
+
+      it "sets itself as a provider for a resource of the same name" do
+        found_providers = Chef::Platform::ProviderPriorityMap.instance.list_handlers(node, :lwrp_buck_passer)
+        # we bypass the per-file loading to get the file to load each time,
+        # which creates the LWRP class repeatedly. New things get prepended to
+        # the list of providers.
+        expect(found_providers.first).to eq(get_lwrp_provider(:lwrp_buck_passer))
+      end
+
+      context "with a cookbook with an underscore in the name" do
+
+        let(:lwrp_cookbok_name) { "l_w_r_p" }
+
+        it "sets itself as a provider for a resource of the same name" do
+          found_providers = Chef::Platform::ProviderPriorityMap.instance.list_handlers(node, :l_w_r_p_buck_passer)
+          expect(found_providers.size).to eq(1)
+          expect(found_providers.last).to eq(get_lwrp_provider(:l_w_r_p_buck_passer))
+        end
+      end
+
+      context "with a cookbook with a hypen in the name" do
+
+        let(:lwrp_cookbok_name) { "l-w-r-p" }
+
+        it "sets itself as a provider for a resource of the same name" do
+          incorrect_providers = Chef::Platform::ProviderPriorityMap.instance.list_handlers(node, :'l-w-r-p_buck_passer')
+          expect(incorrect_providers).to eq([])
+
+          found_providers = Chef::Platform::ProviderPriorityMap.instance.list_handlers(node, :l_w_r_p_buck_passer)
+          expect(found_providers.first).to eq(get_lwrp_provider(:l_w_r_p_buck_passer))
+        end
+      end
     end
 
     it "should insert resources embedded in the provider into the middle of the resource collection" do
-      injector = get_lwrp(:lwrp_foo).new("morpheus", @run_context)
+      injector = get_lwrp(:lwrp_foo).new("morpheus", run_context)
       injector.action(:pass_buck)
       injector.provider(get_lwrp_provider(:lwrp_buck_passer))
-      dummy = Chef::Resource::ZenMaster.new("keanu reeves", @run_context)
+      dummy = Chef::Resource::ZenMaster.new("keanu reeves", run_context)
       dummy.provider(Chef::Provider::Easy)
-      @run_context.resource_collection.insert(injector)
-      @run_context.resource_collection.insert(dummy)
+      run_context.resource_collection.insert(injector)
+      run_context.resource_collection.insert(dummy)
 
-      Chef::Runner.new(@run_context).converge
+      Chef::Runner.new(run_context).converge
 
-      expect(@run_context.resource_collection[0]).to eql(injector)
-      expect(@run_context.resource_collection[1].name).to eql('prepared_thumbs')
-      expect(@run_context.resource_collection[2].name).to eql('twiddled_thumbs')
-      expect(@run_context.resource_collection[3]).to eql(dummy)
+      expect(run_context.resource_collection[0]).to eql(injector)
+      expect(run_context.resource_collection[1].name).to eql('prepared_thumbs')
+      expect(run_context.resource_collection[2].name).to eql('twiddled_thumbs')
+      expect(run_context.resource_collection[3]).to eql(dummy)
     end
 
     it "should insert embedded resources from multiple providers, including from the last position, properly into the resource collection" do
-      injector = get_lwrp(:lwrp_foo).new("morpheus", @run_context)
+      injector = get_lwrp(:lwrp_foo).new("morpheus", run_context)
       injector.action(:pass_buck)
       injector.provider(get_lwrp_provider(:lwrp_buck_passer))
 
-      injector2 = get_lwrp(:lwrp_bar).new("tank", @run_context)
+      injector2 = get_lwrp(:lwrp_bar).new("tank", run_context)
       injector2.action(:pass_buck)
       injector2.provider(get_lwrp_provider(:lwrp_buck_passer_2))
 
-      dummy = Chef::Resource::ZenMaster.new("keanu reeves", @run_context)
+      dummy = Chef::Resource::ZenMaster.new("keanu reeves", run_context)
       dummy.provider(Chef::Provider::Easy)
 
-      @run_context.resource_collection.insert(injector)
-      @run_context.resource_collection.insert(dummy)
-      @run_context.resource_collection.insert(injector2)
+      run_context.resource_collection.insert(injector)
+      run_context.resource_collection.insert(dummy)
+      run_context.resource_collection.insert(injector2)
 
-      Chef::Runner.new(@run_context).converge
+      Chef::Runner.new(run_context).converge
 
-      expect(@run_context.resource_collection[0]).to eql(injector)
-      expect(@run_context.resource_collection[1].name).to eql('prepared_thumbs')
-      expect(@run_context.resource_collection[2].name).to eql('twiddled_thumbs')
-      expect(@run_context.resource_collection[3]).to eql(dummy)
-      expect(@run_context.resource_collection[4]).to eql(injector2)
-      expect(@run_context.resource_collection[5].name).to eql('prepared_eyes')
-      expect(@run_context.resource_collection[6].name).to eql('dried_paint_watched')
+      expect(run_context.resource_collection[0]).to eql(injector)
+      expect(run_context.resource_collection[1].name).to eql('prepared_thumbs')
+      expect(run_context.resource_collection[2].name).to eql('twiddled_thumbs')
+      expect(run_context.resource_collection[3]).to eql(dummy)
+      expect(run_context.resource_collection[4]).to eql(injector2)
+      expect(run_context.resource_collection[5].name).to eql('prepared_eyes')
+      expect(run_context.resource_collection[6].name).to eql('dried_paint_watched')
     end
 
     it "should properly handle a new_resource reference" do
-      resource = get_lwrp(:lwrp_foo).new("morpheus", @run_context)
+      resource = get_lwrp(:lwrp_foo).new("morpheus", run_context)
       resource.monkey("bob")
       resource.provider(get_lwrp_provider(:lwrp_monkey_name_printer))
 
@@ -439,7 +613,7 @@ describe "LWRP" do
     end
 
     it "should properly handle an embedded Resource accessing the enclosing Provider's scope" do
-      resource = get_lwrp(:lwrp_foo).new("morpheus", @run_context)
+      resource = get_lwrp(:lwrp_foo).new("morpheus", run_context)
       resource.monkey("bob")
       resource.provider(get_lwrp_provider(:lwrp_embedded_resource_accesses_providers_scope))
 
@@ -458,7 +632,7 @@ describe "LWRP" do
         # Side effect of lwrp_inline_compiler provider for testing notifications.
         $interior_ruby_block_2 = nil
         # resource type doesn't matter, so make an existing resource type work with provider.
-        @resource = get_lwrp(:lwrp_foo).new("morpheus", @run_context)
+        @resource = get_lwrp(:lwrp_foo).new("morpheus", run_context)
         @resource.allowed_actions << :test
         @resource.action(:test)
         @resource.provider(get_lwrp_provider(:lwrp_inline_compiler))
@@ -466,7 +640,7 @@ describe "LWRP" do
 
       it "does not add interior resources to the exterior resource collection" do
         @resource.run_action(:test)
-        expect(@run_context.resource_collection).to be_empty
+        expect(run_context.resource_collection).to be_empty
       end
 
       context "when interior resources are updated" do