doorkeeper 5.1.0 → 5.5.1

data/spec/routing/default_routes_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe "Default routes" do
-  it "GET /oauth/authorize routes to authorizations controller" do
-    expect(get("/oauth/authorize")).to route_to("doorkeeper/authorizations#new")
-  end
-
-  it "POST /oauth/authorize routes to authorizations controller" do
-    expect(post("/oauth/authorize")).to route_to("doorkeeper/authorizations#create")
-  end
-
-  it "DELETE /oauth/authorize routes to authorizations controller" do
-    expect(delete("/oauth/authorize")).to route_to("doorkeeper/authorizations#destroy")
-  end
-
-  it "POST /oauth/token routes to tokens controller" do
-    expect(post("/oauth/token")).to route_to("doorkeeper/tokens#create")
-  end
-
-  it "POST /oauth/revoke routes to tokens controller" 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
-
-  it "GET /oauth/authorized_applications routes to authorized applications controller" do
-    expect(get("/oauth/authorized_applications")).to route_to("doorkeeper/authorized_applications#index")
-  end
-
-  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/routing/scoped_routes_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe "Scoped routes" do
-  before :all do
-    Rails.application.routes.disable_clear_and_finalize = true
-
-    Rails.application.routes.draw do
-      use_doorkeeper scope: "scope"
-    end
-  end
-
-  after :all do
-    Rails.application.routes.clear!
-
-    load File.expand_path("../dummy/config/routes.rb", __dir__)
-  end
-
-  it "GET /scope/authorize routes to authorizations controller" do
-    expect(get("/scope/authorize")).to route_to("doorkeeper/authorizations#new")
-  end
-
-  it "POST /scope/authorize routes to authorizations controller" do
-    expect(post("/scope/authorize")).to route_to("doorkeeper/authorizations#create")
-  end
-
-  it "DELETE /scope/authorize routes to authorizations controller" do
-    expect(delete("/scope/authorize")).to route_to("doorkeeper/authorizations#destroy")
-  end
-
-  it "POST /scope/token routes to tokens controller" do
-    expect(post("/scope/token")).to route_to("doorkeeper/tokens#create")
-  end
-
-  it "GET /scope/applications routes to applications controller" do
-    expect(get("/scope/applications")).to route_to("doorkeeper/applications#index")
-  end
-
-  it "GET /scope/authorized_applications routes to authorized applications controller" do
-    expect(get("/scope/authorized_applications")).to route_to("doorkeeper/authorized_applications#index")
-  end
-
-  it "GET /scope/token/info route to authorized TokenInfo controller" do
-    expect(get("/scope/token/info")).to route_to("doorkeeper/token_info#show")
-  end
-end

data/spec/spec_helper.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "coveralls"
-
-Coveralls.wear!("rails") do
-  add_filter("/spec/")
-  add_filter("/lib/generators/doorkeeper/templates/")
-end
-
-ENV["RAILS_ENV"] ||= "test"
-
-$LOAD_PATH.unshift File.dirname(__FILE__)
-
-require "#{File.dirname(__FILE__)}/support/doorkeeper_rspec.rb"
-
-DOORKEEPER_ORM = Doorkeeper::RSpec.detect_orm
-
-require "dummy/config/environment"
-require "rspec/rails"
-require "capybara/rspec"
-require "database_cleaner"
-require "generator_spec/test_case"
-
-# Load JRuby SQLite3 if in that platform
-if defined? JRUBY_VERSION
-  require "jdbc/sqlite3"
-  Jdbc::SQLite3.load_driver
-end
-
-Doorkeeper::RSpec.print_configuration_info
-
-# Remove after dropping support of Rails 4.2
-require "#{File.dirname(__FILE__)}/support/http_method_shim"
-
-require "support/orm/#{DOORKEEPER_ORM}"
-
-Dir["#{File.dirname(__FILE__)}/support/{dependencies,helpers,shared}/*.rb"].each { |file| require file }
-
-RSpec.configure do |config|
-  config.infer_spec_type_from_file_location!
-  config.mock_with :rspec
-
-  config.infer_base_class_for_anonymous_controllers = false
-
-  config.include RSpec::Rails::RequestExampleGroup, type: :request
-
-  config.before do
-    DatabaseCleaner.start
-    Doorkeeper.configure { orm DOORKEEPER_ORM }
-  end
-
-  config.after do
-    DatabaseCleaner.clean
-  end
-
-  config.order = "random"
-end

data/spec/spec_helper_integration.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-# For compatibility only
-require "spec_helper"

data/spec/support/dependencies/factory_bot.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-require "factory_bot"
-FactoryBot.find_definitions

data/spec/support/doorkeeper_rspec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Doorkeeper
-  class RSpec
-    # Print's useful information about env: Ruby / Rails versions,
-    # Doorkeeper configuration, etc.
-    def self.print_configuration_info
-      puts <<-INFO.strip_heredoc
-        ====> Doorkeeper ORM: '#{Doorkeeper.configuration.orm}'
-        ====> Doorkeeper version: #{Doorkeeper.gem_version}
-        ====> Rails version: #{::Rails.version}
-        ====> Ruby version: #{RUBY_VERSION} on #{RUBY_PLATFORM}
-      INFO
-    end
-
-    # Tries to find ORM from the Gemfile used to run test suite
-    def self.detect_orm
-      orm = (ENV["BUNDLE_GEMFILE"] || "").match(/Gemfile\.(.+)\.rb/)
-      (orm && orm[1] || :active_record).to_sym
-    end
-  end
-end

data/spec/support/helpers/access_token_request_helper.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module AccessTokenRequestHelper
-  def client_is_authorized(client, resource_owner, access_token_attributes = {})
-    attributes = {
-      application: client,
-      resource_owner_id: resource_owner.id,
-    }.merge(access_token_attributes)
-    FactoryBot.create(:access_token, attributes)
-  end
-end
-
-RSpec.configuration.send :include, AccessTokenRequestHelper

data/spec/support/helpers/authorization_request_helper.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module AuthorizationRequestHelper
-  def resource_owner_is_authenticated(resource_owner = nil)
-    resource_owner ||= User.create!(name: "Joe", password: "sekret")
-    Doorkeeper.configuration.instance_variable_set(:@authenticate_resource_owner, proc { resource_owner })
-  end
-
-  def resource_owner_is_not_authenticated
-    Doorkeeper.configuration.instance_variable_set(:@authenticate_resource_owner, proc { redirect_to("/sign_in") })
-  end
-
-  def default_scopes_exist(*scopes)
-    Doorkeeper.configuration.instance_variable_set(:@default_scopes, Doorkeeper::OAuth::Scopes.from_array(scopes))
-  end
-
-  def optional_scopes_exist(*scopes)
-    Doorkeeper.configuration.instance_variable_set(:@optional_scopes, Doorkeeper::OAuth::Scopes.from_array(scopes))
-  end
-
-  def client_should_be_authorized(client)
-    expect(client.access_grants.size).to eq(1)
-  end
-
-  def client_should_not_be_authorized(client)
-    expect(client.size).to eq(0)
-  end
-
-  def i_should_be_on_client_callback(client)
-    expect(client.redirect_uri).to eq("#{current_uri.scheme}://#{current_uri.host}#{current_uri.path}")
-  end
-
-  def allowing_forgery_protection(&_block)
-    original_value = ActionController::Base.allow_forgery_protection
-    ActionController::Base.allow_forgery_protection = true
-
-    yield
-  ensure
-    ActionController::Base.allow_forgery_protection = original_value
-  end
-end
-
-RSpec.configuration.send :include, AuthorizationRequestHelper

data/spec/support/helpers/config_helper.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module ConfigHelper
-  def config_is_set(setting, value = nil, &block)
-    setting_ivar = "@#{setting}"
-    value = block_given? ? block : value
-    Doorkeeper.configuration.instance_variable_set(setting_ivar, value)
-  end
-end
-
-RSpec.configuration.send :include, ConfigHelper

data/spec/support/helpers/model_helper.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module ModelHelper
-  def client_exists(client_attributes = {})
-    @client = FactoryBot.create(:application, client_attributes)
-  end
-
-  def create_resource_owner
-    @resource_owner = User.create!(name: "Joe", password: "sekret")
-  end
-
-  def authorization_code_exists(options = {})
-    @authorization = FactoryBot.create(:access_grant, options)
-  end
-
-  def access_token_exists(options = {})
-    @access_token = FactoryBot.create(:access_token, options)
-  end
-
-  def access_grant_should_exist_for(client, resource_owner)
-    grant = Doorkeeper::AccessGrant.first
-
-    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)
-    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
-    expect(Doorkeeper::AccessGrant.all).to be_empty
-  end
-
-  def access_token_should_not_exist
-    expect(Doorkeeper::AccessToken.all).to be_empty
-  end
-
-  def access_grant_should_have_scopes(*args)
-    grant = Doorkeeper::AccessGrant.first
-    expect(grant.scopes).to eq(Doorkeeper::OAuth::Scopes.from_array(args))
-  end
-
-  def access_token_should_have_scopes(*args)
-    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

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module RequestSpecHelper
-  def i_am_logged_in
-    allow(Doorkeeper.configuration).to receive(:authenticate_admin).and_return(->(*) {})
-  end
-
-  def i_should_see(content)
-    expect(page).to have_content(content)
-  end
-
-  def i_should_not_see(content)
-    expect(page).to have_no_content(content)
-  end
-
-  def i_should_be_on(path)
-    expect(current_path).to eq(path)
-  end
-
-  def url_should_have_param(param, value)
-    expect(current_params[param]).to eq(value)
-  end
-
-  def url_should_not_have_param(param)
-    expect(current_params).not_to have_key(param)
-  end
-
-  def current_params
-    Rack::Utils.parse_query(current_uri.query)
-  end
-
-  def current_uri
-    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
-
-  def should_have_status(status)
-    expect(page.driver.response.status).to eq(status)
-  end
-
-  def with_access_token_header(token)
-    with_header "Authorization", "Bearer #{token}"
-  end
-
-  def with_header(header, value)
-    page.driver.header header, value
-  end
-
-  def basic_auth_header_for_client(client)
-    ActionController::HttpAuthentication::Basic.encode_credentials client.uid, client.secret
-  end
-
-  def should_have_json(key, value)
-    expect(json_response.fetch(key)).to eq(value)
-  end
-
-  def should_have_json_within(key, value, range)
-    expect(json_response.fetch(key)).to be_within(range).of(value)
-  end
-
-  def should_not_have_json(key)
-    expect(json_response).not_to have_key(key)
-  end
-
-  def sign_in
-    visit "/"
-    click_on "Sign in"
-  end
-
-  def create_access_token(authorization_code, client, code_verifier = nil)
-    page.driver.post token_endpoint_url(code: authorization_code, client: client, code_verifier: code_verifier)
-  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: %i[doorkeeper errors messages]
-  end
-
-  def response_status_should_be(status)
-    expect(request_response.status.to_i).to eq(status)
-  end
-end
-
-RSpec.configuration.send :include, RequestSpecHelper

data/spec/support/helpers/url_helper.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module UrlHelper
-  def token_endpoint_url(options = {})
-    parameters = {
-      code: options[:code],
-      client_id: options[:client_id] || options[:client].try(:uid),
-      client_secret: options[:client_secret] || options[:client].try(:secret),
-      redirect_uri: options[:redirect_uri] || options[:client].try(:redirect_uri),
-      grant_type: options[:grant_type] || "authorization_code",
-      code_verifier: options[:code_verifier],
-      code_challenge_method: options[:code_challenge_method],
-    }.reject { |_, v| v.blank? }
-    "/oauth/token?#{build_query(parameters)}"
-  end
-
-  def password_token_endpoint_url(options = {})
-    parameters = {
-      code: options[:code],
-      client_id: options[:client_id] || options[:client].try(:uid),
-      client_secret: options[:client_secret] || options[:client].try(:secret),
-      username: options[:resource_owner_username] || options[:resource_owner].try(:name),
-      password: options[:resource_owner_password] || options[:resource_owner].try(:password),
-      scope: options[:scope],
-      grant_type: "password",
-    }
-    "/oauth/token?#{build_query(parameters)}"
-  end
-
-  def authorization_endpoint_url(options = {})
-    parameters = {
-      client_id: options[:client_id] || options[:client].try(:uid),
-      redirect_uri: options[:redirect_uri] || options[:client].try(:redirect_uri),
-      response_type: options[:response_type] || "code",
-      scope: options[:scope],
-      state: options[:state],
-      code_challenge: options[:code_challenge],
-      code_challenge_method: options[:code_challenge_method],
-    }.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].try(:uid),
-      client_secret: options[:client_secret] || options[:client].try(:secret),
-      grant_type: options[:grant_type] || "refresh_token",
-    }
-    "/oauth/token?#{build_query(parameters)}"
-  end
-
-  def revocation_token_endpoint_url
-    "/oauth/revoke"
-  end
-
-  def build_query(hash)
-    Rack::Utils.build_query(hash)
-  end
-end
-
-RSpec.configuration.send :include, UrlHelper

data/spec/support/http_method_shim.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-# 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, **args)
-    super(path, args[:params], args[:headers])
-  end
-
-  def post(path, **args)
-    super(path, args[:params], args[:headers])
-  end
-
-  def put(path, **args)
-    super(path, args[:params], args[:headers])
-  end
-end
-
-module ControllerHTTPMethodShim
-  def process(action, http_method = "GET", **args)
-    if (as = args.delete(:as))
-      @request.headers["Content-Type"] = Mime[as].to_s
-    end
-
-    super(action, http_method, args[:params], args[:session], args[:flash])
-  end
-end

data/spec/support/orm/active_record.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-# load schema to in memory sqlite
-ActiveRecord::Migration.verbose = false
-load Rails.root + "db/schema.rb"

data/spec/support/shared/controllers_shared_context.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-shared_context "valid token", token: :valid do
-  let(:token_string) { "1A2B3C4D" }
-
-  let :token do
-    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)
-  end
-end
-
-shared_context "invalid token", token: :invalid do
-  let(:token_string) { "1A2B3C4D" }
-
-  let :token do
-    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)
-  end
-end
-
-shared_context "authenticated resource owner" do
-  before do
-    user = double(:resource, id: 1)
-    allow(Doorkeeper.configuration).to receive(:authenticate_resource_owner) { proc { user } }
-  end
-end
-
-shared_context "not authenticated resource owner" do
-  before do
-    allow(Doorkeeper.configuration).to receive(:authenticate_resource_owner) { proc { redirect_to "/" } }
-  end
-end
-
-shared_context "valid authorization request" do
-  let :authorization do
-    double(:authorization, valid?: true, authorize: true, success_redirect_uri: "http://something.com/cb?code=token")
-  end
-
-  before do
-    allow(controller).to receive(:authorization) { authorization }
-  end
-end
-
-shared_context "invalid authorization request" do
-  let :authorization do
-    double(:authorization, valid?: false, authorize: false, redirect_on_error?: false)
-  end
-
-  before do
-    allow(controller).to receive(:authorization) { authorization }
-  end
-end
-
-shared_context "expired token", token: :expired do
-  let :token_string do
-    "1A2B3C4DEXP"
-  end
-
-  let :token do
-    double(Doorkeeper::AccessToken,
-           accessible?: false, revoked?: false, expired?: true,
-           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)
-  end
-end
-
-shared_context "revoked token", token: :revoked do
-  let :token_string do
-    "1A2B3C4DREV"
-  end
-
-  let :token do
-    double(Doorkeeper::AccessToken,
-           accessible?: false, revoked?: true, 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)
-  end
-end
-
-shared_context "forbidden token", token: :forbidden do
-  let :token_string do
-    "1A2B3C4DFORB"
-  end
-
-  let :token do
-    double(Doorkeeper::AccessToken,
-           accessible?: true, includes_scope?: true, 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)
-  end
-end

data/spec/support/shared/hashing_shared_context.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-shared_context "with token hashing enabled" do
-  let(:hashed_or_plain_token_func) do
-    Doorkeeper::SecretStoring::Sha256Hash.method(:transform_secret)
-  end
-
-  before do
-    Doorkeeper.configure do
-      hash_token_secrets
-    end
-  end
-end
-
-shared_context "with token hashing and fallback lookup enabled" do
-  let(:hashed_or_plain_token_func) do
-    Doorkeeper::SecretStoring::Sha256Hash.method(:transform_secret)
-  end
-
-  before do
-    Doorkeeper.configure do
-      hash_token_secrets fallback: :plain
-    end
-  end
-end
-
-shared_context "with application hashing enabled" do
-  let(:hashed_or_plain_token_func) do
-    Doorkeeper::SecretStoring::Sha256Hash.method(:transform_secret)
-  end
-  before do
-    Doorkeeper.configure do
-      hash_application_secrets
-    end
-  end
-end