cheffish 0.6.2 → 0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 145cdf5b1e5c973e52a35f015e8d65e966da4b7b
-  data.tar.gz: 478715a952fc5ec0462eaf74b28b466aeead3ff3
+  metadata.gz: e58ebae3c3b7856ae29da6639debd75b93d1a2ba
+  data.tar.gz: 278ba389ad45a85bdc19dc9875c88da1084b832a
 SHA512:
-  metadata.gz: 044e7e93aa915dab2db222f9a141dc5d56d5331ff063568a9b24d7420288674f174f21649c0e2d71591818a4cdbe1a5a459cca98f67b1db0cabd68fd306330df
-  data.tar.gz: 65a0b89a357252031a3b2aebf656f6f0207706fc44f7c80dc65a277bd4e24ced71608070170193792bd3aa1987becae9b848e46137ec18ec7d4862bdc478062f
+  metadata.gz: 225c6e83fc286c34a7d1272a3ae53cb02b25ed3168f231ec0315772e3195f492676d011af44d846c0725d79efe2fb97f91f83d9d83207f1908427fad328910a6
+  data.tar.gz: 165ab945e54d38c2e2173b71ac1584eab0d4b613f46c0402aa6dcc2fcb09635b3ae0d4c341d4de13493d36ab9319cc84b347a6996db53b5bc9135b33c0965ff8

data/lib/chef/provider/private_key.rb

@@ -51,12 +51,13 @@ class Chef::Provider::PrivateKey < Chef::Provider::LWRPBase
       #
       # Generate a new key
       #
-      if !current_private_key || regenerate ||
+      if current_resource.action == [ :delete ] || regenerate ||
         (new_resource.regenerate_if_different &&
-          (current_resource.size != new_resource.size ||
+          (!current_private_key ||
+           current_resource.size != new_resource.size ||
            current_resource.type != new_resource.type))
 
-        case new_resource.type
+       case new_resource.type
         when :rsa
           if new_resource.exponent
             final_private_key = OpenSSL::PKey::RSA.generate(new_resource.size, new_resource.exponent)
@@ -68,6 +69,8 @@ class Chef::Provider::PrivateKey < Chef::Provider::LWRPBase
         end
 
         generated_key = true
+      elsif !current_private_key
+        raise "Could not read private key from #{current_resource.path}: missing pass phrase?"
       else
         final_private_key = current_private_key
         generated_key = false

data/lib/cheffish/recipe_dsl.rb

@@ -49,7 +49,7 @@ class Chef
       def with_chef_local_server(options, &block)
         options[:host] ||= '127.0.0.1'
         options[:log_level] ||= Chef::Log.level
-        options[:port] ||= 8901
+        options[:port] ||= 8901.upto(9900)
 
         # Create the data store chef-zero will use
         options[:data_store] ||= begin

data/lib/cheffish/version.rb

@@ -1,3 +1,3 @@
 module Cheffish
-  VERSION = '0.6.2'
+  VERSION = '0.7'
 end

data/lib/cheffish.rb

@@ -88,7 +88,8 @@ module Cheffish
       end
     elsif config[:private_key_paths]
       config[:private_key_paths].each do |private_key_path|
-        Dir.entries(private_key_path).each do |key|
+        next unless File.exist?(private_key_path)
+        Dir.entries(private_key_path).sort.each do |key|
           ext = File.extname(key)
           if ext == '' || ext == '.pem'
             key_name = key[0..-(ext.length+1)]

data/spec/integration/chef_client_spec.rb

@@ -22,11 +22,11 @@ describe Chef::Resource::ChefClient do
         end
 
         it 'the client gets created' do
-          chef_run.should have_updated 'chef_client[blah]', :create
+          expect(chef_run).to have_updated 'chef_client[blah]', :create
           client = get('/clients/blah')
-          client['name'].should == 'blah'
+          expect(client['name']).to eq('blah')
           key, format = Cheffish::KeyFormatter.decode(client['public_key'])
-          key.should be_public_key_for("#{repo_path}/blah.pem")
+          expect(key).to be_public_key_for("#{repo_path}/blah.pem")
         end
       end
 
@@ -39,8 +39,8 @@ describe Chef::Resource::ChefClient do
         end
 
         it 'the output public key gets created' do
-          IO.read("#{repo_path}/blah.pub").should start_with('ssh-rsa ')
-          "#{repo_path}/blah.pub".should be_public_key_for("#{repo_path}/blah.pem")
+          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.pem")
         end
       end
     end
@@ -62,13 +62,13 @@ describe Chef::Resource::ChefClient do
         end
 
         it 'the client is accessible via the given private key' do
-          chef_run.should have_updated 'chef_client[foobar]', :create
+          expect(chef_run).to have_updated 'chef_client[foobar]', :create
           client = get('/clients/foobar')
           key, format = Cheffish::KeyFormatter.decode(client['public_key'])
-          key.should be_public_key_for("#{repo_path}/blah.pem")
+          expect(key).to be_public_key_for("#{repo_path}/blah.pem")
 
           private_key = Cheffish::KeyFormatter.decode(Cheffish.get_private_key('blah'))
-          key.should be_public_key_for(private_key)
+          expect(key).to be_public_key_for(private_key)
         end
       end
     end

data/spec/integration/chef_node_spec.rb

@@ -12,8 +12,8 @@ describe Chef::Resource::ChefNode do
       end
 
       it 'the node gets created' do
-        chef_run.should have_updated 'chef_node[blah]', :create
-        get('/nodes/blah')['name'].should == 'blah'
+        expect(chef_run).to have_updated 'chef_node[blah]', :create
+        expect(get('/nodes/blah')['name']).to eq('blah')
       end
     end
 
@@ -37,9 +37,9 @@ describe Chef::Resource::ChefNode do
         end
 
         it 'the node is created on the second chef server but not the first' do
-          chef_run.should have_updated 'chef_node[blah]', :create
-          lambda { get('/nodes/blah') }.should raise_error(Net::HTTPServerException)
-          get('http://127.0.0.1:8899/nodes/blah')['name'].should == 'blah'
+          expect(chef_run).to have_updated 'chef_node[blah]', :create
+          expect { get('/nodes/blah') }.to raise_error(Net::HTTPServerException)
+          expect(get('http://127.0.0.1:8899/nodes/blah')['name']).to eq('blah')
         end
       end
 
@@ -52,9 +52,9 @@ describe Chef::Resource::ChefNode do
         end
 
         it 'the node is created on the second chef server but not the first' do
-          chef_run.should have_updated 'chef_node[blah]', :create
-          lambda { get('/nodes/blah') }.should raise_error(Net::HTTPServerException)
-          get('http://127.0.0.1:8899/nodes/blah')['name'].should == 'blah'
+          expect(chef_run).to have_updated 'chef_node[blah]', :create
+          expect { get('/nodes/blah') }.to raise_error(Net::HTTPServerException)
+          expect(get('http://127.0.0.1:8899/nodes/blah')['name']).to eq('blah')
         end
       end
 
@@ -69,7 +69,7 @@ describe Chef::Resource::ChefNode do
     end
 
     it 'chef_node "blah" does not get created or updated' do
-      chef_run.should_not have_updated 'chef_node[blah]', :create
+      expect(chef_run).not_to have_updated 'chef_node[blah]', :create
     end
   end
 
@@ -86,7 +86,7 @@ describe Chef::Resource::ChefNode do
       end
 
       it 'the tags in attributes are used' do
-        get('/nodes/blah')['normal']['tags'].should == [ 'a', 'b' ]
+        expect(get('/nodes/blah')['normal']['tags']).to eq([ 'a', 'b' ])
       end
     end
 
@@ -98,7 +98,7 @@ describe Chef::Resource::ChefNode do
       end
 
       it 'the tags in attributes are used' do
-        get('/nodes/blah')['normal']['tags'].should == [ 'c', 'd' ]
+        expect(get('/nodes/blah')['normal']['tags']).to eq([ 'c', 'd' ])
       end
     end
   end
@@ -119,7 +119,7 @@ describe Chef::Resource::ChefNode do
       end
 
       it 'nothing gets updated' do
-        chef_run.should_not have_updated 'chef_node[blah]', :create
+        expect(chef_run).not_to have_updated 'chef_node[blah]', :create
       end
     end
 
@@ -131,14 +131,14 @@ describe Chef::Resource::ChefNode do
       end
 
       it 'default, automatic and override attributes are left alone' do
-        chef_run.should have_updated 'chef_node[blah]', :create
+        expect(chef_run).to have_updated 'chef_node[blah]', :create
         node = get('/nodes/blah')
-        node['chef_environment'].should == '_default'
-        node['run_list'].should == []
-        node['normal'].should == { 'tags' => [ 'a', 'b' ] }
-        node['default'].should == { 'foo2' => 'bar2' }
-        node['automatic'].should == { 'foo3' => 'bar3' }
-        node['override'].should == { 'foo4' => 'bar4' }
+        expect(node['chef_environment']).to eq('_default')
+        expect(node['run_list']).to eq([])
+        expect(node['normal']).to eq({ 'tags' => [ 'a', 'b' ] })
+        expect(node['default']).to eq({ 'foo2' => 'bar2' })
+        expect(node['automatic']).to eq({ 'foo3' => 'bar3' })
+        expect(node['override']).to eq({ 'foo4' => 'bar4' })
       end
     end
   end

data/spec/integration/chef_user_spec.rb

@@ -22,11 +22,11 @@ describe Chef::Resource::ChefUser do
         end
 
         it 'the user gets created' do
-          chef_run.should have_updated 'chef_user[blah]', :create
+          expect(chef_run).to have_updated 'chef_user[blah]', :create
           user = get('/users/blah')
-          user['name'].should == 'blah'
+          expect(user['name']).to eq('blah')
           key, format = Cheffish::KeyFormatter.decode(user['public_key'])
-          key.should be_public_key_for("#{repo_path}/blah.pem")
+          expect(key).to be_public_key_for("#{repo_path}/blah.pem")
         end
       end
 
@@ -39,8 +39,8 @@ describe Chef::Resource::ChefUser do
         end
 
         it 'the output public key gets created' do
-          IO.read("#{repo_path}/blah.pub").should start_with('ssh-rsa ')
-          "#{repo_path}/blah.pub".should be_public_key_for("#{repo_path}/blah.pem")
+          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.pem")
         end
       end
     end

data/spec/integration/private_key_spec.rb

@@ -21,9 +21,9 @@ describe Chef::Resource::PrivateKey do
     end
 
     it 'the private_key is created in pem format' do
-      chef_run.should have_updated "private_key[#{repo_path}/blah]", :create
-      IO.read("#{repo_path}/blah").should start_with('-----BEGIN')
-      OpenSSL::PKey.read(IO.read("#{repo_path}/blah")).kind_of?(OpenSSL::PKey::RSA).should be_true
+      expect(chef_run).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
 
@@ -38,12 +38,12 @@ describe Chef::Resource::PrivateKey do
     end
 
     it 'the private key is created in the private_key_write_path' do
-      chef_run.should have_updated "private_key[blah]", :create
-      Chef::Config.private_key_write_path.should == repo_path
-      File.exist?("#{repo_path}/blah").should be_true
-      File.exist?("#{repo_path}/other_keys/blah").should be_false
-      OpenSSL::PKey.read(IO.read("#{repo_path}/blah")).kind_of?(OpenSSL::PKey::RSA).should be_true
-      OpenSSL::PKey.read(Cheffish.get_private_key('blah')).kind_of?(OpenSSL::PKey::RSA).should be_true
+      expect(chef_run).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
+      expect(OpenSSL::PKey.read(IO.read("#{repo_path}/blah"))).to be_kind_of(OpenSSL::PKey::RSA)
+      expect(OpenSSL::PKey.read(Cheffish.get_private_key('blah'))).to be_kind_of(OpenSSL::PKey::RSA)
     end
 
     context 'and the private key already exists somewhere not in the write path' do
@@ -53,11 +53,11 @@ describe Chef::Resource::PrivateKey do
         end
       end
 
-      it 'the private key should not update' do
-        chef_run.should_not have_updated "private_key[blah]", :create
+      it 'the private expect(key).to not update' do
+        expect(chef_run).not_to have_updated "private_key[blah]", :create
 
-        File.exist?("#{repo_path}/blah").should be_false
-        File.exist?("#{repo_path}/other_keys/blah").should be_true
+        expect(File.exist?("#{repo_path}/blah")).to be false
+        expect(File.exist?("#{repo_path}/other_keys/blah")).to be true
       end
     end
   end
@@ -78,11 +78,11 @@ describe Chef::Resource::PrivateKey do
       end
 
       it 'the private_key is copied in der format and is identical' do
-        chef_run.should have_updated "private_key[#{repo_path}/blah.der]", :create
+        expect(chef_run).to have_updated "private_key[#{repo_path}/blah.der]", :create
         key_str = IO.read("#{repo_path}/blah.der")
-        key_str.should_not start_with('-----BEGIN')
-        key_str.should_not start_with('ssh-')
-        "#{repo_path}/blah.der".should match_private_key("#{repo_path}/blah")
+        expect(key_str).not_to start_with('-----BEGIN')
+        expect(key_str).not_to start_with('ssh-')
+        expect("#{repo_path}/blah.der").to match_private_key("#{repo_path}/blah")
       end
     end
 
@@ -94,11 +94,11 @@ describe Chef::Resource::PrivateKey do
         end
       end
 
-      chef_run.should have_updated "private_key[#{repo_path}/blah.der]", :create
+      expect(chef_run).to have_updated "private_key[#{repo_path}/blah.der]", :create
       key_str = IO.read("#{repo_path}/blah.der")
-      key_str.should_not start_with('-----BEGIN')
-      key_str.should_not start_with('ssh-')
-      "#{repo_path}/blah.der".should match_private_key("#{repo_path}/blah")
+      expect(key_str).not_to start_with('-----BEGIN')
+      expect(key_str).not_to start_with('ssh-')
+      expect("#{repo_path}/blah.der").to match_private_key("#{repo_path}/blah")
     end
 
     it 'a private_key that copies it from in-memory as a key succeeds' do
@@ -110,11 +110,11 @@ describe Chef::Resource::PrivateKey do
         end
       end
 
-      chef_run.should have_updated "private_key[#{repo_path}/blah.der]", :create
+      expect(chef_run).to have_updated "private_key[#{repo_path}/blah.der]", :create
       key_str = IO.read("#{repo_path}/blah.der")
-      key_str.should_not start_with('-----BEGIN')
-      key_str.should_not start_with('ssh-')
-      "#{repo_path}/blah.der".should match_private_key("#{repo_path}/blah")
+      expect(key_str).not_to start_with('-----BEGIN')
+      expect(key_str).not_to start_with('ssh-')
+      expect("#{repo_path}/blah.der").to match_private_key("#{repo_path}/blah")
     end
 
     context 'and a public_key recipe' do
@@ -125,9 +125,9 @@ describe Chef::Resource::PrivateKey do
       end
 
       it 'the public_key is created' do
-        chef_run.should have_updated "public_key[#{repo_path}/blah.pub]", :create
-        IO.read("#{repo_path}/blah.pub").should start_with('ssh-rsa ')
-        "#{repo_path}/blah.pub".should be_public_key_for "#{repo_path}/blah"
+        expect(chef_run).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
     end
 
@@ -148,9 +148,9 @@ describe Chef::Resource::PrivateKey do
         end
 
         it 'the second public_key is created' do
-          chef_run.should have_updated "public_key[#{repo_path}/blah.pub2]", :create
-          IO.read("#{repo_path}/blah.pub").should start_with('ssh-rsa ')
-          "#{repo_path}/blah.pub".should be_public_key_for "#{repo_path}/blah"
+          expect(chef_run).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
 
@@ -162,9 +162,9 @@ describe Chef::Resource::PrivateKey do
         end
 
         it 'the second public_key is created' do
-          chef_run.should have_updated "public_key[#{repo_path}/blah.pub2]", :create
-          IO.read("#{repo_path}/blah.pub").should start_with('ssh-rsa ')
-          "#{repo_path}/blah.pub".should be_public_key_for "#{repo_path}/blah"
+          expect(chef_run).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
 
@@ -177,9 +177,9 @@ describe Chef::Resource::PrivateKey do
           end
         end
 
-        chef_run.should have_updated "public_key[#{repo_path}/blah.pub2]", :create
-        IO.read("#{repo_path}/blah.pub").should start_with('ssh-rsa ')
-        "#{repo_path}/blah.pub".should be_public_key_for "#{repo_path}/blah"
+        expect(chef_run).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
@@ -191,9 +191,9 @@ describe Chef::Resource::PrivateKey do
         end
 
         it 'the second public_key is created' do
-          chef_run.should have_updated "public_key[#{repo_path}/blah.pub2]", :create
-          IO.read("#{repo_path}/blah.pub").should start_with('ssh-rsa ')
-          "#{repo_path}/blah.pub".should be_public_key_for "#{repo_path}/blah"
+          expect(chef_run).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
 
@@ -206,9 +206,9 @@ describe Chef::Resource::PrivateKey do
         end
 
         it 'the second public_key is created' do
-          chef_run.should have_updated "public_key[#{repo_path}/blah.pub2]", :create
-          IO.read("#{repo_path}/blah.pub").should start_with('ssh-rsa ')
-          "#{repo_path}/blah.pub".should be_public_key_for "#{repo_path}/blah"
+          expect(chef_run).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
     end
@@ -222,9 +222,9 @@ describe Chef::Resource::PrivateKey do
       end
 
       it 'the public_key is created' do
-        chef_run.should have_updated "public_key[#{repo_path}/blah.pub]", :create
-        IO.read("#{repo_path}/blah.pub").should start_with('-----BEGIN')
-        "#{repo_path}/blah.pub".should be_public_key_for "#{repo_path}/blah"
+        expect(chef_run).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
 
@@ -237,10 +237,10 @@ describe Chef::Resource::PrivateKey do
       end
 
       it 'the public_key is created in openssh format' do
-        chef_run.should have_updated "public_key[#{repo_path}/blah.pub]", :create
-        IO.read("#{repo_path}/blah.pub").should_not start_with('-----BEGIN')
-        IO.read("#{repo_path}/blah.pub").should_not start_with('ssh-rsa')
-        "#{repo_path}/blah.pub".should be_public_key_for "#{repo_path}/blah"
+        expect(chef_run).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"
       end
     end
   end
@@ -253,9 +253,9 @@ describe Chef::Resource::PrivateKey do
     end
 
     it 'the private_key is created' do
-      chef_run.should have_updated "private_key[#{repo_path}/blah]", :create
-      IO.read("#{repo_path}/blah").should_not start_with('-----BEGIN')
-      OpenSSL::PKey.read(IO.read("#{repo_path}/blah")).kind_of?(OpenSSL::PKey::RSA).should be_true
+      expect(chef_run).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
   end
 
@@ -276,9 +276,9 @@ describe Chef::Resource::PrivateKey do
       end
 
       it 'the public_key is created in openssh format' do
-        chef_run.should have_updated "public_key[#{repo_path}/blah.pub]", :create
-        IO.read("#{repo_path}/blah.pub").should start_with('ssh-rsa ')
-        "#{repo_path}/blah.pub".should be_public_key_for "#{repo_path}/blah"
+        expect(chef_run).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
     end
   end
@@ -291,9 +291,9 @@ describe Chef::Resource::PrivateKey do
     end
 
     it 'the private_key is created' do
-      chef_run.should have_updated "private_key[#{repo_path}/blah]", :create
-      IO.read("#{repo_path}/blah").should start_with('-----BEGIN')
-      OpenSSL::PKey.read(IO.read("#{repo_path}/blah"), 'hello').kind_of?(OpenSSL::PKey::RSA).should be_true
+      expect(chef_run).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
   end
 
@@ -316,11 +316,35 @@ describe Chef::Resource::PrivateKey do
       end
 
       it 'the private_key is copied in der format and is identical' do
-        chef_run.should have_updated "private_key[#{repo_path}/blah.der]", :create
+        expect(chef_run).to have_updated "private_key[#{repo_path}/blah.der]", :create
         key_str = IO.read("#{repo_path}/blah.der")
-        key_str.should_not start_with('-----BEGIN')
-        key_str.should_not start_with('ssh-')
-        "#{repo_path}/blah.der".should match_private_key("#{repo_path}/blah", 'hello')
+        expect(key_str).not_to start_with('-----BEGIN')
+        expect(key_str).not_to start_with('ssh-')
+        expect("#{repo_path}/blah.der").to match_private_key("#{repo_path}/blah", 'hello')
+      end
+    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
+      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(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
 
@@ -333,11 +357,11 @@ describe Chef::Resource::PrivateKey do
         end
       end
 
-      chef_run.should have_updated "private_key[#{repo_path}/blah.der]", :create
+      expect(chef_run).to have_updated "private_key[#{repo_path}/blah.der]", :create
       key_str = IO.read("#{repo_path}/blah.der")
-      key_str.should_not start_with('-----BEGIN')
-      key_str.should_not start_with('ssh-')
-      "#{repo_path}/blah.der".should match_private_key("#{repo_path}/blah", 'hello')
+      expect(key_str).not_to start_with('-----BEGIN')
+      expect(key_str).not_to start_with('ssh-')
+      expect("#{repo_path}/blah.der").to match_private_key("#{repo_path}/blah", 'hello')
     end
 
     context 'and a public_key' do
@@ -349,9 +373,9 @@ describe Chef::Resource::PrivateKey do
       end
 
       it 'the public_key is created in openssh format' do
-        chef_run.should have_updated "public_key[#{repo_path}/blah.pub]", :create
-        IO.read("#{repo_path}/blah.pub").should start_with('ssh-rsa ')
-        "#{repo_path}/blah.pub".should be_public_key_for "#{repo_path}/blah", 'hello'
+        expect(chef_run).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
 
@@ -364,9 +388,9 @@ describe Chef::Resource::PrivateKey do
       end
 
       it 'the public_key is created in openssh format' do
-        chef_run.should have_updated "public_key[#{repo_path}/blah.pub]", :create
-        IO.read("#{repo_path}/blah.pub").should start_with('ssh-rsa ')
-        "#{repo_path}/blah.pub".should be_public_key_for "#{repo_path}/blah", 'hello'
+        expect(chef_run).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
   end
@@ -379,11 +403,11 @@ describe Chef::Resource::PrivateKey do
     end
 
     it 'the private_key and public_key are created' do
-      chef_run.should have_updated "private_key[#{repo_path}/blah]", :create
-      IO.read("#{repo_path}/blah").should start_with('-----BEGIN')
-      OpenSSL::PKey.read(IO.read("#{repo_path}/blah")).kind_of?(OpenSSL::PKey::RSA).should be_true
-      IO.read("#{repo_path}/blah.pub").should start_with('ssh-rsa ')
-      "#{repo_path}/blah.pub".should be_public_key_for("#{repo_path}/blah")
+      expect(chef_run).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 ')
+      expect("#{repo_path}/blah.pub").to be_public_key_for("#{repo_path}/blah")
     end
   end
 
@@ -396,11 +420,11 @@ describe Chef::Resource::PrivateKey do
     end
 
     it 'the private_key and public_key are created' do
-      chef_run.should have_updated "private_key[#{repo_path}/blah]", :create
-      IO.read("#{repo_path}/blah").should start_with('-----BEGIN')
-      OpenSSL::PKey.read(IO.read("#{repo_path}/blah")).kind_of?(OpenSSL::PKey::RSA).should be_true
-      IO.read("#{repo_path}/blah.pub.der").should_not start_with('ssh-rsa ')
-      "#{repo_path}/blah.pub.der".should be_public_key_for("#{repo_path}/blah")
+      expect(chef_run).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 ')
+      expect("#{repo_path}/blah.pub.der").to be_public_key_for("#{repo_path}/blah")
     end
   end
 
@@ -414,8 +438,8 @@ describe Chef::Resource::PrivateKey do
         end
       end
 
-      chef_run.should have_updated "private_key[in_memory]", :create
-      got_private_key.kind_of?(OpenSSL::PKey::RSA).should be_true
+      expect(chef_run).to have_updated "private_key[in_memory]", :create
+      expect(got_private_key).to be_kind_of(OpenSSL::PKey::RSA)
     end
   end
 

data/spec/integration/recipe_dsl_spec.rb

@@ -22,8 +22,8 @@ describe 'Cheffish Recipe DSL' do
       run_recipe do
         chef_node 'blah'
       end
-      chef_run.should have_updated 'chef_node[blah]', :create
-      File.should exist("#{@tmp_repo}/nodes/blah.json")
+      expect(chef_run).to have_updated 'chef_node[blah]', :create
+      expect(File).to exist("#{@tmp_repo}/nodes/blah.json")
     end
   end
 end

data/spec/support/key_support.rb

@@ -8,7 +8,7 @@ RSpec::Matchers.define :be_public_key_for do |private_key, pass_phrase|
     end
 
     encrypted = public_key.public_encrypt('hi there')
-    private_key.private_decrypt(encrypted).should == 'hi there'
+    expect(private_key.private_decrypt(encrypted)).to eq('hi there')
   end
 end
 
@@ -22,8 +22,8 @@ RSpec::Matchers.define :match_private_key do |expected, pass_phrase|
     end
 
     encrypted = actual.public_encrypt('hi there')
-    expected.private_decrypt(encrypted).should == 'hi there'
+    expect(expected.private_decrypt(encrypted)).to eq('hi there')
     encrypted = expected.public_encrypt('hi there')
-    actual.private_decrypt(encrypted).should == 'hi there'
+    expect(actual.private_decrypt(encrypted)).to eq('hi there')
   end
 end

data/spec/support/spec_support.rb

@@ -87,9 +87,9 @@ end
 RSpec::Matchers.define :have_updated do |resource_name, *expected_actions|
   match do |actual|
     actual_actions = actual.select { |event, resource, action| event == :resource_updated && resource.to_s == resource_name }.map { |event, resource, action| action }
-    actual_actions.should == expected_actions
+    expect(actual_actions).to eq(expected_actions)
   end
-  failure_message_for_should do |actual|
+  failure_message do |actual|
     updates = actual.select { |event, resource, action| event == :resource_updated }.to_a
     result = "expected that the chef_run would #{expected_actions.join(',')} #{resource_name}."
     if updates.size > 0
@@ -99,7 +99,7 @@ RSpec::Matchers.define :have_updated do |resource_name, *expected_actions|
     end
     result
   end
-  failure_message_for_should_not do |actual|
+  failure_message_when_negated do |actual|
     updates = actual.select { |event, resource, action| event == :resource_updated }.to_a
     result = "expected that the chef_run would not #{expected_actions.join(',')} #{resource_name}."
     if updates.size > 0
@@ -114,7 +114,6 @@ end
 RSpec.configure do |config|
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
-  config.treat_symbols_as_metadata_keys_with_true_values = true
 
   config.before :each do
     Chef::Config.reset

data/spec/unit/get_private_key_spec.rb

@@ -0,0 +1,93 @@
+require 'support/spec_support'
+
+describe Cheffish do
+  let(:directory_that_exists) {
+    Dir.mktmpdir("cheffish-rspec")
+  }
+
+  let(:directory_that_does_not_exist) {
+    dir = Dir.mktmpdir("cheffish-rspec")
+    FileUtils.remove_entry dir
+    dir
+  }
+
+  let(:private_key_contents) { "contents of private key" }
+
+  let(:private_key_pem_contents) { "contents of private key pem" }
+
+  let(:private_key_garbage_contents) { "da vinci virus" }
+
+  def setup_key
+    key_file = File.expand_path("ned_stark", directory_that_exists)
+    File.open(key_file, "w+") do |f|
+      f.write private_key_contents
+    end
+  end
+
+  def setup_pem_key
+    key_file = File.expand_path("ned_stark.pem", directory_that_exists)
+    File.open(key_file, "w+") do |f|
+      f.write private_key_pem_contents
+    end
+  end
+
+  def setup_garbage_key
+    key_file = File.expand_path("ned_stark.pem.bak", directory_that_exists)
+    File.open(key_file, "w+") do |f|
+      f.write private_key_garbage_contents
+    end
+  end
+
+  shared_examples_for "returning the contents of the key file if it finds one" do
+    it "returns nil if it cannot find the private key file" do
+      expect(Cheffish.get_private_key("ned_stark", config)).to be_nil
+    end
+
+    it "returns the contents of the key if it doesn't have an extension" do
+      setup_key
+      expect(Cheffish.get_private_key("ned_stark", config)).to eq(private_key_contents)
+    end
+
+    it "returns the contents of the key if it has an extension" do
+      setup_pem_key
+      expect(Cheffish.get_private_key("ned_stark", config)).to eq(private_key_pem_contents)
+    end
+
+    # we arbitrarily prefer "ned_stark" over "ned_stark.pem" for deterministic behavior
+    it "returns the contents of the key that does not have an extension if both exist" do
+      setup_key
+      setup_pem_key
+      expect(Cheffish.get_private_key("ned_stark", config)).to eq(private_key_contents)
+    end
+  end
+
+  context "#get_private_key" do
+    context "when private_key_paths has a directory which is empty" do
+      let(:config) {
+        { :private_key_paths => [ directory_that_exists ] }
+      }
+
+      it_behaves_like "returning the contents of the key file if it finds one"
+
+      context "when it also has a garbage file" do
+        before { setup_garbage_key }
+
+        it "does not return the da vinci virus if we find only the garbage file" do
+          setup_garbage_key
+          expect(Cheffish.get_private_key("ned_stark", config)).to be_nil
+        end
+
+        it_behaves_like "returning the contents of the key file if it finds one"
+      end
+
+    end
+
+    context "when private_key_paths leads with a directory that does not exist and then an empty directory" do
+      let(:config) {
+        { :private_key_paths => [ directory_that_does_not_exist, directory_that_exists ] }
+      }
+
+      it_behaves_like "returning the contents of the key file if it finds one"
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cheffish
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: '0.7'
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-18 00:00:00.000000000 Z
+date: 2014-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: chef-zero
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -42,16 +56,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 description: A library to manipulate Chef in Chef.
 email: jkeiser@opscode.com
 executables: []
@@ -104,6 +118,7 @@ files:
 - spec/integration/recipe_dsl_spec.rb
 - spec/support/key_support.rb
 - spec/support/spec_support.rb
+- spec/unit/get_private_key_spec.rb
 homepage: http://wiki.opscode.com/display/chef
 licenses: []
 metadata: {}