rest-assured 2.0.0 → 2.0.1

data/spec/config_spec.rb

@@ -13,18 +13,18 @@ module RestAssured
     describe 'cmd args array conversion' do
       it 'converts true values in form of "value" => ["--#{value}"]' do
         Config.build(:ssl => true)
-        Config.to_cmdargs.should == ['--ssl']
+        expect(Config.to_cmdargs).to eq(['--ssl'])
       end
 
       it 'does not include false values' do
         Config.build(:ssl => false)
-        Config.to_cmdargs.should_not include('--ssl')
+        expect(Config.to_cmdargs).not_to include('--ssl')
       end
 
       it 'converts key value pairs in form of "key => value" => ["--#{key}", "value"]' do
         Config.build(:port => 1234, :database => ':memory:')
         Config.to_cmdargs.each_slice(2) do |a|
-          (a == ['--port', '1234'] || a == ['--database', ':memory:']).should == true
+          expect(a == ['--port', '1234'] || a == ['--database', ':memory:']).to eq(true)
         end
       end
     end

data/spec/functional/double_routes_spec.rb

@@ -33,7 +33,7 @@ module RestAssured
     context "Web UI", :ui => true do
       it "makes doubles index root page" do
         visit '/'
-        current_path.should == '/doubles'
+        expect(current_path).to eq('/doubles')
       end
 
       # this is tested in cucumber
@@ -43,47 +43,47 @@ module RestAssured
 
         visit '/doubles'
 
-        page.should have_content(f.fullpath)
-        page.should have_content(f.description)
-        page.should have_content(f.verb)
-        page.should have_content(f1.fullpath)
-        page.should have_content(f1.description)
-        page.should have_content(f1.verb)
+        expect(page).to have_content(f.fullpath)
+        expect(page).to have_content(f.description)
+        expect(page).to have_content(f.verb)
+        expect(page).to have_content(f1.fullpath)
+        expect(page).to have_content(f1.description)
+        expect(page).to have_content(f1.verb)
       end
 
       it "renders form for creating new double" do
         visit '/doubles/new'
 
-        page.should have_css('#double_fullpath')
-        page.should have_css('#double_content')
-        page.should have_css('#double_verb')
-        page.should have_css('#double_description')
+        expect(page).to have_css('#double_fullpath')
+        expect(page).to have_css('#double_content')
+        expect(page).to have_css('#double_verb')
+        expect(page).to have_css('#double_description')
       end
 
       it "creates double" do
         post '/doubles', valid_params
         follow_redirect!
 
-        last_request.fullpath.should == '/doubles'
-        last_response.body.should =~ /Double created/
+        expect(last_request.fullpath).to eq('/doubles')
+        expect(last_response.body).to match(/Double created/)
 
         d = Models::Double.where(test_double.except(:response_headers)).first
-        d.response_headers['ACCEPT'].should == 'text/html'
+        expect(d.response_headers['ACCEPT']).to eq('text/html')
       end
 
       it "reports failure when creating with invalid parameters" do
         post '/doubles', invalid_params
 
-        last_response.should be_ok
-        last_response.body.should =~ /Crumps!.*Fullpath can't be blank/
+        expect(last_response).to be_ok
+        expect(last_response.body).to match(/Crumps!.*Fullpath can't be blank/)
       end
 
       it "renders double edit form" do
         f = Models::Double.create test_double
         visit "/doubles/#{f.id}/edit"
 
-        find('#double_fullpath').value.should == f.fullpath
-        find('#double_content').value.should == f.content
+        expect(find('#double_fullpath').value).to eq(f.fullpath)
+        expect(find('#double_content').value).to eq(f.content)
       end
 
       it "updates double" do
@@ -92,13 +92,13 @@ module RestAssured
         put "/doubles/#{f.id}", 'double[fullpath]' => '/some/other/api'
         follow_redirect!
 
-        last_request.fullpath.should == '/doubles'
-        last_response.body.should =~ /Double updated/
-        f.reload.fullpath.should  == '/some/other/api'
-        f.content.should          == test_double[:content]
-        f.verb.should             == test_double[:verb]
-        f.status.to_s.should      == test_double[:status]
-        f.response_headers.should == test_double[:response_headers]
+        expect(last_request.fullpath).to eq('/doubles')
+        expect(last_response.body).to match(/Double updated/)
+        expect(f.reload.fullpath).to  eq('/some/other/api')
+        expect(f.content).to          eq(test_double[:content])
+        expect(f.verb).to             eq(test_double[:verb])
+        expect(f.status.to_s).to      eq(test_double[:status])
+        expect(f.response_headers).to eq(test_double[:response_headers])
       end
 
       it "chooses active double" do
@@ -106,8 +106,8 @@ module RestAssured
 
         ajax "/doubles/#{f.id}", :as => :put, :active => true
 
-        last_response.should be_ok
-        last_response.body.should == 'Changed'
+        expect(last_response).to be_ok
+        expect(last_response.body).to eq('Changed')
       end
 
       it "deletes double" do
@@ -116,10 +116,10 @@ module RestAssured
         delete "/doubles/#{f.id}"
         follow_redirect!
 
-        last_response.should be_ok
-        last_response.body.should =~ /Double deleted/
+        expect(last_response).to be_ok
+        expect(last_response.body).to match(/Double deleted/)
 
-        Models::Double.exists?(test_double.except(:response_headers)).should be_false
+        expect(Models::Double.exists?(test_double.except(:response_headers))).to be_falsey
       end
     end
 
@@ -127,17 +127,17 @@ module RestAssured
       it "creates double" do
         post '/doubles.json', test_double
 
-        last_response.should be_ok
+        expect(last_response).to be_ok
 
         d = Models::Double.where(test_double.except(:response_headers)).first
-        d.response_headers['ACCEPT'].should == 'text/html'
+        expect(d.response_headers['ACCEPT']).to eq('text/html')
       end
 
       it "reports failure when creating with invalid parameters" do
         post '/doubles.json', test_double.except(:fullpath)
 
-        last_response.should_not be_ok
-        last_response.body.should =~ /\{"fullpath":\["can't be blank"\]\}/
+        expect(last_response).not_to be_ok
+        expect(last_response.body).to match(/\{"fullpath":\["can't be blank"\]\}/)
       end
 
       it "deletes double" do
@@ -145,9 +145,9 @@ module RestAssured
 
         delete "/doubles/#{f.id}.json"
 
-        last_response.should be_ok
+        expect(last_response).to be_ok
 
-        Models::Double.exists?(test_double.except(:response_headers)).should be_false
+        expect(Models::Double.exists?(test_double.except(:response_headers))).to be_falsey
       end
 
       it "deletes all doubles" do
@@ -155,39 +155,39 @@ module RestAssured
 
         delete '/doubles/all'
 
-        last_response.should be_ok
-        Models::Double.count.should == 0
+        expect(last_response).to be_ok
+        expect(Models::Double.count).to eq(0)
       end
     end
 
     context 'REST (ActiveResource compatible) json api', :ui => false do
       it "gets list of doubles" do
-        f  = Models::Double.create test_double
-        f1 = Models::Double.create test_double.merge(:verb => 'GET')
+        Models::Double.create test_double
+        Models::Double.create test_double.merge(:verb => 'GET')
 
         get '/doubles.json'
 
-        json = MultiJson.load(last_response.body)
+        json = JSON.load(last_response.body)
 
-        json.first['double']['verb'].should == 'POST'
-        json.last['double']['verb'].should == 'GET'
+        expect(json.first['verb']).to eq('POST')
+        expect(json.last['verb']).to eq('GET')
       end
 
       it "creates double as AR resource" do
-        post '/doubles.json', { :double => test_double }.to_json, 'CONTENT_TYPE' => 'Application/json'
+        post '/doubles.json', test_double.to_json, 'CONTENT_TYPE' => 'Application/json'
 
-        last_response.should be_ok
+        expect(last_response).to be_ok
 
         d = Models::Double.where(test_double.except(:response_headers)).first
-        d.response_headers['ACCEPT'].should == 'text/html'
-        last_response.body.should == d.to_json
+        expect(d.response_headers['ACCEPT']).to eq('text/html')
+        expect(last_response.body).to eq(d.to_json)
       end
 
       it "reports failure when creating with invalid parameters" do
-        post '/doubles.json', { :double => test_double.except(:fullpath) }.to_json, 'CONTENT_TYPE' => 'Application/json'
+        post '/doubles.json', test_double.except(:fullpath).to_json, 'CONTENT_TYPE' => 'Application/json'
 
-        last_response.should_not be_ok
-        last_response.body.should =~ /\{"fullpath":\["can't be blank"\]\}/
+        expect(last_response).not_to be_ok
+        expect(last_response.body).to match(/\{"fullpath":\["can't be blank"\]\}/)
       end
 
       it 'loads double as AR resource' do
@@ -195,14 +195,14 @@ module RestAssured
 
         get "/doubles/#{d.id}.json", 'CONTENT_TYPE' => 'Application/json'
 
-        last_response.should be_ok
-        last_response.body.should == d.to_json(:include => :requests)
+        expect(last_response).to be_ok
+        expect(last_response.body).to eq(d.to_json(:include => :requests))
       end
 
       it '404s if double is not found' do
         get "/doubles/345345.json", 'CONTENT_TYPE' => 'Application/json'
 
-        last_response.status.should == 404
+        expect(last_response.status).to eq(404)
       end
     end
   end

data/spec/functional/redirect_routes_spec.rb

@@ -20,39 +20,39 @@ module RestAssured
 
         visit '/redirects'
 
-        page.should have_content(r.pattern)
-        page.should have_content(r.to)
+        expect(page).to have_content(r.pattern)
+        expect(page).to have_content(r.to)
       end
 
       it "shows form for creating new redirect" do
         visit '/redirects/new'
 
-        page.should have_css('#redirect_pattern')
-        page.should have_css('#redirect_to')
+        expect(page).to have_css('#redirect_pattern')
+        expect(page).to have_css('#redirect_to')
       end
 
       it "creates redirect" do
         post '/redirects', valid_params
         follow_redirect!
 
-        last_request.fullpath.should == '/redirects'
-        last_response.body.should =~ /Redirect created/
-        Models::Redirect.exists?(redirect).should be true
+        expect(last_request.fullpath).to eq('/redirects')
+        expect(last_response.body).to match(/Redirect created/)
+        expect(Models::Redirect.exists?(redirect)).to be true
       end
 
       it "reports failure when creating with invalid parameters" do
         post '/redirects', invalid_params
 
-        last_response.should be_ok
-        last_response.body.should =~ /Crumps!.*Pattern can't be blank/
+        expect(last_response).to be_ok
+        expect(last_response.body).to match(/Crumps!.*Pattern can't be blank/)
       end
 
       it "brings up redirect edit form" do
         r = Models::Redirect.create redirect
         visit "/redirects/#{r.id}/edit"
 
-        find('#redirect_pattern').value.should == r.pattern
-        find('#redirect_to').value.should == r.to
+        expect(find('#redirect_pattern').value).to eq(r.pattern)
+        expect(find('#redirect_to').value).to eq(r.to)
       end
 
       it "updates redirect" do
@@ -61,9 +61,9 @@ module RestAssured
         put "/redirects/#{r.id}", 'redirect[to]' => '/some/other/api'
         follow_redirect!
 
-        last_request.fullpath.should == '/redirects'
-        last_response.body.should =~ /Redirect updated/
-        r.reload.to.should == '/some/other/api'
+        expect(last_request.fullpath).to eq('/redirects')
+        expect(last_response.body).to match(/Redirect updated/)
+        expect(r.reload.to).to eq('/some/other/api')
       end
 
       it "reorders redirects" do
@@ -72,10 +72,10 @@ module RestAssured
 
         put "/redirects/reorder", :redirect => [r2.id, r1.id]
 
-        last_response.should be_ok
-        last_response.body.should == 'Changed'
-        r1.reload.position.should == 1
-        r2.reload.position.should == 0
+        expect(last_response).to be_ok
+        expect(last_response.body).to eq('Changed')
+        expect(r1.reload.position).to eq(1)
+        expect(r2.reload.position).to eq(0)
       end
 
       it "deletes redirect" do
@@ -84,10 +84,10 @@ module RestAssured
         delete "/redirects/#{f.id}"
         follow_redirect!
 
-        last_response.should be_ok
-        last_response.body.should =~ /Redirect deleted/
+        expect(last_response).to be_ok
+        expect(last_response.body).to match(/Redirect deleted/)
 
-        Models::Redirect.exists?(redirect).should be_false
+        expect(Models::Redirect.exists?(redirect)).to be_falsey
       end
     end
 
@@ -95,15 +95,15 @@ module RestAssured
       it "creates redirect" do
         post '/redirects.json', redirect
 
-        last_response.should be_ok
-        Models::Redirect.count.should == 1
+        expect(last_response).to be_ok
+        expect(Models::Redirect.count).to eq(1)
       end
 
       it "reports failure when creating with invalid parameters" do
         post '/redirects.json', redirect.except(:pattern)
 
-        last_response.should_not be_ok
-        last_response.body.should =~ /Pattern can't be blank/
+        expect(last_response).not_to be_ok
+        expect(last_response.body).to match(/Pattern can't be blank/)
       end
 
       it "deletes all redirects" do
@@ -111,8 +111,8 @@ module RestAssured
 
         delete '/redirects/all'
 
-        last_response.should be_ok
-        Models::Redirect.count.should == 0
+        expect(last_response).to be_ok
+        expect(Models::Redirect.count).to eq(0)
       end
     end
   end

data/spec/functional/response_spec.rb

@@ -6,7 +6,7 @@ module RestAssured
     [:get, :post, :put, :delete].each do |verb|
       it "processes an unknown request" do
 
-        Response.should_receive(:perform).with(an_instance_of(RestAssured::Application))
+        expect(Response).to receive(:perform).with(an_instance_of(RestAssured::Application))
         send verb, '/some/path'
       end
     end
@@ -31,44 +31,44 @@ module RestAssured
           :response_headers => { 'ACCEPT' => 'text/html' },
           :status           => 201
 
-        request.stub(:fullpath).and_return(@double.fullpath)
+        allow(request).to receive(:fullpath).and_return(@double.fullpath)
       end
 
       it "returns double content" do
-        rest_assured_app.should_receive(:body).with(@double.content)
+        expect(rest_assured_app).to receive(:body).with(@double.content)
 
         Response.perform(rest_assured_app)
       end
 
       it 'sets response status to the one from double' do
-        rest_assured_app.should_receive(:status).with(@double.status)
+        expect(rest_assured_app).to receive(:status).with(@double.status)
 
         Response.perform(rest_assured_app)
       end
 
       it 'sets response headers to those in Double#response_headers' do
-        rest_assured_app.should_receive(:headers).with(@double.response_headers)
+        expect(rest_assured_app).to receive(:headers).with(@double.response_headers)
 
         Response.perform(rest_assured_app)
       end
 
       it 'records request' do
         requests = double
-        Models::Double.stub_chain('where.first').and_return(double(:requests => requests).as_null_object)
+        allow(Models::Double).to receive_message_chain('where.first').and_return(double(:requests => requests).as_null_object)
 
-        requests.should_receive(:create!).with(:rack_env => 'env', :body => 'body', :params => 'params')
+        expect(requests).to receive(:create!).with(:rack_env => 'env', :body => 'body', :params => 'params')
 
         Response.perform(rest_assured_app)
       end
     
       it "returns double when redirect matches double" do
         fullpath = '/some/other/path'
-        request.stub(:fullpath).and_return(fullpath)
-        Models::Redirect.stub(:find_redirect_url_for).with(fullpath).and_return('/some/path')
+        allow(request).to receive(:fullpath).and_return(fullpath)
+        allow(Models::Redirect).to receive(:find_redirect_url_for).with(fullpath).and_return('/some/path')
 
-        rest_assured_app.should_receive(:body).with(@double.content)
-        rest_assured_app.should_receive(:status).with(@double.status)
-        rest_assured_app.should_receive(:headers).with(@double.response_headers)
+        expect(rest_assured_app).to receive(:body).with(@double.content)
+        expect(rest_assured_app).to receive(:status).with(@double.status)
+        expect(rest_assured_app).to receive(:headers).with(@double.response_headers)
 
         Response.perform(rest_assured_app)
       end
@@ -79,16 +79,16 @@ module RestAssured
       #r = Models::Redirect.create :to => 'http://exmple.com/api', :pattern => '.*'
       #
       fullpath = '/some/other/path'
-      request.stub(:fullpath).and_return(fullpath)
-      Models::Redirect.stub(:find_redirect_url_for).with(fullpath).and_return('new_url')
+      allow(request).to receive(:fullpath).and_return(fullpath)
+      allow(Models::Redirect).to receive(:find_redirect_url_for).with(fullpath).and_return('new_url')
 
-      rest_assured_app.should_receive(:redirect).with('new_url')
+      expect(rest_assured_app).to receive(:redirect).with('new_url')
 
       Response.perform(rest_assured_app)
     end
 
     it "returns 404 if neither double nor redirect matches the request" do
-      rest_assured_app.should_receive(:status).with(404)
+      expect(rest_assured_app).to receive(:status).with(404)
 
       Response.perform(rest_assured_app)
     end
@@ -96,9 +96,9 @@ module RestAssured
     # TODO change to instead exclude anything that does not respond_to?(:to_s)
     it 'excludes "rack.input" and "rack.errors" as they break with "IOError - not opened for reading:" on consequent #to_json (as they are IO and StringIO)' do
       requests = double.as_null_object
-      Models::Double.stub_chain('where.first').and_return(double(:requests => requests).as_null_object)
+      allow(Models::Double).to receive_message_chain('where.first').and_return(double(:requests => requests).as_null_object)
 
-      env.should_receive(:except).with('rack.input', 'rack.errors', 'rack.logger')
+      expect(env).to receive(:except).with('rack.input', 'rack.errors', 'rack.logger')
 
       Response.perform(rest_assured_app)
     end