doorkeeper 4.4.3 → 5.5.2

data/spec/support/helpers/config_helper.rb

@@ -1,9 +0,0 @@
-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,72 +0,0 @@
-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_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,88 +0,0 @@
-module RequestSpecHelper
-  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 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)
-    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: %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,56 +0,0 @@
-module UrlHelper
-  def token_endpoint_url(options = {})
-    parameters = {
-      code: options[:code],
-      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'
-    }
-    "/oauth/token?#{build_query(parameters)}"
-  end
-
-  def password_token_endpoint_url(options = {})
-    parameters = {
-      code: options[:code],
-      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)}"
-  end
-
-  def authorization_endpoint_url(options = {})
-    parameters = {
-      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 { |_, 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_secret: options[:client_secret] || options[:client].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,38 +0,0 @@
-# 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/orm/active_record.rb

@@ -1,3 +0,0 @@
-# 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,65 +0,0 @@
-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

data/spec/support/shared/models_shared_examples.rb

@@ -1,52 +0,0 @@
-shared_examples 'an accessible token' do
-  describe :accessible? do
-    it 'is accessible if token is not expired' do
-      allow(subject).to receive(:expired?).and_return(false)
-      should be_accessible
-    end
-
-    it 'is not accessible if token is expired' do
-      allow(subject).to receive(:expired?).and_return(true)
-      should_not be_accessible
-    end
-  end
-end
-
-shared_examples 'a revocable token' do
-  describe :accessible? do
-    before { subject.save! }
-
-    it 'is accessible if token is not revoked' do
-      expect(subject).to be_accessible
-    end
-
-    it 'is not accessible if token is revoked' do
-      subject.revoke
-      expect(subject).not_to be_accessible
-    end
-  end
-end
-
-shared_examples 'a unique token' do
-  describe :token do
-    it 'is generated before validation' do
-      expect { subject.valid? }.to change { subject.token }.from(nil)
-    end
-
-    it 'is not valid if token exists' do
-      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 = FactoryBot.create factory_name
-      token2 = FactoryBot.create factory_name
-      token2.token = token1.token
-      expect do
-        token2.save!(validate: false)
-      end.to raise_error(uniqueness_error)
-    end
-  end
-end

data/spec/validators/redirect_uri_validator_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper_integration'
-
-describe RedirectUriValidator do
-  subject do
-    FactoryBot.create(:application)
-  end
-
-  it 'is valid when the uri is a uri' do
-    subject.redirect_uri = 'https://example.com/callback'
-    expect(subject).to be_valid
-  end
-
-  # Most mobile and desktop operating systems allow apps to register a custom URL
-  # scheme that will launch the app when a URL with that scheme is visited from
-  # the system browser.
-  #
-  # @see https://www.oauth.com/oauth2-servers/redirect-uris/redirect-uris-native-apps/
-  it 'is valid when the uri is custom native URI' do
-    subject.redirect_uri = 'myapp://callback'
-    expect(subject).to be_valid
-  end
-
-  it 'is valid when the uri has a query parameter' do
-    subject.redirect_uri = 'https://example.com/abcd?xyz=123'
-    expect(subject).to be_valid
-  end
-
-  it 'accepts native redirect uri' do
-    subject.redirect_uri = 'urn:ietf:wg:oauth:2.0:oob'
-    expect(subject).to be_valid
-  end
-
-  it 'rejects if test uri is disabled' do
-    allow(RedirectUriValidator).to receive(:native_redirect_uri).and_return(nil)
-    subject.redirect_uri = 'urn:some:test'
-    expect(subject).not_to be_valid
-  end
-
-  it 'is invalid when the uri is not a uri' do
-    subject.redirect_uri = ']'
-    expect(subject).not_to be_valid
-    expect(subject.errors[:redirect_uri].first).to eq('must be a valid URI.')
-  end
-
-  it 'is invalid when the uri is relative' do
-    subject.redirect_uri = '/abcd'
-    expect(subject).not_to be_valid
-    expect(subject.errors[:redirect_uri].first).to eq('must be an absolute URI.')
-  end
-
-  it 'is invalid when the uri has a fragment' do
-    subject.redirect_uri = 'https://example.com/abcd#xyz'
-    expect(subject).not_to be_valid
-    expect(subject.errors[:redirect_uri].first).to eq('cannot contain a fragment.')
-  end
-
-  context 'force secured uri' do
-    it 'accepts an valid uri' do
-      subject.redirect_uri = 'https://example.com/callback'
-      expect(subject).to be_valid
-    end
-
-    it 'accepts native redirect uri' do
-      subject.redirect_uri = 'urn:ietf:wg:oauth:2.0:oob'
-      expect(subject).to be_valid
-    end
-
-    it 'accepts app redirect uri' do
-      subject.redirect_uri = 'some-awesome-app://oauth/callback'
-      expect(subject).to be_valid
-    end
-
-    it 'accepts a non secured protocol when disabled' do
-      subject.redirect_uri = 'http://example.com/callback'
-      allow(Doorkeeper.configuration).to receive(
-                                             :force_ssl_in_redirect_uri
-                                         ).and_return(false)
-      expect(subject).to be_valid
-    end
-
-    it 'accepts a non secured protocol when conditional option defined' do
-      Doorkeeper.configure do
-        orm DOORKEEPER_ORM
-        force_ssl_in_redirect_uri { |uri| uri.host != 'localhost' }
-      end
-
-      application = FactoryBot.build(:application, redirect_uri: 'http://localhost/callback')
-      expect(application).to be_valid
-
-      application = FactoryBot.build(:application, redirect_uri: 'http://localhost2/callback')
-      expect(application).not_to be_valid
-    end
-
-    it 'forbids redirect uri if required' do
-      subject.redirect_uri = 'javascript://document.cookie'
-
-      Doorkeeper.configure do
-        orm DOORKEEPER_ORM
-        forbid_redirect_uri { |uri| uri.scheme == 'javascript' }
-      end
-
-      expect(subject).to be_invalid
-      expect(subject.errors[:redirect_uri].first).to eq('is forbidden by the server.')
-
-      subject.redirect_uri = 'https://localhost/callback'
-      expect(subject).to be_valid
-    end
-
-    it 'invalidates the uri when the uri does not use a secure protocol' do
-      subject.redirect_uri = 'http://example.com/callback'
-      expect(subject).not_to be_valid
-      error = subject.errors[:redirect_uri].first
-      expect(error).to eq('must be an HTTPS/SSL URI.')
-    end
-  end
-
-  context 'multiple redirect uri' do
-    it 'invalidates the second uri when the first uri is native uri' do
-      subject.redirect_uri = "urn:ietf:wg:oauth:2.0:oob\nexample.com/callback"
-      expect(subject).to be_invalid
-    end
-  end
-end