doorkeeper 1.1.0 → 1.2.0

data/spec/lib/models/revocable_spec.rb

@@ -10,20 +10,20 @@ describe 'Revocable' do
   end
 
   describe :revoke do
-    it "updates :revoked_at attribute with current time" do
-      clock = double :now => double
+    it 'updates :revoked_at attribute with current time' do
+      clock = double now: double
       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
+    it 'is revoked if :revoked_at is set' do
       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
+    it 'is not revoked if :revoked_at is not set' do
       allow(subject).to receive(:revoked_at).and_return(nil)
       expect(subject).not_to be_revoked
     end

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

@@ -11,17 +11,17 @@ 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 = subject.uri_with_query '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 = subject.uri_with_query 'http://example.com/', parameter: ''
         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 = subject.uri_with_query 'http://example.com/?query1=value', parameter: 'value'
         expect(uri).to match(/query1=value/)
         expect(uri).to match(/parameter=value/)
       end
@@ -29,7 +29,7 @@ module Doorkeeper::OAuth::Authorization
 
     describe :uri_with_fragment do
       it 'returns uri with parameters as fragments' do
-        uri = subject.uri_with_fragment 'http://example.com/', :parameter => 'value'
+        uri = subject.uri_with_fragment 'http://example.com/', parameter: 'value'
         expect(uri).to eq('http://example.com/#parameter=value')
       end
     end

data/spec/lib/oauth/authorization_code_request_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper_integration'
 
 module Doorkeeper::OAuth
   describe AuthorizationCodeRequest do
-    let(:server) { double :server, :access_token_expires_in => 2.days, :refresh_token_enabled? => false }
+    let(:server) { double :server, access_token_expires_in: 2.days, refresh_token_enabled?: false }
     let(:grant)  { FactoryGirl.create :access_grant }
     let(:client) { grant.application }
 
     subject do
-      AuthorizationCodeRequest.new server, grant, client, :redirect_uri => client.redirect_uri
+      AuthorizationCodeRequest.new server, grant, client, redirect_uri: client.redirect_uri
     end
 
     it 'issues a new token for the client' do

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

@@ -5,15 +5,15 @@ require 'doorkeeper/oauth/client'
 class Doorkeeper::OAuth::Client
   describe Credentials do
     it 'is blank when any of the credentials is blank' do
-      expect(Credentials.new(nil, "something")).to be_blank
-      expect(Credentials.new("something", nil)).to be_blank
+      expect(Credentials.new(nil, 'something')).to be_blank
+      expect(Credentials.new('something', nil)).to be_blank
     end
 
     describe :from_request do
       let(:request) { double.as_null_object }
 
       let(:method) do
-        lambda { |request| return 'uid', 'secret' }
+        ->(request) { return 'uid', 'secret' }
       end
 
       it 'accepts anything that responds to #call' do
@@ -29,7 +29,7 @@ class Doorkeeper::OAuth::Client
       it 'stops at the first credentials found' do
         not_called_method = double
         expect(not_called_method).not_to receive(:call)
-        credentials = Credentials.from_request request, lambda { |r| }, method, not_called_method
+        credentials = Credentials.from_request request, ->(r) {}, method, not_called_method
       end
 
       it 'returns new Credentials' do

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

@@ -4,8 +4,8 @@ require 'doorkeeper/oauth/client'
 
 class Doorkeeper::OAuth::Client
   describe 'Methods' do
-    let(:client_id) { "some-uid" }
-    let(:client_secret) { "some-secret" }
+    let(:client_id) { 'some-uid' }
+    let(:client_secret) { 'some-secret' }
 
     subject do
       Class.new do
@@ -15,15 +15,15 @@ class Doorkeeper::OAuth::Client
 
     describe :from_params do
       it 'returns credentials from parameters when Authorization header is not available' do
-        request     = double :parameters => { :client_id => client_id, :client_secret => client_secret }
+        request     = double parameters: { client_id: client_id, client_secret: client_secret }
         uid, secret = subject.from_params(request)
 
-        expect(uid).to    eq("some-uid")
-        expect(secret).to eq("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 => {}
+        request     = double parameters: {}
         uid, secret = subject.from_params(request)
 
         expect(uid).to    be_blank
@@ -35,15 +35,15 @@ class Doorkeeper::OAuth::Client
       let(:credentials) { Base64.encode64("#{client_id}:#{client_secret}") }
 
       it 'decodes the credentials' do
-        request     = double :authorization => "Basic #{credentials}"
+        request     = double authorization: "Basic #{credentials}"
         uid, secret = subject.from_basic(request)
 
-        expect(uid).to    eq("some-uid")
-        expect(secret).to eq("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}"
+        request     = double authorization: "#{credentials}"
         uid, secret = subject.from_basic(request)
 
         expect(uid).to    be_blank

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

@@ -5,13 +5,13 @@ require 'doorkeeper/oauth/client_credentials/issuer'
 class Doorkeeper::OAuth::ClientCredentialsRequest
   describe Issuer do
     let(:creator) { double :acces_token_creator }
-    let(:server)  { double :server, :access_token_expires_in => 100 }
-    let(:validation) { double :validation, :valid? => true }
+    let(:server)  { double :server, access_token_expires_in: 100 }
+    let(:validation) { double :validation, valid?: true }
 
     subject { Issuer.new(server, validation) }
 
     describe :create do
-      let(:client) { double :client, :id => 'some-id' }
+      let(:client) { double :client, id: 'some-id' }
       let(:scopes) { 'some scope' }
 
       it 'creates and sets the token' do
@@ -22,10 +22,12 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
       end
 
       it 'creates with correct token parameters' do
-        expect(creator).to receive(:call).with(client, scopes, {
-          :expires_in        => 100,
-          :use_refresh_token => false
-        })
+        expect(creator).to receive(:call).with(
+          client,
+          scopes,
+          expires_in: 100,
+          use_refresh_token: false
+        )
 
         subject.create client, scopes, creator
       end

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

@@ -4,8 +4,8 @@ require 'doorkeeper/oauth/client_credentials/validation'
 
 class Doorkeeper::OAuth::ClientCredentialsRequest
   describe Validation do
-    let(:server)  { double :server, :scopes => nil }
-    let(:request) { double :request, :client => double, :original_scopes => nil }
+    let(:server)  { double :server, scopes: nil }
+    let(:request) { double :request, client: double, original_scopes: nil }
 
     subject { Validation.new(server, request) }
 

data/spec/lib/oauth/client_credentials_request_spec.rb

@@ -5,9 +5,9 @@ require 'doorkeeper/oauth/client_credentials_request'
 
 module Doorkeeper::OAuth
   describe ClientCredentialsRequest do
-    let(:server) { double :default_scopes => nil }
+    let(:server) { double default_scopes: nil }
     let(:client) { double }
-    let(:token_creator) { double :issuer, :create => true, :token => double }
+    let(:token_creator) { double :issuer, create: true, token: double }
 
     subject { ClientCredentialsRequest.new(server, client) }
 
@@ -27,7 +27,7 @@ module Doorkeeper::OAuth
 
     context 'if issue was not created' do
       before do
-        subject.issuer = double :create => false, :error => :invalid
+        subject.issuer = double create: false, error: :invalid
       end
 
       it 'has an error response' do
@@ -42,7 +42,7 @@ module Doorkeeper::OAuth
     end
 
     context 'with scopes' do
-      let(:default_scopes) { Doorkeeper::OAuth::Scopes.from_string("public email") }
+      let(:default_scopes) { Doorkeeper::OAuth::Scopes.from_string('public email') }
 
       before do
         allow(server).to receive(:default_scopes).and_return(default_scopes)
@@ -54,9 +54,9 @@ module Doorkeeper::OAuth
       end
 
       it 'issues an access token with requested scopes' do
-        subject = ClientCredentialsRequest.new(server, client, :scope => "email")
+        subject = ClientCredentialsRequest.new(server, client, scope: 'email')
         subject.issuer = token_creator
-        expect(token_creator).to 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

@@ -22,16 +22,16 @@ module Doorkeeper::OAuth
 
     describe :authenticate do
       it 'returns the authenticated client via credentials' do
-        credentials = Client::Credentials.new("some-uid", "some-secret")
+        credentials = Client::Credentials.new('some-uid', 'some-secret')
         authenticator = double
-        expect(authenticator).to receive(:call).with("some-uid", "some-secret").and_return(double)
+        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")
+        credentials = Client::Credentials.new('some-uid', 'some-secret')
         authenticator = double
-        expect(authenticator).to receive(:call).with("some-uid", "some-secret").and_return(nil)
+        expect(authenticator).to receive(:call).with('some-uid', 'some-secret').and_return(nil)
         expect(Client.authenticate(credentials, authenticator)).to be_nil
       end
     end

data/spec/lib/oauth/code_request_spec.rb

@@ -3,17 +3,18 @@ require 'spec_helper_integration'
 module Doorkeeper::OAuth
   describe CodeRequest do
     let(:pre_auth) do
-      double(:pre_auth, {
-        :client => double(:application, :id => 9990),
-        :redirect_uri => 'http://tst.com/cb',
-        :scopes => nil,
-        :state => nil,
-        :error => nil,
-        :authorizable? => true
-      })
+      double(
+        :pre_auth,
+        client: double(:application, id: 9990),
+        redirect_uri: 'http://tst.com/cb',
+        scopes: nil,
+        state: nil,
+        error: nil,
+        authorizable?: true
+      )
     end
 
-    let(:owner) { double :owner, :id => 8900 }
+    let(:owner) { double :owner, id: 8900 }
 
     subject do
       CodeRequest.new(pre_auth, owner)

data/spec/lib/oauth/error_response_spec.rb

@@ -13,28 +13,28 @@ module Doorkeeper::OAuth
 
     describe :from_request do
       it 'has the error from request' do
-        error = ErrorResponse.from_request double(:error => :some_error)
+        error = ErrorResponse.from_request double(error: :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 = ErrorResponse.from_request double(error: :some_error)
         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 = ErrorResponse.from_request double(error: :some_error, state: :hello)
         expect(error.state).to eq(:hello)
       end
     end
 
     it 'ignores empty error values' do
-      subject = ErrorResponse.new(:error => :some_error, :state => nil)
+      subject = ErrorResponse.new(error: :some_error, state: nil)
       expect(subject.body).not_to have_key(:state)
     end
 
     describe '.body' do
-      subject { ErrorResponse.new(:name => :some_error, :state => :some_state).body }
+      subject { ErrorResponse.new(name: :some_error, state: :some_state).body }
 
       describe '#body' do
         it { should have_key(:error) }
@@ -44,7 +44,7 @@ module Doorkeeper::OAuth
     end
 
     describe '.authenticate_info' do
-      let(:error_response) { ErrorResponse.new(:name => :some_error, :state => :some_state) }
+      let(:error_response) { ErrorResponse.new(name: :some_error, state: :some_state) }
       subject { error_response.authenticate_info }
 
       it { should include("realm=\"#{error_response.realm}\"") }
@@ -53,9 +53,9 @@ module Doorkeeper::OAuth
     end
 
     describe '.headers' do
-      subject { ErrorResponse.new(:name => :some_error, :state => :some_state).headers }
+      subject { ErrorResponse.new(name: :some_error, state: :some_state).headers }
 
-      it { should include "WWW-Authenticate" }
+      it { should include 'WWW-Authenticate' }
     end
   end
 end

data/spec/lib/oauth/error_spec.rb

@@ -11,7 +11,7 @@ module Doorkeeper::OAuth
 
     describe :description do
       it 'is translated from translation messages' do
-        expect(I18n).to receive(:translate).with(:some_error, :scope => [:doorkeeper, :errors, :messages])
+        expect(I18n).to receive(:translate).with(:some_error, scope: [:doorkeeper, :errors, :messages])
         subject.description
       end
     end

data/spec/lib/oauth/helpers/scope_checker_spec.rb

@@ -4,71 +4,71 @@ require 'doorkeeper/oauth/helpers/scope_checker'
 require 'doorkeeper/oauth/scopes'
 
 module Doorkeeper::OAuth::Helpers
-  describe ScopeChecker, ".matches?" do
+  describe ScopeChecker, '.matches?' do
     def new_scope(*args)
       Doorkeeper::OAuth::Scopes.from_array args
     end
 
-    it "true if scopes matches" do
+    it 'true if scopes matches' do
       scopes = new_scope :public
       scopes_to_match = new_scope :public
       expect(ScopeChecker.matches?(scopes, scopes_to_match)).to be_true
     end
 
-    it "is false when scopes differs" do
+    it 'is false when scopes differs' do
       scopes = new_scope :public
       scopes_to_match = new_scope :write
       expect(ScopeChecker.matches?(scopes, scopes_to_match)).to be_false
     end
 
-    it "is false when scope in array is missing" do
+    it 'is false when scope in array is missing' do
       scopes = new_scope :public
       scopes_to_match = new_scope :public, :write
       expect(ScopeChecker.matches?(scopes, scopes_to_match)).to be_false
     end
 
-    it "is false when scope in string is missing" do
+    it 'is false when scope in string is missing' do
       scopes = new_scope :public, :write
       scopes_to_match = new_scope :public
       expect(ScopeChecker.matches?(scopes, scopes_to_match)).to be_false
     end
 
-    it "is false when any of attributes is nil" do
+    it 'is false when any of attributes is nil' do
       expect(ScopeChecker.matches?(nil, double)).to be_false
       expect(ScopeChecker.matches?(double, nil)).to be_false
     end
   end
 
-  describe ScopeChecker, ".valid?" do
+  describe ScopeChecker, '.valid?' do
     let(:server_scopes) { Doorkeeper::OAuth::Scopes.new }
 
-    it "is valid if scope is present" do
+    it 'is valid if scope is present' do
       server_scopes.add :scope
-      expect(ScopeChecker.valid?("scope", server_scopes)).to be_true
+      expect(ScopeChecker.valid?('scope', server_scopes)).to be_true
     end
 
-    it "is invalid if includes tabs space" do
+    it 'is invalid if includes tabs space' do
       expect(ScopeChecker.valid?("\tsomething", server_scopes)).to be_false
     end
 
-    it "is invalid if scope is not present" do
+    it 'is invalid if scope is not present' do
       expect(ScopeChecker.valid?(nil, server_scopes)).to be_false
     end
 
-    it "is invalid if scope is blank" do
-      expect(ScopeChecker.valid?(" ", server_scopes)).to be_false
+    it 'is invalid if scope is blank' do
+      expect(ScopeChecker.valid?(' ', server_scopes)).to be_false
     end
 
-    it "is invalid if includes return space" do
+    it 'is invalid if includes return space' do
       expect(ScopeChecker.valid?("scope\r", server_scopes)).to be_false
     end
 
-    it "is invalid if includes new lines" do
+    it 'is invalid if includes new lines' do
       expect(ScopeChecker.valid?("scope\nanother", server_scopes)).to be_false
     end
 
-    it "is invalid if any scope is not included in server scopes" do
-      expect(ScopeChecker.valid?("scope another", server_scopes)).to be_false
+    it 'is invalid if any scope is not included in server scopes' do
+      expect(ScopeChecker.valid?('scope another', server_scopes)).to be_false
     end
   end
 end

data/spec/lib/oauth/helpers/unique_token_spec.rb

@@ -4,17 +4,17 @@ require 'doorkeeper/oauth/helpers/unique_token'
 module Doorkeeper::OAuth::Helpers
   describe UniqueToken do
     let :generator do
-      lambda { |size| "a" * size }
+      ->(size) { 'a' * size }
     end
 
-    it "is able to customize the generator method" do
-      token = UniqueToken.generate(:generator => generator)
-      expect(token).to eq("a" * 32)
+    it 'is able to customize the generator method' do
+      token = UniqueToken.generate(generator: generator)
+      expect(token).to eq('a' * 32)
     end
 
-    it "is able to customize the size of the token" do
-      token = UniqueToken.generate(:generator => generator, :size => 2)
-      expect(token).to eq("aa")
+    it 'is able to customize the size of the token' do
+      token = UniqueToken.generate(generator: generator, size: 2)
+      expect(token).to eq('aa')
     end
   end
 end