chef 12.0.0.alpha.0 → 12.0.0.alpha.1

data/spec/functional/resource/{user_spec.rb → user/useradd_spec.rb}

@@ -18,14 +18,24 @@
 #
 
 require 'spec_helper'
+require 'functional/resource/base'
 require 'chef/mixin/shell_out'
 
+def user_provider_for_platform
+  case ohai[:platform]
+  when "aix"
+    Chef::Provider::User::Aix
+  else
+    Chef::Provider::User::Useradd
+  end
+end
+
 metadata = { :unix_only => true,
   :requires_root => true,
-  :provider => {:user => Chef::Provider::User::Useradd}
+  :provider => {:user => user_provider_for_platform}
 }
 
-describe Chef::Resource::User, metadata do
+describe Chef::Provider::User::Useradd, metadata do
 
   include Chef::Mixin::ShellOut
 
@@ -46,15 +56,27 @@ describe Chef::Resource::User, metadata do
   end
 
   def etc_shadow
-    File.open("/etc/shadow") {|f| f.read }
+    case ohai[:platform]
+    when "aix"
+      File.open("/etc/security/passwd") {|f| f.read }
+    else
+      File.open("/etc/shadow") {|f| f.read }
+    end
   end
 
   def supports_quote_in_username?
     OHAI_SYSTEM["platform_family"] == "debian"
   end
 
+  def password_should_be_set
+    if ohai[:platform] == "aix"
+      pw_entry.passwd.should == "!"
+    else
+      pw_entry.passwd.should == "x"
+    end
+  end
+
   before do
-    pending "porting implementation for user provider in aix" if OHAI_SYSTEM[:platform] == 'aix'
     # Silence shell_out live stream
     Chef::Log.level = :warn
   end
@@ -62,7 +84,7 @@ describe Chef::Resource::User, metadata do
   after do
     begin
       pw_entry # will raise if the user doesn't exist
-      shell_out!("userdel", "-f", "-r", username, :returns => [0,12])
+      shell_out!("userdel", "-r", username, :returns => [0,12])
     rescue UserNotFound
       # nothing to remove
     end
@@ -83,7 +105,7 @@ describe Chef::Resource::User, metadata do
   end
 
   let(:username) do
-    "chef-functional-test"
+    "cf-test"
   end
 
   let(:uid) { nil }
@@ -105,6 +127,14 @@ describe Chef::Resource::User, metadata do
     r
   end
 
+  let(:expected_shadow) do
+    if ohai[:platform] == "aix"
+      expected_shadow = "cf-test"  # For aix just check user entry in shadow file
+    else
+      expected_shadow = "cf-test:$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/"
+    end
+  end
+
   let(:skip) { false }
 
   describe "action :create" do
@@ -218,10 +248,17 @@ describe Chef::Resource::User, metadata do
 
       context "when a password is specified" do
         # openssl passwd -1 "secretpassword"
-        let(:password) { "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/" }
+        let(:password) do
+          case ohai[:platform]
+          when "aix"
+            "eL5qfEVznSNss"
+          else
+            "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/"
+          end
+        end
+
         it "sets the user's shadow password" do
-          pw_entry.passwd.should == "x"
-          expected_shadow = "chef-functional-test:$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/"
+          password_should_be_set
           etc_shadow.should include(expected_shadow)
         end
       end
@@ -229,14 +266,21 @@ describe Chef::Resource::User, metadata do
       context "when a system user is specified" do
         let(:system) { true }
         let(:uid_min) do
-          # from `man useradd`, login user means uid will be between
-          # UID_SYS_MIN and UID_SYS_MAX defined in /etc/login.defs. On my
-          # Ubuntu 13.04 system, these are commented out, so we'll look at
-          # UID_MIN to find the lower limit of the non-system-user range, and
-          # use that value in our assertions.
-          login_defs = File.open("/etc/login.defs", "rb") {|f| f.read }
-          uid_min_scan = /^UID_MIN\s+(\d+)/
-          login_defs.match(uid_min_scan)[1]
+          case ohai[:platform]
+          when "aix"
+            # UIDs and GIDs below 100 are typically reserved for system accounts and services
+            # http://www.ibm.com/developerworks/aix/library/au-satuidgid/
+            100
+          else
+            # from `man useradd`, login user means uid will be between
+            # UID_SYS_MIN and UID_SYS_MAX defined in /etc/login.defs. On my
+            # Ubuntu 13.04 system, these are commented out, so we'll look at
+            # UID_MIN to find the lower limit of the non-system-user range, and
+            # use that value in our assertions.
+            login_defs = File.open("/etc/login.defs", "rb") {|f| f.read }
+            uid_min_scan = /^UID_MIN\s+(\d+)/
+            login_defs.match(uid_min_scan)[1]
+          end
         end
 
         it "ensures the user has the properties of a system user" do
@@ -284,7 +328,15 @@ describe Chef::Resource::User, metadata do
         let(:home) { "/home/bobo" }
         let(:manage_home) { true }
         # openssl passwd -1 "secretpassword"
-        let(:password) { "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/" }
+        let(:password) do
+          case ohai[:platform]
+          when "aix"
+            "eL5qfEVznSNss"
+          else
+            "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/"
+          end
+        end
+
         let(:system) { false }
         let(:comment) { "hello this is dog" }
 
@@ -347,6 +399,11 @@ describe Chef::Resource::User, metadata do
               File.should_not exist("/home/foo")
               File.should exist("/home/bar")
             end
+          elsif ohai[:platform] == "aix"
+            it "creates the home dir in the desired location" do
+              File.should_not exist("/home/foo")
+              File.should exist("/home/bar")
+            end
           else
             it "does not create the home dir in the desired location (XXX)" do
               # This behavior seems contrary to expectation and non-convergent.
@@ -370,11 +427,18 @@ describe Chef::Resource::User, metadata do
 
       context "and a password is added" do
         # openssl passwd -1 "secretpassword"
-        let(:password) { "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/" }
+        let(:password) do
+          case ohai[:platform]
+          when "aix"
+            "eL5qfEVznSNss"
+          else
+            "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/"
+          end
+        end
+
 
         it "ensures the password is set" do
-          pw_entry.passwd.should == "x"
-          expected_shadow = "chef-functional-test:$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/"
+          password_should_be_set
           etc_shadow.should include(expected_shadow)
         end
 
@@ -382,13 +446,28 @@ describe Chef::Resource::User, metadata do
 
       context "and the password is updated" do
         # openssl passwd -1 "OLDpassword"
-        let(:existing_password) { "$1$1dVmwm4z$CftsFn8eBDjDRUytYKkXB." }
+        let(:existing_password) do
+          case ohai[:platform]
+          when "aix"
+            "jkzG6MvUxjk2g"
+          else
+            "$1$1dVmwm4z$CftsFn8eBDjDRUytYKkXB."
+          end
+        end
+
         # openssl passwd -1 "secretpassword"
-        let(:password) { "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/" }
+        let(:password) do
+          case ohai[:platform]
+          when "aix"
+            "eL5qfEVznSNss"
+          else
+            "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/"
+          end
+        end
+
 
         it "ensures the password is set to the desired value" do
-          pw_entry.passwd.should == "x"
-          expected_shadow = "chef-functional-test:$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/"
+          password_should_be_set
           etc_shadow.should include(expected_shadow)
         end
       end
@@ -427,15 +506,47 @@ describe Chef::Resource::User, metadata do
       shadow_entry.split(':')[1]
     end
 
+    def aix_user_lock_status
+      lock_info = shell_out!("lsuser -a account_locked #{username}")
+      status = /\S+\s+account_locked=(\S+)/.match(lock_info.stdout)[1]
+    end
+
+    def user_account_should_be_locked
+      case ohai[:platform]
+      when "aix"
+        aix_user_lock_status.should == "true"
+      else
+        shadow_password.should include("!")
+      end
+    end
+
+    def user_account_should_be_unlocked
+      case ohai[:platform]
+      when "aix"
+        aix_user_lock_status.should == "false"
+      else
+        shadow_password.should_not include("!")
+      end
+    end
+
+    def lock_user_account
+      case ohai[:platform]
+      when "aix"
+        shell_out!("chuser account_locked=true #{username}")
+      else
+        shell_out!("usermod -L #{username}")
+      end
+    end
+
     before do
       # create user and setup locked/unlocked state
       user_resource.dup.run_action(:create)
 
       if user_locked_context?
-        shell_out!("usermod -L #{username}")
-        shadow_password.should include("!")
+        lock_user_account
+        user_account_should_be_locked
       elsif password
-        shadow_password.should_not include("!")
+        user_account_should_be_unlocked
       end
     end
   end
@@ -457,16 +568,32 @@ describe Chef::Resource::User, metadata do
 
       context "and the user is not locked" do
         # user will be locked if it has no password
-        let(:password) { "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/" }
+        let(:password) do
+          case ohai[:platform]
+          when "aix"
+            "eL5qfEVznSNss"
+          else
+            "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/"
+          end
+        end
+
 
         it "locks the user's password" do
-          shadow_password.should include("!")
+          user_account_should_be_locked
         end
       end
 
       context "and the user is locked" do
         # user will be locked if it has no password
-        let(:password) { "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/" }
+        let(:password) do
+          case ohai[:platform]
+          when "aix"
+            "eL5qfEVznSNss"
+          else
+            "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/"
+          end
+        end
+
         let(:user_locked_context?) { true }
         it "does not update the user" do
           user_resource.should_not be_updated_by_last_action
@@ -518,14 +645,27 @@ describe Chef::Resource::User, metadata do
             # DEBUG: ---- End output of usermod -U chef-functional-test ----
             # DEBUG: Ran usermod -U chef-functional-test returned 0
             @error.should be_nil
-            pw_entry.passwd.should == 'x'
-            shadow_password.should == "!"
+            if ohai[:platform] == "aix"
+              pw_entry.passwd.should == '*'
+              user_account_should_be_unlocked
+            else
+              pw_entry.passwd.should == 'x'
+              shadow_password.should include("!")
+            end
           end
         end
       end
 
       context "and has a password" do
-        let(:password) { "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/" }
+        let(:password) do
+          case ohai[:platform]
+          when "aix"
+            "eL5qfEVznSNss"
+          else
+            "$1$RRa/wMM/$XltKfoX5ffnexVF4dHZZf/"
+          end
+        end
+
         context "and the user is not locked" do
           it "does not update the user" do
             user_resource.should_not be_updated_by_last_action
@@ -536,9 +676,7 @@ describe Chef::Resource::User, metadata do
           let(:user_locked_context?) { true }
 
           it "unlocks the user's password" do
-            shadow_entry = etc_shadow.lines.select {|l| l.include?(username) }.first
-            shadow_password = shadow_entry.split(':')[1]
-            shadow_password.should_not include("!")
+            user_account_should_be_unlocked
           end
         end
       end

data/spec/integration/client/client_spec.rb

@@ -2,7 +2,7 @@ require 'support/shared/integration/integration_helper'
 require 'chef/mixin/shell_out'
 
 describe "chef-client" do
-  extend IntegrationSupport
+  include IntegrationSupport
   include Chef::Mixin::ShellOut
 
   let(:chef_dir) { File.join(File.dirname(__FILE__), "..", "..", "..", "bin") }
@@ -19,7 +19,7 @@ describe "chef-client" do
   let(:chef_client) { "ruby #{chef_dir}/chef-client" }
 
   when_the_repository "has a cookbook with a no-op recipe" do
-    file 'cookbooks/x/recipes/default.rb', ''
+    before { file 'cookbooks/x/recipes/default.rb', '' }
 
     it "should complete with success" do
       file 'config/client.rb', <<EOM
@@ -49,7 +49,7 @@ EOM
     end
 
     context 'and a config file under .chef/knife.rb' do
-      file '.chef/knife.rb', 'xxx.xxx'
+      before { file '.chef/knife.rb', 'xxx.xxx' }
 
       it 'should load .chef/knife.rb when -z is specified' do
         result = shell_out("#{chef_client} -z -o 'x::default' --config-file-jail \"#{path_to('')}\"", :cwd => path_to(''))
@@ -74,7 +74,8 @@ EOM
     end
 
     context 'and a private key' do
-      file 'mykey.pem', <<EOM
+      before do
+        file 'mykey.pem', <<EOM
 -----BEGIN RSA PRIVATE KEY-----
 MIIEogIBAAKCAQEApubutqtYYQ5UiA9QhWP7UvSmsfHsAoPKEVVPdVW/e8Svwpyf
 0Xef6OFWVmBE+W442ZjLOe2y6p2nSnaq4y7dg99NFz6X+16mcKiCbj0RCiGqCvCk
@@ -103,6 +104,7 @@ syHLXYFNy0OxMtH/bBAXBGNHd9gf5uOnqh0pYcbe/uRAxumC7Rl0cL509eURiA2T
 +vFmf54y9YdnLXaqv+FhJT6B6V7WX7IpU9BMqJY1cJYXHuHG2KA=
 -----END RSA PRIVATE KEY-----
 EOM
+      end
 
       it "should complete with success even with a client key" do
         file 'config/client.rb', <<EOM

data/spec/integration/client/ipv6_spec.rb

@@ -19,7 +19,7 @@ require 'support/shared/integration/integration_helper'
 require 'chef/mixin/shell_out'
 
 describe "chef-client" do
-  extend IntegrationSupport
+  include IntegrationSupport
   include Chef::Mixin::ShellOut
 
   let(:chef_zero_opts) { {:host => "::1"} }
@@ -87,8 +87,8 @@ END_CLIENT_RB
   when_the_chef_server "is running on IPv6", :not_supported_on_solaris do
 
     when_the_repository "has a cookbook with a no-op recipe" do
-      cookbook 'noop', '1.0.0', { 'metadata.rb' => 'version "1.0.0"' }, "recipes" => {"default.rb" => "#raise 'foo'"}
       before do
+        cookbook 'noop', '1.0.0', { }, "recipes" => {"default.rb" => "#raise 'foo'"}
         file 'config/client.rb', client_rb_content
         file 'config/validator.pem', validation_pem
       end
@@ -102,21 +102,23 @@ END_CLIENT_RB
 
     when_the_repository "has a cookbook that hits server APIs" do
 
-      recipe=<<-END_RECIPE
-        actual_item = data_bag_item("expect_bag", "expect_item")
-        if actual_item.key?("expect_key") and actual_item["expect_key"] == "expect_value"
-          Chef::Log.info "lookin good"
-        else
-          Chef::Log.error("!" * 80)
-          raise "unexpected data bag item content \#{actual_item.inspect}"
-          Chef::Log.error("!" * 80)
-        end
+      before do
+        recipe=<<-END_RECIPE
+          actual_item = data_bag_item("expect_bag", "expect_item")
+          if actual_item.key?("expect_key") and actual_item["expect_key"] == "expect_value"
+            Chef::Log.info "lookin good"
+          else
+            Chef::Log.error("!" * 80)
+            raise "unexpected data bag item content \#{actual_item.inspect}"
+            Chef::Log.error("!" * 80)
+          end
 
-      END_RECIPE
+        END_RECIPE
 
-      data_bag('expect_bag', { 'expect_item' => {"expect_key" => "expect_value"} })
+        data_bag('expect_bag', { 'expect_item' => {"expect_key" => "expect_value"} })
 
-      cookbook 'api-smoke-test', '1.0.0', { 'metadata.rb' => 'version "1.0.0"' }, "recipes" => {"default.rb" => recipe}
+        cookbook 'api-smoke-test', '1.0.0', { }, "recipes" => {"default.rb" => recipe}
+      end
 
       before do
         file 'config/client.rb', client_rb_content

data/spec/integration/knife/chef_fs_data_store_spec.rb

@@ -23,17 +23,22 @@ require 'chef/knife/raw'
 require 'chef/knife/cookbook_upload'
 
 describe 'ChefFSDataStore tests' do
-  extend IntegrationSupport
+  include IntegrationSupport
   include KnifeSupport
 
+  let(:cookbook_x_100_metadata_rb) { cb_metadata("x", "1.0.0") }
+  let(:cookbook_z_100_metadata_rb) { cb_metadata("z", "1.0.0") }
+
   when_the_repository "has one of each thing" do
-    file 'clients/x.json', {}
-    file 'cookbooks/x/metadata.rb', 'version "1.0.0"'
-    file 'data_bags/x/y.json', {}
-    file 'environments/x.json', {}
-    file 'nodes/x.json', {}
-    file 'roles/x.json', {}
-    file 'users/x.json', {}
+    before do
+      file 'clients/x.json', {}
+      file 'cookbooks/x/metadata.rb', cookbook_x_100_metadata_rb
+      file 'data_bags/x/y.json', {}
+      file 'environments/x.json', {}
+      file 'nodes/x.json', {}
+      file 'roles/x.json', {}
+      file 'users/x.json', {}
+    end
 
     context 'GET /TYPE' do
       it 'knife list -z -R returns everything' do
@@ -102,41 +107,43 @@ EOM
 
     context 'GET /TYPE/NAME' do
       it 'knife show -z /clients/x.json works' do
-        knife('show -z /clients/x.json').should_succeed /"x"/
+        knife('show -z /clients/x.json').should_succeed( /"x"/ )
       end
 
       it 'knife show -z /cookbooks/x/metadata.rb works' do
-        knife('show -z /cookbooks/x/metadata.rb').should_succeed "/cookbooks/x/metadata.rb:\nversion \"1.0.0\"\n"
+        knife('show -z /cookbooks/x/metadata.rb').should_succeed "/cookbooks/x/metadata.rb:\n#{cookbook_x_100_metadata_rb}\n"
       end
 
       it 'knife show -z /data_bags/x/y.json works' do
-        knife('show -z /data_bags/x/y.json').should_succeed /"y"/
+        knife('show -z /data_bags/x/y.json').should_succeed( /"y"/ )
       end
 
       it 'knife show -z /environments/x.json works' do
-        knife('show -z /environments/x.json').should_succeed /"x"/
+        knife('show -z /environments/x.json').should_succeed( /"x"/ )
       end
 
       it 'knife show -z /nodes/x.json works' do
-        knife('show -z /nodes/x.json').should_succeed /"x"/
+        knife('show -z /nodes/x.json').should_succeed( /"x"/ )
       end
 
       it 'knife show -z /roles/x.json works' do
-        knife('show -z /roles/x.json').should_succeed /"x"/
+        knife('show -z /roles/x.json').should_succeed( /"x"/ )
       end
 
       it 'knife show -z /users/x.json works' do
-        knife('show -z /users/x.json').should_succeed /"x"/
+        knife('show -z /users/x.json').should_succeed( /"x"/ )
       end
     end
 
     context 'PUT /TYPE/NAME' do
-      file 'empty.json', {}
-      file 'rolestuff.json', '{"description":"hi there","name":"x"}'
-      file 'cookbooks_to_upload/x/metadata.rb', "version '1.0.0'\n\n"
+      before do
+        file 'empty.json', {}
+        file 'rolestuff.json', '{"description":"hi there","name":"x"}'
+        file 'cookbooks_to_upload/x/metadata.rb', cookbook_x_100_metadata_rb
+      end
 
       it 'knife raw -z -i empty.json -m PUT /clients/x' do
-        knife("raw -z -i #{path_to('empty.json')} -m PUT /clients/x").should_succeed /"x"/
+        knife("raw -z -i #{path_to('empty.json')} -m PUT /clients/x").should_succeed( /"x"/ )
         knife('list --local /clients').should_succeed "/clients/x.json\n"
       end
 
@@ -149,32 +156,32 @@ EOM
       end
 
       it 'knife raw -z -i empty.json -m PUT /data/x/y' do
-        knife("raw -z -i #{path_to('empty.json')} -m PUT /data/x/y").should_succeed /"y"/
+        knife("raw -z -i #{path_to('empty.json')} -m PUT /data/x/y").should_succeed( /"y"/ )
         knife('list --local -Rfp /data_bags').should_succeed "/data_bags/x/\n/data_bags/x/y.json\n"
       end
 
       it 'knife raw -z -i empty.json -m PUT /environments/x' do
-        knife("raw -z -i #{path_to('empty.json')} -m PUT /environments/x").should_succeed /"x"/
+        knife("raw -z -i #{path_to('empty.json')} -m PUT /environments/x").should_succeed( /"x"/ )
         knife('list --local /environments').should_succeed "/environments/x.json\n"
       end
 
       it 'knife raw -z -i empty.json -m PUT /nodes/x' do
-        knife("raw -z -i #{path_to('empty.json')} -m PUT /nodes/x").should_succeed /"x"/
+        knife("raw -z -i #{path_to('empty.json')} -m PUT /nodes/x").should_succeed( /"x"/ )
         knife('list --local /nodes').should_succeed "/nodes/x.json\n"
       end
 
       it 'knife raw -z -i empty.json -m PUT /roles/x' do
-        knife("raw -z -i #{path_to('empty.json')} -m PUT /roles/x").should_succeed /"x"/
+        knife("raw -z -i #{path_to('empty.json')} -m PUT /roles/x").should_succeed( /"x"/ )
         knife('list --local /roles').should_succeed "/roles/x.json\n"
       end
 
       it 'knife raw -z -i empty.json -m PUT /users/x' do
-        knife("raw -z -i #{path_to('empty.json')} -m PUT /users/x").should_succeed /"x"/
+        knife("raw -z -i #{path_to('empty.json')} -m PUT /users/x").should_succeed( /"x"/ )
         knife('list --local /users').should_succeed "/users/x.json\n"
       end
 
       it 'After knife raw -z -i rolestuff.json -m PUT /roles/x, the output is pretty', :pending => (RUBY_VERSION < "1.9") do
-        knife("raw -z -i #{path_to('rolestuff.json')} -m PUT /roles/x").should_succeed /"x"/
+        knife("raw -z -i #{path_to('rolestuff.json')} -m PUT /roles/x").should_succeed( /"x"/ )
         IO.read(path_to('roles/x.json')).should == <<EOM.strip
 {
   "name": "x",
@@ -187,14 +194,16 @@ EOM
 
   when_the_repository 'is empty' do
     context 'POST /TYPE/NAME' do
-      file 'empty.json', { 'name' => 'z' }
-      file 'empty_x.json', { 'name' => 'x' }
-      file 'empty_id.json', { 'id' => 'z' }
-      file 'rolestuff.json', '{"description":"hi there","name":"x"}'
-      file 'cookbooks_to_upload/z/metadata.rb', "version '1.0.0'"
+      before do
+        file 'empty.json', { 'name' => 'z' }
+        file 'empty_x.json', { 'name' => 'x' }
+        file 'empty_id.json', { 'id' => 'z' }
+        file 'rolestuff.json', '{"description":"hi there","name":"x"}'
+        file 'cookbooks_to_upload/z/metadata.rb', cookbook_z_100_metadata_rb
+      end
 
       it 'knife raw -z -i empty.json -m POST /clients' do
-        knife("raw -z -i #{path_to('empty.json')} -m POST /clients").should_succeed /uri/
+        knife("raw -z -i #{path_to('empty.json')} -m POST /clients").should_succeed( /uri/ )
         knife('list --local /clients').should_succeed "/clients/z.json\n"
       end
 
@@ -207,38 +216,38 @@ EOM
       end
 
       it 'knife raw -z -i empty.json -m POST /data' do
-        knife("raw -z -i #{path_to('empty.json')} -m POST /data").should_succeed /uri/
+        knife("raw -z -i #{path_to('empty.json')} -m POST /data").should_succeed( /uri/ )
         knife('list --local -Rfp /data_bags').should_succeed "/data_bags/z/\n"
       end
 
       it 'knife raw -z -i empty.json -m POST /data/x' do
-        knife("raw -z -i #{path_to('empty_x.json')} -m POST /data").should_succeed /uri/
-        knife("raw -z -i #{path_to('empty_id.json')} -m POST /data/x").should_succeed /"z"/
+        knife("raw -z -i #{path_to('empty_x.json')} -m POST /data").should_succeed( /uri/ )
+        knife("raw -z -i #{path_to('empty_id.json')} -m POST /data/x").should_succeed( /"z"/ )
         knife('list --local -Rfp /data_bags').should_succeed "/data_bags/x/\n/data_bags/x/z.json\n"
       end
 
       it 'knife raw -z -i empty.json -m POST /environments' do
-        knife("raw -z -i #{path_to('empty.json')} -m POST /environments").should_succeed /uri/
+        knife("raw -z -i #{path_to('empty.json')} -m POST /environments").should_succeed( /uri/ )
         knife('list --local /environments').should_succeed "/environments/z.json\n"
       end
 
       it 'knife raw -z -i empty.json -m POST /nodes' do
-        knife("raw -z -i #{path_to('empty.json')} -m POST /nodes").should_succeed /uri/
+        knife("raw -z -i #{path_to('empty.json')} -m POST /nodes").should_succeed( /uri/ )
         knife('list --local /nodes').should_succeed "/nodes/z.json\n"
       end
 
       it 'knife raw -z -i empty.json -m POST /roles' do
-        knife("raw -z -i #{path_to('empty.json')} -m POST /roles").should_succeed /uri/
+        knife("raw -z -i #{path_to('empty.json')} -m POST /roles").should_succeed( /uri/ )
         knife('list --local /roles').should_succeed "/roles/z.json\n"
       end
 
       it 'knife raw -z -i empty.json -m POST /users' do
-        knife("raw -z -i #{path_to('empty.json')} -m POST /users").should_succeed /uri/
+        knife("raw -z -i #{path_to('empty.json')} -m POST /users").should_succeed( /uri/ )
         knife('list --local /users').should_succeed "/users/z.json\n"
       end
 
       it 'After knife raw -z -i rolestuff.json -m POST /roles, the output is pretty', :pending => (RUBY_VERSION < "1.9") do
-        knife("raw -z -i #{path_to('rolestuff.json')} -m POST /roles").should_succeed /uri/
+        knife("raw -z -i #{path_to('rolestuff.json')} -m POST /roles").should_succeed( /uri/ )
         IO.read(path_to('roles/x.json')).should == <<EOM.strip
 {
   "name": "x",
@@ -325,30 +334,32 @@ EOM
     end
 
     context 'PUT /TYPE/NAME' do
-      file 'empty.json', {}
+      before do
+        file 'empty.json', {}
+      end
 
       it 'knife raw -z -i empty.json -m PUT /clients/x fails with 404' do
-        knife("raw -z -i #{path_to('empty.json')} -m PUT /clients/x").should_fail /404/
+        knife("raw -z -i #{path_to('empty.json')} -m PUT /clients/x").should_fail( /404/ )
       end
 
       it 'knife raw -z -i empty.json -m PUT /data/x/y fails with 404' do
-        knife("raw -z -i #{path_to('empty.json')} -m PUT /data/x/y").should_fail /404/
+        knife("raw -z -i #{path_to('empty.json')} -m PUT /data/x/y").should_fail( /404/ )
       end
 
       it 'knife raw -z -i empty.json -m PUT /environments/x fails with 404' do
-        knife("raw -z -i #{path_to('empty.json')} -m PUT /environments/x").should_fail /404/
+        knife("raw -z -i #{path_to('empty.json')} -m PUT /environments/x").should_fail( /404/ )
       end
 
       it 'knife raw -z -i empty.json -m PUT /nodes/x fails with 404' do
-        knife("raw -z -i #{path_to('empty.json')} -m PUT /nodes/x").should_fail /404/
+        knife("raw -z -i #{path_to('empty.json')} -m PUT /nodes/x").should_fail( /404/ )
       end
 
       it 'knife raw -z -i empty.json -m PUT /roles/x fails with 404' do
-        knife("raw -z -i #{path_to('empty.json')} -m PUT /roles/x").should_fail /404/
+        knife("raw -z -i #{path_to('empty.json')} -m PUT /roles/x").should_fail( /404/ )
       end
 
       it 'knife raw -z -i empty.json -m PUT /users/x fails with 404' do
-        knife("raw -z -i #{path_to('empty.json')} -m PUT /users/x").should_fail /404/
+        knife("raw -z -i #{path_to('empty.json')} -m PUT /users/x").should_fail( /404/ )
       end
     end
   end