chef 12.0.3 → 12.1.0.rc.0

data/spec/support/shared/unit/windows_script_resource.rb

@@ -35,30 +35,30 @@ shared_examples_for "a Windows script resource" do
   end
 
   it "should be a kind of Chef::Resource::WindowsScript" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::WindowsScript)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::WindowsScript)
   end
 
   context "when evaluating guards" do
     it "should have a default_guard_interpreter attribute that is the same as the resource" do
-      @resource.default_guard_interpreter.should == @resource.resource_name
+      expect(@resource.default_guard_interpreter).to eq(@resource.resource_name)
     end
 
     it "should default to using guard_interpreter attribute that is the same as the resource" do
-      @resource.guard_interpreter.should == @resource.resource_name
+      expect(@resource.guard_interpreter).to eq(@resource.resource_name)
     end
 
     it "should use a resource to evaluate the guard when guard_interpreter is not specified" do
-      Chef::GuardInterpreter::ResourceGuardInterpreter.any_instance.should_receive(:evaluate_action).and_return(true)
-      Chef::GuardInterpreter::DefaultGuardInterpreter.any_instance.should_not_receive(:evaluate)
+      expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(true)
+      expect_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).not_to receive(:evaluate)
       @resource.only_if 'echo hi'
-      @resource.should_skip?(:run).should == nil
+      expect(@resource.should_skip?(:run)).to eq(nil)
     end
 
     describe "when the guard is given a ruby block" do
       it "should evaluate the guard if the guard_interpreter is set to its default value" do
         @resource.only_if { true }
-        @resource.should_skip?(:run).should == nil
+        expect(@resource.should_skip?(:run)).to eq(nil)
       end
 
       it "should raise an exception if the guard_interpreter is overridden from its default value" do

data/spec/unit/api_client/registration_spec.rb

@@ -85,7 +85,7 @@ describe Chef::ApiClient::Registration do
   before do
     Chef::Config[:validation_client_name] = "test-validator"
     Chef::Config[:validation_key] = File.expand_path('ssl/private_key.pem', CHEF_SPEC_DATA)
-    OpenSSL::PKey::RSA.stub(:generate).with(2048).and_return(generated_private_key)
+    allow(OpenSSL::PKey::RSA).to receive(:generate).with(2048).and_return(generated_private_key)
   end
 
   after do
@@ -93,51 +93,51 @@ describe Chef::ApiClient::Registration do
   end
 
   it "has an HTTP client configured with validator credentials" do
-    registration.http_api.should be_a_kind_of(Chef::REST)
-    registration.http_api.client_name.should == "test-validator"
-    registration.http_api.signing_key.should == private_key_data
+    expect(registration.http_api).to be_a_kind_of(Chef::REST)
+    expect(registration.http_api.client_name).to eq("test-validator")
+    expect(registration.http_api.signing_key).to eq(private_key_data)
   end
 
   describe "when creating/updating the client on the server" do
     before do
-      registration.stub(:http_api).and_return(http_mock)
+      allow(registration).to receive(:http_api).and_return(http_mock)
     end
 
     it "posts a locally generated public key to the server to create a client" do
-      http_mock.should_receive(:post).
+      expect(http_mock).to receive(:post).
         with("clients", expected_post_data).
         and_return(create_with_pkey_response)
-      registration.create_or_update.should == create_with_pkey_response
-      registration.private_key.should == generated_private_key_pem
+      expect(registration.create_or_update).to eq(create_with_pkey_response)
+      expect(registration.private_key).to eq(generated_private_key_pem)
     end
 
     it "puts a locally generated public key to the server to update a client" do
-      http_mock.should_receive(:post).
+      expect(http_mock).to receive(:post).
         with("clients", expected_post_data).
         and_raise(exception_409)
-      http_mock.should_receive(:put).
+      expect(http_mock).to receive(:put).
         with("clients/#{client_name}", expected_put_data).
         and_return(update_with_pkey_response)
-      registration.create_or_update.should == update_with_pkey_response
-      registration.private_key.should == generated_private_key_pem
+      expect(registration.create_or_update).to eq(update_with_pkey_response)
+      expect(registration.private_key).to eq(generated_private_key_pem)
     end
 
     it "writes the generated private key to disk" do
-      http_mock.should_receive(:post).
+      expect(http_mock).to receive(:post).
         with("clients", expected_post_data).
         and_return(create_with_pkey_response)
       registration.run
-      IO.read(key_location).should == generated_private_key_pem
+      expect(IO.read(key_location)).to eq(generated_private_key_pem)
     end
 
     context "and the client already exists on a Chef 11 server" do
       it "requests a new key from the server and saves it" do
-        http_mock.should_receive(:post).and_raise(exception_409)
-        http_mock.should_receive(:put).
+        expect(http_mock).to receive(:post).and_raise(exception_409)
+        expect(http_mock).to receive(:put).
           with("clients/#{client_name}", expected_put_data).
           and_return(update_with_pkey_response)
-        registration.create_or_update.should == update_with_pkey_response
-        registration.private_key.should == generated_private_key_pem
+        expect(registration.create_or_update).to eq(update_with_pkey_response)
+        expect(registration.private_key).to eq(generated_private_key_pem)
       end
     end
 
@@ -153,37 +153,37 @@ describe Chef::ApiClient::Registration do
 
       before do
         Chef::Config[:local_key_generation] = false
-        OpenSSL::PKey::RSA.should_not_receive(:generate)
+        expect(OpenSSL::PKey::RSA).not_to receive(:generate)
       end
 
       it "creates a new ApiClient on the server using the validator identity" do
-        http_mock.should_receive(:post).
+        expect(http_mock).to receive(:post).
           with("clients", expected_post_data).
           and_return(server_v10_response)
-        registration.create_or_update.should == server_v10_response
-        registration.private_key.should == "--begin rsa key etc--"
+        expect(registration.create_or_update).to eq(server_v10_response)
+        expect(registration.private_key).to eq("--begin rsa key etc--")
       end
 
       context "and the client already exists on a Chef 11 server" do
         it "requests a new key from the server and saves it" do
-          http_mock.should_receive(:post).and_raise(exception_409)
-          http_mock.should_receive(:put).
+          expect(http_mock).to receive(:post).and_raise(exception_409)
+          expect(http_mock).to receive(:put).
             with("clients/#{client_name}", expected_put_data).
             and_return(server_v11_response)
-          registration.create_or_update.should == server_v11_response
-          registration.private_key.should == "--begin rsa key etc--"
+          expect(registration.create_or_update).to eq(server_v11_response)
+          expect(registration.private_key).to eq("--begin rsa key etc--")
         end
       end
 
       context "and the client already exists on a Chef 10 server" do
         it "requests a new key from the server and saves it" do
-          http_mock.should_receive(:post).with("clients", expected_post_data).
+          expect(http_mock).to receive(:post).with("clients", expected_post_data).
             and_raise(exception_409)
-          http_mock.should_receive(:put).
+          expect(http_mock).to receive(:put).
             with("clients/#{client_name}", expected_put_data).
             and_return(server_v10_response)
-          registration.create_or_update.should == server_v10_response
-          registration.private_key.should == "--begin rsa key etc--"
+          expect(registration.create_or_update).to eq(server_v10_response)
+          expect(registration.private_key).to eq("--begin rsa key etc--")
         end
       end
     end
@@ -191,23 +191,23 @@ describe Chef::ApiClient::Registration do
 
   describe "when writing the private key to disk" do
     before do
-      registration.stub(:private_key).and_return('--begin rsa key etc--')
+      allow(registration).to receive(:private_key).and_return('--begin rsa key etc--')
     end
 
     # Permission read via File.stat is busted on windows, though creating the
     # file with 0600 has the desired effect of giving access rights to the
     # owner only. A platform-specific functional test would be helpful.
     it "creates the file with 0600 permissions", :unix_only do
-      File.should_not exist(key_location)
+      expect(File).not_to exist(key_location)
       registration.write_key
-      File.should exist(key_location)
+      expect(File).to exist(key_location)
       stat = File.stat(key_location)
-      (stat.mode & 07777).should == 0600
+      expect(stat.mode & 07777).to eq(0600)
     end
 
     it "writes the private key content to the file" do
       registration.write_key
-      IO.read(key_location).should == "--begin rsa key etc--"
+      expect(IO.read(key_location)).to eq("--begin rsa key etc--")
     end
 
     context 'when the client key location is a symlink' do
@@ -236,37 +236,37 @@ describe Chef::ApiClient::Registration do
   describe "when registering a client" do
 
     before do
-      registration.stub(:http_api).and_return(http_mock)
+      allow(registration).to receive(:http_api).and_return(http_mock)
     end
 
     it "creates the client on the server and writes the key" do
-      http_mock.should_receive(:post).ordered.and_return(server_v10_response)
+      expect(http_mock).to receive(:post).ordered.and_return(server_v10_response)
       registration.run
-      IO.read(key_location).should == generated_private_key_pem
+      expect(IO.read(key_location)).to eq(generated_private_key_pem)
     end
 
     it "retries up to 5 times" do
       response_500 = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
       exception_500 = Net::HTTPFatalError.new("500 Internal Server Error", response_500)
 
-      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 1
-      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 2
-      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 3
-      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 4
-      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 5
+      expect(http_mock).to receive(:post).ordered.and_raise(exception_500) # 1
+      expect(http_mock).to receive(:post).ordered.and_raise(exception_500) # 2
+      expect(http_mock).to receive(:post).ordered.and_raise(exception_500) # 3
+      expect(http_mock).to receive(:post).ordered.and_raise(exception_500) # 4
+      expect(http_mock).to receive(:post).ordered.and_raise(exception_500) # 5
 
-      http_mock.should_receive(:post).ordered.and_return(server_v10_response)
+      expect(http_mock).to receive(:post).ordered.and_return(server_v10_response)
       registration.run
-      IO.read(key_location).should == generated_private_key_pem
+      expect(IO.read(key_location)).to eq(generated_private_key_pem)
     end
 
     it "gives up retrying after the max attempts" do
       response_500 = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
       exception_500 = Net::HTTPFatalError.new("500 Internal Server Error", response_500)
 
-      http_mock.should_receive(:post).exactly(6).times.and_raise(exception_500)
+      expect(http_mock).to receive(:post).exactly(6).times.and_raise(exception_500)
 
-      lambda {registration.run}.should raise_error(Net::HTTPFatalError)
+      expect {registration.run}.to raise_error(Net::HTTPFatalError)
     end
 
   end

data/spec/unit/api_client_spec.rb

@@ -28,64 +28,64 @@ describe Chef::ApiClient do
 
   it "has a name attribute" do
     @client.name("ops_master")
-    @client.name.should == "ops_master"
+    expect(@client.name).to eq("ops_master")
   end
 
   it "does not allow spaces in the name" do
-    lambda { @client.name "ops master" }.should raise_error(ArgumentError)
+    expect { @client.name "ops master" }.to raise_error(ArgumentError)
   end
 
   it "only allows string values for the name" do
-    lambda { @client.name Hash.new }.should raise_error(ArgumentError)
+    expect { @client.name Hash.new }.to raise_error(ArgumentError)
   end
 
   it "has an admin flag attribute" do
     @client.admin(true)
-    @client.admin.should be_true
+    expect(@client.admin).to be_truthy
   end
 
   it "defaults to non-admin" do
-    @client.admin.should be_false
+    expect(@client.admin).to be_falsey
   end
 
   it "allows only boolean values for the admin flag" do
-    lambda { @client.admin(false) }.should_not raise_error
-    lambda { @client.admin(Hash.new) }.should raise_error(ArgumentError)
+    expect { @client.admin(false) }.not_to raise_error
+    expect { @client.admin(Hash.new) }.to raise_error(ArgumentError)
   end
 
   it "has a 'validator' flag attribute" do
     @client.validator(true)
-    @client.validator.should be_true
+    expect(@client.validator).to be_truthy
   end
 
   it "defaults to non-validator" do
-    @client.validator.should be_false
+    expect(@client.validator).to be_falsey
   end
 
   it "allows only boolean values for the 'validator' flag" do
-    lambda { @client.validator(false) }.should_not raise_error
-    lambda { @client.validator(Hash.new) }.should raise_error(ArgumentError)
+    expect { @client.validator(false) }.not_to raise_error
+    expect { @client.validator(Hash.new) }.to raise_error(ArgumentError)
   end
 
   it "has a public key attribute" do
     @client.public_key("super public")
-    @client.public_key.should == "super public"
+    expect(@client.public_key).to eq("super public")
   end
 
   it "accepts only String values for the public key" do
-    lambda { @client.public_key "" }.should_not raise_error
-    lambda { @client.public_key Hash.new }.should raise_error(ArgumentError)
+    expect { @client.public_key "" }.not_to raise_error
+    expect { @client.public_key Hash.new }.to raise_error(ArgumentError)
   end
 
 
   it "has a private key attribute" do
     @client.private_key("super private")
-    @client.private_key.should == "super private"
+    expect(@client.private_key).to eq("super private")
   end
 
   it "accepts only String values for the private key" do
-    lambda { @client.private_key "" }.should_not raise_error
-    lambda { @client.private_key Hash.new }.should raise_error(ArgumentError)
+    expect { @client.private_key "" }.not_to raise_error
+    expect { @client.private_key Hash.new }.to raise_error(ArgumentError)
   end
 
   describe "when serializing to JSON" do
@@ -96,32 +96,32 @@ describe Chef::ApiClient do
     end
 
     it "serializes as a JSON object" do
-      @json.should match(/^\{.+\}$/)
+      expect(@json).to match(/^\{.+\}$/)
     end
 
     it "includes the name value" do
-      @json.should include(%q{"name":"black"})
+      expect(@json).to include(%q{"name":"black"})
     end
 
     it "includes the public key value" do
-      @json.should include(%{"public_key":"crowes"})
+      expect(@json).to include(%{"public_key":"crowes"})
     end
 
     it "includes the 'admin' flag" do
-      @json.should include(%q{"admin":false})
+      expect(@json).to include(%q{"admin":false})
     end
 
     it "includes the 'validator' flag" do
-      @json.should include(%q{"validator":false})
+      expect(@json).to include(%q{"validator":false})
     end
 
     it "includes the private key when present" do
       @client.private_key("monkeypants")
-      @client.to_json.should include(%q{"private_key":"monkeypants"})
+      expect(@client.to_json).to include(%q{"private_key":"monkeypants"})
     end
 
     it "does not include the private key if not present" do
-      @json.should_not include("private_key")
+      expect(@json).not_to include("private_key")
     end
 
     include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
@@ -129,43 +129,83 @@ describe Chef::ApiClient do
     end
   end
 
-  describe "when deserializing from JSON" do
-    before(:each) do
-      client = {
-      "name" => "black",
-      "public_key" => "crowes",
-      "private_key" => "monkeypants",
-      "admin" => true,
-      "validator" => true,
-      "json_class" => "Chef::ApiClient"
-      }
-      @client = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(client))
+  describe "when deserializing from JSON (string) using ApiClient#from_json" do
+    let(:client_string) do
+      "{\"name\":\"black\",\"public_key\":\"crowes\",\"private_key\":\"monkeypants\",\"admin\":true,\"validator\":true}"
+    end
+
+    let(:client) do
+      Chef::ApiClient.from_json(client_string)
+    end
+
+    it "does not require a 'json_class' string" do
+      expect(Chef::JSONCompat.parse(client_string)["json_class"]).to eq(nil)
     end
 
     it "should deserialize to a Chef::ApiClient object" do
-      @client.should be_a_kind_of(Chef::ApiClient)
+      expect(client).to be_a_kind_of(Chef::ApiClient)
     end
 
     it "preserves the name" do
-      @client.name.should == "black"
+      expect(client.name).to eq("black")
     end
 
     it "preserves the public key" do
-      @client.public_key.should == "crowes"
+      expect(client.public_key).to eq("crowes")
     end
 
     it "preserves the admin status" do
-      @client.admin.should be_true
+      expect(client.admin).to be_truthy
     end
 
     it "preserves the 'validator' status" do
-      @client.validator.should be_true
+      expect(client.validator).to be_truthy
     end
 
     it "includes the private key if present" do
-      @client.private_key.should == "monkeypants"
+      expect(client.private_key).to eq("monkeypants")
+    end
+  end
+
+  describe "when deserializing from JSON (hash) using JSONCompat#from_json" do
+    let(:client_hash) do
+      {
+        "name" => "black",
+        "public_key" => "crowes",
+        "private_key" => "monkeypants",
+        "admin" => true,
+        "validator" => true,
+        "json_class" => "Chef::ApiClient"
+      }
+    end
+
+    let(:client) do
+      Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(client_hash))
     end
 
+    it "should deserialize to a Chef::ApiClient object" do
+      expect(client).to be_a_kind_of(Chef::ApiClient)
+    end
+
+    it "preserves the name" do
+      expect(client.name).to eq("black")
+    end
+
+    it "preserves the public key" do
+      expect(client.public_key).to eq("crowes")
+    end
+
+    it "preserves the admin status" do
+      expect(client.admin).to be_truthy
+    end
+
+    it "preserves the 'validator' status" do
+      expect(client.validator).to be_truthy
+    end
+
+    it "includes the private key if present" do
+      expect(client.private_key).to eq("monkeypants")
+    end
   end
 
   describe "when loading from JSON" do
@@ -183,33 +223,33 @@ describe Chef::ApiClient do
       "json_class" => "Chef::ApiClient"
       }
       @http_client = double("Chef::REST mock")
-      Chef::REST.stub(:new).and_return(@http_client)
-      @http_client.should_receive(:get).with("clients/black").and_return(client)
+      allow(Chef::REST).to receive(:new).and_return(@http_client)
+      expect(@http_client).to receive(:get).with("clients/black").and_return(client)
       @client = Chef::ApiClient.load(client['name'])
     end
 
     it "should deserialize to a Chef::ApiClient object" do
-      @client.should be_a_kind_of(Chef::ApiClient)
+      expect(@client).to be_a_kind_of(Chef::ApiClient)
     end
 
     it "preserves the name" do
-      @client.name.should == "black"
+      expect(@client.name).to eq("black")
     end
 
     it "preserves the public key" do
-      @client.public_key.should == "crowes"
+      expect(@client.public_key).to eq("crowes")
     end
 
     it "preserves the admin status" do
-      @client.admin.should be_a_kind_of(TrueClass)
+      expect(@client.admin).to be_a_kind_of(TrueClass)
     end
 
     it "preserves the 'validator' status" do
-      @client.validator.should be_a_kind_of(TrueClass)
+      expect(@client.validator).to be_a_kind_of(TrueClass)
     end
 
     it "includes the private key if present" do
-      @client.private_key.should == "monkeypants"
+      expect(@client.private_key).to eq("monkeypants")
     end
 
   end
@@ -230,9 +270,9 @@ describe Chef::ApiClient do
     end
 
     it "has an HTTP client configured with default credentials" do
-      @client.http_api.should be_a_kind_of(Chef::REST)
-      @client.http_api.client_name.should == "silent-bob"
-      @client.http_api.signing_key.to_s.should == private_key_data
+      expect(@client.http_api).to be_a_kind_of(Chef::REST)
+      expect(@client.http_api.client_name).to eq("silent-bob")
+      expect(@client.http_api.signing_key.to_s).to eq(private_key_data)
     end
   end
 
@@ -240,7 +280,7 @@ describe Chef::ApiClient do
   describe "when requesting a new key" do
     before do
       @http_client = double("Chef::REST mock")
-      Chef::REST.stub(:new).and_return(@http_client)
+      allow(Chef::REST).to receive(:new).and_return(@http_client)
     end
 
     context "and the client does not exist on the server" do
@@ -248,11 +288,11 @@ describe Chef::ApiClient do
         @a_404_response = Net::HTTPNotFound.new("404 not found and such", nil, nil)
         @a_404_exception = Net::HTTPServerException.new("404 not found exception", @a_404_response)
 
-        @http_client.should_receive(:get).with("clients/lost-my-key").and_raise(@a_404_exception)
+        expect(@http_client).to receive(:get).with("clients/lost-my-key").and_raise(@a_404_exception)
       end
 
       it "raises a 404 error" do
-        lambda { Chef::ApiClient.reregister("lost-my-key") }.should raise_error(Net::HTTPServerException)
+        expect { Chef::ApiClient.reregister("lost-my-key") }.to raise_error(Net::HTTPServerException)
       end
     end
 
@@ -260,7 +300,7 @@ describe Chef::ApiClient do
       before do
         @api_client_without_key = Chef::ApiClient.new
         @api_client_without_key.name("lost-my-key")
-        @http_client.should_receive(:get).with("clients/lost-my-key").and_return(@api_client_without_key)
+        expect(@http_client).to receive(:get).with("clients/lost-my-key").and_return(@api_client_without_key)
       end
 
 
@@ -269,7 +309,7 @@ describe Chef::ApiClient do
           @api_client_with_key = Chef::ApiClient.new
           @api_client_with_key.name("lost-my-key")
           @api_client_with_key.private_key("the new private key")
-          @http_client.should_receive(:put).
+          expect(@http_client).to receive(:put).
             with("clients/lost-my-key", :name => "lost-my-key", :admin => false, :validator => false, :private_key => true).
             and_return(@api_client_with_key)
         end
@@ -277,17 +317,17 @@ describe Chef::ApiClient do
         it "returns an ApiClient with a private key" do
           response = Chef::ApiClient.reregister("lost-my-key")
           # no sane == method for ApiClient :'(
-          response.should == @api_client_without_key
-          response.private_key.should == "the new private key"
-          response.name.should == "lost-my-key"
-          response.admin.should be_false
+          expect(response).to eq(@api_client_without_key)
+          expect(response.private_key).to eq("the new private key")
+          expect(response.name).to eq("lost-my-key")
+          expect(response.admin).to be_falsey
         end
       end
 
       context "and the client exists on a Chef 10-like server" do
         before do
           @api_client_with_key = {"name" => "lost-my-key", "private_key" => "the new private key"}
-          @http_client.should_receive(:put).
+          expect(@http_client).to receive(:put).
             with("clients/lost-my-key", :name => "lost-my-key", :admin => false, :validator => false, :private_key => true).
             and_return(@api_client_with_key)
         end
@@ -295,16 +335,14 @@ describe Chef::ApiClient do
         it "returns an ApiClient with a private key" do
           response = Chef::ApiClient.reregister("lost-my-key")
           # no sane == method for ApiClient :'(
-          response.should == @api_client_without_key
-          response.private_key.should == "the new private key"
-          response.name.should == "lost-my-key"
-          response.admin.should be_false
-          response.validator.should be_false
+          expect(response).to eq(@api_client_without_key)
+          expect(response.private_key).to eq("the new private key")
+          expect(response.name).to eq("lost-my-key")
+          expect(response.admin).to be_falsey
+          expect(response.validator).to be_falsey
         end
       end
 
     end
   end
 end
-
-