cheffish 1.1.2 → 1.2

data/spec/integration/chef_organization_spec.rb

@@ -12,10 +12,9 @@ describe Chef::Resource::ChefOrganization do
       user 'u2', {}
 
       it 'chef_organization "x" creates the organization' do
-        run_recipe do
+        expect_recipe {
           chef_organization 'x'
-        end
-        expect(chef_run).to have_updated('chef_organization[x]', :create)
+        }.to have_updated('chef_organization[x]', :create)
         expect(get('/organizations/x')['full_name']).to eq('x')
       end
     end
@@ -32,40 +31,36 @@ describe Chef::Resource::ChefOrganization do
         user 'u2', {}
 
         it 'chef_organization "x" creates the organization' do
-          run_recipe do
+          expect_recipe {
             chef_organization 'x'
-          end
-          expect(chef_run).to have_updated('chef_organization[x]', :create)
+          }.to have_updated('chef_organization[x]', :create)
           expect(get('/organizations/x')['full_name']).to eq('x')
         end
 
         it 'chef_organization "x" with full_name creates the organization' do
-          run_recipe do
+          expect_recipe {
             chef_organization 'x' do
               full_name 'Hi'
             end
-          end
-          expect(chef_run).to have_updated('chef_organization[x]', :create)
+          }.to have_updated('chef_organization[x]', :create)
           expect(get('/organizations/x')['full_name']).to eq('Hi')
         end
 
         it 'chef_organization "x" and inviting users creates the invites' do
-          run_recipe do
+          expect_recipe {
             chef_organization 'x' do
               invites 'u', 'u2'
             end
-          end
-          expect(chef_run).to have_updated('chef_organization[x]', :create)
+          }.to have_updated('chef_organization[x]', :create)
           expect(get('/organizations/x/association_requests').map { |u| u['username'] }).to eq(%w(u u2))
         end
 
         it 'chef_organization "x" adds members' do
-          run_recipe do
+          expect_recipe {
             chef_organization 'x' do
               members 'u', 'u2'
             end
-          end
-          expect(chef_run).to have_updated('chef_organization[x]', :create)
+          }.to have_updated('chef_organization[x]', :create)
           expect(get('/organizations/x/users').map { |u| u['user']['username'] }).to eq(%w(u u2))
         end
       end
@@ -84,156 +79,142 @@ describe Chef::Resource::ChefOrganization do
         end
 
         it 'chef_organization "x" changes nothing' do
-          run_recipe do
+          expect_recipe {
             chef_organization 'x'
-          end
-          expect(chef_run).not_to have_updated('chef_organization[x]', :create)
+          }.not_to have_updated('chef_organization[x]', :create)
           expect(get('/organizations/x')['full_name']).to eq('Lo')
         end
 
         it 'chef_organization "x" with "complete true" reverts the full_name' do
-          run_recipe do
+          expect_recipe {
             chef_organization 'x' do
               complete true
             end
-          end
-          expect(chef_run).to have_updated('chef_organization[x]', :create)
+          }.to have_updated('chef_organization[x]', :create)
           expect(get('/organizations/x')['full_name']).to eq('x')
         end
 
         it 'chef_organization "x" with new full_name updates the organization' do
-          run_recipe do
+          expect_recipe {
             chef_organization 'x' do
               full_name 'Hi'
             end
-          end
-          expect(chef_run).to have_updated('chef_organization[x]', :create)
+          }.to have_updated('chef_organization[x]', :create)
           expect(get('/organizations/x')['full_name']).to eq('Hi')
         end
 
         context 'invites and membership tests' do
           it 'chef_organization "x" and inviting users creates the invites' do
-            run_recipe do
+            expect_recipe {
               chef_organization 'x' do
                 invites 'u', 'u2'
               end
-            end
-            expect(chef_run).to have_updated('chef_organization[x]', :create)
+            }.to have_updated('chef_organization[x]', :create)
             expect(get('/organizations/x/association_requests').map { |u| u['username'] }).to eq(%w(invited invited2 u u2))
           end
 
           it 'chef_organization "x" adds members' do
-            run_recipe do
+            expect_recipe {
               chef_organization 'x' do
                 members 'u', 'u2'
               end
-            end
-            expect(chef_run).to have_updated('chef_organization[x]', :create)
+            }.to have_updated('chef_organization[x]', :create)
             expect(get('/organizations/x/users').map { |u| u['user']['username'] }).to eq(%w(member member2 u u2))
           end
 
           it 'chef_organization "x" does nothing when inviting already-invited users and members' do
-            run_recipe do
+            expect_recipe {
               chef_organization 'x' do
                 invites 'invited', 'member'
               end
-            end
-            expect(chef_run).not_to have_updated('chef_organization[x]', :create)
+            }.not_to have_updated('chef_organization[x]', :create)
             expect(get('/organizations/x/association_requests').map { |u| u['username'] }).to eq(%w(invited invited2))
             expect(get('/organizations/x/users').map { |u| u['user']['username'] }).to eq(%w(member member2))
           end
 
           it 'chef_organization "x" does nothing when adding members who are already members' do
-            run_recipe do
+            expect_recipe {
               chef_organization 'x' do
                 members 'member'
               end
-            end
-            expect(chef_run).not_to have_updated('chef_organization[x]', :create)
+            }.not_to have_updated('chef_organization[x]', :create)
             expect(get('/organizations/x/association_requests').map { |u| u['username'] }).to eq(%w(invited invited2))
             expect(get('/organizations/x/users').map { |u| u['user']['username'] }).to eq(%w(member member2))
           end
 
           it 'chef_organization "x" upgrades invites to members when asked' do
-            run_recipe do
+            expect_recipe {
               chef_organization 'x' do
                 members 'invited'
               end
-            end
-            expect(chef_run).to have_updated('chef_organization[x]', :create)
+            }.to have_updated('chef_organization[x]', :create)
             expect(get('/organizations/x/users').map { |u| u['user']['username'] }).to eq(%w(invited member member2))
             expect(get('/organizations/x/association_requests').map { |u| u['username'] }).to eq(%w(invited2))
           end
 
           it 'chef_organization "x" removes members and invites when asked' do
-            run_recipe do
+            expect_recipe {
               chef_organization 'x' do
                 remove_members 'invited', 'member'
               end
-            end
-            expect(chef_run).to have_updated('chef_organization[x]', :create)
+            }.to have_updated('chef_organization[x]', :create)
             expect(get('/organizations/x/association_requests').map { |u| u['username'] }).to eq(%w(invited2))
             expect(get('/organizations/x/users').map { |u| u['user']['username'] }).to eq(%w(member2))
           end
 
           it 'chef_organization "x" does nothing when asked to remove non-members' do
-            run_recipe do
+            expect_recipe {
               chef_organization 'x' do
                 remove_members 'u', 'u2'
               end
-            end
-            expect(chef_run).not_to have_updated('chef_organization[x]', :create)
+            }.not_to have_updated('chef_organization[x]', :create)
             expect(get('/organizations/x/association_requests').map { |u| u['username'] }).to eq(%w(invited invited2))
             expect(get('/organizations/x/users').map { |u| u['user']['username'] }).to eq(%w(member member2))
           end
 
           it 'chef_organization "x" with "complete true" reverts the full_name but does not remove invites or members' do
-            run_recipe do
+            expect_recipe {
               chef_organization 'x' do
                 complete true
               end
-            end
-            expect(chef_run).to have_updated('chef_organization[x]', :create)
+            }.to have_updated('chef_organization[x]', :create)
             expect(get('/organizations/x')['full_name']).to eq('x')
             expect(get('/organizations/x/association_requests').map { |u| u['username'] }).to eq(%w(invited invited2))
             expect(get('/organizations/x/users').map { |u| u['user']['username'] }).to eq(%w(member member2))
           end
 
           it 'chef_organization "x" with members [] and "complete true" removes invites and members' do
-            run_recipe do
+            expect_recipe {
               chef_organization 'x' do
                 members []
                 complete true
               end
-            end
-            expect(chef_run).to have_updated('chef_organization[x]', :create)
+            }.to have_updated('chef_organization[x]', :create)
             expect(get('/organizations/x')['full_name']).to eq('x')
             expect(get('/organizations/x/association_requests').map { |u| u['username'] }).to eq([])
             expect(get('/organizations/x/users').map { |u| u['user']['username'] }).to eq([])
           end
 
           it 'chef_organization "x" with members [] and "complete true" removes invites but not members' do
-            run_recipe do
+            expect_recipe {
               chef_organization 'x' do
                 invites []
                 complete true
               end
-            end
-            expect(chef_run).to have_updated('chef_organization[x]', :create)
+            }.to have_updated('chef_organization[x]', :create)
             expect(get('/organizations/x')['full_name']).to eq('x')
             expect(get('/organizations/x/association_requests').map { |u| u['username'] }).to eq([])
             expect(get('/organizations/x/users').map { |u| u['user']['username'] }).to eq(%w(member member2))
           end
 
           it 'chef_organization "x" with invites, members and "complete true" removes all non-specified invites and members' do
-            run_recipe do
+            expect_recipe {
               chef_organization 'x' do
                 invites 'invited', 'u'
                 members 'member', 'u2'
                 complete true
               end
-            end
-            expect(chef_run).to have_updated('chef_organization[x]', :create)
+            }.to have_updated('chef_organization[x]', :create)
             expect(get('/organizations/x')['full_name']).to eq('x')
             expect(get('/organizations/x/association_requests').map { |u| u['username'] }).to eq(%w(invited u))
             expect(get('/organizations/x/users').map { |u| u['user']['username'] }).to eq(%w(member u2))

data/spec/integration/chef_user_spec.rb

@@ -9,20 +9,18 @@ repo_path = Dir.mktmpdir('chef_repo')
 describe Chef::Resource::ChefUser do
   extend Cheffish::RSpec::ChefRunSupport
 
-  with_recipe do
+  with_converge do
     private_key "#{repo_path}/blah.pem"
   end
 
   when_the_chef_server 'is empty' do
     context 'and we run a recipe that creates user "blah"'do
-      with_converge do
-        chef_user 'blah' do
-          source_key_path "#{repo_path}/blah.pem"
-        end
-      end
-
       it 'the user gets created' do
-        expect(chef_run).to have_updated 'chef_user[blah]', :create
+        expect_recipe {
+          chef_user 'blah' do
+            source_key_path "#{repo_path}/blah.pem"
+          end
+        }.to have_updated 'chef_user[blah]', :create
         user = get('/users/blah')
         expect(user['name']).to eq('blah')
         key, format = Cheffish::KeyFormatter.decode(user['public_key'])
@@ -48,14 +46,12 @@ describe Chef::Resource::ChefUser do
   when_the_chef_12_server 'is in multi-org mode' do
     context 'and chef_server_url is pointed at the top level' do
       context 'and we run a recipe that creates user "blah"'do
-        with_converge do
-          chef_user 'blah' do
-            source_key_path "#{repo_path}/blah.pem"
-          end
-        end
-
         it 'the user gets created' do
-          expect(chef_run).to have_updated 'chef_user[blah]', :create
+          expect_recipe {
+            chef_user 'blah' do
+              source_key_path "#{repo_path}/blah.pem"
+            end
+          }.to have_updated 'chef_user[blah]', :create
           user = get('/users/blah')
           expect(user['name']).to eq('blah')
           key, format = Cheffish::KeyFormatter.decode(user['public_key'])
@@ -72,14 +68,12 @@ describe Chef::Resource::ChefUser do
       end
 
       context 'and we run a recipe that creates user "blah"'do
-        with_converge do
-          chef_user 'blah' do
-            source_key_path "#{repo_path}/blah.pem"
-          end
-        end
-
         it 'the user gets created' do
-          expect(chef_run).to have_updated 'chef_user[blah]', :create
+          expect_recipe {
+            chef_user 'blah' do
+              source_key_path "#{repo_path}/blah.pem"
+            end
+          }.to have_updated 'chef_user[blah]', :create
           user = get('/users/blah')
           expect(user['name']).to eq('blah')
           key, format = Cheffish::KeyFormatter.decode(user['public_key'])

data/spec/integration/private_key_spec.rb

@@ -17,12 +17,10 @@ describe Chef::Resource::PrivateKey do
   end
 
   context 'with a recipe with a private_key' do
-    with_recipe do
-      private_key "#{repo_path}/blah"
-    end
-
     it 'the private_key is created in pem format' do
-      expect(chef_run).to have_updated "private_key[#{repo_path}/blah]", :create
+      expect_recipe {
+        private_key "#{repo_path}/blah"
+      }.to have_updated "private_key[#{repo_path}/blah]", :create
       expect(IO.read("#{repo_path}/blah")).to start_with('-----BEGIN')
       expect(OpenSSL::PKey.read(IO.read("#{repo_path}/blah"))).to be_kind_of(OpenSSL::PKey::RSA)
     end
@@ -34,12 +32,10 @@ describe Chef::Resource::PrivateKey do
       Chef::Config.private_key_paths = [ repo_path, "#{repo_path}/other_keys" ]
     end
 
-    with_recipe do
-      private_key 'blah'
-    end
-
     it 'the private key is created in the private_key_write_path' do
-      expect(chef_run).to have_updated "private_key[blah]", :create
+      expect_recipe {
+        private_key 'blah'
+      }.to have_updated "private_key[blah]", :create
       expect(Chef::Config.private_key_write_path).to eq(repo_path)
       expect(File.exist?("#{repo_path}/blah")).to be true
       expect(File.exist?("#{repo_path}/other_keys/blah")).to be false
@@ -49,13 +45,13 @@ describe Chef::Resource::PrivateKey do
 
     context 'and the private key already exists somewhere not in the write path' do
       before :each do
-        Cheffish::BasicChefClient.converge_block do
-          private_key "#{repo_path}/other_keys/blah"
-        end
+        recipe { private_key "#{repo_path}/other_keys/blah" }.converge
       end
 
       it 'the private expect(key).to not update' do
-        expect(chef_run).not_to have_updated "private_key[blah]", :create
+        expect_recipe {
+          private_key 'blah'
+        }.not_to have_updated "private_key[blah]", :create
 
         expect(File.exist?("#{repo_path}/blah")).to be false
         expect(File.exist?("#{repo_path}/other_keys/blah")).to be true
@@ -71,15 +67,13 @@ describe Chef::Resource::PrivateKey do
     end
 
     context 'and a private_key that copies it in der format' do
-      with_converge do
-        private_key "#{repo_path}/blah.der" do
-          source_key_path "#{repo_path}/blah"
-          format :der
-        end
-      end
-
       it 'the private_key is copied in der format and is identical' do
-        expect(chef_run).to have_updated "private_key[#{repo_path}/blah.der]", :create
+        expect_recipe {
+          private_key "#{repo_path}/blah.der" do
+            source_key_path "#{repo_path}/blah"
+            format :der
+          end
+        }.to have_updated "private_key[#{repo_path}/blah.der]", :create
         key_str = IO.read("#{repo_path}/blah.der")
         expect(key_str).not_to start_with('-----BEGIN')
         expect(key_str).not_to start_with('ssh-')
@@ -88,14 +82,12 @@ describe Chef::Resource::PrivateKey do
     end
 
     it 'a private_key that copies it from in-memory as a string succeeds' do
-      run_recipe do
+      expect_recipe {
         private_key "#{repo_path}/blah.der" do
           source_key IO.read("#{repo_path}/blah")
           format :der
         end
-      end
-
-      expect(chef_run).to have_updated "private_key[#{repo_path}/blah.der]", :create
+      }.to have_updated "private_key[#{repo_path}/blah.der]", :create
       key_str = IO.read("#{repo_path}/blah.der")
       expect(key_str).not_to start_with('-----BEGIN')
       expect(key_str).not_to start_with('ssh-')
@@ -104,14 +96,12 @@ describe Chef::Resource::PrivateKey do
 
     it 'a private_key that copies it from in-memory as a key succeeds' do
       key = OpenSSL::PKey.read(IO.read("#{repo_path}/blah"))
-      run_recipe do
+      expect_recipe {
         private_key "#{repo_path}/blah.der" do
           source_key key
           format :der
         end
-      end
-
-      expect(chef_run).to have_updated "private_key[#{repo_path}/blah.der]", :create
+      }.to have_updated "private_key[#{repo_path}/blah.der]", :create
       key_str = IO.read("#{repo_path}/blah.der")
       expect(key_str).not_to start_with('-----BEGIN')
       expect(key_str).not_to start_with('ssh-')
@@ -119,14 +109,12 @@ describe Chef::Resource::PrivateKey do
     end
 
     context 'and a public_key recipe' do
-      with_converge do
-        public_key "#{repo_path}/blah.pub" do
-          source_key_path "#{repo_path}/blah"
-        end
-      end
-
       it 'the public_key is created' do
-        expect(chef_run).to have_updated "public_key[#{repo_path}/blah.pub]", :create
+        expect_recipe {
+          public_key "#{repo_path}/blah.pub" do
+            source_key_path "#{repo_path}/blah"
+          end
+        }.to have_updated "public_key[#{repo_path}/blah.pub]", :create
         expect(IO.read("#{repo_path}/blah.pub")).to start_with('ssh-rsa ')
         expect("#{repo_path}/blah.pub").to be_public_key_for "#{repo_path}/blah"
       end
@@ -142,28 +130,24 @@ describe Chef::Resource::PrivateKey do
       end
 
       context 'and public_key resource based off the public key file' do
-        with_converge do
-          public_key "#{repo_path}/blah.pub2" do
-            source_key_path "#{repo_path}/blah.pub"
-          end
-        end
-
         it 'the second public_key is created' do
-          expect(chef_run).to have_updated "public_key[#{repo_path}/blah.pub2]", :create
+          expect_recipe {
+            public_key "#{repo_path}/blah.pub2" do
+              source_key_path "#{repo_path}/blah.pub"
+            end
+          }.to have_updated "public_key[#{repo_path}/blah.pub2]", :create
           expect(IO.read("#{repo_path}/blah.pub")).to start_with('ssh-rsa ')
           expect("#{repo_path}/blah.pub").to be_public_key_for "#{repo_path}/blah"
         end
       end
 
       context 'and another public_key based off the first public_key in-memory in a string' do
-        with_converge do
-          public_key "#{repo_path}/blah.pub2" do
-            source_key IO.read("#{repo_path}/blah.pub")
-          end
-        end
-
         it 'the second public_key is created' do
-          expect(chef_run).to have_updated "public_key[#{repo_path}/blah.pub2]", :create
+          expect_recipe {
+            public_key "#{repo_path}/blah.pub2" do
+              source_key IO.read("#{repo_path}/blah.pub")
+            end
+          }.to have_updated "public_key[#{repo_path}/blah.pub2]", :create
           expect(IO.read("#{repo_path}/blah.pub")).to start_with('ssh-rsa ')
           expect("#{repo_path}/blah.pub").to be_public_key_for "#{repo_path}/blah"
         end
@@ -172,42 +156,36 @@ describe Chef::Resource::PrivateKey do
       it 'and another public_key based off the first public_key in-memory in a key, the second public_key is created' do
         key, format = Cheffish::KeyFormatter.decode(IO.read("#{repo_path}/blah.pub"))
 
-        run_recipe do
+        expect_recipe {
           public_key "#{repo_path}/blah.pub2" do
             source_key key
           end
-        end
-
-        expect(chef_run).to have_updated "public_key[#{repo_path}/blah.pub2]", :create
+        }.to have_updated "public_key[#{repo_path}/blah.pub2]", :create
         expect(IO.read("#{repo_path}/blah.pub")).to start_with('ssh-rsa ')
         expect("#{repo_path}/blah.pub").to be_public_key_for "#{repo_path}/blah"
       end
 
       context 'and another public_key in :pem format based off the first public_key' do
-        with_converge do
-          public_key "#{repo_path}/blah.pub2" do
-            source_key_path "#{repo_path}/blah.pub"
-            format :pem
-          end
-        end
-
         it 'the second public_key is created' do
-          expect(chef_run).to have_updated "public_key[#{repo_path}/blah.pub2]", :create
+          expect_recipe {
+            public_key "#{repo_path}/blah.pub2" do
+              source_key_path "#{repo_path}/blah.pub"
+              format :pem
+            end
+          }.to have_updated "public_key[#{repo_path}/blah.pub2]", :create
           expect(IO.read("#{repo_path}/blah.pub")).to start_with('ssh-rsa ')
           expect("#{repo_path}/blah.pub").to be_public_key_for "#{repo_path}/blah"
         end
       end
 
       context 'and another public_key in :der format based off the first public_key' do
-        with_converge do
-          public_key "#{repo_path}/blah.pub2" do
-            source_key_path "#{repo_path}/blah.pub"
-            format :pem
-          end
-        end
-
         it 'the second public_key is created' do
-          expect(chef_run).to have_updated "public_key[#{repo_path}/blah.pub2]", :create
+          expect_recipe {
+            public_key "#{repo_path}/blah.pub2" do
+              source_key_path "#{repo_path}/blah.pub"
+              format :pem
+            end
+          }.to have_updated "public_key[#{repo_path}/blah.pub2]", :create
           expect(IO.read("#{repo_path}/blah.pub")).to start_with('ssh-rsa ')
           expect("#{repo_path}/blah.pub").to be_public_key_for "#{repo_path}/blah"
         end
@@ -215,30 +193,26 @@ describe Chef::Resource::PrivateKey do
     end
 
     context 'and a public_key resource in pem format' do
-      with_converge do
-        public_key "#{repo_path}/blah.pub" do
-          source_key_path "#{repo_path}/blah"
-          format :pem
-        end
-      end
-
       it 'the public_key is created' do
-        expect(chef_run).to have_updated "public_key[#{repo_path}/blah.pub]", :create
+        expect_recipe {
+          public_key "#{repo_path}/blah.pub" do
+            source_key_path "#{repo_path}/blah"
+            format :pem
+          end
+        }.to have_updated "public_key[#{repo_path}/blah.pub]", :create
         expect(IO.read("#{repo_path}/blah.pub")).to start_with('-----BEGIN')
         expect("#{repo_path}/blah.pub").to be_public_key_for "#{repo_path}/blah"
       end
     end
 
     context 'and a public_key resource in der format' do
-      with_converge do
-        public_key "#{repo_path}/blah.pub" do
-          source_key_path "#{repo_path}/blah"
-          format :der
-        end
-      end
-
       it 'the public_key is created in openssh format' do
-        expect(chef_run).to have_updated "public_key[#{repo_path}/blah.pub]", :create
+        expect_recipe {
+          public_key "#{repo_path}/blah.pub" do
+            source_key_path "#{repo_path}/blah"
+            format :der
+          end
+        }.to have_updated "public_key[#{repo_path}/blah.pub]", :create
         expect(IO.read("#{repo_path}/blah.pub")).not_to start_with('-----BEGIN')
         expect(IO.read("#{repo_path}/blah.pub")).not_to start_with('ssh-rsa')
         expect("#{repo_path}/blah.pub").to be_public_key_for "#{repo_path}/blah"
@@ -247,14 +221,12 @@ describe Chef::Resource::PrivateKey do
   end
 
   context 'with a recipe with a private_key in der format' do
-    with_recipe do
-      private_key "#{repo_path}/blah" do
-        format :der
-      end
-    end
-
     it 'the private_key is created' do
-      expect(chef_run).to have_updated "private_key[#{repo_path}/blah]", :create
+      expect_recipe {
+        private_key "#{repo_path}/blah" do
+          format :der
+        end
+      }.to have_updated "private_key[#{repo_path}/blah]", :create
       expect(IO.read("#{repo_path}/blah")).not_to start_with('-----BEGIN')
       expect(OpenSSL::PKey.read(IO.read("#{repo_path}/blah"))).to be_kind_of(OpenSSL::PKey::RSA)
     end
@@ -270,14 +242,12 @@ describe Chef::Resource::PrivateKey do
     end
 
     context 'and a public_key' do
-      with_converge do
-        public_key "#{repo_path}/blah.pub" do
-          source_key_path "#{repo_path}/blah"
-        end
-      end
-
       it 'the public_key is created in openssh format' do
-        expect(chef_run).to have_updated "public_key[#{repo_path}/blah.pub]", :create
+        expect_recipe {
+          public_key "#{repo_path}/blah.pub" do
+            source_key_path "#{repo_path}/blah"
+          end
+        }.to have_updated "public_key[#{repo_path}/blah.pub]", :create
         expect(IO.read("#{repo_path}/blah.pub")).to start_with('ssh-rsa ')
         expect("#{repo_path}/blah.pub").to be_public_key_for "#{repo_path}/blah"
       end
@@ -285,14 +255,12 @@ describe Chef::Resource::PrivateKey do
   end
 
   context 'with a recipe with a private_key with a pass_phrase' do
-    with_converge do
-      private_key "#{repo_path}/blah" do
-        pass_phrase 'hello'
-      end
-    end
-
     it 'the private_key is created' do
-      expect(chef_run).to have_updated "private_key[#{repo_path}/blah]", :create
+      expect_recipe {
+        private_key "#{repo_path}/blah" do
+          pass_phrase 'hello'
+        end
+      }.to have_updated "private_key[#{repo_path}/blah]", :create
       expect(IO.read("#{repo_path}/blah")).to start_with('-----BEGIN')
       expect(OpenSSL::PKey.read(IO.read("#{repo_path}/blah"), 'hello')).to be_kind_of(OpenSSL::PKey::RSA)
     end
@@ -308,16 +276,14 @@ describe Chef::Resource::PrivateKey do
     end
 
     context 'and a private_key that copies it in der format' do
-      with_converge do
-        private_key "#{repo_path}/blah.der" do
-          source_key_path "#{repo_path}/blah"
-          source_key_pass_phrase 'hello'
-          format :der
-        end
-      end
-
       it 'the private_key is copied in der format and is identical' do
-        expect(chef_run).to have_updated "private_key[#{repo_path}/blah.der]", :create
+        expect_recipe {
+          private_key "#{repo_path}/blah.der" do
+            source_key_path "#{repo_path}/blah"
+            source_key_pass_phrase 'hello'
+            format :der
+          end
+        }.to have_updated "private_key[#{repo_path}/blah.der]", :create
         key_str = IO.read("#{repo_path}/blah.der")
         expect(key_str).not_to start_with('-----BEGIN')
         expect(key_str).not_to start_with('ssh-')
@@ -326,39 +292,35 @@ describe Chef::Resource::PrivateKey do
     end
 
     context 'and a private_key resource pointing at it without a pass_phrase' do
-      with_recipe do
-        private_key "#{repo_path}/blah"
-      end
-
       it 'the run fails with an exception' do
-        expect { chef_run }.to raise_error
+        expect {
+          converge {
+            private_key "#{repo_path}/blah"
+          }
+        }.to raise_error
       end
     end
 
     context 'and a private_key resource with no pass phrase and regenerate_if_different' do
-      with_recipe do
-        private_key "#{repo_path}/blah" do
-          regenerate_if_different true
-        end
-      end
-
       it 'the private_key is regenerated' do
-        expect(chef_run).to have_updated "private_key[#{repo_path}/blah]", :create
+        expect_recipe {
+          private_key "#{repo_path}/blah" do
+            regenerate_if_different true
+          end
+        }.to have_updated "private_key[#{repo_path}/blah]", :create
         expect(IO.read("#{repo_path}/blah")).to start_with('-----BEGIN')
         expect(OpenSSL::PKey.read(IO.read("#{repo_path}/blah"))).to be_kind_of(OpenSSL::PKey::RSA)
       end
     end
 
     it 'a private_key resource that copies it from in-memory as a string succeeds' do
-      run_recipe do
+      expect_recipe {
         private_key "#{repo_path}/blah.der" do
           source_key IO.read("#{repo_path}/blah")
           source_key_pass_phrase 'hello'
           format :der
         end
-      end
-
-      expect(chef_run).to have_updated "private_key[#{repo_path}/blah.der]", :create
+      }.to have_updated "private_key[#{repo_path}/blah.der]", :create
       key_str = IO.read("#{repo_path}/blah.der")
       expect(key_str).not_to start_with('-----BEGIN')
       expect(key_str).not_to start_with('ssh-')
@@ -366,30 +328,26 @@ describe Chef::Resource::PrivateKey do
     end
 
     context 'and a public_key' do
-      with_converge do
-        public_key "#{repo_path}/blah.pub" do
-          source_key_path "#{repo_path}/blah"
-          source_key_pass_phrase 'hello'
-        end
-      end
-
       it 'the public_key is created in openssh format' do
-        expect(chef_run).to have_updated "public_key[#{repo_path}/blah.pub]", :create
+        expect_recipe {
+          public_key "#{repo_path}/blah.pub" do
+            source_key_path "#{repo_path}/blah"
+            source_key_pass_phrase 'hello'
+          end
+        }.to have_updated "public_key[#{repo_path}/blah.pub]", :create
         expect(IO.read("#{repo_path}/blah.pub")).to start_with('ssh-rsa ')
         expect("#{repo_path}/blah.pub").to be_public_key_for "#{repo_path}/blah", 'hello'
       end
     end
 
     context 'and a public_key derived from the private key in an in-memory string' do
-      with_converge do
-        public_key "#{repo_path}/blah.pub" do
-          source_key IO.read("#{repo_path}/blah")
-          source_key_pass_phrase 'hello'
-        end
-      end
-
       it 'the public_key is created in openssh format' do
-        expect(chef_run).to have_updated "public_key[#{repo_path}/blah.pub]", :create
+        expect_recipe {
+          public_key "#{repo_path}/blah.pub" do
+            source_key IO.read("#{repo_path}/blah")
+            source_key_pass_phrase 'hello'
+          end
+        }.to have_updated "public_key[#{repo_path}/blah.pub]", :create
         expect(IO.read("#{repo_path}/blah.pub")).to start_with('ssh-rsa ')
         expect("#{repo_path}/blah.pub").to be_public_key_for "#{repo_path}/blah", 'hello'
       end
@@ -397,14 +355,12 @@ describe Chef::Resource::PrivateKey do
   end
 
   context 'with a recipe with a private_key and public_key_path' do
-    with_converge do
-      private_key "#{repo_path}/blah" do
-        public_key_path "#{repo_path}/blah.pub"
-      end
-    end
-
     it 'the private_key and public_key are created' do
-      expect(chef_run).to have_updated "private_key[#{repo_path}/blah]", :create
+      expect_recipe {
+        private_key "#{repo_path}/blah" do
+          public_key_path "#{repo_path}/blah.pub"
+        end
+      }.to have_updated "private_key[#{repo_path}/blah]", :create
       expect(IO.read("#{repo_path}/blah")).to start_with('-----BEGIN')
       expect(OpenSSL::PKey.read(IO.read("#{repo_path}/blah"))).to be_kind_of(OpenSSL::PKey::RSA)
       expect(IO.read("#{repo_path}/blah.pub")).to start_with('ssh-rsa ')
@@ -413,15 +369,13 @@ describe Chef::Resource::PrivateKey do
   end
 
   context 'with a recipe with a private_key and public_key_path and public_key_format' do
-    with_converge do
-      private_key "#{repo_path}/blah" do
-        public_key_path "#{repo_path}/blah.pub.der"
-        public_key_format :der
-      end
-    end
-
     it 'the private_key and public_key are created' do
-      expect(chef_run).to have_updated "private_key[#{repo_path}/blah]", :create
+      expect_recipe {
+        private_key "#{repo_path}/blah" do
+          public_key_path "#{repo_path}/blah.pub.der"
+          public_key_format :der
+        end
+      }.to have_updated "private_key[#{repo_path}/blah]", :create
       expect(IO.read("#{repo_path}/blah")).to start_with('-----BEGIN')
       expect(OpenSSL::PKey.read(IO.read("#{repo_path}/blah"))).to be_kind_of(OpenSSL::PKey::RSA)
       expect(IO.read("#{repo_path}/blah.pub.der")).not_to start_with('ssh-rsa ')
@@ -432,14 +386,12 @@ describe Chef::Resource::PrivateKey do
   context 'with a recipe with a private_key with path :none' do
     it 'the private_key is created' do
       got_private_key = nil
-      run_recipe do
+      expect_recipe {
         private_key 'in_memory' do
           path :none
           after { |resource, private_key| got_private_key = private_key }
         end
-      end
-
-      expect(chef_run).to have_updated "private_key[in_memory]", :create
+      }.to have_updated "private_key[in_memory]", :create
       expect(got_private_key).to be_kind_of(OpenSSL::PKey::RSA)
     end
   end