doorkeeper 4.4.3 → 5.5.2

data/spec/lib/oauth/token_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-require 'active_support/core_ext/string'
-require 'doorkeeper/oauth/token'
-
-module Doorkeeper
-  unless defined?(AccessToken)
-    class AccessToken
-    end
-  end
-
-  module OAuth
-    describe Token do
-      describe :from_request do
-        let(:request) { double.as_null_object }
-
-        let(:method) do
-          ->(request) { return 'token-value' }
-        end
-
-        it 'accepts anything that responds to #call' do
-          expect(method).to receive(:call).with(request)
-          Token.from_request request, method
-        end
-
-        it 'delegates methods received as symbols to Token class' do
-          expect(Token).to receive(:from_params).with(request)
-          Token.from_request request, :from_params
-        end
-
-        it 'stops at the first credentials found' do
-          not_called_method = double
-          expect(not_called_method).not_to receive(:call)
-          Token.from_request request, ->(_r) {}, method, not_called_method
-        end
-
-        it 'returns the credential from extractor method' do
-          credentials = Token.from_request request, method
-          expect(credentials).to eq('token-value')
-        end
-      end
-
-      describe :from_access_token_param do
-        it 'returns token from access_token parameter' do
-          request = double parameters: { access_token: 'some-token' }
-          token   = Token.from_access_token_param(request)
-          expect(token).to eq('some-token')
-        end
-      end
-
-      describe :from_bearer_param do
-        it 'returns token from bearer_token parameter' do
-          request = double parameters: { bearer_token: 'some-token' }
-          token   = Token.from_bearer_param(request)
-          expect(token).to eq('some-token')
-        end
-      end
-
-      describe :from_bearer_authorization do
-        it 'returns token from capitalized authorization bearer' do
-          request = double authorization: 'Bearer SomeToken'
-          token   = Token.from_bearer_authorization(request)
-          expect(token).to eq('SomeToken')
-        end
-
-        it 'returns token from lowercased authorization bearer' do
-          request = double authorization: 'bearer SomeToken'
-          token   = Token.from_bearer_authorization(request)
-          expect(token).to eq('SomeToken')
-        end
-
-        it 'does not return token if authorization is not bearer' do
-          request = double authorization: 'MAC SomeToken'
-          token   = Token.from_bearer_authorization(request)
-          expect(token).to be_blank
-        end
-      end
-
-      describe :from_basic_authorization do
-        it 'returns token from capitalized authorization basic' do
-          request = double authorization: "Basic #{Base64.encode64 'SomeToken:'}"
-          token   = Token.from_basic_authorization(request)
-          expect(token).to eq('SomeToken')
-        end
-
-        it 'returns token from lowercased authorization basic' do
-          request = double authorization: "basic #{Base64.encode64 'SomeToken:'}"
-          token   = Token.from_basic_authorization(request)
-          expect(token).to eq('SomeToken')
-        end
-
-        it 'does not return token if authorization is not basic' do
-          request = double authorization: "MAC #{Base64.encode64 'SomeToken:'}"
-          token   = Token.from_basic_authorization(request)
-          expect(token).to be_blank
-        end
-      end
-
-      describe :authenticate do
-        it 'calls the finder if token was returned' do
-          token = ->(_r) { 'token' }
-          expect(AccessToken).to receive(:by_token).with('token')
-          Token.authenticate double, token
-        end
-
-        it 'revokes previous refresh_token if token was found' do
-          token = ->(_r) { 'token' }
-          expect(
-            AccessToken
-          ).to receive(:by_token).with('token').and_return(token)
-          expect(token).to receive(:revoke_previous_refresh_token!)
-          Token.authenticate double, token
-        end
-      end
-    end
-  end
-end

data/spec/lib/request/strategy_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-require 'doorkeeper/request/strategy'
-
-module Doorkeeper
-  module Request
-    describe Strategy do
-      let(:server) { double }
-      subject(:strategy) { Strategy.new(server) }
-
-      describe :initialize do
-        it "sets the server attribute" do
-          expect(strategy.server).to eq server
-        end
-      end
-
-      describe :request do
-        it "requires an implementation" do
-          expect { strategy.request }.to raise_exception NotImplementedError
-        end
-      end
-
-      describe "a sample Strategy subclass" do
-        let(:fake_request) { double }
-
-        let(:strategy_class) do
-          subclass = Class.new(Strategy) do
-            class << self
-              attr_accessor :fake_request
-            end
-
-            def request
-              self.class.fake_request
-            end
-          end
-
-          subclass.fake_request = fake_request
-          subclass
-        end
-
-        subject(:strategy) { strategy_class.new(server) }
-
-        it "provides a request implementation" do
-          expect(strategy.request).to eq fake_request
-        end
-
-        it "authorizes the request" do
-          expect(fake_request).to receive :authorize
-          strategy.authorize
-        end
-      end
-    end
-  end
-end

data/spec/lib/server_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe Doorkeeper::Server do
-  let(:fake_class) { double :fake_class }
-
-  subject do
-    described_class.new
-  end
-
-  describe '.authorization_request' do
-    it 'raises error when strategy does not exist' do
-      expect do
-        subject.authorization_request(:duh)
-      end.to raise_error(Doorkeeper::Errors::InvalidAuthorizationStrategy)
-    end
-
-    it 'raises error when strategy does not match phase' do
-      expect do
-        subject.token_request(:code)
-      end.to raise_error(Doorkeeper::Errors::InvalidTokenStrategy)
-    end
-
-    context 'when only Authorization Code strategy is enabled' do
-      before do
-        allow(Doorkeeper.configuration).
-          to receive(:grant_flows).
-          and_return(['authorization_code'])
-      end
-
-      it 'raises error when using the disabled Implicit strategy' do
-        expect do
-          subject.authorization_request(:token)
-        end.to raise_error(Doorkeeper::Errors::InvalidAuthorizationStrategy)
-      end
-
-      it 'raises error when using the disabled Client Credentials strategy' do
-        expect do
-          subject.token_request(:client_credentials)
-        end.to raise_error(Doorkeeper::Errors::InvalidTokenStrategy)
-      end
-    end
-
-    it 'builds the request with selected strategy' do
-      stub_const 'Doorkeeper::Request::Code', fake_class
-      expect(fake_class).to receive(:new).with(subject)
-      subject.authorization_request :code
-    end
-
-    it 'builds the request with composit strategy name' do
-      allow(Doorkeeper.configuration).
-        to receive(:authorization_response_types).
-        and_return(['id_token token'])
-
-      stub_const 'Doorkeeper::Request::IdTokenToken', fake_class
-      expect(fake_class).to receive(:new).with(subject)
-      subject.authorization_request 'id_token token'
-    end
-  end
-end

data/spec/models/doorkeeper/access_grant_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper_integration'
-
-describe Doorkeeper::AccessGrant do
-  subject { FactoryBot.build(:access_grant) }
-
-  it { expect(subject).to be_valid }
-
-  it_behaves_like 'an accessible token'
-  it_behaves_like 'a revocable token'
-  it_behaves_like 'a unique token' do
-    let(:factory_name) { :access_grant }
-  end
-
-  describe 'validations' do
-    it 'is invalid without resource_owner_id' do
-      subject.resource_owner_id = nil
-      expect(subject).not_to be_valid
-    end
-
-    it 'is invalid without application_id' do
-      subject.application_id = nil
-      expect(subject).not_to be_valid
-    end
-
-    it 'is invalid without token' do
-      subject.save
-      subject.token = nil
-      expect(subject).not_to be_valid
-    end
-
-    it 'is invalid without expires_in' do
-      subject.expires_in = nil
-      expect(subject).not_to be_valid
-    end
-  end
-end

data/spec/models/doorkeeper/access_token_spec.rb

@@ -1,418 +0,0 @@
-require 'spec_helper_integration'
-
-module Doorkeeper
-  describe AccessToken do
-    subject { FactoryBot.build(:access_token) }
-
-    it { expect(subject).to be_valid }
-
-    it_behaves_like 'an accessible token'
-    it_behaves_like 'a revocable token'
-    it_behaves_like 'a unique token' do
-      let(:factory_name) { :access_token }
-    end
-
-    module CustomGeneratorArgs
-      def self.generate
-      end
-    end
-
-    describe :generate_token do
-      it 'generates a token using the default method' do
-        FactoryBot.create :access_token
-
-        token = FactoryBot.create :access_token
-        expect(token.token).to be_a(String)
-      end
-
-      it 'generates a token using a custom object' do
-        eigenclass = class << CustomGeneratorArgs; self; end
-        eigenclass.class_eval do
-          remove_method :generate
-        end
-        module CustomGeneratorArgs
-          def self.generate(opts = {})
-            "custom_generator_token_#{opts[:resource_owner_id]}"
-          end
-        end
-
-        Doorkeeper.configure do
-          orm DOORKEEPER_ORM
-          access_token_generator "Doorkeeper::CustomGeneratorArgs"
-        end
-
-        token = FactoryBot.create :access_token
-        expect(token.token).to match(%r{custom_generator_token_\d+})
-      end
-
-      it 'allows the custom generator to access the application details' do
-        eigenclass = class << CustomGeneratorArgs; self; end
-        eigenclass.class_eval do
-          remove_method :generate
-        end
-        module CustomGeneratorArgs
-          def self.generate(opts = {})
-            "custom_generator_token_#{opts[:application].name}"
-          end
-        end
-
-        Doorkeeper.configure do
-          orm DOORKEEPER_ORM
-          access_token_generator "Doorkeeper::CustomGeneratorArgs"
-        end
-
-        token = FactoryBot.create :access_token
-        expect(token.token).to match(%r{custom_generator_token_Application \d+})
-      end
-
-      it 'allows the custom generator to access the scopes' do
-        eigenclass = class << CustomGeneratorArgs; self; end
-        eigenclass.class_eval do
-          remove_method :generate
-        end
-        module CustomGeneratorArgs
-          def self.generate(opts = {})
-            "custom_generator_token_#{opts[:scopes].count}_#{opts[:scopes]}"
-          end
-        end
-
-        Doorkeeper.configure do
-          orm DOORKEEPER_ORM
-          access_token_generator "Doorkeeper::CustomGeneratorArgs"
-        end
-
-        token = FactoryBot.create :access_token, scopes: 'public write'
-
-        expect(token.token).to eq 'custom_generator_token_2_public write'
-      end
-
-      it 'allows the custom generator to access the expiry length' do
-        eigenclass = class << CustomGeneratorArgs; self; end
-        eigenclass.class_eval do
-          remove_method :generate
-        end
-        module CustomGeneratorArgs
-          def self.generate(opts = {})
-            "custom_generator_token_#{opts[:expires_in]}"
-          end
-        end
-
-        Doorkeeper.configure do
-          orm DOORKEEPER_ORM
-          access_token_generator "Doorkeeper::CustomGeneratorArgs"
-        end
-
-        token = FactoryBot.create :access_token
-        expect(token.token).to eq 'custom_generator_token_7200'
-      end
-
-      it 'allows the custom generator to access the created time' do
-        module CustomGeneratorArgs
-          def self.generate(opts = {})
-            "custom_generator_token_#{opts[:created_at].to_i}"
-          end
-        end
-
-        Doorkeeper.configure do
-          orm DOORKEEPER_ORM
-          access_token_generator "Doorkeeper::CustomGeneratorArgs"
-        end
-
-        token = FactoryBot.create :access_token
-        created_at = token.created_at
-        expect(token.token).to eq "custom_generator_token_#{created_at.to_i}"
-      end
-
-      it 'raises an error if the custom object does not support generate' do
-        module NoGenerate
-        end
-
-        Doorkeeper.configure do
-          orm DOORKEEPER_ORM
-          access_token_generator "Doorkeeper::NoGenerate"
-        end
-
-        expect { FactoryBot.create :access_token }.to(
-          raise_error(Doorkeeper::Errors::UnableToGenerateToken)
-        )
-      end
-
-      it 'raises original error if something went wrong in custom generator' do
-        eigenclass = class << CustomGeneratorArgs; self; end
-        eigenclass.class_eval do
-          remove_method :generate
-        end
-
-        module CustomGeneratorArgs
-          def self.generate(opts = {})
-            raise LoadError, 'custom behaviour'
-          end
-        end
-
-        Doorkeeper.configure do
-          orm DOORKEEPER_ORM
-          access_token_generator "Doorkeeper::CustomGeneratorArgs"
-        end
-
-        expect { FactoryBot.create :access_token }.to(
-          raise_error(LoadError)
-        )
-      end
-
-      it 'raises an error if the custom object does not exist' do
-        Doorkeeper.configure do
-          orm DOORKEEPER_ORM
-          access_token_generator "Doorkeeper::NotReal"
-        end
-
-        expect { FactoryBot.create :access_token }.to(
-          raise_error(Doorkeeper::Errors::TokenGeneratorNotFound, /NotReal/)
-        )
-      end
-    end
-
-    describe :refresh_token do
-      it 'has empty refresh token if it was not required' do
-        token = FactoryBot.create :access_token
-        expect(token.refresh_token).to be_nil
-      end
-
-      it 'generates a refresh token if it was requested' do
-        token = FactoryBot.create :access_token, use_refresh_token: true
-        expect(token.refresh_token).not_to be_nil
-      end
-
-      it 'is not valid if token exists' do
-        token1 = FactoryBot.create :access_token, use_refresh_token: true
-        token2 = FactoryBot.create :access_token, use_refresh_token: true
-        token2.refresh_token = token1.refresh_token
-        expect(token2).not_to be_valid
-      end
-
-      it 'expects database to raise an error if refresh tokens are the same' do
-        token1 = FactoryBot.create :access_token, use_refresh_token: true
-        token2 = FactoryBot.create :access_token, use_refresh_token: true
-        expect do
-          token2.refresh_token = token1.refresh_token
-          token2.save(validate: false)
-        end.to raise_error(uniqueness_error)
-      end
-    end
-
-    describe 'validations' do
-      it 'is valid without resource_owner_id' do
-        # For client credentials flow
-        subject.resource_owner_id = nil
-        expect(subject).to be_valid
-      end
-
-      it 'is valid without application_id' do
-        # For resource owner credentials flow
-        subject.application_id = nil
-        expect(subject).to be_valid
-      end
-    end
-
-    describe '#same_credential?' do
-
-      context 'with default parameters' do
-
-        let(:resource_owner_id) { 100 }
-        let(:application)    { FactoryBot.create :application }
-        let(:default_attributes) do
-          { application: application, resource_owner_id: resource_owner_id }
-        end
-        let(:access_token1) { FactoryBot.create :access_token, default_attributes }
-
-        context 'the second token has the same owner and same app' do
-          let(:access_token2) { FactoryBot.create :access_token, default_attributes }
-          it 'success' do
-            expect(access_token1.same_credential?(access_token2)).to be_truthy
-          end
-        end
-
-        context 'the second token has same owner and different app' do
-          let(:other_application) { FactoryBot.create :application }
-          let(:access_token2) { FactoryBot.create :access_token, application: other_application, resource_owner_id: resource_owner_id }
-
-          it 'fail' do
-            expect(access_token1.same_credential?(access_token2)).to be_falsey
-          end
-        end
-
-        context 'the second token has different owner and different app' do
-
-          let(:other_application) { FactoryBot.create :application }
-          let(:access_token2) { FactoryBot.create :access_token, application: other_application, resource_owner_id: 42 }
-
-          it 'fail' do
-            expect(access_token1.same_credential?(access_token2)).to be_falsey
-          end
-        end
-
-        context 'the second token has different owner and same app' do
-          let(:access_token2) { FactoryBot.create :access_token, application: application, resource_owner_id: 42 }
-
-          it 'fail' do
-            expect(access_token1.same_credential?(access_token2)).to be_falsey
-          end
-        end
-      end
-    end
-
-    describe '#acceptable?' do
-      context 'a token that is not accessible' do
-        let(:token) { FactoryBot.create(:access_token, created_at: 6.hours.ago) }
-
-        it 'should return false' do
-          expect(token.acceptable?(nil)).to be false
-        end
-      end
-
-      context 'a token that has the incorrect scopes' do
-        let(:token) { FactoryBot.create(:access_token) }
-
-        it 'should return false' do
-          expect(token.acceptable?(['public'])).to be false
-        end
-      end
-
-      context 'a token is acceptable with the correct scopes' do
-        let(:token) do
-          token = FactoryBot.create(:access_token)
-          token[:scopes] = 'public'
-          token
-        end
-
-        it 'should return true' do
-          expect(token.acceptable?(['public'])).to be true
-        end
-      end
-    end
-
-    describe '.revoke_all_for' do
-      let(:resource_owner) { double(id: 100) }
-      let(:application)    { FactoryBot.create :application }
-      let(:default_attributes) do
-        { application: application, resource_owner_id: resource_owner.id }
-      end
-
-      it 'revokes all tokens for given application and resource owner' do
-        FactoryBot.create :access_token, default_attributes
-        AccessToken.revoke_all_for application.id, resource_owner
-        AccessToken.all.each do |token|
-          expect(token).to be_revoked
-        end
-      end
-
-      it 'matches application' do
-        FactoryBot.create :access_token, default_attributes.merge(application: FactoryBot.create(:application))
-        AccessToken.revoke_all_for application.id, resource_owner
-        expect(AccessToken.all).not_to be_empty
-      end
-
-      it 'matches resource owner' do
-        FactoryBot.create :access_token, default_attributes.merge(resource_owner_id: 90)
-        AccessToken.revoke_all_for application.id, resource_owner
-        expect(AccessToken.all).not_to be_empty
-      end
-    end
-
-    describe '.matching_token_for' do
-      let(:resource_owner_id) { 100 }
-      let(:application)       { FactoryBot.create :application }
-      let(:scopes) { Doorkeeper::OAuth::Scopes.from_string('public write') }
-      let(:default_attributes) do
-        {
-          application: application,
-          resource_owner_id: resource_owner_id,
-          scopes: scopes.to_s
-        }
-      end
-
-      it 'returns only one token' do
-        token = FactoryBot.create :access_token, default_attributes
-        last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        expect(last_token).to eq(token)
-      end
-
-      it 'accepts resource owner as object' do
-        resource_owner = double(to_key: true, id: 100)
-        token = FactoryBot.create :access_token, default_attributes
-        last_token = AccessToken.matching_token_for(application, resource_owner, scopes)
-        expect(last_token).to eq(token)
-      end
-
-      it 'accepts nil as resource owner' do
-        token = FactoryBot.create :access_token, default_attributes.merge(resource_owner_id: nil)
-        last_token = AccessToken.matching_token_for(application, nil, scopes)
-        expect(last_token).to eq(token)
-      end
-
-      it 'excludes revoked tokens' do
-        FactoryBot.create :access_token, default_attributes.merge(revoked_at: 1.day.ago)
-        last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        expect(last_token).to be_nil
-      end
-
-      it 'matches the application' do
-        FactoryBot.create :access_token, default_attributes.merge(application: FactoryBot.create(:application))
-        last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        expect(last_token).to be_nil
-      end
-
-      it 'matches the resource owner' do
-        FactoryBot.create :access_token, default_attributes.merge(resource_owner_id: 2)
-        last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        expect(last_token).to be_nil
-      end
-
-      it 'matches token with fewer scopes' do
-        FactoryBot.create :access_token, default_attributes.merge(scopes: 'public')
-        last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        expect(last_token).to be_nil
-      end
-
-      it 'matches token with different scopes' do
-        FactoryBot.create :access_token, default_attributes.merge(scopes: 'public email')
-        last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        expect(last_token).to be_nil
-      end
-
-      it 'matches token with more scopes' do
-        FactoryBot.create :access_token, default_attributes.merge(scopes: 'public write email')
-        last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        expect(last_token).to be_nil
-      end
-
-      it 'matches application scopes' do
-        application = FactoryBot.create :application, scopes: "private read"
-        FactoryBot.create :access_token, default_attributes.merge(
-          application: application
-        )
-        last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        expect(last_token).to be_nil
-      end
-
-      it 'returns the last created token' do
-        FactoryBot.create :access_token, default_attributes.merge(created_at: 1.day.ago)
-        token = FactoryBot.create :access_token, default_attributes
-        last_token = AccessToken.matching_token_for(application, resource_owner_id, scopes)
-        expect(last_token).to eq(token)
-      end
-
-      it 'returns as_json hash' do
-        token = FactoryBot.create :access_token, default_attributes
-        token_hash = {
-          resource_owner_id:  token.resource_owner_id,
-          scopes:             token.scopes,
-          expires_in_seconds: token.expires_in_seconds,
-          application:        { uid: token.application.uid },
-          created_at:         token.created_at.to_i,
-        }
-        expect(token.as_json).to eq token_hash
-      end
-    end
-
-  end
-end