doorkeeper 1.0.0.rc2 → 1.0.0

data/spec/lib/oauth/token_request_spec.rb

@@ -28,19 +28,19 @@ module Doorkeeper::OAuth
     end
 
     it 'returns a code response' do
-      subject.authorize.should be_a(CodeResponse)
+      expect(subject.authorize).to be_a(CodeResponse)
     end
 
     it 'does not create token when not authorizable' do
-      pre_auth.stub :authorizable? => false
+      allow(pre_auth).to receive(:authorizable?).and_return(false)
       expect do
         subject.authorize
       end.to_not change { Doorkeeper::AccessToken.count }
     end
 
     it 'returns a error response' do
-      pre_auth.stub :authorizable? => false
-      subject.authorize.should be_a(ErrorResponse)
+      allow(pre_auth).to receive(:authorizable?).and_return(false)
+      expect(subject.authorize).to be_a(ErrorResponse)
     end
   end
 end

data/spec/lib/oauth/token_response_spec.rb

@@ -7,12 +7,12 @@ module Doorkeeper::OAuth
 
     it 'includes access token response headers' do
       headers = subject.headers
-      headers.fetch('Cache-Control').should == 'no-store'
-      headers.fetch('Pragma').should == 'no-cache'
+      expect(headers.fetch('Cache-Control')).to eq('no-store')
+      expect(headers.fetch('Pragma')).to eq('no-cache')
     end
 
     it 'status is ok' do
-      subject.status.should == :ok
+      expect(subject.status).to eq(:ok)
     end
 
     describe '.body' do
@@ -30,25 +30,25 @@ module Doorkeeper::OAuth
       subject { TokenResponse.new(access_token).body }
 
       it 'includes :access_token' do
-        subject['access_token'].should == 'some-token'
+        expect(subject['access_token']).to eq('some-token')
       end
 
       it 'includes :token_type' do
-        subject['token_type'].should == 'bearer'
+        expect(subject['token_type']).to eq('bearer')
       end
 
       # expires_in_seconds is returned as `expires_in` in order to match
       # the OAuth spec (section 4.2.2)
       it 'includes :expires_in' do
-        subject['expires_in'].should == '300'
+        expect(subject['expires_in']).to eq('300')
       end
 
       it 'includes :scope' do
-        subject['scope'].should == 'two scopes'
+        expect(subject['scope']).to eq('two scopes')
       end
 
       it 'includes :refresh_token' do
-        subject['refresh_token'].should == 'some-refresh-token'
+        expect(subject['refresh_token']).to eq('some-refresh-token')
       end
     end
 
@@ -66,15 +66,15 @@ module Doorkeeper::OAuth
       subject { TokenResponse.new(access_token).body }
 
       it 'includes :expires_in' do
-        subject['expires_in'].should be_nil
+        expect(subject['expires_in']).to be_nil
       end
 
       it 'includes :scope' do
-        subject['scope'].should be_nil
+        expect(subject['scope']).to be_nil
       end
 
       it 'includes :refresh_token' do
-        subject['refresh_token'].should be_nil
+        expect(subject['refresh_token']).to be_nil
       end
     end
   end

data/spec/lib/oauth/token_spec.rb

@@ -18,24 +18,24 @@ module Doorkeeper
         end
 
         it 'accepts anything that responds to #call' do
-          method.should_receive(:call).with(request)
+          expect(method).to receive(:call).with(request)
           Token.from_request request, method
         end
 
         it 'delegates methods received as symbols to Token class' do
-          Token.should_receive(:from_params).with(request)
+          expect(Token).to receive(:from_params).with(request)
           Token.from_request request, :from_params
         end
 
         it 'stops at the first credentials found' do
           not_called_method = double
-          not_called_method.should_not_receive(:call)
+          expect(not_called_method).not_to receive(:call)
           credentials = Token.from_request request, lambda { |r| }, method, not_called_method
         end
 
         it 'returns the credential from extractor method' do
           credentials = Token.from_request request, method
-          credentials.should == 'token-value'
+          expect(credentials).to eq('token-value')
         end
       end
 
@@ -43,7 +43,7 @@ module Doorkeeper
         it 'returns token from access_token parameter' do
           request = double :parameters => { :access_token => 'some-token' }
           token   = Token.from_access_token_param(request)
-          token.should == "some-token"
+          expect(token).to eq("some-token")
         end
       end
 
@@ -51,7 +51,7 @@ module Doorkeeper
         it 'returns token from bearer_token parameter' do
           request = double :parameters => { :bearer_token => 'some-token' }
           token   = Token.from_bearer_param(request)
-          token.should == "some-token"
+          expect(token).to eq("some-token")
         end
       end
 
@@ -59,13 +59,13 @@ module Doorkeeper
         it 'returns token from authorization bearer' do
           request = double :authorization => "Bearer SomeToken"
           token   = Token.from_bearer_authorization(request)
-          token.should == "SomeToken"
+          expect(token).to eq("SomeToken")
         end
 
         it 'does not return token if authorization is not bearer' do
           request = double :authorization => "MAC SomeToken"
           token   = Token.from_bearer_authorization(request)
-          token.should be_blank
+          expect(token).to be_blank
         end
       end
 
@@ -74,7 +74,7 @@ module Doorkeeper
 
         it 'calls the finder if token was found' do
           token = lambda { |r| 'token' }
-          AccessToken.should_receive(:authenticate).with('token')
+          expect(AccessToken).to receive(:authenticate).with('token')
           Token.authenticate double, token
         end
       end

data/spec/lib/server_spec.rb

@@ -21,7 +21,7 @@ describe Doorkeeper::Server do
 
     it 'builds the request with selected strategy' do
       stub_const 'Doorkeeper::Request::Code', fake_class
-      fake_class.should_receive(:build).with(subject)
+      expect(fake_class).to receive(:build).with(subject)
       subject.authorization_request :code
     end
   end

data/spec/models/doorkeeper/access_token_spec.rb

@@ -15,19 +15,19 @@ module Doorkeeper
     describe :refresh_token do
       it 'has empty refresh token if it was not required' do
         token = FactoryGirl.create :access_token
-        token.refresh_token.should be_nil
+        expect(token.refresh_token).to be_nil
       end
 
       it 'generates a refresh token if it was requested' do
         token = FactoryGirl.create :access_token, :use_refresh_token => true
-        token.refresh_token.should_not be_nil
+        expect(token.refresh_token).not_to be_nil
       end
 
       it "is not valid if token exists" do
         token1 = FactoryGirl.create :access_token, :use_refresh_token => true
         token2 = FactoryGirl.create :access_token, :use_refresh_token => true
         token2.send :write_attribute, :refresh_token, token1.refresh_token
-        token2.should_not be_valid
+        expect(token2).not_to be_valid
       end
 
       it 'expects database to raise an error if refresh tokens are the same' do
@@ -59,20 +59,20 @@ module Doorkeeper
         FactoryGirl.create :access_token, default_attributes
         AccessToken.revoke_all_for application.id, resource_owner
         AccessToken.all.each do |token|
-          token.should be_revoked
+          expect(token).to be_revoked
         end
       end
 
       it 'matches application' do
         FactoryGirl.create :access_token, default_attributes.merge(:application => FactoryGirl.create(:application))
         AccessToken.revoke_all_for application.id, resource_owner
-        AccessToken.all.should_not be_empty
+        expect(AccessToken.all).not_to be_empty
       end
 
       it 'matches resource owner' do
         FactoryGirl.create :access_token, default_attributes.merge(:resource_owner_id => 90)
         AccessToken.revoke_all_for application.id, resource_owner
-        AccessToken.all.should_not be_empty
+        expect(AccessToken.all).not_to be_empty
       end
     end
 
@@ -87,51 +87,51 @@ module Doorkeeper
       it 'returns only one token' do
         token = FactoryGirl.create :access_token, default_attributes
         last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        last_token.should == token
+        expect(last_token).to eq(token)
       end
 
       it 'accepts resource owner as object' do
         resource_owner = double(:to_key => true, :id => 100)
         token = FactoryGirl.create :access_token, default_attributes
         last_token = AccessToken.matching_token_for(application, resource_owner, scopes)
-        last_token.should == token
+        expect(last_token).to eq(token)
       end
 
       it 'accepts nil as resource owner' do
         token = FactoryGirl.create :access_token, default_attributes.merge(:resource_owner_id => nil)
         last_token = AccessToken.matching_token_for(application, nil, scopes)
-        last_token.should == token
+        expect(last_token).to eq(token)
       end
 
       it 'excludes revoked tokens' do
         FactoryGirl.create :access_token, default_attributes.merge(:revoked_at => 1.day.ago)
         last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        last_token.should be_nil
+        expect(last_token).to be_nil
       end
 
       it 'matches the application' do
         token = FactoryGirl.create :access_token, default_attributes.merge(:application => FactoryGirl.create(:application))
         last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        last_token.should be_nil
+        expect(last_token).to be_nil
       end
 
       it 'matches the resource owner' do
         FactoryGirl.create :access_token, default_attributes.merge(:resource_owner_id => 2)
         last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        last_token.should be_nil
+        expect(last_token).to be_nil
       end
 
       it 'matches the scopes' do
         FactoryGirl.create :access_token, default_attributes.merge(:scopes => 'public email')
         last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        last_token.should be_nil
+        expect(last_token).to be_nil
       end
 
       it 'returns the last created token' do
         FactoryGirl.create :access_token, default_attributes.merge(:created_at => 1.day.ago)
         token = FactoryGirl.create :access_token, default_attributes
         last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        last_token.should == token
+        expect(last_token).to eq(token)
       end
 
       it 'returns as_json hash'   do
@@ -142,7 +142,7 @@ module Doorkeeper
                       :expires_in_seconds => token.expires_in_seconds,
                       :application => { :uid => token.application.uid }
                      }
-        token.as_json.should eq token_hash
+        expect(token.as_json).to eq token_hash
       end
     end
 

data/spec/models/doorkeeper/application_spec.rb

@@ -25,7 +25,7 @@ module Doorkeeper
         end
 
         it 'is valid given valid attributes' do
-          new_application.should be_valid
+          expect(new_application).to be_valid
         end
       end
 
@@ -36,50 +36,50 @@ module Doorkeeper
         end
 
         it 'is invalid without an owner' do
-          new_application.should_not be_valid
+          expect(new_application).not_to be_valid
         end
 
         it 'is valid with an owner' do
           new_application.owner = @owner
-          new_application.should be_valid
+          expect(new_application).to be_valid
         end
       end
     end
 
     it 'is invalid without a name' do
       new_application.name = nil
-      new_application.should_not be_valid
+      expect(new_application).not_to be_valid
     end
 
     it 'generates uid on create' do
-      new_application.uid.should be_nil
+      expect(new_application.uid).to be_nil
       new_application.save
-      new_application.uid.should_not be_nil
+      expect(new_application.uid).not_to be_nil
     end
 
     it 'generates uid on create unless one is set' do
       new_application.uid = uid
       new_application.save
-      new_application.uid.should eq(uid)
+      expect(new_application.uid).to eq(uid)
     end
 
     it 'is invalid without uid' do
       new_application.save
       new_application.uid = nil
-      new_application.should_not be_valid
+      expect(new_application).not_to be_valid
     end
 
     it 'is invalid without redirect_uri' do
       new_application.save
       new_application.redirect_uri = nil
-      new_application.should_not be_valid
+      expect(new_application).not_to be_valid
     end
 
     it 'checks uniqueness of uid' do
       app1 = Factory(:application)
       app2 = Factory(:application)
       app2.uid = app1.uid
-      app2.should_not be_valid
+      expect(app2).not_to be_valid
     end
 
     it 'expects database to throw an error when uids are the same' do
@@ -92,21 +92,21 @@ module Doorkeeper
     end
 
     it 'generate secret on create' do
-      new_application.secret.should be_nil
+      expect(new_application.secret).to be_nil
       new_application.save
-      new_application.secret.should_not be_nil
+      expect(new_application.secret).not_to be_nil
     end
 
     it 'generate secret on create unless one is set' do
       new_application.secret = secret
       new_application.save
-      new_application.secret.should eq(secret)
+      expect(new_application.secret).to eq(secret)
     end
 
     it 'is invalid without secret' do
       new_application.save
       new_application.secret = nil
-      new_application.should_not be_valid
+      expect(new_application).not_to be_valid
     end
 
     describe 'destroy related models on cascade' do
@@ -130,31 +130,31 @@ module Doorkeeper
       let(:resource_owner) { double(:resource_owner, :id => 10) }
 
       it "is empty if the application is not authorized for anyone" do
-        Application.authorized_for(resource_owner).should be_empty
+        expect(Application.authorized_for(resource_owner)).to be_empty
       end
 
       it "returns only application for a specific resource owner" do
         FactoryGirl.create(:access_token, :resource_owner_id => resource_owner.id + 1)
         token = FactoryGirl.create(:access_token, :resource_owner_id => resource_owner.id)
-        Application.authorized_for(resource_owner).should == [token.application]
+        expect(Application.authorized_for(resource_owner)).to eq([token.application])
       end
 
       it "excludes revoked tokens" do
         FactoryGirl.create(:access_token, :resource_owner_id => resource_owner.id, :revoked_at => 2.days.ago)
-        Application.authorized_for(resource_owner).should be_empty
+        expect(Application.authorized_for(resource_owner)).to be_empty
       end
 
       it "returns all applications that have been authorized" do
         token1 = FactoryGirl.create(:access_token, :resource_owner_id => resource_owner.id)
         token2 = FactoryGirl.create(:access_token, :resource_owner_id => resource_owner.id)
-        Application.authorized_for(resource_owner).should == [token1.application, token2.application]
+        expect(Application.authorized_for(resource_owner)).to eq([token1.application, token2.application])
       end
 
       it "returns only one application even if it has been authorized twice" do
         application = FactoryGirl.create(:application)
         FactoryGirl.create(:access_token, :resource_owner_id => resource_owner.id, :application => application)
         FactoryGirl.create(:access_token, :resource_owner_id => resource_owner.id, :application => application)
-        Application.authorized_for(resource_owner).should == [application]
+        expect(Application.authorized_for(resource_owner)).to eq([application])
       end
 
       it "should fail to mass assign a new application", if: ::Rails::VERSION::MAJOR < 4 do
@@ -162,7 +162,7 @@ module Doorkeeper
                         :redirect_uri => 'http://somewhere.com/something',
                         :uid => 123,
                         :secret => 'something' }
-        Application.create(mass_assign).uid.should_not == 123
+        expect(Application.create(mass_assign).uid).not_to eq(123)
       end
     end
 
@@ -170,7 +170,7 @@ module Doorkeeper
       it 'finds the application via uid/secret' do
         app = FactoryGirl.create :application
         authenticated = Application.authenticate(app.uid, app.secret)
-        authenticated.should == app
+        expect(authenticated).to eq(app)
       end
     end
   end

data/spec/requests/flows/authorization_code_spec.rb

@@ -100,7 +100,7 @@ feature 'Authorization Code Flow' do
       authorization_code = Doorkeeper::AccessGrant.first.token
       post token_endpoint_url(:code => authorization_code, :client => @client)
 
-      Doorkeeper::AccessToken.count.should be(2)
+      expect(Doorkeeper::AccessToken.count).to be(2)
 
       should_have_json 'access_token', Doorkeeper::AccessToken.last.token
     end

data/spec/requests/flows/client_credentials_spec.rb

@@ -47,7 +47,7 @@ describe 'Client Credentials Request' do
       should_have_json 'error_description', translated_error_message(:invalid_client)
       should_not_have_json 'access_token'
 
-      response.status.should == 401
+      expect(response.status).to eq(401)
     end
   end