Merge branch 'zlx-feature/patch-2'

samples/client/petstore/ruby/README.md

@@ -138,12 +138,6 @@ Class | Method | HTTP request | Description
 ## Documentation for Authorization
 
 
-### api_key
-
-- **Type**: API key
-- **API key parameter name**: api_key
-- **Location**: HTTP header
-
 ### petstore_auth
 
 - **Type**: OAuth
@@ -153,3 +147,9 @@ Class | Method | HTTP request | Description
   - write:pets: modify pets in your account
   - read:pets: read your pets
 
+### api_key
+
+- **Type**: API key
+- **API key parameter name**: api_key
+- **Location**: HTTP header
+

samples/client/petstore/ruby/lib/petstore/configuration.rb

@@ -157,13 +157,6 @@ module Petstore
     # Returns Auth Settings hash for api client.
     def auth_settings
       {
-        'api_key' =>
-          {
-            type: 'api_key',
-            in: 'header',
-            key: 'api_key',
-            value: api_key_with_prefix('api_key')
-          },
         'petstore_auth' =>
           {
             type: 'oauth2',
@@ -171,6 +164,13 @@ module Petstore
             key: 'Authorization',
             value: "Bearer #{access_token}"
           },
+        'api_key' =>
+          {
+            type: 'api_key',
+            in: 'header',
+            key: 'api_key',
+            value: api_key_with_prefix('api_key')
+          },
       }
     end
   end

samples/client/petstore/ruby/spec/api_client_spec.rb

@@ -10,34 +10,34 @@ describe Petstore::ApiClient do
       context 'host' do
         it 'removes http from host' do
           Petstore.configure { |c| c.host = 'http://example.com' }
-          Petstore::Configuration.default.host.should == 'example.com'
+          expect(Petstore::Configuration.default.host).to eq('example.com')
         end
 
         it 'removes https from host' do
           Petstore.configure { |c| c.host = 'https://wookiee.com' }
-          Petstore::ApiClient.default.config.host.should == 'wookiee.com'
+          expect(Petstore::ApiClient.default.config.host).to eq('wookiee.com')
         end
 
         it 'removes trailing path from host' do
           Petstore.configure { |c| c.host = 'hobo.com/v4' }
-          Petstore::Configuration.default.host.should == 'hobo.com'
+          expect(Petstore::Configuration.default.host).to eq('hobo.com')
         end
       end
 
       context 'base_path' do
         it "prepends a slash to base_path" do
           Petstore.configure { |c| c.base_path = 'v4/dog' }
-          Petstore::Configuration.default.base_path.should == '/v4/dog'
+          expect(Petstore::Configuration.default.base_path).to eq('/v4/dog')
         end
 
         it "doesn't prepend a slash if one is already there" do
           Petstore.configure { |c| c.base_path = '/v4/dog' }
-          Petstore::Configuration.default.base_path.should == '/v4/dog'
+          expect(Petstore::Configuration.default.base_path).to eq('/v4/dog')
         end
 
         it "ends up as a blank string if nil" do
           Petstore.configure { |c| c.base_path = nil }
-          Petstore::Configuration.default.base_path.should == ''
+          expect(Petstore::Configuration.default.base_path).to eq('')
         end
       end
 
@@ -65,14 +65,14 @@ describe Petstore::ApiClient do
       header_params = {}
       query_params = {}
       api_client.update_params_for_auth! header_params, query_params, auth_names
-      header_params.should == {'api_key' => 'PREFIX special-key'}
+      expect(header_params).to eq({'api_key' => 'PREFIX special-key'})
-      query_params.should == {}
+      expect(query_params).to eq({})
 
       header_params = {}
       query_params = {}
       api_client2.update_params_for_auth! header_params, query_params, auth_names
-      header_params.should == {'api_key' => 'PREFIX2 special-key2'}
+      expect(header_params).to eq({'api_key' => 'PREFIX2 special-key2'})
-      query_params.should == {}
+      expect(query_params).to eq({})
     end
 
     it "sets header api-key parameter without prefix" do
@@ -87,8 +87,8 @@ describe Petstore::ApiClient do
       query_params = {}
       auth_names = ['api_key', 'unknown']
       api_client.update_params_for_auth! header_params, query_params, auth_names
-      header_params.should == {'api_key' => 'special-key'}
+      expect(header_params).to eq({'api_key' => 'special-key'})
-      query_params.should == {}
+      expect(query_params).to eq({})
     end
   end
 
@@ -97,17 +97,17 @@ describe Petstore::ApiClient do
     let(:api_client) { Petstore::ApiClient.new(config) }
 
     it "defaults to 0" do
-      Petstore::Configuration.default.timeout.should == 0
+      expect(Petstore::Configuration.default.timeout).to eq(0)
-      config.timeout.should == 0
+      expect(config.timeout).to eq(0)
 
       request = api_client.build_request(:get, '/test')
-      request.options[:timeout].should == 0
+      expect(request.options[:timeout]).to eq(0)
     end
 
     it "can be customized" do
       config.timeout = 100
       request = api_client.build_request(:get, '/test')
-      request.options[:timeout].should == 100
+      expect(request.options[:timeout]).to eq(100)
     end
   end
 
@@ -117,8 +117,8 @@ describe Petstore::ApiClient do
       headers = {'Content-Type' => 'application/json'}
       response = double('response', headers: headers, body: '[12, 34]')
       data = api_client.deserialize(response, 'Array<Integer>')
-      data.should be_a(Array)
+      expect(data).to be_a(Array)
-      data.should == [12, 34]
+      expect(data).to eq([12, 34])
     end
 
     it "handles Array<Array<Integer>>" do
@@ -126,8 +126,8 @@ describe Petstore::ApiClient do
       headers = {'Content-Type' => 'application/json'}
       response = double('response', headers: headers, body: '[[12, 34], [56]]')
       data = api_client.deserialize(response, 'Array<Array<Integer>>')
-      data.should be_a(Array)
+      expect(data).to be_a(Array)
-      data.should == [[12, 34], [56]]
+      expect(data).to eq([[12, 34], [56]])
     end
 
     it "handles Hash<String, String>" do
@@ -135,8 +135,8 @@ describe Petstore::ApiClient do
       headers = {'Content-Type' => 'application/json'}
       response = double('response', headers: headers, body: '{"message": "Hello"}')
       data = api_client.deserialize(response, 'Hash<String, String>')
-      data.should be_a(Hash)
+      expect(data).to be_a(Hash)
-      data.should == {:message => 'Hello'}
+      expect(data).to eq({:message => 'Hello'})
     end
 
     it "handles Hash<String, Pet>" do
@@ -144,11 +144,11 @@ describe Petstore::ApiClient do
       headers = {'Content-Type' => 'application/json'}
       response = double('response', headers: headers, body: '{"pet": {"id": 1}}')
       data = api_client.deserialize(response, 'Hash<String, Pet>')
-      data.should be_a(Hash)
+      expect(data).to be_a(Hash)
-      data.keys.should == [:pet]
+      expect(data.keys).to eq([:pet])
       pet = data[:pet]
-      pet.should be_a(Petstore::Pet)
+      expect(pet).to be_a(Petstore::Pet)
-      pet.id.should == 1
+      expect(pet.id).to eq(1)
     end
 
     it "handles Hash<String, Hash<String, Pet>>" do
@@ -156,14 +156,14 @@ describe Petstore::ApiClient do
       headers = {'Content-Type' => 'application/json'}
       response = double('response', headers: headers, body: '{"data": {"pet": {"id": 1}}}')
       result = api_client.deserialize(response, 'Hash<String, Hash<String, Pet>>')
-      result.should be_a(Hash)
+      expect(result).to be_a(Hash)
-      result.keys.should == [:data]
+      expect(result.keys).to eq([:data])
       data = result[:data]
-      data.should be_a(Hash)
+      expect(data).to be_a(Hash)
-      data.keys.should == [:pet]
+      expect(data.keys).to eq([:pet])
       pet = data[:pet]
-      pet.should be_a(Petstore::Pet)
+      expect(pet).to be_a(Petstore::Pet)
-      pet.id.should == 1
+      expect(pet.id).to eq(1)
     end
   end
 
@@ -177,7 +177,7 @@ describe Petstore::ApiClient do
       pet.photo_urls = nil
       pet.tags = []
       expected = {id: 1, name: '', tags: []}
-      api_client.object_to_hash(pet).should == expected
+      expect(api_client.object_to_hash(pet)).to eq(expected)
     end
   end
 
@@ -186,27 +186,27 @@ describe Petstore::ApiClient do
     let(:api_client) { Petstore::ApiClient.new }
 
     it "works for csv" do
-      api_client.build_collection_param(param, :csv).should == 'aa,bb,cc'
+      expect(api_client.build_collection_param(param, :csv)).to eq('aa,bb,cc')
     end
 
     it "works for ssv" do
-      api_client.build_collection_param(param, :ssv).should == 'aa bb cc'
+      expect(api_client.build_collection_param(param, :ssv)).to eq('aa bb cc')
     end
 
     it "works for tsv" do
-      api_client.build_collection_param(param, :tsv).should == "aa\tbb\tcc"
+      expect(api_client.build_collection_param(param, :tsv)).to eq("aa\tbb\tcc")
     end
 
     it "works for pipes" do
-      api_client.build_collection_param(param, :pipes).should == 'aa|bb|cc'
+      expect(api_client.build_collection_param(param, :pipes)).to eq('aa|bb|cc')
     end
 
     it "works for multi" do
-      api_client.build_collection_param(param, :multi).should == ['aa', 'bb', 'cc']
+      expect(api_client.build_collection_param(param, :multi)).to eq(['aa', 'bb', 'cc'])
     end
 
     it "fails for invalid collection format" do
-      proc { api_client.build_collection_param(param, :INVALID) }.should raise_error(RuntimeError, 'unknown collection format: :INVALID')
+      expect { api_client.build_collection_param(param, :INVALID) }.to raise_error(RuntimeError, 'unknown collection format: :INVALID')
     end
   end
 
@@ -214,16 +214,16 @@ describe Petstore::ApiClient do
     let(:api_client) { Petstore::ApiClient.new }
 
     it "works" do
-      api_client.json_mime?(nil).should == false
+      expect(api_client.json_mime?(nil)).to eq(false)
-      api_client.json_mime?('').should == false
+      expect(api_client.json_mime?('')).to eq(false)
 
-      api_client.json_mime?('application/json').should == true
+      expect(api_client.json_mime?('application/json')).to eq(true)
-      api_client.json_mime?('application/json; charset=UTF8').should == true
+      expect(api_client.json_mime?('application/json; charset=UTF8')).to eq(true)
-      api_client.json_mime?('APPLICATION/JSON').should == true
+      expect(api_client.json_mime?('APPLICATION/JSON')).to eq(true)
 
-      api_client.json_mime?('application/xml').should == false
+      expect(api_client.json_mime?('application/xml')).to eq(false)
-      api_client.json_mime?('text/plain').should == false
+      expect(api_client.json_mime?('text/plain')).to eq(false)
-      api_client.json_mime?('application/jsonp').should == false
+      expect(api_client.json_mime?('application/jsonp')).to eq(false)
     end
   end
 
@@ -231,15 +231,15 @@ describe Petstore::ApiClient do
     let(:api_client) { Petstore::ApiClient.new }
 
     it "works" do
-      api_client.select_header_accept(nil).should == nil
+      expect(api_client.select_header_accept(nil)).to eq(nil)
-      api_client.select_header_accept([]).should == nil
+      expect(api_client.select_header_accept([])).to eq(nil)
 
-      api_client.select_header_accept(['application/json']).should == 'application/json'
+      expect(api_client.select_header_accept(['application/json'])).to eq('application/json')
-      api_client.select_header_accept(['application/xml', 'application/json; charset=UTF8']).should == 'application/json; charset=UTF8'
+      expect(api_client.select_header_accept(['application/xml', 'application/json; charset=UTF8'])).to eq('application/json; charset=UTF8')
-      api_client.select_header_accept(['APPLICATION/JSON', 'text/html']).should == 'APPLICATION/JSON'
+      expect(api_client.select_header_accept(['APPLICATION/JSON', 'text/html'])).to eq('APPLICATION/JSON')
 
-      api_client.select_header_accept(['application/xml']).should == 'application/xml'
+      expect(api_client.select_header_accept(['application/xml'])).to eq('application/xml')
-      api_client.select_header_accept(['text/html', 'application/xml']).should == 'text/html,application/xml'
+      expect(api_client.select_header_accept(['text/html', 'application/xml'])).to eq('text/html,application/xml')
     end
   end
 
@@ -247,14 +247,14 @@ describe Petstore::ApiClient do
     let(:api_client) { Petstore::ApiClient.new }
 
     it "works" do
-      api_client.select_header_content_type(nil).should == 'application/json'
+      expect(api_client.select_header_content_type(nil)).to eq('application/json')
-      api_client.select_header_content_type([]).should == 'application/json'
+      expect(api_client.select_header_content_type([])).to eq('application/json')
 
-      api_client.select_header_content_type(['application/json']).should == 'application/json'
+      expect(api_client.select_header_content_type(['application/json'])).to eq('application/json')
-      api_client.select_header_content_type(['application/xml', 'application/json; charset=UTF8']).should == 'application/json; charset=UTF8'
+      expect(api_client.select_header_content_type(['application/xml', 'application/json; charset=UTF8'])).to eq('application/json; charset=UTF8')
-      api_client.select_header_content_type(['APPLICATION/JSON', 'text/html']).should == 'APPLICATION/JSON'
+      expect(api_client.select_header_content_type(['APPLICATION/JSON', 'text/html'])).to eq('APPLICATION/JSON')
-      api_client.select_header_content_type(['application/xml']).should == 'application/xml'
+      expect(api_client.select_header_content_type(['application/xml'])).to eq('application/xml')
-      api_client.select_header_content_type(['text/plain', 'application/xml']).should == 'text/plain'
+      expect(api_client.select_header_content_type(['text/plain', 'application/xml'])).to eq('text/plain')
     end
   end
 
@@ -262,15 +262,15 @@ describe Petstore::ApiClient do
     let(:api_client) { Petstore::ApiClient.new }
 
     it "works" do
-      api_client.sanitize_filename('sun').should == 'sun'
+      expect(api_client.sanitize_filename('sun')).to eq('sun')
-      api_client.sanitize_filename('sun.gif').should == 'sun.gif'
+      expect(api_client.sanitize_filename('sun.gif')).to eq('sun.gif')
-      api_client.sanitize_filename('../sun.gif').should == 'sun.gif'
+      expect(api_client.sanitize_filename('../sun.gif')).to eq('sun.gif')
-      api_client.sanitize_filename('/var/tmp/sun.gif').should == 'sun.gif'
+      expect(api_client.sanitize_filename('/var/tmp/sun.gif')).to eq('sun.gif')
-      api_client.sanitize_filename('./sun.gif').should == 'sun.gif'
+      expect(api_client.sanitize_filename('./sun.gif')).to eq('sun.gif')
-      api_client.sanitize_filename('..\sun.gif').should == 'sun.gif'
+      expect(api_client.sanitize_filename('..\sun.gif')).to eq('sun.gif')
-      api_client.sanitize_filename('\var\tmp\sun.gif').should == 'sun.gif'
+      expect(api_client.sanitize_filename('\var\tmp\sun.gif')).to eq('sun.gif')
-      api_client.sanitize_filename('c:\var\tmp\sun.gif').should == 'sun.gif'
+      expect(api_client.sanitize_filename('c:\var\tmp\sun.gif')).to eq('sun.gif')
-      api_client.sanitize_filename('.\sun.gif').should == 'sun.gif'
+      expect(api_client.sanitize_filename('.\sun.gif')).to eq('sun.gif')
     end
   end
 

samples/client/petstore/ruby/spec/configuration_spec.rb

@@ -12,13 +12,13 @@ describe Petstore::Configuration do
 
   describe '#base_url' do
     it 'should have the default value' do
-      config.base_url.should == 'http://petstore.swagger.io/v2'
+      expect(config.base_url).to eq('http://petstore.swagger.io/v2')
     end
 
     it 'should remove trailing slashes' do
       [nil, '', '/', '//'].each do |base_path|
         config.base_path = base_path
-        config.base_url.should == 'http://petstore.swagger.io'
+        expect(config.base_url).to eq('http://petstore.swagger.io')
       end
     end
   end

samples/client/petstore/ruby/spec/pet_spec.rb

@@ -33,42 +33,42 @@ describe "Pet" do
       }
       pet = Petstore::Pet.new(pet_hash)
       # test new
-      pet.name.should == "RUBY UNIT TESTING"
+      expect(pet.name).to eq("RUBY UNIT TESTING")
-      pet.status.should == "pending"
+      expect(pet.status).to eq("pending")
-      pet.id.should == @pet_id
+      expect(pet.id).to eq(@pet_id)
-      pet.tags[0].id.should == 1
+      expect(pet.tags[0].id).to eq(1)
-      pet.tags[1].name.should == 'tag2'
+      expect(pet.tags[1].name).to eq('tag2')
-      pet.category.name.should == 'category unknown'
+      expect(pet.category.name).to eq('category unknown')
 
       # test build_from_hash
       pet2 = Petstore::Pet.new
       pet2.build_from_hash(pet.to_hash)
-      pet.to_hash.should == pet2.to_hash
+      expect(pet.to_hash).to eq(pet2.to_hash)
 
       # make sure sub-object has different object id
-      pet.tags[0].object_id.should_not == pet2.tags[0].object_id
+      expect(pet.tags[0].object_id).not_to eq(pet2.tags[0].object_id)
-      pet.tags[1].object_id.should_not == pet2.tags[1].object_id
+      expect(pet.tags[1].object_id).not_to eq(pet2.tags[1].object_id)
-      pet.category.object_id.should_not == pet2.category.object_id
+      expect(pet.category.object_id).not_to eq(pet2.category.object_id)
     end
 
     it "should fetch a pet object" do
       pet = @pet_api.get_pet_by_id(@pet_id)
-      pet.should be_a(Petstore::Pet)
+      expect(pet).to be_a(Petstore::Pet)
-      pet.id.should == @pet_id
+      expect(pet.id).to eq(@pet_id)
-      pet.name.should == "RUBY UNIT TESTING"
+      expect(pet.name).to eq("RUBY UNIT TESTING")
-      pet.tags[0].name.should == "tag test"
+      expect(pet.tags[0].name).to eq("tag test")
-      pet.category.name.should == "category test"
+      expect(pet.category.name).to eq("category test")
     end
 
     it "should fetch a pet object with http info" do
       pet, status_code, headers = @pet_api.get_pet_by_id_with_http_info(@pet_id)
-      status_code.should == 200
+      expect(status_code).to eq(200)
-      headers['Content-Type'].should == 'application/json'
+      expect(headers['Content-Type']).to eq('application/json')
-      pet.should be_a(Petstore::Pet)
+      expect(pet).to be_a(Petstore::Pet)
-      pet.id.should == @pet_id
+      expect(pet.id).to eq(@pet_id)
-      pet.name.should == "RUBY UNIT TESTING"
+      expect(pet.name).to eq("RUBY UNIT TESTING")
-      pet.tags[0].name.should == "tag test"
+      expect(pet.tags[0].name).to eq("tag test")
-      pet.category.name.should == "category test"
+      expect(pet.category.name).to eq("category test")
     end
 
     it "should not find a pet that does not exist" do
@@ -76,11 +76,11 @@ describe "Pet" do
         @pet_api.get_pet_by_id(-@pet_id)
         fail 'it should raise error'
       rescue Petstore::ApiError => e
-        e.code.should == 404
+        expect(e.code).to eq(404)
-        e.message.should == 'Not Found'
+        expect(e.message).to eq('Not Found')
-        e.response_body.should == '{"code":1,"type":"error","message":"Pet not found"}'
+        expect(e.response_body).to eq('{"code":1,"type":"error","message":"Pet not found"}')
-        e.response_headers.should be_a(Hash)
+        expect(e.response_headers).to be_a(Hash)
-        e.response_headers['Content-Type'].should == 'application/json'
+        expect(e.response_headers['Content-Type']).to eq('application/json')
       end
     end
 
@@ -93,12 +93,12 @@ describe "Pet" do
       @pet_api.add_pet_using_byte_array(body: str)
 
       fetched_str = @pet_api.pet_pet_idtesting_byte_arraytrue_get(pet.id)
-      fetched_str.should be_a(String)
+      expect(fetched_str).to be_a(String)
       fetched = deserialize_json(fetched_str, 'Pet')
-      fetched.should be_a(Petstore::Pet)
+      expect(fetched).to be_a(Petstore::Pet)
-      fetched.id.should == pet.id
+      expect(fetched.id).to eq(pet.id)
-      fetched.category.should be_a(Petstore::Category)
+      expect(fetched.category).to be_a(Petstore::Category)
-      fetched.category.name.should == pet.category.name
+      expect(fetched.category.name).to eq(pet.category.name)
 
       @pet_api.delete_pet(pet.id)
     end
@@ -107,40 +107,40 @@ describe "Pet" do
     # we will re-enable this after updating the petstore server
     xit "should get pet in object" do
       pet = @pet_api.get_pet_by_id_in_object(@pet_id)
-      pet.should be_a(Petstore::InlineResponse200)
+      expect(pet).to be_a(Petstore::InlineResponse200)
-      pet.id.should == @pet_id
+      expect(pet.id).to eq(@pet_id)
-      pet.name.should == "RUBY UNIT TESTING"
+      expect(pet.name).to eq("RUBY UNIT TESTING")
-      pet.category.should be_a(Hash)
+      expect(pet.category).to be_a(Hash)
-      pet.category[:id].should == 20002
+      expect(pet.category[:id]).to eq(20002)
-      pet.category[:name].should == 'category test'
+      expect(pet.category[:name]).to eq('category test')
     end
 
     it "should update a pet" do
       pet = @pet_api.get_pet_by_id(@pet_id)
-      pet.id.should == @pet_id
+      expect(pet.id).to eq(@pet_id)
-      pet.name.should == "RUBY UNIT TESTING"
+      expect(pet.name).to eq("RUBY UNIT TESTING")
-      pet.status.should == 'pending'
+      expect(pet.status).to eq('pending')
 
       @pet_api.update_pet_with_form(@pet_id, name: 'new name', status: 'sold')
 
       fetched = @pet_api.get_pet_by_id(@pet_id)
-      fetched.id.should == @pet_id
+      expect(fetched.id).to eq(@pet_id)
-      fetched.name.should == "new name"
+      expect(fetched.name).to eq("new name")
-      fetched.status.should == 'sold'
+      expect(fetched.status).to eq('sold')
     end
 
     it "should find pets by status" do
       pets = @pet_api.find_pets_by_status(['available'])
-      pets.length.should >= 3
+      expect(pets.length).to be >= 3
       pets.each do |pet|
-        pet.should be_a(Petstore::Pet)
+        expect(pet).to be_a(Petstore::Pet)
-        pet.status.should == 'available'
+        expect(pet.status).to eq('available')
       end
     end
 
     it "should not find a pet with invalid status" do
       pets = @pet_api.find_pets_by_status(['invalid-status'])
-      pets.length.should == 0
+      expect(pets.length).to eq(0)
     end
 
     it "should find a pet by status" do
@@ -158,11 +158,11 @@ describe "Pet" do
       pet = Petstore::Pet.new('id' => id, 'name' => "RUBY UNIT TESTING")
       result = @pet_api.add_pet(pet)
       # nothing is returned
-      result.should be_nil
+      expect(result).to be_nil
 
       pet = @pet_api.get_pet_by_id(id)
-      pet.id.should == id
+      expect(pet.id).to eq(id)
-      pet.name.should == "RUBY UNIT TESTING"
+      expect(pet.name).to eq("RUBY UNIT TESTING")
 
       @pet_api.delete_pet(id)
     end
@@ -170,48 +170,48 @@ describe "Pet" do
     it "should upload a file to a pet" do
       result = @pet_api.upload_file(@pet_id, file: File.new('hello.txt'))
       # ApiResponse is returned
-      result.should be_a(Petstore::ApiResponse)
+      expect(result).to be_a(Petstore::ApiResponse)
     end
 
     it "should upload a file with form parameter to a pet" do
       result = @pet_api.upload_file(@pet_id, file: File.new('hello.txt'), additional_metadata: 'metadata')
       # ApiResponse is returned
-      result.should be_a(Petstore::ApiResponse)
+      expect(result).to be_a(Petstore::ApiResponse)
     end
 
     it "should implement eql? and hash" do
       pet1 = Petstore::Pet.new
       pet2 = Petstore::Pet.new
-      pet1.should == pet2
+      expect(pet1).to eq(pet2)
-      pet2.should == pet1
+      expect(pet2).to eq(pet1)
-      pet1.eql?(pet2).should == true
+      expect(pet1.eql?(pet2)).to eq(true)
-      pet2.eql?(pet1).should == true
+      expect(pet2.eql?(pet1)).to eq(true)
-      pet1.hash.should == pet2.hash
+      expect(pet1.hash).to eq(pet2.hash)
-      pet1.should == pet1
+      expect(pet1).to eq(pet1)
-      pet1.eql?(pet1).should == true
+      expect(pet1.eql?(pet1)).to eq(true)
-      pet1.hash.should == pet1.hash
+      expect(pet1.hash).to eq(pet1.hash)
 
       pet1.name = 'really-happy'
       pet1.photo_urls = ['http://foo.bar.com/1', 'http://foo.bar.com/2']
-      pet1.should_not == pet2
+      expect(pet1).not_to eq(pet2)
-      pet2.should_not == pet1
+      expect(pet2).not_to eq(pet1)
-      pet1.eql?(pet2).should == false
+      expect(pet1.eql?(pet2)).to eq(false)
-      pet2.eql?(pet1).should == false
+      expect(pet2.eql?(pet1)).to eq(false)
-      pet1.hash.should_not == pet2.hash
+      expect(pet1.hash).not_to eq(pet2.hash)
-      pet1.should == pet1
+      expect(pet1).to eq(pet1)
-      pet1.eql?(pet1).should == true
+      expect(pet1.eql?(pet1)).to eq(true)
-      pet1.hash.should == pet1.hash
+      expect(pet1.hash).to eq(pet1.hash)
 
       pet2.name = 'really-happy'
       pet2.photo_urls = ['http://foo.bar.com/1', 'http://foo.bar.com/2']
-      pet1.should == pet2
+      expect(pet1).to eq(pet2)
-      pet2.should == pet1
+      expect(pet2).to eq(pet1)
-      pet1.eql?(pet2).should == true
+      expect(pet1.eql?(pet2)).to eq(true)
-      pet2.eql?(pet1).should == true
+      expect(pet2.eql?(pet1)).to eq(true)
-      pet1.hash.should == pet2.hash
+      expect(pet1.hash).to eq(pet2.hash)
-      pet2.should == pet2
+      expect(pet2).to eq(pet2)
-      pet2.eql?(pet2).should == true
+      expect(pet2.eql?(pet2)).to eq(true)
-      pet2.hash.should == pet2.hash
+      expect(pet2.hash).to eq(pet2.hash)
     end
   end
 end

samples/client/petstore/ruby/spec/store_spec.rb

@@ -9,18 +9,18 @@ describe "Store" do
     @order_id = prepare_store(@api)
 
     item = @api.get_order_by_id(@order_id)
-    item.id.should == @order_id
+    expect(item.id).to eq(@order_id)
 
     @api.delete_order(@order_id)
   end
 
   it "should featch the inventory" do
     result = @api.get_inventory
-    result.should be_a(Hash)
+    expect(result).to be_a(Hash)
-    result.should_not be_empty
+    expect(result).not_to be_empty
     result.each do |k, v|
-      k.should be_a(Symbol)
+      expect(k).to be_a(Symbol)
-      v.should be_a(Integer)
+      expect(v).to be_a(Integer)
     end
   end
 
@@ -28,11 +28,11 @@ describe "Store" do
   # will re-enable this after updating the petstore server
   xit "should featch the inventory in object" do
     result = @api.get_inventory_in_object
-    result.should be_a(Hash)
+    expect(result).to be_a(Hash)
-    result.should_not be_empty
+    expect(result).not_to be_empty
     result.each do |k, v|
-      k.should be_a(Symbol)
+      expect(k).to be_a(Symbol)
-      v.should be_a(Integer)
+      expect(v).to be_a(Integer)
     end
   end
 end