doorkeeper-grants_assertion 0.1.0 → 0.2.0

data/spec/spec_helper.rb

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

data/spec/spec_helper_integration.rb

@@ -1,28 +0,0 @@
-ENV['RAILS_ENV'] ||= 'test'
-
-$LOAD_PATH.unshift File.dirname(__FILE__)
-
-require 'dummy/config/environment'
-require 'rspec/rails'
-require 'database_cleaner'
-
-Rails.logger.info "====> Doorkeeper.orm = #{Doorkeeper.configuration.orm.inspect}"
-Rails.logger.info "====> Rails version: #{Rails.version}"
-Rails.logger.info "====> Ruby version: #{RUBY_VERSION}"
-
-Dir["#{File.dirname(__FILE__)}/support/{dependencies,helpers,shared}/*.rb"].each { |f| require f }
-
-# load schema to in memory sqlite
-ActiveRecord::Migration.verbose = false
-load Rails.root + 'db/schema.rb'
-
-RSpec.configure do |config|
-  config.mock_with :rspec
-
-  config.infer_base_class_for_anonymous_controllers = false
-
-  config.before { DatabaseCleaner.start }
-  config.after { DatabaseCleaner.clean }
-
-  config.order = 'random'
-end

data/spec/support/dependencies/factory_girl.rb

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

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, type: :request

data/spec/support/helpers/model_helper.rb

@@ -1,45 +0,0 @@
-module ModelHelper
-  def client_exists(client_attributes = {})
-    @client = FactoryGirl.create(:application, client_attributes)
-  end
-
-  def create_resource_owner
-    @resource_owner = User.create!(name: 'Joe', password: 'sekret', assertion: 'assertion')
-  end
-
-  def authorization_code_exists(options = {})
-    @authorization = FactoryGirl.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
-  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
-  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.first
-    expect(grant.scopes).to eq(Doorkeeper::OAuth::Scopes.from_array(args))
-  end
-end
-
-RSpec.configuration.send :include, ModelHelper, type: :request

data/spec/support/helpers/request_spec_helper.rb

@@ -1,76 +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 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.parse(response.body).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)
-  end
-
-  def should_not_have_json(key)
-    expect(JSON.parse(response.body)).not_to have_key(key)
-  end
-
-  def sign_in
-    visit '/'
-    click_on 'Sign in'
-  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]
-  end
-
-  def response_status_should_be(status)
-    expect(page.driver.response.status.to_i).to eq(status)
-  end
-end
-
-RSpec.configuration.send :include, RequestSpecHelper, type: :request

data/spec/support/helpers/url_helper.rb

@@ -1,19 +0,0 @@
-module UrlHelper
-  def assertion_endpoint_url(options = {})
-    parameters = {
-      :code          => options[:code],
-      :client_id     => options[:client_id]     || options[:client].uid,
-      :client_secret => options[:client_secret] || options[:client].secret,
-      :redirect_uri  => options[:redirect_uri]  || options[:client].redirect_uri,
-      :grant_type    => options[:grant_type]    || "assertion",
-      :assertion     => options[:assertion]     || (options[:resource_owner] ? options[:resource_owner].assertion : nil)
-    }
-    "/oauth/token?#{build_query(parameters)}"
-  end
-
-  def build_query(hash)
-    Rack::Utils.build_query(hash)
-  end
-end
-
-RSpec.configuration.send :include, UrlHelper, type: :request

data/spec/support/shared/controllers_shared_context.rb

@@ -1,60 +0,0 @@
-shared_context 'valid token', token: :valid do
-  let :token_string do
-    '1A2B3C4D'
-  end
-
-  let :token do
-    double(Doorkeeper::AccessToken, accessible?: true)
-  end
-
-  before :each do
-    allow(Doorkeeper::AccessToken).to receive(:authenticate).with(token_string).and_return(token)
-  end
-end
-
-shared_context 'invalid token', token: :invalid do
-  let :token_string do
-    '1A2B3C4D'
-  end
-
-  let :token do
-    double(Doorkeeper::AccessToken, accessible?: false, revoked?: false, expired?: false)
-  end
-
-  before :each do
-    allow(Doorkeeper::AccessToken).to receive(:authenticate).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 = FactoryGirl.create factory_name
-      token2 = FactoryGirl.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
-      token2.token = token1.token
-      expect do
-        token2.save!(validate: false)
-      end.to raise_error
-    end
-  end
-end