doorkeeper 4.4.3 → 5.5.2

data/spec/lib/doorkeeper_spec.rb

@@ -1,150 +0,0 @@
-require 'spec_helper_integration'
-
-describe Doorkeeper do
-  describe "#authenticate" do
-    let(:request) { double }
-
-    it "calls OAuth::Token#authenticate" do
-      token_strategies = Doorkeeper.configuration.access_token_methods
-
-      expect(Doorkeeper::OAuth::Token).to receive(:authenticate).
-        with(request, *token_strategies)
-
-      Doorkeeper.authenticate(request)
-    end
-
-    it "accepts custom token strategies" do
-      token_strategies = [:first_way, :second_way]
-
-      expect(Doorkeeper::OAuth::Token).to receive(:authenticate).
-        with(request, *token_strategies)
-
-      Doorkeeper.authenticate(request, token_strategies)
-    end
-  end
-
-  describe "#configured?" do
-    after do
-      Doorkeeper.remove_instance_variable(:@config)
-    end
-
-    context "@config is set" do
-      it "returns true" do
-        Doorkeeper.instance_variable_set(:@config, "hi")
-
-        expect(Doorkeeper.configured?).to eq(true)
-      end
-    end
-
-    context "@config is not set" do
-      it "returns false" do
-        Doorkeeper.instance_variable_set(:@config, nil)
-
-        expect(Doorkeeper.configured?).to eq(false)
-      end
-    end
-
-    it "is deprecated" do
-      expect(ActiveSupport::Deprecation).to receive(:warn).
-        with("Method `Doorkeeper#configured?` has been deprecated without replacement.")
-
-      Doorkeeper.configured?
-    end
-  end
-
-  describe "#database_installed?" do
-    before do
-      ["AccessToken", "AccessGrant", "Application"].each do |klass|
-        @original_classes ||= {}
-        @original_classes[klass] = Doorkeeper.const_get(klass)
-        Doorkeeper.send(:remove_const, klass)
-      end
-    end
-
-    after do
-      ["AccessToken", "AccessGrant", "Application"].each do |klass|
-        Doorkeeper.send(:remove_const, klass)
-        Doorkeeper.const_set(klass, @original_classes[klass])
-      end
-    end
-
-    context "all tables exist" do
-      before do
-        klass = double table_exists?: true
-
-        Doorkeeper.const_set(:AccessToken, klass)
-        Doorkeeper.const_set(:AccessGrant, klass)
-        Doorkeeper.const_set(:Application, klass)
-      end
-
-      it "returns true" do
-        expect(Doorkeeper.database_installed?).to eq(true)
-      end
-
-      it "is deprecated" do
-        expect(ActiveSupport::Deprecation).to receive(:warn).
-          with("Method `Doorkeeper#database_installed?` has been deprecated without replacement.")
-
-        Doorkeeper.database_installed?
-      end
-    end
-
-    context "all tables do not exist" do
-      before do
-        klass = double table_exists?: false
-
-        Doorkeeper.const_set(:AccessToken, klass)
-        Doorkeeper.const_set(:AccessGrant, klass)
-        Doorkeeper.const_set(:Application, klass)
-      end
-
-      it "returns false" do
-        expect(Doorkeeper.database_installed?).to eq(false)
-      end
-
-      it "is deprecated" do
-        expect(ActiveSupport::Deprecation).to receive(:warn).
-          with("Method `Doorkeeper#database_installed?` has been deprecated without replacement.")
-
-        Doorkeeper.database_installed?
-      end
-    end
-  end
-
-  describe "#installed?" do
-    context "methods return true" do
-      before do
-        allow(Doorkeeper).to receive(:configured?).and_return(true).once
-        allow(Doorkeeper).to receive(:database_installed?).and_return(true).once
-      end
-
-      it "returns true" do
-        expect(Doorkeeper.installed?).to eq(true)
-      end
-    end
-
-    context "methods return false" do
-      before do
-        allow(Doorkeeper).to receive(:configured?).and_return(false).once
-        allow(Doorkeeper).to receive(:database_installed?).and_return(false).once
-      end
-
-      it "returns false" do
-        expect(Doorkeeper.installed?).to eq(false)
-      end
-    end
-
-    it "is deprecated" do
-      expect(ActiveSupport::Deprecation).to receive(:warn).
-        with("Method `Doorkeeper#configured?` has been deprecated without replacement.")
-
-      expect(ActiveSupport::Deprecation).to receive(:warn).
-        with("Method `Doorkeeper#database_installed?` has been deprecated without replacement.")
-
-      expect(ActiveSupport::Deprecation).to receive(:warn).
-        with("Method `Doorkeeper#installed?` has been deprecated without replacement.")
-
-      Doorkeeper.installed?
-    end
-  end
-end

data/spec/lib/models/expirable_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-require 'active_support/time'
-require 'doorkeeper/models/concerns/expirable'
-
-describe 'Expirable' do
-  subject do
-    Class.new do
-      include Doorkeeper::Models::Expirable
-    end.new
-  end
-
-  before do
-    allow(subject).to receive(:created_at).and_return(1.minute.ago)
-  end
-
-  describe :expired? do
-    it 'is not expired if time has not passed' do
-      allow(subject).to receive(:expires_in).and_return(2.minutes)
-      expect(subject).not_to be_expired
-    end
-
-    it 'is expired if time has passed' do
-      allow(subject).to receive(:expires_in).and_return(10.seconds)
-      expect(subject).to be_expired
-    end
-
-    it 'is not expired if expires_in is not set' do
-      allow(subject).to receive(:expires_in).and_return(nil)
-      expect(subject).not_to be_expired
-    end
-  end
-
-  describe :expires_in_seconds do
-    it 'should return the amount of time remaining until the token is expired' do
-      allow(subject).to receive(:expires_in).and_return(2.minutes)
-      expect(subject.expires_in_seconds).to eq(60)
-    end
-
-    it 'should return 0 when expired' do
-      allow(subject).to receive(:expires_in).and_return(30.seconds)
-      expect(subject.expires_in_seconds).to eq(0)
-    end
-
-    it 'should return nil when expires_in is nil' do
-      allow(subject).to receive(:expires_in).and_return(nil)
-      expect(subject.expires_in_seconds).to be_nil
-    end
-
-  end
-end

data/spec/lib/models/revocable_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-require 'active_support/core_ext/object/blank'
-require 'doorkeeper/models/concerns/revocable'
-
-describe 'Revocable' do
-  subject do
-    Class.new do
-      include Doorkeeper::Models::Revocable
-    end.new
-  end
-
-  describe :revoke do
-    it 'updates :revoked_at attribute with current time' do
-      utc = double utc: double
-      clock = double now: utc
-      expect(subject).to receive(:update_attribute).with(:revoked_at, clock.now.utc)
-      subject.revoke(clock)
-    end
-  end
-
-  describe :revoked? do
-    it 'is revoked if :revoked_at has passed' do
-      allow(subject).to receive(:revoked_at).and_return(Time.now.utc - 1000)
-      expect(subject).to be_revoked
-    end
-
-    it 'is not revoked if :revoked_at has not passed' do
-      allow(subject).to receive(:revoked_at).and_return(Time.now.utc + 1000)
-      expect(subject).not_to be_revoked
-    end
-
-    it 'is not revoked if :revoked_at is not set' do
-      allow(subject).to receive(:revoked_at).and_return(nil)
-      expect(subject).not_to be_revoked
-    end
-  end
-
-  describe :revoke_previous_refresh_token! do
-    it "revokes the previous token if existing, and resets the
-      `previous_refresh_token` attribute" do
-      previous_token = FactoryBot.create(
-        :access_token,
-        refresh_token: "refresh_token"
-      )
-      current_token = FactoryBot.create(
-        :access_token,
-        previous_refresh_token: previous_token.refresh_token
-      )
-
-      expect_any_instance_of(
-        Doorkeeper::AccessToken
-      ).to receive(:revoke).and_call_original
-      current_token.revoke_previous_refresh_token!
-
-      expect(current_token.previous_refresh_token).to be_empty
-      expect(previous_token.reload).to be_revoked
-    end
-  end
-end

data/spec/lib/models/scopes_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/object/blank'
-require 'doorkeeper/oauth/scopes'
-require 'doorkeeper/models/concerns/scopes'
-
-describe 'Doorkeeper::Models::Scopes' do
-  subject do
-    Class.new(Hash) do
-      include Doorkeeper::Models::Scopes
-    end.new
-  end
-
-  before do
-    subject[:scopes] = 'public admin'
-  end
-
-  describe :scopes do
-    it 'is a `Scopes` class' do
-      expect(subject.scopes).to be_a(Doorkeeper::OAuth::Scopes)
-    end
-
-    it 'includes scopes' do
-      expect(subject.scopes).to include('public')
-    end
-  end
-
-  describe :scopes_string do
-    it 'is a `Scopes` class' do
-      expect(subject.scopes_string).to eq('public admin')
-    end
-  end
-
-  describe :includes_scope? do
-    it 'should return true if at least one scope is included' do
-      expect(subject.includes_scope?('public', 'private')).to be true
-    end
-
-    it 'should return false if no scopes are included' do
-      expect(subject.includes_scope?('teacher', 'student')).to be false
-    end
-  end
-end

data/spec/lib/oauth/authorization/uri_builder_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-require 'active_support/core_ext/string'
-require 'uri'
-require 'rack/utils'
-require 'doorkeeper/oauth/authorization/uri_builder'
-
-module Doorkeeper::OAuth::Authorization
-  describe URIBuilder do
-    subject { URIBuilder }
-
-    describe :uri_with_query do
-      it 'returns the uri with query' do
-        uri = subject.uri_with_query 'http://example.com/', parameter: 'value'
-        expect(uri).to eq('http://example.com/?parameter=value')
-      end
-
-      it 'rejects nil values' do
-        uri = subject.uri_with_query 'http://example.com/', parameter: ''
-        expect(uri).to eq('http://example.com/?')
-      end
-
-      it 'preserves original query parameters' do
-        uri = subject.uri_with_query 'http://example.com/?query1=value', parameter: 'value'
-        expect(uri).to match(/query1=value/)
-        expect(uri).to match(/parameter=value/)
-      end
-    end
-
-    describe :uri_with_fragment do
-      it 'returns uri with parameters as fragments' do
-        uri = subject.uri_with_fragment 'http://example.com/', parameter: 'value'
-        expect(uri).to eq('http://example.com/#parameter=value')
-      end
-
-      it 'preserves original query parameters' do
-        uri = subject.uri_with_fragment 'http://example.com/?query1=value1', parameter: 'value'
-        expect(uri).to eq('http://example.com/?query1=value1#parameter=value')
-      end
-    end
-  end
-end

data/spec/lib/oauth/authorization_code_request_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper_integration'
-
-module Doorkeeper::OAuth
-  describe AuthorizationCodeRequest do
-    let(:server) do
-      double :server,
-             access_token_expires_in: 2.days,
-             refresh_token_enabled?: false,
-             custom_access_token_expires_in: ->(_app) { nil }
-    end
-
-    let(:grant)  { FactoryBot.create :access_grant }
-    let(:client) { grant.application }
-    let(:redirect_uri) { client.redirect_uri }
-    let(:params) { { redirect_uri: redirect_uri } }
-
-    subject do
-      AuthorizationCodeRequest.new server, grant, client, params
-    end
-
-    it 'issues a new token for the client' do
-      expect do
-        subject.authorize
-      end.to change { client.reload.access_tokens.count }.by(1)
-    end
-
-    it "issues the token with same grant's scopes" do
-      subject.authorize
-      expect(Doorkeeper::AccessToken.last.scopes).to eq(grant.scopes)
-    end
-
-    it 'revokes the grant' do
-      expect { subject.authorize }.to change { grant.reload.accessible? }
-    end
-
-    it 'requires the grant to be accessible' do
-      grant.revoke
-      subject.validate
-      expect(subject.error).to eq(:invalid_grant)
-    end
-
-    it 'requires the grant' do
-      subject.grant = nil
-      subject.validate
-      expect(subject.error).to eq(:invalid_grant)
-    end
-
-    it 'requires the client' do
-      subject.client = nil
-      subject.validate
-      expect(subject.error).to eq(:invalid_client)
-    end
-
-    it 'requires the redirect_uri' do
-      subject.redirect_uri = nil
-      subject.validate
-      expect(subject.error).to eq(:invalid_request)
-    end
-
-    it "matches the redirect_uri with grant's one" do
-      subject.redirect_uri = 'http://other.com'
-      subject.validate
-      expect(subject.error).to eq(:invalid_grant)
-    end
-
-    it "matches the client with grant's one" do
-      subject.client = FactoryBot.create :application
-      subject.validate
-      expect(subject.error).to eq(:invalid_grant)
-    end
-
-    it 'skips token creation if there is a matching one' do
-      Doorkeeper.configure do
-        orm DOORKEEPER_ORM
-        reuse_access_token
-      end
-
-      FactoryBot.create(:access_token, application_id: client.id,
-        resource_owner_id: grant.resource_owner_id, scopes: grant.scopes.to_s)
-
-      expect { subject.authorize }.to_not change { Doorkeeper::AccessToken.count }
-    end
-
-    it "calls configured request callback methods" do
-      expect(Doorkeeper.configuration.before_successful_strategy_response).to receive(:call).with(subject).once
-      expect(Doorkeeper.configuration.after_successful_strategy_response).to receive(:call).with(subject, instance_of(Doorkeeper::OAuth::TokenResponse)).once
-      subject.authorize
-    end
-
-    context "when redirect_uri contains some query params" do
-      let(:redirect_uri) { client.redirect_uri + "?query=q" }
-
-      it "compares only host part with grant's redirect_uri" do
-        subject.validate
-        expect(subject.error).to eq(nil)
-      end
-    end
-
-    context "when redirect_uri is not an URI" do
-      let(:redirect_uri) { '123d#!s' }
-
-      it "responds with invalid_grant" do
-        subject.validate
-        expect(subject.error).to eq(:invalid_grant)
-      end
-    end
-
-    context "when redirect_uri is the native one" do
-      let(:redirect_uri) { 'urn:ietf:wg:oauth:2.0:oob' }
-
-      it "invalidates when redirect_uri of the grant is not native" do
-        subject.validate
-        expect(subject.error).to eq(:invalid_grant)
-      end
-
-      it "validates when redirect_uri of the grant is also native" do
-        allow(grant).to receive(:redirect_uri) { redirect_uri }
-        subject.validate
-        expect(subject.error).to eq(nil)
-      end
-    end
-  end
-end