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

data/spec/unit/knife/ssl_check_spec.rb

@@ -35,8 +35,8 @@ describe Chef::Knife::SslCheck do
 
   subject(:ssl_check) do
     s = Chef::Knife::SslCheck.new
-    s.ui.stub(:stdout).and_return(stdout_io)
-    s.ui.stub(:stderr).and_return(stderr_io)
+    allow(s.ui).to receive(:stdout).and_return(stdout_io)
+    allow(s.ui).to receive(:stderr).and_return(stderr_io)
     s.name_args = name_args
     s
   end
@@ -106,17 +106,17 @@ E
 
     before do
       Chef::Config[:trusted_certs_dir] = trusted_certs_dir
-      ssl_check.stub(:trusted_certificates).and_return([trusted_cert_file])
-      store.stub(:add_cert).with(certificate)
-      OpenSSL::X509::Store.stub(:new).and_return(store)
-      OpenSSL::X509::Certificate.stub(:new).with(IO.read(trusted_cert_file)).and_return(certificate)
-      ssl_check.stub(:verify_cert).and_return(true)
-      ssl_check.stub(:verify_cert_host).and_return(true)
+      allow(ssl_check).to receive(:trusted_certificates).and_return([trusted_cert_file])
+      allow(store).to receive(:add_cert).with(certificate)
+      allow(OpenSSL::X509::Store).to receive(:new).and_return(store)
+      allow(OpenSSL::X509::Certificate).to receive(:new).with(IO.read(trusted_cert_file)).and_return(certificate)
+      allow(ssl_check).to receive(:verify_cert).and_return(true)
+      allow(ssl_check).to receive(:verify_cert_host).and_return(true)
     end
 
     context "when the trusted certificates have valid X509 properties" do
       before do
-        store.stub(:verify).with(certificate).and_return(true)
+        allow(store).to receive(:verify).with(certificate).and_return(true)
       end
 
       it "does not generate any X509 warnings" do
@@ -127,8 +127,8 @@ E
 
     context "when the trusted certificates have invalid X509 properties" do
       before do
-        store.stub(:verify).with(certificate).and_return(false)
-        store.stub(:error_string).and_return("unable to get local issuer certificate")
+        allow(store).to receive(:verify).with(certificate).and_return(false)
+        allow(store).to receive(:error_string).and_return("unable to get local issuer certificate")
       end
 
       it "generates a warning message with invalid certificate file names" do
@@ -145,8 +145,8 @@ E
     let(:ssl_socket) { double(OpenSSL::SSL::SSLSocket) }
 
     before do
-      TCPSocket.should_receive(:new).with("foo.example.com", 8443).and_return(tcp_socket)
-      OpenSSL::SSL::SSLSocket.should_receive(:new).with(tcp_socket, ssl_check.verify_peer_ssl_context).and_return(ssl_socket)
+      expect(TCPSocket).to receive(:new).with("foo.example.com", 8443).and_return(tcp_socket)
+      expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(tcp_socket, ssl_check.verify_peer_ssl_context).and_return(ssl_socket)
     end
 
     def run
@@ -160,9 +160,9 @@ E
     context "when the remote host's certificate is valid" do
 
       before do
-        ssl_check.should_receive(:verify_X509).and_return(true) # X509 valid certs (no warn)
-        ssl_socket.should_receive(:connect) # no error
-        ssl_socket.should_receive(:post_connection_check).with("foo.example.com") # no error
+        expect(ssl_check).to receive(:verify_X509).and_return(true) # X509 valid certs (no warn)
+        expect(ssl_socket).to receive(:connect) # no error
+        expect(ssl_socket).to receive(:post_connection_check).with("foo.example.com") # no error
       end
 
       it "prints a success message" do
@@ -182,23 +182,23 @@ E
       before do
         trap(:INT, "DEFAULT")
 
-        TCPSocket.should_receive(:new).
+        expect(TCPSocket).to receive(:new).
           with("foo.example.com", 8443).
           and_return(tcp_socket_for_debug)
-        OpenSSL::SSL::SSLSocket.should_receive(:new).
+        expect(OpenSSL::SSL::SSLSocket).to receive(:new).
           with(tcp_socket_for_debug, ssl_check.noverify_peer_ssl_context).
           and_return(ssl_socket_for_debug)
       end
 
       context "when the certificate's CN does not match the hostname" do
         before do
-          ssl_check.should_receive(:verify_X509).and_return(true) # X509 valid certs
-          ssl_socket.should_receive(:connect) # no error
-          ssl_socket.should_receive(:post_connection_check).
+          expect(ssl_check).to receive(:verify_X509).and_return(true) # X509 valid certs
+          expect(ssl_socket).to receive(:connect) # no error
+          expect(ssl_socket).to receive(:post_connection_check).
             with("foo.example.com").
             and_raise(OpenSSL::SSL::SSLError)
-          ssl_socket_for_debug.should_receive(:connect)
-          ssl_socket_for_debug.should_receive(:peer_cert).and_return(self_signed_crt)
+          expect(ssl_socket_for_debug).to receive(:connect)
+          expect(ssl_socket_for_debug).to receive(:peer_cert).and_return(self_signed_crt)
         end
 
         it "shows the CN used by the certificate and prints an error" do
@@ -212,11 +212,11 @@ E
 
       context "when the cert is not signed by any trusted authority" do
         before do
-          ssl_check.should_receive(:verify_X509).and_return(true) # X509 valid certs
-          ssl_socket.should_receive(:connect).
+          expect(ssl_check).to receive(:verify_X509).and_return(true) # X509 valid certs
+          expect(ssl_socket).to receive(:connect).
             and_raise(OpenSSL::SSL::SSLError)
-          ssl_socket_for_debug.should_receive(:connect)
-          ssl_socket_for_debug.should_receive(:peer_cert).and_return(self_signed_crt)
+          expect(ssl_socket_for_debug).to receive(:connect)
+          expect(ssl_socket_for_debug).to receive(:peer_cert).and_return(self_signed_crt)
         end
 
         it "shows the CN used by the certificate and prints an error" do

data/spec/unit/knife/ssl_fetch_spec.rb

@@ -36,8 +36,8 @@ describe Chef::Knife::SslFetch do
   subject(:ssl_fetch) do
     s = Chef::Knife::SslFetch.new
     s.name_args = name_args
-    s.ui.stub(:stdout).and_return(stdout_io)
-    s.ui.stub(:stderr).and_return(stderr_io)
+    allow(s.ui).to receive(:stdout).and_return(stdout_io)
+    allow(s.ui).to receive(:stderr).and_return(stderr_io)
     s
   end
 
@@ -130,22 +130,55 @@ E
 
     before do
       Chef::Config.trusted_certs_dir = trusted_certs_dir
-
-      TCPSocket.should_receive(:new).with("foo.example.com", 8443).and_return(tcp_socket)
-      OpenSSL::SSL::SSLSocket.should_receive(:new).with(tcp_socket, ssl_fetch.noverify_peer_ssl_context).and_return(ssl_socket)
-      ssl_socket.should_receive(:connect)
-      ssl_socket.should_receive(:peer_cert_chain).and_return([self_signed_crt])
     end
 
     after do
       FileUtils.rm_rf(trusted_certs_dir)
     end
 
-    it "fetches the cert chain and writes the certs to the trusted_certs_dir" do
-      run
-      stored_cert_path = File.join(trusted_certs_dir, "example_local.crt")
-      expect(File).to exist(stored_cert_path)
-      expect(File.read(stored_cert_path)).to eq(File.read(self_signed_crt_path))
+    context "when the TLS connection is successful" do
+
+      before do
+        expect(TCPSocket).to receive(:new).with("foo.example.com", 8443).and_return(tcp_socket)
+        expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(tcp_socket, ssl_fetch.noverify_peer_ssl_context).and_return(ssl_socket)
+        expect(ssl_socket).to receive(:connect)
+        expect(ssl_socket).to receive(:peer_cert_chain).and_return([self_signed_crt])
+      end
+
+      it "fetches the cert chain and writes the certs to the trusted_certs_dir" do
+        run
+        stored_cert_path = File.join(trusted_certs_dir, "example_local.crt")
+        expect(File).to exist(stored_cert_path)
+        expect(File.read(stored_cert_path)).to eq(File.read(self_signed_crt_path))
+      end
+
+    end
+
+    context "when connecting to a non-SSL service (like HTTP)" do
+
+      let(:name_args) { %w{http://foo.example.com} }
+
+      let(:unknown_protocol_error) { OpenSSL::SSL::SSLError.new("SSL_connect returned=1 errno=0 state=SSLv2/v3 read server hello A: unknown protocol") }
+
+      before do
+        expect(TCPSocket).to receive(:new).with("foo.example.com", 80).and_return(tcp_socket)
+        expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(tcp_socket, ssl_fetch.noverify_peer_ssl_context).and_return(ssl_socket)
+        expect(ssl_socket).to receive(:connect).and_raise(unknown_protocol_error)
+
+        expect(ssl_fetch).to receive(:exit).with(1)
+      end
+
+      it "tells the user their URL is for a non-ssl service" do
+        expected_error_text = <<-ERROR_TEXT
+ERROR: The service at the given URI (http://foo.example.com) does not accept SSL connections
+ERROR: Perhaps you meant to connect to 'https://foo.example.com'?
+ERROR_TEXT
+
+        run
+        expect(stderr).to include(expected_error_text)
+      end
+
     end
+
   end
 end

data/spec/unit/knife/status_spec.rb

@@ -25,18 +25,18 @@ describe Chef::Knife::Status do
       n.automatic_attrs["ohai_time"] = 1343845969
     end
     query = double("Chef::Search::Query")
-    query.stub(:search).and_yield(node)
-    Chef::Search::Query.stub(:new).and_return(query)
+    allow(query).to receive(:search).and_yield(node)
+    allow(Chef::Search::Query).to receive(:new).and_return(query)
     @knife  = Chef::Knife::Status.new
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
   end
 
   describe "run" do
     it "should not colorize output unless it's writing to a tty" do
       @knife.run
-      @stdout.string.match(/foobar/).should_not be_nil
-      @stdout.string.match(/\e.*ago/).should be_nil
+      expect(@stdout.string.match(/foobar/)).not_to be_nil
+      expect(@stdout.string.match(/\e.*ago/)).to be_nil
     end
   end
 end

data/spec/unit/knife/tag_create_spec.rb

@@ -7,17 +7,17 @@ describe Chef::Knife::TagCreate do
     @knife.name_args = [ Chef::Config[:node_name], "happytag" ]
 
     @node = Chef::Node.new
-    @node.stub :save
-    Chef::Node.stub(:load).and_return @node
+    allow(@node).to receive :save
+    allow(Chef::Node).to receive(:load).and_return @node
     @stderr = StringIO.new
-    @knife.ui.stub(:stderr).and_return(@stderr)
+    allow(@knife.ui).to receive(:stderr).and_return(@stderr)
   end
 
   describe "run" do
     it "can create tags on a node" do
       @knife.run
-      @node.tags.should == ["happytag"]
-      @stderr.string.should match /created tags happytag.+node webmonkey.example.com/i
+      expect(@node.tags).to eq(["happytag"])
+      expect(@stderr.string).to match /created tags happytag.+node webmonkey.example.com/i
     end
   end
 end

data/spec/unit/knife/tag_delete_spec.rb

@@ -7,19 +7,19 @@ describe Chef::Knife::TagDelete do
     @knife.name_args = [ Chef::Config[:node_name], "sadtag" ]
 
     @node = Chef::Node.new
-    @node.stub :save
+    allow(@node).to receive :save
     @node.tags << "sadtag" << "happytag"
-    Chef::Node.stub(:load).and_return @node
+    allow(Chef::Node).to receive(:load).and_return @node
     @stderr = StringIO.new
-    @knife.ui.stub(:stderr).and_return(@stderr)
+    allow(@knife.ui).to receive(:stderr).and_return(@stderr)
   end
 
   describe "run" do
     it "can delete tags on a node" do
-      @node.tags.should == ["sadtag", "happytag"]
+      expect(@node.tags).to eq(["sadtag", "happytag"])
       @knife.run
-      @node.tags.should == ["happytag"]
-      @stderr.string.should match /deleted.+sadtag/i
+      expect(@node.tags).to eq(["happytag"])
+      expect(@stderr.string).to match /deleted.+sadtag/i
     end
   end
 end

data/spec/unit/knife/tag_list_spec.rb

@@ -7,16 +7,16 @@ describe Chef::Knife::TagList do
     @knife.name_args = [ Chef::Config[:node_name], "sadtag" ]
 
     @node = Chef::Node.new
-    @node.stub :save
+    allow(@node).to receive :save
     @node.tags << "sadtag" << "happytag"
-    Chef::Node.stub(:load).and_return @node
+    allow(Chef::Node).to receive(:load).and_return @node
   end
 
   describe "run" do
     it "can list tags on a node" do
       expected = %w(sadtag happytag)
-      @node.tags.should == expected
-      @knife.should_receive(:output).with(expected)
+      expect(@node.tags).to eq(expected)
+      expect(@knife).to receive(:output).with(expected)
       @knife.run
     end
   end

data/spec/unit/knife/user_create_spec.rb

@@ -26,8 +26,8 @@ describe Chef::Knife::UserCreate do
 
     @stdout = StringIO.new
     @stderr = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
-    @knife.ui.stub(:stderr).and_return(@stderr)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stderr).and_return(@stderr)
 
     @knife.name_args = [ 'a_user' ]
     @knife.config[:user_password] = "foobar"
@@ -36,53 +36,53 @@ describe Chef::Knife::UserCreate do
     @user_with_private_key = Chef::User.new
     @user_with_private_key.name "a_user"
     @user_with_private_key.private_key 'private_key'
-    @user.stub(:create).and_return(@user_with_private_key)
-    Chef::User.stub(:new).and_return(@user)
-    Chef::User.stub(:from_hash).and_return(@user)
-    @knife.stub(:edit_data).and_return(@user.to_hash)
+    allow(@user).to receive(:create).and_return(@user_with_private_key)
+    allow(Chef::User).to receive(:new).and_return(@user)
+    allow(Chef::User).to receive(:from_hash).and_return(@user)
+    allow(@knife).to receive(:edit_data).and_return(@user.to_hash)
   end
 
   it "creates a new user" do
-    Chef::User.should_receive(:new).and_return(@user)
-    @user.should_receive(:create)
+    expect(Chef::User).to receive(:new).and_return(@user)
+    expect(@user).to receive(:create)
     @knife.run
-    @stderr.string.should match /created user.+a_user/i
+    expect(@stderr.string).to match /created user.+a_user/i
   end
 
   it "sets the password" do
     @knife.config[:user_password] = "a_password"
-    @user.should_receive(:password).with("a_password")
+    expect(@user).to receive(:password).with("a_password")
     @knife.run
   end
 
   it "exits with an error if password is blank" do
     @knife.config[:user_password] = ''
-    lambda { @knife.run }.should raise_error SystemExit
-    @stderr.string.should match /You must specify a non-blank password/
+    expect { @knife.run }.to raise_error SystemExit
+    expect(@stderr.string).to match /You must specify a non-blank password/
   end
 
   it "sets the user name" do
-    @user.should_receive(:name).with("a_user")
+    expect(@user).to receive(:name).with("a_user")
     @knife.run
   end
 
   it "sets the public key if given" do
     @knife.config[:user_key] = "/a/filename"
-    File.stub(:read).with(File.expand_path("/a/filename")).and_return("a_key")
-    @user.should_receive(:public_key).with("a_key")
+    allow(File).to receive(:read).with(File.expand_path("/a/filename")).and_return("a_key")
+    expect(@user).to receive(:public_key).with("a_key")
     @knife.run
   end
 
   it "allows you to edit the data" do
-    @knife.should_receive(:edit_data).with(@user)
+    expect(@knife).to receive(:edit_data).with(@user)
     @knife.run
   end
 
   it "writes the private key to a file when --file is specified" do
     @knife.config[:file] = "/tmp/a_file"
     filehandle = double("filehandle")
-    filehandle.should_receive(:print).with('private_key')
-    File.should_receive(:open).with("/tmp/a_file", "w").and_yield(filehandle)
+    expect(filehandle).to receive(:print).with('private_key')
+    expect(File).to receive(:open).with("/tmp/a_file", "w").and_yield(filehandle)
     @knife.run
   end
 end

data/spec/unit/knife/user_delete_spec.rb

@@ -26,14 +26,14 @@ describe Chef::Knife::UserDelete do
   end
 
   it 'deletes the user' do
-    @knife.should_receive(:delete_object).with(Chef::User, 'my_user')
+    expect(@knife).to receive(:delete_object).with(Chef::User, 'my_user')
     @knife.run
   end
 
   it 'prints usage and exits when a user 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

data/spec/unit/knife/user_edit_spec.rb

@@ -25,23 +25,23 @@ describe Chef::Knife::UserEdit do
 
     Chef::Knife::UserEdit.load_deps
     @knife = Chef::Knife::UserEdit.new
-    @knife.ui.stub(:stderr).and_return(@stderr)
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stderr).and_return(@stderr)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
     @knife.name_args = [ 'my_user' ]
     @knife.config[:disable_editing] = true
   end
 
   it 'loads and edits the user' do
     data = { :name => "my_user" }
-    Chef::User.stub(:load).with("my_user").and_return(data)
-    @knife.should_receive(:edit_data).with(data).and_return(data)
+    allow(Chef::User).to receive(:load).with("my_user").and_return(data)
+    expect(@knife).to receive(:edit_data).with(data).and_return(data)
     @knife.run
   end
 
   it 'prints usage and exits when a user 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

data/spec/unit/knife/user_list_spec.rb

@@ -25,8 +25,8 @@ describe Chef::Knife::UserList do
   end
 
   it 'lists the users' do
-    Chef::User.should_receive(:list)
-    @knife.should_receive(:format_list_for_display)
+    expect(Chef::User).to receive(:list)
+    expect(@knife).to receive(:format_list_for_display)
     @knife.run
   end
 end

data/spec/unit/knife/user_reregister_spec.rb

@@ -24,30 +24,30 @@ describe Chef::Knife::UserReregister do
     @knife = Chef::Knife::UserReregister.new
     @knife.name_args = [ 'a_user' ]
     @user_mock = double('user_mock', :private_key => "private_key")
-    Chef::User.stub(:load).and_return(@user_mock)
+    allow(Chef::User).to receive(:load).and_return(@user_mock)
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
   end
 
   it 'prints usage and exits when a user 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
 
   it 'reregisters the user and prints the key' do
-    @user_mock.should_receive(:reregister).and_return(@user_mock)
+    expect(@user_mock).to receive(:reregister).and_return(@user_mock)
     @knife.run
-    @stdout.string.should match( /private_key/ )
+    expect(@stdout.string).to match( /private_key/ )
   end
 
   it 'writes the private key to a file when --file is specified' do
-    @user_mock.should_receive(:reregister).and_return(@user_mock)
+    expect(@user_mock).to receive(:reregister).and_return(@user_mock)
     @knife.config[:file] = '/tmp/a_file'
     filehandle = StringIO.new
-    File.should_receive(:open).with('/tmp/a_file', 'w').and_yield(filehandle)
+    expect(File).to receive(:open).with('/tmp/a_file', 'w').and_yield(filehandle)
     @knife.run
-    filehandle.string.should == "private_key"
+    expect(filehandle.string).to eq("private_key")
   end
 end