doorkeeper 1.0.0.rc2 → 1.0.0

data/spec/lib/models/revocable_spec.rb

@@ -12,20 +12,20 @@ describe 'Revocable' do
   describe :revoke do
     it "updates :revoked_at attribute with current time" do
       clock = double :now => double
-      subject.should_receive(:update_column).with(:revoked_at, clock.now)
+      expect(subject).to receive(:update_column).with(:revoked_at, clock.now)
       subject.revoke(clock)
     end
   end
 
   describe :revoked? do
     it "is revoked if :revoked_at is set" do
-      subject.stub :revoked_at => double
-      subject.should be_revoked
+      allow(subject).to receive(:revoked_at).and_return(double)
+      expect(subject).to be_revoked
     end
 
     it "is not revoked if :revoked_at is not set" do
-      subject.stub :revoked_at => nil
-      subject.should_not be_revoked
+      allow(subject).to receive(:revoked_at).and_return(nil)
+      expect(subject).not_to be_revoked
     end
   end
 end

data/spec/lib/models/scopes_spec.rb

@@ -16,17 +16,17 @@ describe 'Doorkeeper::Models::Scopes' do
 
   describe :scopes do
     it 'is a `Scopes` class' do
-      subject.scopes.should be_a(Doorkeeper::OAuth::Scopes)
+      expect(subject.scopes).to be_a(Doorkeeper::OAuth::Scopes)
     end
 
     it 'includes scopes' do
-      subject.scopes.should include('public')
+      expect(subject.scopes).to include('public')
     end
   end
 
   describe :scopes_string do
     it 'is a `Scopes` class' do
-      subject.scopes_string.should == 'public admin'
+      expect(subject.scopes_string).to eq('public admin')
     end
   end
 end

data/spec/lib/oauth/authorization/uri_builder_spec.rb

@@ -12,25 +12,25 @@ module Doorkeeper::OAuth::Authorization
     describe :uri_with_query do
       it 'returns the uri with query' do
         uri = subject.uri_with_query 'http://example.com/', :parameter => 'value'
-        uri.should == 'http://example.com/?parameter=value'
+        expect(uri).to eq('http://example.com/?parameter=value')
       end
 
       it 'rejects nil values' do
         uri = subject.uri_with_query 'http://example.com/', :parameter => ""
-        uri.should == 'http://example.com/?'
+        expect(uri).to eq('http://example.com/?')
       end
 
       it 'preserves original query parameters' do
         uri = subject.uri_with_query 'http://example.com/?query1=value', :parameter => 'value'
-        uri.should =~ /query1=value/
-        uri.should =~ /parameter=value/
+        expect(uri).to match(/query1=value/)
+        expect(uri).to match(/parameter=value/)
       end
     end
 
     describe :uri_with_fragment do
       it 'returns uri with parameters as fragments' do
         uri = subject.uri_with_fragment 'http://example.com/', :parameter => 'value'
-        uri.should == 'http://example.com/#parameter=value'
+        expect(uri).to eq('http://example.com/#parameter=value')
       end
     end
   end

data/spec/lib/oauth/authorization_code_request_spec.rb

@@ -18,7 +18,7 @@ module Doorkeeper::OAuth
 
     it "issues the token with same grant's scopes" do
       subject.authorize
-      Doorkeeper::AccessToken.last.scopes.should == grant.scopes
+      expect(Doorkeeper::AccessToken.last.scopes).to eq(grant.scopes)
     end
 
     it 'revokes the grant' do
@@ -30,37 +30,37 @@ module Doorkeeper::OAuth
     it 'requires the grant to be accessible' do
       grant.revoke
       subject.validate
-      subject.error.should == :invalid_grant
+      expect(subject.error).to eq(:invalid_grant)
     end
 
     it 'requires the grant' do
       subject.grant = nil
       subject.validate
-      subject.error.should == :invalid_grant
+      expect(subject.error).to eq(:invalid_grant)
     end
 
     it 'requires the client' do
       subject.client = nil
       subject.validate
-      subject.error.should == :invalid_client
+      expect(subject.error).to eq(:invalid_client)
     end
 
     it 'requires the redirect_uri' do
       subject.redirect_uri = nil
       subject.validate
-      subject.error.should == :invalid_request
+      expect(subject.error).to eq(:invalid_request)
     end
 
     it "matches the redirect_uri with grant's one" do
       subject.redirect_uri = 'http://other.com'
       subject.validate
-      subject.error.should == :invalid_grant
+      expect(subject.error).to eq(:invalid_grant)
     end
 
     it "matches the client with grant's one" do
       subject.client = FactoryGirl.create :application
       subject.validate
-      subject.error.should == :invalid_grant
+      expect(subject.error).to eq(:invalid_grant)
     end
   end
 end

data/spec/lib/oauth/client/credentials_spec.rb

@@ -5,8 +5,8 @@ require 'doorkeeper/oauth/client'
 class Doorkeeper::OAuth::Client
   describe Credentials do
     it 'is blank when any of the credentials is blank' do
-      Credentials.new(nil, "something").should be_blank
-      Credentials.new("something", nil).should be_blank
+      expect(Credentials.new(nil, "something")).to be_blank
+      expect(Credentials.new("something", nil)).to be_blank
     end
 
     describe :from_request do
@@ -17,30 +17,30 @@ class Doorkeeper::OAuth::Client
       end
 
       it 'accepts anything that responds to #call' do
-        method.should_receive(:call).with(request)
+        expect(method).to receive(:call).with(request)
         Credentials.from_request request, method
       end
 
       it 'delegates methods received as symbols to Credentials class' do
-        Credentials.should_receive(:from_params).with(request)
+        expect(Credentials).to receive(:from_params).with(request)
         Credentials.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 = Credentials.from_request request, lambda { |r| }, method, not_called_method
       end
 
       it 'returns new Credentials' do
         credentials = Credentials.from_request request, method
-        credentials.should be_a(Credentials)
+        expect(credentials).to be_a(Credentials)
       end
 
       it 'returns uid and secret from extractor method' do
         credentials = Credentials.from_request request, method
-        credentials.uid.should    == 'uid'
-        credentials.secret.should == 'secret'
+        expect(credentials.uid).to    eq('uid')
+        expect(credentials.secret).to eq('secret')
       end
     end
   end

data/spec/lib/oauth/client/methods_spec.rb

@@ -18,16 +18,16 @@ class Doorkeeper::OAuth::Client
         request     = double :parameters => { :client_id => client_id, :client_secret => client_secret }
         uid, secret = subject.from_params(request)
 
-        uid.should    == "some-uid"
-        secret.should == "some-secret"
+        expect(uid).to    eq("some-uid")
+        expect(secret).to eq("some-secret")
       end
 
       it 'is blank when there are no credentials' do
         request     = double :parameters => {}
         uid, secret = subject.from_params(request)
 
-        uid.should    be_blank
-        secret.should be_blank
+        expect(uid).to    be_blank
+        expect(secret).to be_blank
       end
     end
 
@@ -38,16 +38,16 @@ class Doorkeeper::OAuth::Client
         request     = double :authorization => "Basic #{credentials}"
         uid, secret = subject.from_basic(request)
 
-        uid.should    == "some-uid"
-        secret.should == "some-secret"
+        expect(uid).to    eq("some-uid")
+        expect(secret).to eq("some-secret")
       end
 
       it 'is blank if Authorization is not Basic' do
         request     = double :authorization => "#{credentials}"
         uid, secret = subject.from_basic(request)
 
-        uid.should    be_blank
-        secret.should be_blank
+        expect(uid).to    be_blank
+        expect(secret).to be_blank
       end
     end
   end

data/spec/lib/oauth/client_credentials/creator_spec.rb

@@ -12,9 +12,9 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
     end
 
     it 'returns false if creation fails' do
-      Doorkeeper::AccessToken.should_receive(:create).and_return(false)
+      expect(Doorkeeper::AccessToken).to receive(:create).and_return(false)
       created = subject.call(client, scopes)
-      created.should be_false
+      expect(created).to be_false
     end
   end
 end

data/spec/lib/oauth/client_credentials/issuer_spec.rb

@@ -15,14 +15,14 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
       let(:scopes) { 'some scope' }
 
       it 'creates and sets the token' do
-        creator.should_receive(:call).and_return('token')
+        expect(creator).to receive(:call).and_return('token')
         subject.create client, scopes, creator
 
-        subject.token.should == 'token'
+        expect(subject.token).to eq('token')
       end
 
       it 'creates with correct token parameters' do
-        creator.should_receive(:call).with(client, scopes, {
+        expect(creator).to receive(:call).with(client, scopes, {
           :expires_in        => 100,
           :use_refresh_token => false
         })
@@ -31,25 +31,26 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
       end
 
       it 'has error set to :server_error if creator fails' do
-        creator.should_receive(:call).and_return(false)
+        expect(creator).to receive(:call).and_return(false)
         subject.create client, scopes, creator
 
-        subject.error.should == :server_error
+        expect(subject.error).to eq(:server_error)
       end
 
       context 'when validation fails' do
         before do
-          validation.stub :valid? => false, :error => :validation_error
-          creator.should_not_receive(:create)
+          allow(validation).to receive(:valid?).and_return(false)
+          allow(validation).to receive(:error).and_return(:validation_error)
+          expect(creator).not_to receive(:create)
         end
 
         it 'has error set from validation' do
           subject.create client, scopes, creator
-          subject.error.should == :validation_error
+          expect(subject.error).to eq(:validation_error)
         end
 
         it 'returns false' do
-          subject.create(client, scopes, creator).should be_false
+          expect(subject.create(client, scopes, creator)).to be_false
         end
       end
     end

data/spec/lib/oauth/client_credentials/validation_spec.rb

@@ -10,19 +10,19 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
     subject { Validation.new(server, request) }
 
     it 'is valid with valid request' do
-      subject.should be_valid
+      expect(subject).to be_valid
     end
 
     it 'is invalid when client is not present' do
-      request.stub :client => nil
-      subject.should_not be_valid
+      allow(request).to receive(:client).and_return(nil)
+      expect(subject).not_to be_valid
     end
 
     context 'with scopes' do
       it 'is invalid when scopes are not included in the server' do
-        server.stub :scopes => Doorkeeper::OAuth::Scopes.from_string('email')
-        request.stub :original_scopes => 'invalid'
-        subject.should_not be_valid
+        allow(server).to receive(:scopes).and_return(Doorkeeper::OAuth::Scopes.from_string('email'))
+        allow(request).to receive(:original_scopes).and_return('invalid')
+        expect(subject).not_to be_valid
       end
     end
   end

data/spec/lib/oauth/client_credentials_request_spec.rb

@@ -16,13 +16,13 @@ module Doorkeeper::OAuth
     end
 
     it 'issues an access token for the current client' do
-      token_creator.should_receive(:create).with(client, nil)
+      expect(token_creator).to receive(:create).with(client, nil)
       subject.authorize
     end
 
     it 'has successful response when issue was created' do
       subject.authorize
-      subject.response.should be_a(TokenResponse)
+      expect(subject.response).to be_a(TokenResponse)
     end
 
     context 'if issue was not created' do
@@ -32,12 +32,12 @@ module Doorkeeper::OAuth
 
       it 'has an error response' do
         subject.authorize
-        subject.response.should be_a(Doorkeeper::OAuth::ErrorResponse)
+        expect(subject.response).to be_a(Doorkeeper::OAuth::ErrorResponse)
       end
 
       it 'delegates the error to issuer' do
         subject.authorize
-        subject.error.should == :invalid
+        expect(subject.error).to eq(:invalid)
       end
     end
 
@@ -45,18 +45,18 @@ module Doorkeeper::OAuth
       let(:default_scopes) { Doorkeeper::OAuth::Scopes.from_string("public email") }
 
       before do
-        server.stub(:default_scopes).and_return(default_scopes)
+        allow(server).to receive(:default_scopes).and_return(default_scopes)
       end
 
       it 'issues an access token with default scopes if none was requested' do
-        token_creator.should_receive(:create).with(client, default_scopes)
+        expect(token_creator).to receive(:create).with(client, default_scopes)
         subject.authorize
       end
 
       it 'issues an access token with requested scopes' do
         subject = ClientCredentialsRequest.new(server, client, :scope => "email")
         subject.issuer = token_creator
-        token_creator.should_receive(:create).with(client, Doorkeeper::OAuth::Scopes.from_string("email"))
+        expect(token_creator).to receive(:create).with(client, Doorkeeper::OAuth::Scopes.from_string("email"))
         subject.authorize
       end
     end

data/spec/lib/oauth/client_spec.rb

@@ -10,13 +10,13 @@ module Doorkeeper::OAuth
 
       it 'finds the client via uid' do
         client = double
-        method.should_receive(:call).with('uid').and_return(client)
-        Client.find('uid', method).should be_a(Client)
+        expect(method).to receive(:call).with('uid').and_return(client)
+        expect(Client.find('uid', method)).to be_a(Client)
       end
 
       it 'returns nil if client was not found' do
-        method.should_receive(:call).with('uid').and_return(nil)
-        Client.find('uid', method).should be_nil
+        expect(method).to receive(:call).with('uid').and_return(nil)
+        expect(Client.find('uid', method)).to be_nil
       end
     end
 
@@ -24,15 +24,15 @@ module Doorkeeper::OAuth
       it 'returns the authenticated client via credentials' do
         credentials = Client::Credentials.new("some-uid", "some-secret")
         authenticator = double
-        authenticator.should_receive(:call).with("some-uid", "some-secret").and_return(double)
-        Client.authenticate(credentials, authenticator).should be_a(Client)
+        expect(authenticator).to receive(:call).with("some-uid", "some-secret").and_return(double)
+        expect(Client.authenticate(credentials, authenticator)).to be_a(Client)
       end
 
       it 'retunrs nil if client was not authenticated' do
         credentials = Client::Credentials.new("some-uid", "some-secret")
         authenticator = double
-        authenticator.should_receive(:call).with("some-uid", "some-secret").and_return(nil)
-        Client.authenticate(credentials, authenticator).should be_nil
+        expect(authenticator).to receive(:call).with("some-uid", "some-secret").and_return(nil)
+        expect(Client.authenticate(credentials, authenticator)).to be_nil
       end
     end
   end

data/spec/lib/oauth/code_request_spec.rb

@@ -26,19 +26,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 grant 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::AccessGrant.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/error_response_spec.rb

@@ -5,50 +5,57 @@ require 'doorkeeper/oauth/error_response'
 
 module Doorkeeper::OAuth
   describe ErrorResponse do
-    its(:status) { should == :unauthorized }
+    describe '#status' do
+      it 'should have a status of unauthorized' do
+        expect(subject.status).to eq(:unauthorized)
+      end
+    end
 
     describe :from_request do
       it 'has the error from request' do
         error = ErrorResponse.from_request double(:error => :some_error)
-        error.name.should == :some_error
+        expect(error.name).to eq(:some_error)
       end
 
       it 'ignores state if request does not respond to state' do
         error = ErrorResponse.from_request double(:error => :some_error)
-        error.state.should be_nil
+        expect(error.state).to be_nil
       end
 
       it 'has state if request responds to state' do
         error = ErrorResponse.from_request double(:error => :some_error, :state => :hello)
-        error.state.should == :hello
+        expect(error.state).to eq(:hello)
       end
     end
 
     it 'ignores empty error values' do
       subject = ErrorResponse.new(:error => :some_error, :state => nil)
-      subject.body.should_not have_key(:state)
+      expect(subject.body).not_to have_key(:state)
     end
 
     describe '.body' do
-      subject { ErrorResponse.new(:name => :some_error, :state => :some_state) }
+      subject { ErrorResponse.new(:name => :some_error, :state => :some_state).body }
 
-      its(:body) { should have_key(:error) }
-      its(:body) { should have_key(:error_description) }
-      its(:body) { should have_key(:state) }
+      describe '#body' do
+        it { should have_key(:error) }
+        it { should have_key(:error_description) }
+        it { should have_key(:state) }
+      end
     end
 
     describe '.authenticate_info' do
-      subject { ErrorResponse.new(:name => :some_error, :state => :some_state) }
+      let(:error_response) { ErrorResponse.new(:name => :some_error, :state => :some_state) }
+      subject { error_response.authenticate_info }
 
-      its(:authenticate_info) { should include("realm=\"#{subject.realm}\"") }
-      its(:authenticate_info) { should include("error=\"#{subject.name}\"") }
-      its(:authenticate_info) { should include("error_description=\"#{subject.description}\"") }
+      it { should include("realm=\"#{error_response.realm}\"") }
+      it { should include("error=\"#{error_response.name}\"") }
+      it { should include("error_description=\"#{error_response.description}\"") }
     end
 
     describe '.headers' do
-      subject { ErrorResponse.new(:name => :some_error, :state => :some_state) }
+      subject { ErrorResponse.new(:name => :some_error, :state => :some_state).headers }
 
-      its(:headers) { should include "WWW-Authenticate" }
+      it { should include "WWW-Authenticate" }
     end
   end
 end