We're sorry, but something went wrong.
If you are the application owner check the logs for more information.
doorkeeper-openid_connect-1.6.3/spec/dummy/public/favicon.ico 0000664 0000000 0000000 00000000000 13542416054 0024323 0 ustar 00root root 0000000 0000000 doorkeeper-openid_connect-1.6.3/spec/factories.rb 0000664 0000000 0000000 00000001502 13542416054 0022105 0 ustar 00root root 0000000 0000000 FactoryBot.define do
factory :access_grant, class: Doorkeeper::AccessGrant do
resource_owner_id { create(:user).id }
application
redirect_uri { 'https://app.com/callback' }
expires_in { 100 }
scopes { 'public write' }
end
factory :access_token, class: Doorkeeper::AccessToken do
resource_owner_id { create(:user).id }
application
expires_in { 2.hours }
factory :clientless_access_token do
application { nil }
end
end
factory :application, class: Doorkeeper::Application do
sequence(:name) { |n| "Application #{n}" }
redirect_uri { 'https://app.com/callback' }
end
factory :user do
current_sign_in_at { Time.at(23) }
end
factory :openid_request, class: Doorkeeper::OpenidConnect::Request do
access_grant
sequence(:nonce) { |n| n.to_s }
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/ 0000775 0000000 0000000 00000000000 13542416054 0020351 5 ustar 00root root 0000000 0000000 doorkeeper-openid_connect-1.6.3/spec/lib/claims/ 0000775 0000000 0000000 00000000000 13542416054 0021621 5 ustar 00root root 0000000 0000000 doorkeeper-openid_connect-1.6.3/spec/lib/claims/claim_spec.rb 0000664 0000000 0000000 00000002201 13542416054 0024240 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect::Claims::Claim do
subject { described_class.new name: 'username', scope: 'profile' }
describe '#initialize' do
it 'uses the given name' do
expect(subject.name).to eq :username
end
it 'uses the given scope' do
expect(subject.scope).to eq :profile
end
it 'falls back to the default scope for standard claims' do
expect(described_class.new(name: 'family_name').scope).to eq :profile
expect(described_class.new(name: :family_name).scope).to eq :profile
expect(described_class.new(name: 'email').scope).to eq :email
expect(described_class.new(name: :email).scope).to eq :email
expect(described_class.new(name: 'address').scope).to eq :address
expect(described_class.new(name: :address).scope).to eq :address
expect(described_class.new(name: 'phone_number').scope).to eq :phone
expect(described_class.new(name: :phone_number).scope).to eq :phone
end
it 'falls back to the profile scope for non-standard claims' do
expect(described_class.new(name: 'unknown').scope).to eq :profile
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/config_spec.rb 0000664 0000000 0000000 00000010667 13542416054 0023167 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect, 'configuration' do
subject { Doorkeeper::OpenidConnect.configuration }
describe '#configure' do
it 'fails if not set to :active_record' do
# stub ORM setup to avoid Doorkeeper exceptions
allow(Doorkeeper).to receive(:setup_orm_adapter)
allow(Doorkeeper).to receive(:setup_orm_models)
Doorkeeper.configure do
orm :mongoid
end
expect do
Doorkeeper::OpenidConnect.configure {}
end.to raise_error Doorkeeper::OpenidConnect::Errors::InvalidConfiguration
end
end
describe 'jws_private_key' do
it 'delegates to signing_key' do
value = 'private_key'
Doorkeeper::OpenidConnect.configure do
jws_private_key value
end
expect(subject.signing_key).to eq(value)
end
end
describe 'signing_key' do
it 'sets the value that is accessible via signing_key' do
value = 'private_key'
Doorkeeper::OpenidConnect.configure do
signing_key value
end
expect(subject.signing_key).to eq(value)
end
end
describe 'issuer' do
it 'sets the value that is accessible via issuer' do
value = 'issuer'
Doorkeeper::OpenidConnect.configure do
issuer value
end
expect(subject.issuer).to eq(value)
end
end
describe 'resource_owner_from_access_token' do
it 'sets the block that is accessible via resource_owner_from_access_token' do
block = proc {}
Doorkeeper::OpenidConnect.configure do
resource_owner_from_access_token(&block)
end
expect(subject.resource_owner_from_access_token).to eq(block)
end
it 'fails if unset' do
Doorkeeper::OpenidConnect.configure {}
expect do
subject.resource_owner_from_access_token.call
end.to raise_error Doorkeeper::OpenidConnect::Errors::InvalidConfiguration
end
end
describe 'auth_time_from_resource_owner' do
it 'sets the block that is accessible via auth_time_from_resource_owner' do
block = proc {}
Doorkeeper::OpenidConnect.configure do
auth_time_from_resource_owner(&block)
end
expect(subject.auth_time_from_resource_owner).to eq(block)
end
it 'fails if unset' do
Doorkeeper::OpenidConnect.configure {}
expect do
subject.auth_time_from_resource_owner.call
end.to raise_error Doorkeeper::OpenidConnect::Errors::InvalidConfiguration
end
end
describe 'reauthenticate_resource_owner' do
it 'sets the block that is accessible via reauthenticate_resource_owner' do
block = proc {}
Doorkeeper::OpenidConnect.configure do
reauthenticate_resource_owner(&block)
end
expect(subject.reauthenticate_resource_owner).to eq(block)
end
it 'fails if unset' do
Doorkeeper::OpenidConnect.configure {}
expect do
subject.reauthenticate_resource_owner.call
end.to raise_error Doorkeeper::OpenidConnect::Errors::InvalidConfiguration
end
end
describe 'subject' do
it 'sets the block that is accessible via subject' do
block = proc {}
Doorkeeper::OpenidConnect.configure do
subject(&block)
end
expect(subject.subject).to eq(block)
end
it 'fails if unset' do
Doorkeeper::OpenidConnect.configure {}
expect do
subject.subject.call
end.to raise_error Doorkeeper::OpenidConnect::Errors::InvalidConfiguration
end
end
describe 'expiration' do
it 'sets the value that is accessible via expiration' do
value = 'expiration'
Doorkeeper::OpenidConnect.configure do
expiration value
end
expect(subject.expiration).to eq(value)
end
end
describe 'claims' do
it 'sets the claims configuration that is accessible via claims' do
Doorkeeper::OpenidConnect.configure do
claims do
end
end
expect(subject.claims).to_not be_nil
end
end
describe 'protocol' do
it 'defaults to https in production' do
expect(::Rails.env).to receive(:production?).and_return(true)
expect(subject.protocol.call).to eq(:https)
end
it 'defaults to http in other environments' do
expect(::Rails.env).to receive(:production?).and_return(false)
expect(subject.protocol.call).to eq(:http)
end
it 'can be set to other protocols' do
Doorkeeper::OpenidConnect.configure do
protocol { :ftp }
end
expect(subject.protocol.call).to eq(:ftp)
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/id_token_spec.rb 0000664 0000000 0000000 00000003473 13542416054 0023513 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect::IdToken do
subject { described_class.new(access_token, nonce) }
let(:access_token) { create :access_token, resource_owner_id: user.id, scopes: 'openid' }
let(:user) { create :user }
let(:nonce) { '123456' }
before do
allow(Time).to receive(:now) { Time.at 60 }
end
describe '#nonce' do
it 'returns the stored nonce' do
expect(subject.nonce).to eq '123456'
end
end
describe '#claims' do
it 'returns all default claims' do
expect(subject.claims).to eq({
iss: 'dummy',
sub: user.id.to_s,
aud: access_token.application.uid,
exp: 180,
iat: 60,
nonce: nonce,
auth_time: 23,
both_responses: 'both',
id_token_response: 'id_token',
})
end
end
describe '#as_json' do
it 'returns claims with nil values and empty strings removed' do
allow(subject).to receive(:issuer).and_return(nil)
allow(subject).to receive(:subject).and_return('')
allow(subject).to receive(:audience).and_return(' ')
json = subject.as_json
expect(json).to_not include :iss
expect(json).to_not include :sub
expect(json).to include :aud
end
end
describe '#as_jws_token' do
shared_examples 'a jws token' do
it 'returns claims encoded as JWT' do
jwt = JSON::JWT.decode_compact_serialized subject.as_jws_token, Doorkeeper::OpenidConnect.signing_key
expect(jwt.to_hash).to eq subject.as_json.stringify_keys
end
end
it_behaves_like 'a jws token'
context 'when signing_algorithm is EC' do
before { configure_ec }
it_behaves_like 'a jws token'
end
context 'when signing_algorithm is HMAC' do
before { configure_hmac }
it_behaves_like 'a jws token'
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/id_token_token_spec.rb 0000664 0000000 0000000 00000001703 13542416054 0024705 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect::IdTokenToken do
subject { described_class.new(access_token, nonce) }
let(:access_token) { create :access_token, resource_owner_id: user.id, scopes: 'openid' }
let(:user) { create :user }
let(:nonce) { '123456' }
before do
allow(Time).to receive(:now) { Time.at 60 }
end
describe '#claims' do
it 'returns all default claims' do
# access token is from http://openid.net/specs/openid-connect-core-1_0.html
# so we can test `at_hash` value
access_token.update(token: 'jHkWEdUXMU1BwAsC4vtUsZwnNvTIxEl0z9K3vx5KF0Y')
expect(subject.claims).to eq({
iss: 'dummy',
sub: user.id.to_s,
aud: access_token.application.uid,
exp: 180,
iat: 60,
nonce: nonce,
auth_time: 23,
at_hash: '77QmUPtjPfzWtF2AnpK9RQ',
both_responses: 'both',
id_token_response: 'id_token',
})
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/oauth/ 0000775 0000000 0000000 00000000000 13542416054 0021471 5 ustar 00root root 0000000 0000000 doorkeeper-openid_connect-1.6.3/spec/lib/oauth/authorization/ 0000775 0000000 0000000 00000000000 13542416054 0024371 5 ustar 00root root 0000000 0000000 doorkeeper-openid_connect-1.6.3/spec/lib/oauth/authorization/code_spec.rb 0000664 0000000 0000000 00000003026 13542416054 0026643 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect::OAuth::Authorization::Code do
subject { Doorkeeper::OAuth::Authorization::Code.new pre_auth, resource_owner }
let(:resource_owner) { create :user }
let(:access_grant) { create :access_grant }
let(:pre_auth) { double }
let(:client) { double }
describe '#issue_token' do
before do
allow(pre_auth).to receive(:client) { client }
allow(pre_auth).to receive(:redirect_uri) { 'redirect_uri' }
allow(pre_auth).to receive(:scopes) { 'scopes' }
allow(pre_auth).to receive(:nonce) { '123456' }
allow(client).to receive(:id) { 'client_id' }
allow(Doorkeeper::AccessGrant).to receive(:create!) { access_grant }
allow(Doorkeeper::OpenidConnect::Request).to receive(:create!)
end
it 'stores the nonce' do
subject.issue_token
expect(Doorkeeper::OpenidConnect::Request).to have_received(:create!).with({
access_grant: access_grant,
nonce: '123456'
})
end
it 'does not store the nonce if not present' do
allow(pre_auth).to receive(:nonce) { nil }
subject.issue_token
expect(Doorkeeper::OpenidConnect::Request).to_not have_received(:create!)
end
it 'does not store the nonce if blank' do
allow(pre_auth).to receive(:nonce) { ' ' }
subject.issue_token
expect(Doorkeeper::OpenidConnect::Request).to_not have_received(:create!)
end
it 'returns the created grant' do
expect(subject.issue_token).to be_a Doorkeeper::AccessGrant
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/oauth/authorization_code_request_spec.rb 0000664 0000000 0000000 00000002376 13542416054 0030502 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect::OAuth::AuthorizationCodeRequest do
subject {
Doorkeeper::OAuth::AuthorizationCodeRequest.new(server, grant, client).tap do |request|
request.instance_variable_set '@response', response
request.access_token = token
end
}
let(:server) { double }
let(:client) { double }
let(:grant) { create :access_grant, openid_request: openid_request }
let(:openid_request) { create :openid_request, nonce: '123456' }
let(:token) { create :access_token }
let(:response) { Doorkeeper::OAuth::TokenResponse.new token }
describe '#after_successful_response' do
it 'adds the ID token to the response' do
subject.send :after_successful_response
expect(response.id_token).to be_a Doorkeeper::OpenidConnect::IdToken
expect(response.id_token.nonce).to eq '123456'
end
it 'destroys the OpenID request record' do
grant.save!
expect do
subject.send :after_successful_response
end.to change { Doorkeeper::OpenidConnect::Request.count }.by(-1)
end
it 'skips the nonce if not present' do
grant.openid_request.nonce = nil
subject.send :after_successful_response
expect(response.id_token.nonce).to be_nil
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/oauth/id_token_request_spec.rb 0000664 0000000 0000000 00000004554 13542416054 0026404 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OAuth::IdTokenRequest do
let(:application) do
scopes = double(all: ['public'])
double(:application, id: 9990, scopes: scopes)
end
let(:pre_auth) do
double(
:pre_auth,
client: application,
redirect_uri: 'http://tst.com/cb',
state: nil,
scopes: Doorkeeper::OAuth::Scopes.from_string('public'),
error: nil,
authorizable?: true,
nonce: '12345'
)
end
let(:owner) do
double :owner, id: 7866
end
subject do
Doorkeeper::OAuth::IdTokenRequest.new(pre_auth, owner)
end
it 'creates an access token' do
expect do
subject.authorize
end.to change { Doorkeeper::AccessToken.count }.by(1)
end
it 'returns id_token response' do
expect(subject.authorize).to be_a(Doorkeeper::OAuth::IdTokenResponse)
end
it 'does not create token when not authorizable' do
allow(pre_auth).to receive(:authorizable?).and_return(false)
expect { subject.authorize }.not_to change { Doorkeeper::AccessToken.count }
end
it 'returns a error response' do
allow(pre_auth).to receive(:authorizable?).and_return(false)
expect(subject.authorize).to be_a(Doorkeeper::OAuth::ErrorResponse)
end
context 'token reuse' do
it 'creates a new token if there are no matching tokens' do
allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(true)
expect do
subject.authorize
end.to change { Doorkeeper::AccessToken.count }.by(1)
end
it 'creates a new token if scopes do not match' do
allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(true)
create(:access_token, application_id: pre_auth.client.id,
resource_owner_id: owner.id, scopes: '')
expect do
subject.authorize
end.to change { Doorkeeper::AccessToken.count }.by(1)
end
it 'skips token creation if there is a matching one' do
allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(true)
allow(application.scopes).to receive(:has_scopes?).and_return(true)
allow(application.scopes).to receive(:all?).and_return(true)
create(:access_token, application_id: pre_auth.client.id,
resource_owner_id: owner.id, scopes: 'public')
expect { subject.authorize }.not_to change { Doorkeeper::AccessToken.count }
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/oauth/id_token_response_spec.rb 0000664 0000000 0000000 00000002031 13542416054 0026536 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OAuth::IdTokenResponse do
subject { Doorkeeper::OAuth::IdTokenResponse.new(pre_auth, auth, id_token) }
let(:token) { create :access_token }
let(:application) do
scopes = double(all: ['public'])
double(:application, id: 9990, scopes: scopes)
end
let(:pre_auth) do
double(
:pre_auth,
client: application,
redirect_uri: 'http://tst.com/cb',
state: nil,
scopes: Doorkeeper::OAuth::Scopes.from_string('public'),
error: nil,
authorizable?: true,
nonce: '12345'
)
end
let(:auth) do
Doorkeeper::OAuth::Authorization::Token.new(pre_auth, double(id: 1)).tap do |c|
c.issue_token
end
end
let(:id_token) { Doorkeeper::OpenidConnect::IdToken.new(token, pre_auth) }
describe '#redirect_uri' do
it 'includes id_token' do
expect(subject.redirect_uri).to include('id_token')
end
it 'does not include access_token' do
expect(subject.redirect_uri).not_to include('access_token')
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/oauth/id_token_token_request_spec.rb 0000664 0000000 0000000 00000001552 13542416054 0027577 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OAuth::IdTokenTokenRequest do
let(:application) do
scopes = double(all: ['public'])
double(:application, id: 9990, scopes: scopes)
end
let(:pre_auth) do
double(
:pre_auth,
client: application,
redirect_uri: 'http://tst.com/cb',
state: nil,
scopes: Doorkeeper::OAuth::Scopes.from_string('public'),
error: nil,
authorizable?: true,
nonce: '12345'
)
end
let(:owner) do
double :owner, id: 7866
end
subject do
Doorkeeper::OAuth::IdTokenTokenRequest.new(pre_auth, owner)
end
it 'creates an access token' do
expect do
subject.authorize
end.to change { Doorkeeper::AccessToken.count }.by(1)
end
it 'returns id_token token response' do
expect(subject.authorize).to be_a(Doorkeeper::OAuth::IdTokenTokenResponse)
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/oauth/id_token_token_response_spec.rb 0000664 0000000 0000000 00000002172 13542416054 0027744 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OAuth::IdTokenTokenResponse do
subject { Doorkeeper::OAuth::IdTokenTokenResponse.new(pre_auth, auth, id_token) }
let(:token) { create :access_token }
let(:application) do
scopes = double(all: ['public'])
double(:application, id: 9990, scopes: scopes)
end
let(:pre_auth) do
double(
:pre_auth,
client: application,
redirect_uri: 'http://tst.com/cb',
state: nil,
scopes: Doorkeeper::OAuth::Scopes.from_string('public'),
error: nil,
authorizable?: true,
nonce: '12345'
)
end
let(:auth) do
Doorkeeper::OAuth::Authorization::Token.new(pre_auth, double(id: 1)).tap do |c|
c.issue_token
end
end
let(:id_token) { Doorkeeper::OpenidConnect::IdToken.new(token, pre_auth) }
describe '#redirect_uri' do
it 'includes id_token' do
expect(subject.redirect_uri).to include('id_token')
end
it 'includes access_token' do
expect(subject.redirect_uri).to include('access_token')
end
it 'includes token_type' do
expect(subject.redirect_uri).to include('token_type')
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/oauth/password_access_token_request_spec.rb 0000664 0000000 0000000 00000001615 13542416054 0031166 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect::OAuth::PasswordAccessTokenRequest do
subject { Doorkeeper::OAuth::PasswordAccessTokenRequest.new server, client, resource_owner, { nonce: '123456' } }
let(:server) { double }
let(:client) { double }
let(:resource_owner) { create :user }
let(:token) { create :access_token }
let(:response) { Doorkeeper::OAuth::TokenResponse.new token }
describe '#initialize' do
it 'stores the nonce attribute' do
expect(subject.nonce).to eq '123456'
end
end
describe '#after_successful_response' do
it 'adds the ID token to the response' do
subject.instance_variable_set '@response', response
subject.access_token = token
subject.send :after_successful_response
expect(response.id_token).to be_a Doorkeeper::OpenidConnect::IdToken
expect(response.id_token.nonce).to eq '123456'
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/oauth/pre_authorization_spec.rb 0000664 0000000 0000000 00000000546 13542416054 0026603 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect::OAuth::PreAuthorization do
subject { Doorkeeper::OAuth::PreAuthorization.new server, client, { nonce: '123456' } }
let(:server) { double }
let(:client) { double }
describe '#initialize' do
it 'stores the nonce attribute' do
expect(subject.nonce).to eq '123456'
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/oauth/token_response_spec.rb 0000664 0000000 0000000 00000002412 13542416054 0026065 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect::OAuth::TokenResponse do
subject { Doorkeeper::OAuth::TokenResponse.new token }
let(:token) { create :access_token }
let(:client) { Doorkeeper::OAuth::Client.new create(:application) }
let(:pre_auth) { Doorkeeper::OAuth::PreAuthorization.new(Doorkeeper.configuration, client, nonce: '123456')}
let(:id_token) { Doorkeeper::OpenidConnect::IdToken.new token, pre_auth }
describe '#body' do
before do
subject.id_token = id_token
end
context 'with the openid scope present' do
before do
token.scopes = 'openid email'
end
it 'adds the ID token to the response' do
expect(subject.body[:id_token]).to eq id_token.as_jws_token
end
end
context 'with the openid scope present but no id_token' do
before do
token.scopes = 'openid email'
subject.id_token = nil
end
it 'adds the ID token to the response' do
expect(subject.body[:id_token]).to be_truthy
end
end
context 'with the openid scope not present' do
before do
token.scopes = 'email'
end
it 'does not add the ID token to the response' do
expect(subject.body).to_not include :id_token
end
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/openid_connect_spec.rb 0000664 0000000 0000000 00000003751 13542416054 0024705 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect do
describe '.signing_algorithm' do
it 'returns the signing_algorithm as an uppercase symbol' do
expect(subject.signing_algorithm).to eq :RS256
end
end
describe '.signing_key' do
it 'returns the private key as JWK instance' do
expect(subject.signing_key).to be_instance_of JSON::JWK
expect(subject.signing_key[:kid]).to eq 'IqYwZo2cE6hsyhs48cU8QHH4GanKIx0S4Dc99kgTIMA'
end
end
describe '.signing_key_normalized' do
context 'when signing key is RSA' do
it 'returns the RSA public key parameters' do
expect(subject.signing_key_normalized).to eq(
'kty' => :RSA,
'kid' => 'IqYwZo2cE6hsyhs48cU8QHH4GanKIx0S4Dc99kgTIMA',
'e' => 'AQAB',
'n' => 'sjdnSA6UWUQQHf6BLIkIEUhMRNBJC1NN_pFt1EJmEiI88GS0ceROO5B5Ooo9Y3QOWJ_n-u1uwTHBz0HCTN4wgArWd1TcqB5GQzQRP4eYnWyPfi4CfeqAHzQp-v4VwbcK0LW4FqtW5D0dtrFtI281FDxLhARzkhU2y7fuYhL8fVw5rUhE8uwvHRZ5CEZyxf7BSHxIvOZAAymhuzNLATt2DGkDInU1BmF75tEtBJAVLzWG_j4LPZh1EpSdfezqaXQlcy9PJi916UzTl0P7Yy-ulOdUsMlB6yo8qKTY1-AbZ5jzneHbGDU_O8QjYvii1WDmJ60t0jXicmOkGrOhruOptw'
)
end
end
context 'when signing key is EC' do
before { configure_ec }
it 'returns the EC public key parameters' do
expect(subject.signing_key_normalized).to eq(
'kty' => :EC,
'kid' => 'dOx_AhaepicN2r2M-sxZhgkYZMCX7dYhPsNOw1ZiFnI',
'crv' => :'P-521',
'x' => 'AeYVvbl3zZcFCdE-0msqOowYODjzeXAhjsZKhdNjGlDREvko3UFOw6S43g-s8bvVBmBz3fCodEzFRYQqJVI4UFvF',
'y' => 'AYJ7GYeBm_Fb6liN53xGASdbRSzF34h4BDSVYzjtQc7I-1LK17fwwS3VfQCJwaT6zX33HTrhR4VoUEUJHKwR3dNs'
)
end
end
context 'when signing key is HMAC' do
before { configure_hmac }
it 'returns the HMAC public key parameters' do
expect(subject.signing_key_normalized).to eq(
'kty' => :oct,
'kid' => 'lyAW7LdxryFWQtLdgxZpOrI87APHrzJKgWLT0BkWVog'
)
end
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/routes_spec.rb 0000664 0000000 0000000 00000002073 13542416054 0023233 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect::Rails::Routes, type: :routing do
describe 'userinfo' do
it 'maps GET #show' do
expect(get: 'oauth/userinfo').to route_to(
controller: 'doorkeeper/openid_connect/userinfo',
action: 'show'
)
end
it 'maps POST #show' do
expect(post: 'oauth/userinfo').to route_to(
controller: 'doorkeeper/openid_connect/userinfo',
action: 'show'
)
end
end
describe 'discovery' do
it 'maps GET #provider' do
expect(get: '.well-known/openid-configuration').to route_to(
controller: 'doorkeeper/openid_connect/discovery',
action: 'provider'
)
end
it 'maps GET #webfinger' do
expect(get: '.well-known/webfinger').to route_to(
controller: 'doorkeeper/openid_connect/discovery',
action: 'webfinger'
)
end
it 'maps GET #keys' do
expect(get: 'oauth/discovery/keys').to route_to(
controller: 'doorkeeper/openid_connect/discovery',
action: 'keys'
)
end
end
end
doorkeeper-openid_connect-1.6.3/spec/lib/user_info_spec.rb 0000664 0000000 0000000 00000002571 13542416054 0023706 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect::UserInfo do
subject { described_class.new token }
let(:user) { create :user, name: 'Joe' }
let(:token) { create :access_token, resource_owner_id: user.id, scopes: scopes }
let(:scopes) { 'openid' }
describe '#claims' do
it 'returns all accessible claims' do
expect(subject.claims).to eq({
sub: user.id.to_s,
created_at: user.created_at.to_i,
variable_name: 'openid-name',
token_id: token.id,
both_responses: 'both',
user_info_response: 'user_info',
})
end
context 'with a grant for the profile scopes' do
let(:scopes) { 'openid profile' }
it 'returns additional profile claims' do
expect(subject.claims).to eq({
sub: user.id.to_s,
name: 'Joe',
created_at: user.created_at.to_i,
updated_at: user.updated_at.to_i,
variable_name: 'profile-name',
token_id: token.id,
both_responses: 'both',
user_info_response: 'user_info',
})
end
end
end
describe '#as_json' do
it 'returns claims with nil values and empty strings removed' do
allow(subject).to receive(:claims).and_return({
nil: nil,
empty: '',
blank: ' ',
})
expect(subject.as_json).to eq({
blank: ' '
})
end
end
end
doorkeeper-openid_connect-1.6.3/spec/models/ 0000775 0000000 0000000 00000000000 13542416054 0021066 5 ustar 00root root 0000000 0000000 doorkeeper-openid_connect-1.6.3/spec/models/access_grant_spec.rb 0000664 0000000 0000000 00000000613 13542416054 0025061 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect::AccessGrant do
subject { Doorkeeper::AccessGrant.new }
it 'has one openid_request' do
association = subject.class.reflect_on_association :openid_request
expect(association.options).to eq({
class_name: 'Doorkeeper::OpenidConnect::Request',
inverse_of: :access_grant,
dependent: :delete,
})
end
end
doorkeeper-openid_connect-1.6.3/spec/models/request_spec.rb 0000664 0000000 0000000 00000001326 13542416054 0024117 0 ustar 00root root 0000000 0000000 require 'rails_helper'
describe Doorkeeper::OpenidConnect::Request do
describe 'validations' do
it 'requires an access grant' do
subject.access_grant_id = nil
expect(subject).to_not be_valid
expect(subject.errors).to include :access_grant_id
end
it 'requires a nonce' do
subject.nonce = nil
expect(subject).to_not be_valid
expect(subject.errors).to include :nonce
end
end
describe 'associations' do
it 'belongs to an access_grant' do
association = subject.class.reflect_on_association :access_grant
expect(association.options).to eq({
class_name: 'Doorkeeper::AccessGrant',
inverse_of: :openid_request,
})
end
end
end
doorkeeper-openid_connect-1.6.3/spec/rails_helper.rb 0000664 0000000 0000000 00000004750 13542416054 0022607 0 ustar 00root root 0000000 0000000 # This file is copied to spec/ when you run 'rails generate rspec:install'
ENV['RAILS_ENV'] ||= 'test'
require 'dummy/config/environment'
# Prevent database truncation if the environment is production
abort("The Rails environment is running in production mode!") if Rails.env.production?
require 'spec_helper'
require 'rspec/rails'
# Add additional requires below this line. Rails is not loaded until this point!
# Requires supporting ruby files with custom matchers and macros, etc, in
# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
# run as spec files by default. This means that files in spec/support that end
# in _spec.rb will both be required and run as specs, causing the specs to be
# run twice. It is recommended that you do not name files matching this glob to
# end with _spec.rb. You can configure this pattern with the --pattern
# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
#
# The following line is provided for convenience purposes. It has the downside
# of increasing the boot-up time by auto-requiring all files in the support
# directory. Alternatively, in the individual `*_spec.rb` files, manually
# require only the support files necessary.
#
# Dir[Rails.root.join('spec/support/**/*.rb')].each { |f| require f }
# Checks for pending migration and applies them before tests are run.
# If you are not using ActiveRecord, you can remove this line.
Dir.chdir('spec/dummy') do
ActiveRecord::Migration.maintain_test_schema!
end
# Remove after dropping support of Rails 4.2
require_relative 'support/http_method_shim.rb'
require_relative 'support/doorkeeper_configuration.rb'
require 'factory_bot'
FactoryBot.find_definitions
RSpec.configure do |config|
# Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
config.fixture_path = "#{::Rails.root}/spec/fixtures"
# If you're not using ActiveRecord, or you'd prefer not to run each of your
# examples within a transaction, remove the following line or assign false
# instead of true.
config.use_transactional_fixtures = true
# Filter lines from Rails gems in backtraces.
config.filter_rails_from_backtrace!
# arbitrary gems may also be filtered via:
# config.filter_gems_from_backtrace("gem name")
config.include FactoryBot::Syntax::Methods
# Reinitialize configuration after each example
config.after :each do
load "#{Rails.root}/config/initializers/doorkeeper.rb"
load "#{Rails.root}/config/initializers/doorkeeper_openid_connect.rb"
end
end
doorkeeper-openid_connect-1.6.3/spec/spec_helper.rb 0000664 0000000 0000000 00000011417 13542416054 0022425 0 ustar 00root root 0000000 0000000 require 'pry-byebug'
# This file was generated by the `rails generate rspec:install` command. Conventionally, all
# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
# The generated `.rspec` file contains `--require spec_helper` which will cause
# this file to always be loaded, without a need to explicitly require it in any
# files.
#
# Given that it is always loaded, you are encouraged to keep this file as
# light-weight as possible. Requiring heavyweight dependencies from this file
# will add to the boot time of your test suite on EVERY test run, even for an
# individual file that may not need all of that loaded. Instead, consider making
# a separate helper file that requires the additional dependencies and performs
# the additional setup, and require it from the spec files that actually need
# it.
#
# The `.rspec` file also contains a few flags that are not defaults but that
# users commonly want.
#
# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
RSpec.configure do |config|
# rspec-expectations config goes here. You can use an alternate
# assertion/expectation library such as wrong or the stdlib/minitest
# assertions if you prefer.
config.expect_with :rspec do |expectations|
# This option will default to `true` in RSpec 4. It makes the `description`
# and `failure_message` of custom matchers include text for helper methods
# defined using `chain`, e.g.:
# be_bigger_than(2).and_smaller_than(4).description
# # => "be bigger than 2 and smaller than 4"
# ...rather than:
# # => "be bigger than 2"
expectations.include_chain_clauses_in_custom_matcher_descriptions = true
end
# rspec-mocks config goes here. You can use an alternate test double
# library (such as bogus or mocha) by changing the `mock_with` option here.
config.mock_with :rspec do |mocks|
# Prevents you from mocking or stubbing a method that does not exist on
# a real object. This is generally recommended, and will default to
# `true` in RSpec 4.
mocks.verify_partial_doubles = true
end
# This option will default to `:apply_to_host_groups` in RSpec 4 (and will
# have no way to turn it off -- the option exists only for backwards
# compatibility in RSpec 3). It causes shared context metadata to be
# inherited by the metadata hash of host groups and examples, rather than
# triggering implicit auto-inclusion in groups with matching metadata.
config.shared_context_metadata_behavior = :apply_to_host_groups
# The settings below are suggested to provide a good initial experience
# with RSpec, but feel free to customize to your heart's content.
# This allows you to limit a spec run to individual examples or groups
# you care about by tagging them with `:focus` metadata. When nothing
# is tagged with `:focus`, all examples get run. RSpec also provides
# aliases for `it`, `describe`, and `context` that include `:focus`
# metadata: `fit`, `fdescribe` and `fcontext`, respectively.
config.filter_run_when_matching :focus
# Allows RSpec to persist some state between runs in order to support
# the `--only-failures` and `--next-failure` CLI options. We recommend
# you configure your source control system to ignore this file.
config.example_status_persistence_file_path = "spec/examples.txt"
# Limits the available syntax to the non-monkey patched syntax that is
# recommended. For more details, see:
# - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
# - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
# - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
#config.disable_monkey_patching!
# Many RSpec users commonly either run the entire suite or an individual
# file, and it's useful to allow more verbose output when running an
# individual spec file.
if config.files_to_run.one?
# Use the documentation formatter for detailed output,
# unless a formatter has already been configured
# (e.g. via a command-line flag).
config.default_formatter = 'doc'
end
# Print the 10 slowest examples and example groups at the
# end of the spec run, to help surface which specs are running
# particularly slow.
#config.profile_examples = 10
# Run specs in random order to surface order dependencies. If you find an
# order dependency and want to debug it, you can fix the order by providing
# the seed, which is printed after each run.
# --seed 1234
config.order = :random
# Seed global randomization in this process using the `--seed` CLI option.
# Setting this allows you to use `--seed` to deterministically reproduce
# test failures related to randomization by passing the same `--seed` value
# as the one that triggered the failure.
Kernel.srand config.seed
end
doorkeeper-openid_connect-1.6.3/spec/support/ 0000775 0000000 0000000 00000000000 13542416054 0021317 5 ustar 00root root 0000000 0000000 doorkeeper-openid_connect-1.6.3/spec/support/doorkeeper_configuration.rb 0000664 0000000 0000000 00000002204 13542416054 0026730 0 ustar 00root root 0000000 0000000 module DoorkeeperConfiguration
def configure_doorkeeper(signing_key, signing_algorithm)
Doorkeeper::OpenidConnect.configure do
signing_key signing_key
signing_algorithm signing_algorithm
resource_owner_from_access_token do |access_token|
User.find_by(id: access_token.resource_owner_id)
end
auth_time_from_resource_owner do |resource_owner|
resource_owner.current_sign_in_at
end
subject do |resource_owner|
resource_owner.id
end
end
end
def configure_ec
signing_key = <<-EOL
-----BEGIN EC PRIVATE KEY-----
MIHbAgEBBEF9VcxGjPKczrJlE1N3oEpZsauQfDXIjLeini7h4/3+DOKw2VWE4lCU
rNJJL65EHT+2TriRg2xSb0l0rK/MAFAFraAHBgUrgQQAI6GBiQOBhgAEAeYVvbl3
zZcFCdE+0msqOowYODjzeXAhjsZKhdNjGlDREvko3UFOw6S43g+s8bvVBmBz3fCo
dEzFRYQqJVI4UFvFAYJ7GYeBm/Fb6liN53xGASdbRSzF34h4BDSVYzjtQc7I+1LK
17fwwS3VfQCJwaT6zX33HTrhR4VoUEUJHKwR3dNs
-----END EC PRIVATE KEY-----
EOL
configure_doorkeeper(signing_key, :ES512)
end
def configure_hmac
configure_doorkeeper('the_greatest_secret_key', :HS512)
end
end
RSpec.configure { |config| config.include DoorkeeperConfiguration }
doorkeeper-openid_connect-1.6.3/spec/support/http_method_shim.rb 0000664 0000000 0000000 00000001762 13542416054 0025211 0 ustar 00root root 0000000 0000000 # 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
if ::Rails::VERSION::MAJOR < 5
RSpec.configure do |config|
config.include ControllerHTTPMethodShim, type: :controller
config.include RoutingHTTPMethodShim, type: :request
end
end