doorkeeper 3.1.0 → 4.4.3

data/spec/requests/flows/revoke_token_spec.rb

@@ -6,137 +6,151 @@ describe 'Revoke Token Flow' do
   end
 
   context 'with default parameters' do
-    let(:client_application) { FactoryGirl.create :application }
+    let(:client_application) { FactoryBot.create :application }
     let(:resource_owner) { User.create!(name: 'John', password: 'sekret') }
-    let(:authorization_access_token) do
-      FactoryGirl.create(:access_token,
+    let(:access_token) do
+      FactoryBot.create(:access_token,
                          application: client_application,
                          resource_owner_id: resource_owner.id,
                          use_refresh_token: true)
     end
-    let(:headers) { { 'HTTP_AUTHORIZATION' => "Bearer #{authorization_access_token.token}" } }
 
-    context 'With invalid token to revoke' do
-      it 'client wants to revoke the given access token' do
-        post revocation_token_endpoint_url, { token: 'I_AM_AN_INVALIDE_TOKEN' }, headers
+    context 'with authenticated, confidential OAuth 2.0 client/application' do
+      let(:headers) do
+        client_id = client_application.uid
+        client_secret = client_application.secret
+        credentials = Base64.encode64("#{client_id}:#{client_secret}")
+        { 'HTTP_AUTHORIZATION' => "Basic #{credentials}" }
+      end
+
+      it 'should revoke the access token provided' do
+        post revocation_token_endpoint_url, { token: access_token.token }, headers
+
+        access_token.reload
 
-        authorization_access_token.reload
-        # The authorization server responds with HTTP status code 200 if the token
-        # has been revoked successfully or if the client submitted an invalid token.
-        expect(response).to be_success
-        expect(authorization_access_token).to_not be_revoked
+        expect(response).to be_successful
+        expect(access_token.revoked?).to be_truthy
       end
-    end
 
-    context 'The access token to revoke is the same than the authorization access token' do
-      let(:token_to_revoke) { authorization_access_token }
+      it 'should revoke the refresh token provided' do
+        post revocation_token_endpoint_url, { token: access_token.refresh_token }, headers
+
+        access_token.reload
 
-      it 'client wants to revoke the given access token' do
-        post revocation_token_endpoint_url, { token: token_to_revoke.token }, headers
+        expect(response).to be_successful
+        expect(access_token.revoked?).to be_truthy
+      end
 
-        token_to_revoke.reload
-        authorization_access_token.reload
+      context 'with invalid token to revoke' do
+        it 'should not revoke any tokens and respond successfully' do
+          num_prev_revoked_tokens = Doorkeeper::AccessToken.where(revoked_at: nil).count
+          post revocation_token_endpoint_url, { token: 'I_AM_AN_INVALID_TOKEN' }, headers
 
-        expect(response).to be_success
-        expect(token_to_revoke.revoked?).to be_truthy
-        expect(Doorkeeper::AccessToken.by_refresh_token(token_to_revoke.refresh_token).revoked?).to be_truthy
+          # The authorization server responds with HTTP status code 200 even if
+          # token is invalid
+          expect(response).to be_successful
+          expect(Doorkeeper::AccessToken.where(revoked_at: nil).count).to eq(num_prev_revoked_tokens)
+        end
       end
 
-      it 'client wants to revoke the given access token using the POST query string' do
-        url_with_query_string = revocation_token_endpoint_url + '?' + Rack::Utils.build_query(token: token_to_revoke.token)
-        post url_with_query_string, {}, headers
+      context 'with bad credentials and a valid token' do
+        let(:headers) do
+          client_id = client_application.uid
+          credentials = Base64.encode64("#{client_id}:poop")
+          { 'HTTP_AUTHORIZATION' => "Basic #{credentials}" }
+        end
+        it 'should not revoke any tokens and respond successfully' do
+          post revocation_token_endpoint_url, { token: access_token.token }, headers
 
-        token_to_revoke.reload
-        authorization_access_token.reload
+          access_token.reload
 
-        expect(response).to be_success
-        expect(token_to_revoke.revoked?).to be_falsey
-        expect(Doorkeeper::AccessToken.by_refresh_token(token_to_revoke.refresh_token).revoked?).to be_falsey
-        expect(authorization_access_token.revoked?).to be_falsey
+          expect(response).to be_successful
+          expect(access_token.revoked?).to be_falsey
+        end
       end
-    end
 
-    context 'The access token to revoke app and owners are the same than the authorization access token' do
-      let(:token_to_revoke) do
-        FactoryGirl.create(:access_token,
-                           application: client_application,
-                           resource_owner_id: resource_owner.id,
-                           use_refresh_token: true)
+      context 'with no credentials and a valid token' do
+        it 'should not revoke any tokens and respond successfully' do
+          post revocation_token_endpoint_url, { token: access_token.token }
+
+          access_token.reload
+
+          expect(response).to be_successful
+          expect(access_token.revoked?).to be_falsey
+        end
       end
 
-      it 'client wants to revoke the given access token' do
-        post revocation_token_endpoint_url, { token: token_to_revoke.token }, headers
+      context 'with valid token for another client application' do
+        let(:other_client_application) { FactoryBot.create :application }
+        let(:headers) do
+          client_id = other_client_application.uid
+          client_secret = other_client_application.secret
+          credentials = Base64.encode64("#{client_id}:#{client_secret}")
+          { 'HTTP_AUTHORIZATION' => "Basic #{credentials}" }
+        end
 
-        token_to_revoke.reload
-        authorization_access_token.reload
+        it 'should not revoke the token as its unauthorized' do
+          post revocation_token_endpoint_url, { token: access_token.token }, headers
 
-        expect(response).to be_success
-        expect(token_to_revoke.revoked?).to be_truthy
-        expect(Doorkeeper::AccessToken.by_refresh_token(token_to_revoke.refresh_token).revoked?).to be_truthy
-        expect(authorization_access_token.revoked?).to be_falsey
+          access_token.reload
+
+          expect(response).to be_successful
+          expect(access_token.revoked?).to be_falsey
+        end
       end
     end
 
-    context 'The access token to revoke authorization owner is the same than the authorization access token' do
-      let(:other_client_application) { FactoryGirl.create :application }
-      let(:token_to_revoke) do
-        FactoryGirl.create(:access_token,
-                           application: other_client_application,
+    context 'with public OAuth 2.0 client/application' do
+      let(:access_token) do
+        FactoryBot.create(:access_token,
+                           application: nil,
                            resource_owner_id: resource_owner.id,
                            use_refresh_token: true)
       end
 
-      it 'client wants to revoke the given access token' do
-        post revocation_token_endpoint_url, { token: token_to_revoke.token }, headers
+      it 'should revoke the access token provided' do
+        post revocation_token_endpoint_url, { token: access_token.token }
 
-        token_to_revoke.reload
-        authorization_access_token.reload
+        access_token.reload
 
-        expect(response).to be_success
-        expect(token_to_revoke.revoked?).to be_falsey
-        expect(Doorkeeper::AccessToken.by_refresh_token(token_to_revoke.refresh_token).revoked?).to be_falsey
-        expect(authorization_access_token.revoked?).to be_falsey
+        expect(response).to be_successful
+        expect(access_token.revoked?).to be_truthy
       end
-    end
 
-    context 'The access token to revoke app is the same than the authorization access token' do
-      let(:other_resource_owner) { User.create!(name: 'Matheo', password: 'pareto') }
-      let(:token_to_revoke) do
-        FactoryGirl.create(:access_token,
-                           application: client_application,
-                           resource_owner_id: other_resource_owner.id,
-                           use_refresh_token: true)
+      it 'should revoke the refresh token provided' do
+        post revocation_token_endpoint_url, { token: access_token.refresh_token }
+
+        access_token.reload
+
+        expect(response).to be_successful
+        expect(access_token.revoked?).to be_truthy
       end
 
-      it 'client wants to revoke the given access token' do
-        post revocation_token_endpoint_url, { token: token_to_revoke.token }, headers
+      context 'with a valid token issued for a confidential client' do
+        let(:access_token) do
+          FactoryBot.create(:access_token,
+                             application: client_application,
+                             resource_owner_id: resource_owner.id,
+                             use_refresh_token: true)
+        end
 
-        token_to_revoke.reload
-        authorization_access_token.reload
+        it 'should not revoke the access token provided' do
+          post revocation_token_endpoint_url, { token: access_token.token }
 
-        expect(response).to be_success
-        expect(token_to_revoke.revoked?).to be_falsey
-        expect(Doorkeeper::AccessToken.by_refresh_token(token_to_revoke.refresh_token).revoked?).to be_falsey
-        expect(authorization_access_token.revoked?).to be_falsey
-      end
-    end
+          access_token.reload
 
-    context 'With valid refresh token to revoke' do
-      let(:token_to_revoke) do
-        FactoryGirl.create(:access_token,
-                           application: client_application,
-                           resource_owner_id: resource_owner.id,
-                           use_refresh_token: true)
-      end
+          expect(response).to be_successful
+          expect(access_token.revoked?).to be_falsey
+        end
+
+        it 'should not revoke the refresh token provided' do
+          post revocation_token_endpoint_url, { token: access_token.token }
 
-      it 'client wants to revoke the given refresh token' do
-        post revocation_token_endpoint_url, { token: token_to_revoke.refresh_token, token_type_hint: 'refresh_token' }, headers
-        authorization_access_token.reload
-        token_to_revoke.reload
+          access_token.reload
 
-        expect(response).to be_success
-        expect(Doorkeeper::AccessToken.by_refresh_token(token_to_revoke.refresh_token).revoked?).to be_truthy
-        expect(authorization_access_token).to_not be_revoked
+          expect(response).to be_successful
+          expect(access_token.revoked?).to be_falsey
+        end
       end
     end
   end

data/spec/requests/protected_resources/metal_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper_integration'
 
 describe 'ActionController::Metal API' do
   before do
-    @client   = FactoryGirl.create(:application)
+    @client   = FactoryBot.create(:application)
     @resource = User.create!(name: 'Joe', password: 'sekret')
     @token    = client_is_authorized(@client, @resource)
   end

data/spec/requests/protected_resources/private_api_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper_integration'
 
 feature 'Private API' do
   background do
-    @client   = FactoryGirl.create(:application)
+    @client   = FactoryBot.create(:application)
     @resource = User.create!(name: 'Joe', password: 'sekret')
     @token    = client_is_authorized(@client, @resource)
   end

data/spec/routing/custom_controller_routes_spec.rb

@@ -45,6 +45,10 @@ describe 'Custom controller for routes' do
     expect(post('/space/oauth/revoke')).to route_to('custom_authorizations#revoke')
   end
 
+  it 'POST /space/oauth/introspect routes to tokens controller' do
+    expect(post('/space/oauth/introspect')).to route_to('custom_authorizations#introspect')
+  end
+
   it 'GET /space/oauth/applications routes to applications controller' do
     expect(get('/space/oauth/applications')).to route_to('custom_authorizations#index')
   end

data/spec/routing/default_routes_spec.rb

@@ -21,6 +21,10 @@ describe 'Default routes' do
     expect(post('/oauth/revoke')).to route_to('doorkeeper/tokens#revoke')
   end
 
+  it 'POST /oauth/introspect routes to tokens controller' do
+    expect(post('/oauth/introspect')).to route_to('doorkeeper/tokens#introspect')
+  end
+
   it 'GET /oauth/applications routes to applications controller' do
     expect(get('/oauth/applications')).to route_to('doorkeeper/applications#index')
   end
@@ -29,7 +33,7 @@ describe 'Default routes' do
     expect(get('/oauth/authorized_applications')).to route_to('doorkeeper/authorized_applications#index')
   end
 
-  it 'GET /oauth/token/info route to authorzed tokeninfo controller' do
+  it 'GET /oauth/token/info route to authorized tokeninfo controller' do
     expect(get('/oauth/token/info')).to route_to('doorkeeper/token_info#show')
   end
 end

data/spec/spec_helper.rb

@@ -1,2 +1,4 @@
 $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '../lib'))
 $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '../app'))
+
+require 'doorkeeper'

data/spec/spec_helper_integration.rb

@@ -1,3 +1,19 @@
+if ENV['TRAVIS']
+  require 'coveralls'
+
+  Coveralls.wear!('rails') do
+    add_filter('/spec/')
+    add_filter('/lib/generators/doorkeeper/templates/')
+  end
+else
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter('/spec/')
+    add_filter('/lib/generators/doorkeeper/templates/')
+  end
+end
+
 ENV['RAILS_ENV'] ||= 'test'
 TABLE_NAME_PREFIX = ENV['table_name_prefix'] || nil
 TABLE_NAME_SUFFIX = ENV['table_name_suffix'] || nil
@@ -11,7 +27,6 @@ require 'capybara/rspec'
 require 'dummy/config/environment'
 require 'rspec/rails'
 require 'generator_spec/test_case'
-require 'timecop'
 require 'database_cleaner'
 
 # Load JRuby SQLite3 if in that platform
@@ -21,10 +36,10 @@ begin
 rescue LoadError
 end
 
-Rails.logger.info "====> Doorkeeper.orm = #{Doorkeeper.configuration.orm.inspect}"
+Rails.logger.info "====> Doorkeeper.orm = #{Doorkeeper.configuration.orm}"
 if Doorkeeper.configuration.orm == :active_record
-  Rails.logger.info "======> active_record.table_name_prefix = #{Rails.configuration.active_record.table_name_prefix.inspect}"
-  Rails.logger.info "======> active_record.table_name_suffix = #{Rails.configuration.active_record.table_name_suffix.inspect}"
+  Rails.logger.info "======> active_record.table_name_prefix = #{Rails.configuration.active_record.table_name_prefix}"
+  Rails.logger.info "======> active_record.table_name_suffix = #{Rails.configuration.active_record.table_name_suffix}"
 end
 Rails.logger.info "====> Rails version: #{Rails.version}"
 Rails.logger.info "====> Ruby version: #{RUBY_VERSION}"
@@ -35,6 +50,9 @@ ENGINE_RAILS_ROOT = File.join(File.dirname(__FILE__), '../')
 
 Dir["#{File.dirname(__FILE__)}/support/{dependencies,helpers,shared}/*.rb"].each { |f| require f }
 
+# Remove after dropping support of Rails 4.2
+require "#{File.dirname(__FILE__)}/support/http_method_shim.rb"
+
 RSpec.configure do |config|
   config.infer_spec_type_from_file_location!
   config.mock_with :rspec

data/spec/support/dependencies/factory_girl.rb

@@ -1,2 +1,2 @@
-require 'factory_girl'
-FactoryGirl.find_definitions
+require 'factory_bot'
+FactoryBot.find_definitions

data/spec/support/helpers/access_token_request_helper.rb

@@ -4,7 +4,7 @@ module AccessTokenRequestHelper
       application: client,
       resource_owner_id: resource_owner.id
     }.merge(access_token_attributes)
-    FactoryGirl.create(:access_token, attributes)
+    FactoryBot.create(:access_token, attributes)
   end
 end
 

data/spec/support/helpers/model_helper.rb

@@ -1,6 +1,6 @@
 module ModelHelper
   def client_exists(client_attributes = {})
-    @client = FactoryGirl.create(:application, client_attributes)
+    @client = FactoryBot.create(:application, client_attributes)
   end
 
   def create_resource_owner
@@ -8,19 +8,25 @@ module ModelHelper
   end
 
   def authorization_code_exists(options = {})
-    @authorization = FactoryGirl.create(:access_grant, options)
+    @authorization = FactoryBot.create(:access_grant, options)
   end
 
   def access_grant_should_exist_for(client, resource_owner)
     grant = Doorkeeper::AccessGrant.first
-    expect(grant.application).to eq(client)
-    grant.resource_owner_id  == resource_owner.id
+
+    expect(grant.application).to have_attributes(id: client.id).
+      and(be_instance_of(Doorkeeper::Application))
+
+    expect(grant.resource_owner_id).to eq(resource_owner.id)
   end
 
   def access_token_should_exist_for(client, resource_owner)
-    grant = Doorkeeper::AccessToken.first
-    expect(grant.application).to eq(client)
-    grant.resource_owner_id  == resource_owner.id
+    token = Doorkeeper::AccessToken.first
+
+    expect(token.application).to have_attributes(id: client.id).
+      and(be_instance_of(Doorkeeper::Application))
+
+    expect(token.resource_owner_id).to eq(resource_owner.id)
   end
 
   def access_grant_should_not_exist
@@ -40,6 +46,27 @@ module ModelHelper
     grant = Doorkeeper::AccessToken.last
     expect(grant.scopes).to eq(Doorkeeper::OAuth::Scopes.from_array(args))
   end
+
+  def uniqueness_error
+    case DOORKEEPER_ORM
+    when :active_record
+      ActiveRecord::RecordNotUnique
+    when :sequel
+      error_classes = [Sequel::UniqueConstraintViolation, Sequel::ValidationFailed]
+      proc { |error| expect(error.class).to be_in(error_classes) }
+    when :mongo_mapper
+      error_classes = [MongoMapper::DocumentNotValid, Mongo::OperationFailure]
+      proc { |error| expect(error.class).to be_in(error_classes) }
+    when /mongoid/
+      error_classes = [Mongoid::Errors::Validations]
+      error_classes << Moped::Errors::OperationFailure if defined?(::Moped) # Mongoid 4
+      error_classes << Mongo::Error::OperationFailure if defined?(::Mongo) # Mongoid 5
+
+      proc { |error| expect(error.class).to be_in(error_classes) }
+    else
+      raise "'#{DOORKEEPER_ORM}' ORM is not supported!"
+    end
+  end
 end
 
 RSpec.configuration.send :include, ModelHelper

data/spec/support/helpers/request_spec_helper.rb

@@ -27,6 +27,14 @@ module RequestSpecHelper
     URI.parse(page.current_url)
   end
 
+  def request_response
+    respond_to?(:response) ? response : page.driver.response
+  end
+
+  def json_response
+    JSON.parse(request_response.body)
+  end
+
   def should_have_header(header, value)
     expect(headers[header]).to eq(value)
   end
@@ -44,15 +52,15 @@ module RequestSpecHelper
   end
 
   def should_have_json(key, value)
-    expect(JSON.parse(response.body).fetch(key)).to eq(value)
+    expect(json_response.fetch(key)).to eq(value)
   end
 
   def should_have_json_within(key, value, range)
-    expect(JSON.parse(response.body).fetch(key)).to be_within(range).of(value)
+    expect(json_response.fetch(key)).to be_within(range).of(value)
   end
 
   def should_not_have_json(key)
-    expect(JSON.parse(response.body)).not_to have_key(key)
+    expect(json_response).not_to have_key(key)
   end
 
   def sign_in
@@ -60,16 +68,20 @@ module RequestSpecHelper
     click_on 'Sign in'
   end
 
+  def create_access_token(authorization_code, client)
+    page.driver.post token_endpoint_url(code: authorization_code, client: client)
+  end
+
   def i_should_see_translated_error_message(key)
     i_should_see translated_error_message(key)
   end
 
   def translated_error_message(key)
-    I18n.translate key, scope: [:doorkeeper, :errors, :messages]
+    I18n.translate key, scope: %i[doorkeeper errors messages]
   end
 
   def response_status_should_be(status)
-    expect(page.driver.response.status.to_i).to eq(status)
+    expect(request_response.status.to_i).to eq(status)
   end
 end
 

data/spec/support/helpers/url_helper.rb

@@ -2,10 +2,10 @@ module UrlHelper
   def token_endpoint_url(options = {})
     parameters = {
       code: options[:code],
-      client_id: options[:client_id]     || (options[:client] ? options[:client].uid : nil),
+      client_id: options[:client_id] || (options[:client] ? options[:client].uid : nil),
       client_secret: options[:client_secret] || (options[:client] ? options[:client].secret : nil),
       redirect_uri: options[:redirect_uri]  || (options[:client] ? options[:client].redirect_uri : nil),
-      grant_type: options[:grant_type]    || 'authorization_code'
+      grant_type: options[:grant_type] || 'authorization_code'
     }
     "/oauth/token?#{build_query(parameters)}"
   end
@@ -13,10 +13,11 @@ module UrlHelper
   def password_token_endpoint_url(options = {})
     parameters = {
       code: options[:code],
-      client_id: options[:client_id]     || (options[:client] ? options[:client].uid : nil),
+      client_id: options[:client_id] || (options[:client] ? options[:client].uid : nil),
       client_secret: options[:client_secret] || (options[:client] ? options[:client].secret : nil),
       username: options[:resource_owner_username] || (options[:resource_owner] ? options[:resource_owner].name : nil),
       password: options[:resource_owner_password] || (options[:resource_owner] ? options[:resource_owner].password : nil),
+      scope: options[:scope],
       grant_type: 'password'
     }
     "/oauth/token?#{build_query(parameters)}"
@@ -24,21 +25,21 @@ module UrlHelper
 
   def authorization_endpoint_url(options = {})
     parameters = {
-      client_id: options[:client_id]     || options[:client].uid,
-      redirect_uri: options[:redirect_uri]  || options[:client].redirect_uri,
+      client_id: options[:client_id] || options[:client].uid,
+      redirect_uri: options[:redirect_uri] || options[:client].redirect_uri,
       response_type: options[:response_type] || 'code',
       scope: options[:scope],
       state: options[:state]
-    }.reject { |k, v| v.blank? }
+    }.reject { |_, v| v.blank? }
     "/oauth/authorize?#{build_query(parameters)}"
   end
 
   def refresh_token_endpoint_url(options = {})
     parameters = {
       refresh_token: options[:refresh_token],
-      client_id: options[:client_id]     || options[:client].uid,
+      client_id: options[:client_id] || options[:client].uid,
       client_secret: options[:client_secret] || options[:client].secret,
-      grant_type: options[:grant_type]    || 'refresh_token'
+      grant_type: options[:grant_type] || 'refresh_token'
     }
     "/oauth/token?#{build_query(parameters)}"
   end

data/spec/support/http_method_shim.rb

@@ -0,0 +1,38 @@
+# Rails 5 deprecates calling HTTP action methods with positional arguments
+# in favor of keyword arguments. However, the keyword argument form is only
+# supported in Rails 5+. Since we support back to 4, we need some sort of shim
+# to avoid super noisy deprecations when running tests.
+module RoutingHTTPMethodShim
+  def get(path, params = {}, headers = nil)
+    super(path, params: params, headers: headers)
+  end
+
+  def post(path, params = {}, headers = nil)
+    super(path, params: params, headers: headers)
+  end
+
+  def put(path, params = {}, headers = nil)
+    super(path, params: params, headers: headers)
+  end
+end
+
+module ControllerHTTPMethodShim
+  def get(path, params = {})
+    super(path, params: params)
+  end
+
+  def post(path, params = {})
+    super(path, params: params)
+  end
+
+  def put(path, params = {})
+    super(path, params: params)
+  end
+end
+
+if ::Rails::VERSION::MAJOR >= 5
+  RSpec.configure do |config|
+    config.include ControllerHTTPMethodShim, type: :controller
+    config.include RoutingHTTPMethodShim, type: :request
+  end
+end

data/spec/support/shared/controllers_shared_context.rb

@@ -1,28 +1,33 @@
 shared_context 'valid token', token: :valid do
-  let :token_string do
-    '1A2B3C4D'
-  end
+  let(:token_string) { '1A2B3C4D' }
 
   let :token do
-    double(Doorkeeper::AccessToken, accessible?: true, includes_scope?: true, acceptable?: true)
+    double(Doorkeeper::AccessToken,
+           accessible?: true, includes_scope?: true, acceptable?: true,
+           previous_refresh_token: "", revoke_previous_refresh_token!: true)
   end
 
   before :each do
-    allow(Doorkeeper::AccessToken).to receive(:by_token).with(token_string).and_return(token)
+    allow(
+      Doorkeeper::AccessToken
+    ).to receive(:by_token).with(token_string).and_return(token)
   end
 end
 
 shared_context 'invalid token', token: :invalid do
-  let :token_string do
-    '1A2B3C4D'
-  end
+  let(:token_string) { '1A2B3C4D' }
 
   let :token do
-    double(Doorkeeper::AccessToken, accessible?: false, revoked?: false, expired?: false, includes_scope?: false, acceptable?: false)
+    double(Doorkeeper::AccessToken,
+           accessible?: false, revoked?: false, expired?: false,
+           includes_scope?: false, acceptable?: false,
+           previous_refresh_token: "", revoke_previous_refresh_token!: true)
   end
 
   before :each do
-    allow(Doorkeeper::AccessToken).to receive(:by_token).with(token_string).and_return(token)
+    allow(
+      Doorkeeper::AccessToken
+    ).to receive(:by_token).with(token_string).and_return(token)
   end
 end
 

data/spec/support/shared/models_shared_examples.rb

@@ -34,19 +34,19 @@ shared_examples 'a unique token' do
     end
 
     it 'is not valid if token exists' do
-      token1 = FactoryGirl.create factory_name
-      token2 = FactoryGirl.create factory_name
+      token1 = FactoryBot.create factory_name
+      token2 = FactoryBot.create factory_name
       token2.token = token1.token
       expect(token2).not_to be_valid
     end
 
     it 'expects database to throw an error when tokens are the same' do
-      token1 = FactoryGirl.create factory_name
-      token2 = FactoryGirl.create factory_name
+      token1 = FactoryBot.create factory_name
+      token2 = FactoryBot.create factory_name
       token2.token = token1.token
       expect do
         token2.save!(validate: false)
-      end.to raise_error(ActiveRecord::RecordNotUnique)
+      end.to raise_error(uniqueness_error)
     end
   end
 end