chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/spec/unit/knife/client_bulk_delete_spec.rb

@@ -28,10 +28,10 @@ describe Chef::Knife::ClientBulkDelete do
     k = Chef::Knife::ClientBulkDelete.new
     k.name_args = name_args
     k.config = option_args
-    k.ui.stub(:stdout).and_return(stdout_io)
-    k.ui.stub(:stderr).and_return(stderr_io)
-    k.ui.stub(:confirm).and_return(knife_confirm)
-    k.ui.stub(:confirm_without_exit).and_return(knife_confirm)
+    allow(k.ui).to receive(:stdout).and_return(stdout_io)
+    allow(k.ui).to receive(:stderr).and_return(stderr_io)
+    allow(k.ui).to receive(:confirm).and_return(knife_confirm)
+    allow(k.ui).to receive(:confirm_without_exit).and_return(knife_confirm)
     k
   }
 
@@ -47,7 +47,7 @@ describe Chef::Knife::ClientBulkDelete do
     nonvalidator_client_names.each do |client_name|
       client = Chef::ApiClient.new()
       client.name(client_name)
-      client.stub(:destroy).and_return(true)
+      allow(client).to receive(:destroy).and_return(true)
       clients[client_name] = client
     end
 
@@ -61,8 +61,8 @@ describe Chef::Knife::ClientBulkDelete do
     validator_client_names.each do |validator_client_name|
       validator_client = Chef::ApiClient.new()
       validator_client.name(validator_client_name)
-      validator_client.stub(:validator).and_return(true)
-      validator_client.stub(:destroy).and_return(true)
+      allow(validator_client).to receive(:validator).and_return(true)
+      allow(validator_client).to receive(:destroy).and_return(true)
       clients[validator_client_name] = validator_client
     end
 
@@ -75,7 +75,7 @@ describe Chef::Knife::ClientBulkDelete do
   }
 
   before(:each) do
-    Chef::ApiClient.stub(:list).and_return(clients)
+    allow(Chef::ApiClient).to receive(:list).and_return(clients)
   end
 
   describe "run" do
@@ -83,44 +83,44 @@ describe Chef::Knife::ClientBulkDelete do
       let(:name_args) { [ ] }
 
       it "should exit if the regex is not provided" do
-        lambda { knife.run }.should raise_error(SystemExit)
+        expect { knife.run }.to raise_error(SystemExit)
       end
     end
 
     describe "with any clients" do
       it "should get the list of the clients" do
-        Chef::ApiClient.should_receive(:list)
+        expect(Chef::ApiClient).to receive(:list)
         knife.run
       end
 
       it "should print the name of the clients" do
         knife.run
         client_names.each do |client_name|
-          stdout.should include(client_name)
+          expect(stdout).to include(client_name)
         end
       end
 
       it "should confirm you really want to delete them" do
-        knife.ui.should_receive(:confirm)
+        expect(knife.ui).to receive(:confirm)
         knife.run
       end
 
       describe "without --delete-validators" do
         it "should mention that validator clients wont be deleted" do
           knife.run
-          stdout.should include("Following clients are validators and will not be deleted.")
+          expect(stdout).to include("Following clients are validators and will not be deleted.")
           info = stdout.index "Following clients are validators and will not be deleted."
           val = stdout.index "myorg-validator"
-          (val > info).should be_true
+          expect(val > info).to be_truthy
         end
 
         it "should only delete nonvalidator clients" do
           nonvalidator_clients.each_value do |c|
-            c.should_receive(:destroy)
+            expect(c).to receive(:destroy)
           end
 
           validator_clients.each_value do |c|
-            c.should_not_receive(:destroy)
+            expect(c).not_to receive(:destroy)
           end
 
           knife.run
@@ -132,18 +132,18 @@ describe Chef::Knife::ClientBulkDelete do
 
         it "should mention that validator clients will be deleted" do
           knife.run
-          stdout.should include("The following validators will be deleted")
+          expect(stdout).to include("The following validators will be deleted")
         end
 
         it "should confirm twice" do
-          knife.ui.should_receive(:confirm).once
-          knife.ui.should_receive(:confirm_without_exit).once
+          expect(knife.ui).to receive(:confirm).once
+          expect(knife.ui).to receive(:confirm_without_exit).once
           knife.run
         end
 
         it "should delete all clients" do
           clients.each_value do |c|
-            c.should_receive(:destroy)
+            expect(c).to receive(:destroy)
           end
 
           knife.run
@@ -155,10 +155,10 @@ describe Chef::Knife::ClientBulkDelete do
       let(:name_args) { [ "^ti" ] }
 
       it "should only delete clients that match the regex" do
-        clients["tim"].should_receive(:destroy)
-        clients["stephen"].should_not_receive(:destroy)
-        clients["dan"].should_not_receive(:destroy)
-        clients["myorg-validator"].should_not_receive(:destroy)
+        expect(clients["tim"]).to receive(:destroy)
+        expect(clients["stephen"]).not_to receive(:destroy)
+        expect(clients["dan"]).not_to receive(:destroy)
+        expect(clients["myorg-validator"]).not_to receive(:destroy)
         knife.run
       end
     end

data/spec/unit/knife/client_create_spec.rb

@@ -21,82 +21,96 @@ require 'spec_helper'
 Chef::Knife::ClientCreate.load_deps
 
 describe Chef::Knife::ClientCreate do
+  let(:stderr) { StringIO.new }
+
+  let(:default_client_hash) do
+    {
+      "name" => "adam",
+      "validator" => false,
+      "admin" => false
+    }
+  end
+
+  let(:client) do
+    c = double("Chef::ApiClient")
+    allow(c).to receive(:save).and_return({"private_key" => ""})
+    allow(c).to receive(:to_s).and_return("client[adam]")
+    c
+  end
+
+  let(:knife) do
+    k = Chef::Knife::ClientCreate.new
+    k.name_args = [ "adam" ]
+    k.ui.config[:disable_editing] = true
+    allow(k.ui).to receive(:stderr).and_return(stderr)
+    allow(k.ui).to receive(:stdout).and_return(stderr)
+    k
+  end
+
   before(:each) do
     Chef::Config[:node_name]  = "webmonkey.example.com"
-    @knife = Chef::Knife::ClientCreate.new
-    @knife.config = {
-      :file => nil,
-      :admin => false,
-      :validator => false
-    }
-    @knife.name_args = [ "adam" ]
-    @client = Chef::ApiClient.new
-    @client.stub(:save).and_return({ 'private_key' => '' })
-    @knife.stub(:edit_data).and_return(@client)
-    @knife.stub(:puts)
-    Chef::ApiClient.stub(:new).and_return(@client)
-    @stderr = StringIO.new
-    @knife.ui.stub(:stderr).and_return(@stderr)
   end
 
   describe "run" do
-    it "should create a new Client" do
-      Chef::ApiClient.should_receive(:new).and_return(@client)
-      @knife.run
-      @stderr.string.should match /created client.+adam/i
+    it "should create and save the ApiClient" do
+      expect(Chef::ApiClient).to receive(:from_hash).and_return(client)
+      expect(client).to receive(:save)
+      knife.run
+    end
+
+    it "should print a message upon creation" do
+      expect(Chef::ApiClient).to receive(:from_hash).and_return(client)
+      expect(client).to receive(:save)
+      knife.run
+      expect(stderr.string).to match /Created client.*adam/i
     end
 
     it "should set the Client name" do
-      @client.should_receive(:name).with("adam")
-      @knife.run
+      expect(Chef::ApiClient).to receive(:from_hash).with(hash_including("name" => "adam")).and_return(client)
+      knife.run
     end
 
     it "by default it is not an admin" do
-      @client.should_receive(:admin).with(false)
-      @knife.run
+      expect(Chef::ApiClient).to receive(:from_hash).with(hash_including("admin" => false)).and_return(client)
+      knife.run
     end
 
     it "by default it is not a validator" do
-      @client.should_receive(:validator).with(false)
-      @knife.run
+      expect(Chef::ApiClient).to receive(:from_hash).with(hash_including("validator" => false)).and_return(client)
+      knife.run
     end
 
     it "should allow you to edit the data" do
-      @knife.should_receive(:edit_data).with(@client)
-      @knife.run
-    end
-
-    it "should save the Client" do
-      @client.should_receive(:save)
-      @knife.run
+      expect(knife).to receive(:edit_hash).with(default_client_hash).and_return(default_client_hash)
+      allow(Chef::ApiClient).to receive(:from_hash).and_return(client)
+      knife.run
     end
 
     describe "with -f or --file" do
       it "should write the private key to a file" do
-        @knife.config[:file] = "/tmp/monkeypants"
-        @client.stub(:save).and_return({ 'private_key' => "woot" })
+        knife.config[:file] = "/tmp/monkeypants"
+        allow_any_instance_of(Chef::ApiClient).to receive(:save).and_return({ 'private_key' => "woot" })
         filehandle = double("Filehandle")
-        filehandle.should_receive(:print).with('woot')
-        File.should_receive(:open).with("/tmp/monkeypants", "w").and_yield(filehandle)
-        @knife.run
+        expect(filehandle).to receive(:print).with('woot')
+        expect(File).to receive(:open).with("/tmp/monkeypants", "w").and_yield(filehandle)
+        knife.run
       end
     end
 
     describe "with -a or --admin" do
       it "should create an admin client" do
-        @knife.config[:admin] = true
-        @client.should_receive(:admin).with(true)
-        @knife.run
+        knife.config[:admin] = true
+        expect(Chef::ApiClient).to receive(:from_hash).with(hash_including("admin" => true)).and_return(client)
+        knife.run
       end
     end
 
     describe "with --validator" do
       it "should create an validator client" do
-        @knife.config[:validator] = true
-        @client.should_receive(:validator).with(true)
-        @knife.run
+        knife.config[:validator] = true
+        expect(Chef::ApiClient).to receive(:from_hash).with(hash_including("validator" => true)).and_return(client)
+        knife.run
       end
     end
-
   end
 end

data/spec/unit/knife/client_delete_spec.rb

@@ -30,52 +30,52 @@ describe Chef::Knife::ClientDelete do
 
   describe 'run' do
     it 'should delete the client' do
-      @knife.should_receive(:delete_object).with(Chef::ApiClient, 'adam', 'client')
+      expect(@knife).to receive(:delete_object).with(Chef::ApiClient, 'adam', 'client')
       @knife.run
     end
 
     it 'should print usage and exit when a client name is not provided' do
       @knife.name_args = []
-      @knife.should_receive(:show_usage)
-      @knife.ui.should_receive(:fatal)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect(@knife).to receive(:show_usage)
+      expect(@knife.ui).to receive(:fatal)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
   end
 
   describe 'with a validator' do
     before(:each) do
-      Chef::Knife::UI.stub(:confirm).and_return(true)
-      @knife.stub(:confirm).and_return(true)
+      allow(Chef::Knife::UI).to receive(:confirm).and_return(true)
+      allow(@knife).to receive(:confirm).and_return(true)
       @client = Chef::ApiClient.new
-      Chef::ApiClient.should_receive(:load).and_return(@client)
+      expect(Chef::ApiClient).to receive(:load).and_return(@client)
     end
 
     it 'should delete non-validator client if --delete-validators is not set' do
       @knife.config[:delete_validators] = false
-      @client.should_receive(:destroy).and_return(@client)
-      @knife.should_receive(:msg)
+      expect(@client).to receive(:destroy).and_return(@client)
+      expect(@knife).to receive(:msg)
 
       @knife.run
     end
 
     it 'should delete non-validator client if --delete-validators is set' do
       @knife.config[:delete_validators] = true
-      @client.should_receive(:destroy).and_return(@client)
-      @knife.should_receive(:msg)
+      expect(@client).to receive(:destroy).and_return(@client)
+      expect(@knife).to receive(:msg)
 
       @knife.run
     end
 
     it 'should not delete validator client if --delete-validators is not set' do
       @client.validator(true)
-      @knife.ui.should_receive(:fatal)
-      lambda { @knife.run}.should raise_error(SystemExit)
+      expect(@knife.ui).to receive(:fatal)
+      expect { @knife.run}.to raise_error(SystemExit)
     end
 
     it 'should delete validator client if --delete-validators is set' do
       @knife.config[:delete_validators] = true
-      @client.should_receive(:destroy).and_return(@client)
-      @knife.should_receive(:msg)
+      expect(@client).to receive(:destroy).and_return(@client)
+      expect(@knife).to receive(:msg)
 
       @knife.run
     end

data/spec/unit/knife/client_edit_spec.rb

@@ -26,15 +26,15 @@ describe Chef::Knife::ClientEdit do
 
   describe 'run' do
     it 'should edit the client' do
-      @knife.should_receive(:edit_object).with(Chef::ApiClient, 'adam')
+      expect(@knife).to receive(:edit_object).with(Chef::ApiClient, 'adam')
       @knife.run
     end
 
     it 'should print usage and exit when a client name is not provided' do
       @knife.name_args = []
-      @knife.should_receive(:show_usage)
-      @knife.ui.should_receive(:fatal)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect(@knife).to receive(:show_usage)
+      expect(@knife.ui).to receive(:fatal)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
   end
 end

data/spec/unit/knife/client_list_spec.rb

@@ -26,8 +26,8 @@ describe Chef::Knife::ClientList do
 
   describe 'run' do
     it 'should list the clients' do
-      Chef::ApiClient.should_receive(:list)
-      @knife.should_receive(:format_list_for_display)
+      expect(Chef::ApiClient).to receive(:list)
+      expect(@knife).to receive(:format_list_for_display)
       @knife.run
     end
   end

data/spec/unit/knife/client_reregister_spec.rb

@@ -24,7 +24,7 @@ describe Chef::Knife::ClientReregister do
     @knife.name_args = [ 'adam' ]
     @client_mock = double('client_mock', :private_key => "foo_key")
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
   end
 
   context "when no client name is given on the command line" do
@@ -33,29 +33,29 @@ describe Chef::Knife::ClientReregister do
     end
 
     it 'should print usage and exit when a client name is not provided' do
-      @knife.should_receive(:show_usage)
-      @knife.ui.should_receive(:fatal)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect(@knife).to receive(:show_usage)
+      expect(@knife.ui).to receive(:fatal)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
   end
 
   context 'when not configured for file output' do
     it 'reregisters the client and prints the key' do
-      Chef::ApiClient.should_receive(:reregister).with('adam').and_return(@client_mock)
+      expect(Chef::ApiClient).to receive(:reregister).with('adam').and_return(@client_mock)
       @knife.run
-      @stdout.string.should match( /foo_key/ )
+      expect(@stdout.string).to match( /foo_key/ )
     end
   end
 
   context 'when configured for file output' do
     it 'should write the private key to a file' do
-      Chef::ApiClient.should_receive(:reregister).with('adam').and_return(@client_mock)
+      expect(Chef::ApiClient).to receive(:reregister).with('adam').and_return(@client_mock)
 
       @knife.config[:file] = '/tmp/monkeypants'
       filehandle = StringIO.new
-      File.should_receive(:open).with('/tmp/monkeypants', 'w').and_yield(filehandle)
+      expect(File).to receive(:open).with('/tmp/monkeypants', 'w').and_yield(filehandle)
       @knife.run
-      filehandle.string.should == "foo_key"
+      expect(filehandle.string).to eq("foo_key")
     end
   end
 

data/spec/unit/knife/configure_client_spec.rb

@@ -26,16 +26,16 @@ describe Chef::Knife::ConfigureClient do
     Chef::Config[:validation_key] = '/etc/chef/validation.pem'
 
     @stderr = StringIO.new
-    @knife.ui.stub(:stderr).and_return(@stderr)
+    allow(@knife.ui).to receive(:stderr).and_return(@stderr)
   end
 
   describe 'run' do
     it 'should print usage and exit when a directory is not provided' do
-      @knife.should_receive(:show_usage)
-      @knife.ui.should_receive(:fatal).with(/must provide the directory/)
-      lambda {
+      expect(@knife).to receive(:show_usage)
+      expect(@knife.ui).to receive(:fatal).with(/must provide the directory/)
+      expect {
         @knife.run
-      }.should raise_error SystemExit
+      }.to raise_error SystemExit
     end
 
     describe 'when specifing a directory' do
@@ -43,39 +43,39 @@ describe Chef::Knife::ConfigureClient do
         @knife.name_args = ['/home/bob/.chef']
         @client_file = StringIO.new
         @validation_file = StringIO.new
-        File.should_receive(:open).with('/home/bob/.chef/client.rb', 'w').
+        expect(File).to receive(:open).with('/home/bob/.chef/client.rb', 'w').
                                    and_yield(@client_file)
-        File.should_receive(:open).with('/home/bob/.chef/validation.pem', 'w').
+        expect(File).to receive(:open).with('/home/bob/.chef/validation.pem', 'w').
                                    and_yield(@validation_file)
-        IO.should_receive(:read).and_return('foo_bar_baz')
+        expect(IO).to receive(:read).and_return('foo_bar_baz')
       end
 
       it 'should recursively create the directory' do
-        FileUtils.should_receive(:mkdir_p).with('/home/bob/.chef')
+        expect(FileUtils).to receive(:mkdir_p).with('/home/bob/.chef')
         @knife.run
       end
 
       it 'should write out the config file' do
-        FileUtils.stub(:mkdir_p)
+        allow(FileUtils).to receive(:mkdir_p)
         @knife.run
-        @client_file.string.should match /log_level\s+\:info/
-        @client_file.string.should match /log_location\s+STDOUT/
-        @client_file.string.should match /chef_server_url\s+'https\:\/\/chef\.example\.com'/
-        @client_file.string.should match /validation_client_name\s+'chef-validator'/
+        expect(@client_file.string).to match /log_level\s+\:info/
+        expect(@client_file.string).to match /log_location\s+STDOUT/
+        expect(@client_file.string).to match /chef_server_url\s+'https\:\/\/chef\.example\.com'/
+        expect(@client_file.string).to match /validation_client_name\s+'chef-validator'/
       end
 
       it 'should write out the validation.pem file' do
-        FileUtils.stub(:mkdir_p)
+        allow(FileUtils).to receive(:mkdir_p)
         @knife.run
-        @validation_file.string.should match /foo_bar_baz/
+        expect(@validation_file.string).to match /foo_bar_baz/
       end
 
       it 'should print information on what is being configured' do
-        FileUtils.stub(:mkdir_p)
+        allow(FileUtils).to receive(:mkdir_p)
         @knife.run
-        @stderr.string.should match /creating client configuration/i
-        @stderr.string.should match /writing client\.rb/i
-        @stderr.string.should match /writing validation\.pem/i
+        expect(@stderr.string).to match /creating client configuration/i
+        expect(@stderr.string).to match /writing client\.rb/i
+        expect(@stderr.string).to match /writing validation\.pem/i
       end
     end
   end