doorkeeper 4.4.3 → 5.5.2

data/spec/lib/oauth/base_request_spec.rb

@@ -1,155 +0,0 @@
-require 'spec_helper_integration'
-
-module Doorkeeper::OAuth
-  describe BaseRequest do
-    let(:access_token) do
-      double :access_token,
-        token:              "some-token",
-        expires_in:         "3600",
-        expires_in_seconds: "300",
-        scopes_string:      "two scopes",
-        refresh_token:      "some-refresh-token",
-        token_type:         "bearer",
-        created_at:         0
-    end
-
-    let(:client) { double :client, id: '1' }
-
-    let(:scopes_array) { %w[public write] }
-
-    let(:server) do
-      double :server,
-        access_token_expires_in: 100,
-        custom_access_token_expires_in: ->(_) { nil },
-        refresh_token_enabled?: false
-    end
-
-    subject do
-      BaseRequest.new
-    end
-
-    describe "#authorize" do
-      before do
-        allow(subject).to receive(:access_token).and_return(access_token)
-      end
-
-      it "validates itself" do
-        expect(subject).to receive(:validate).once
-        subject.authorize
-      end
-
-      context "valid" do
-        before do
-          allow(subject).to receive(:valid?).and_return(true)
-        end
-
-        it "calls callback methods" do
-          expect(subject).to receive(:before_successful_response).once
-          expect(subject).to receive(:after_successful_response).once
-          subject.authorize
-        end
-
-        it "returns a TokenResponse object" do
-          result = subject.authorize
-
-          expect(result).to be_an_instance_of(TokenResponse)
-          expect(result.body).to eq(
-            TokenResponse.new(access_token).body
-          )
-        end
-      end
-
-      context "invalid" do
-        before do
-          allow(subject).to receive(:valid?).and_return(false)
-          allow(subject).to receive(:error).and_return("server_error")
-          allow(subject).to receive(:state).and_return("hello")
-        end
-
-        it "returns an ErrorResponse object" do
-          error_description = I18n.translate(
-            "server_error",
-            scope: %i[doorkeeper errors messages]
-          )
-
-          result = subject.authorize
-
-          expect(result).to be_an_instance_of(ErrorResponse)
-
-          expect(result.body).to eq(
-            error: "server_error",
-            error_description: error_description,
-            state: "hello"
-          )
-        end
-      end
-    end
-
-    describe "#default_scopes" do
-      it "delegates to the server" do
-        expect(subject).to receive(:server).and_return(server).once
-        expect(server).to receive(:default_scopes).once
-
-        subject.default_scopes
-      end
-    end
-
-    describe "#find_or_create_access_token" do
-      it "returns an instance of AccessToken" do
-        result = subject.find_or_create_access_token(
-          client,
-          "1",
-          "public",
-          server
-        )
-
-        expect(result).to be_an_instance_of(Doorkeeper::AccessToken)
-      end
-    end
-
-    describe "#scopes" do
-      context "@original_scopes is present" do
-        before do
-          subject.instance_variable_set(:@original_scopes, "public write")
-        end
-
-        it "returns array of @original_scopes" do
-          result = subject.scopes
-
-          expect(result).to eq(scopes_array)
-        end
-      end
-
-      context "@original_scopes is not present" do
-        before do
-          subject.instance_variable_set(:@original_scopes, "")
-        end
-
-        it "calls #default_scopes" do
-          allow(subject).to receive(:server).and_return(server).once
-          allow(server).to receive(:default_scopes).and_return(scopes_array).once
-
-          result = subject.scopes
-
-          expect(result).to eq(scopes_array)
-        end
-      end
-    end
-
-    describe "#valid?" do
-      context "error is nil" do
-        it "returns true" do
-          allow(subject).to receive(:error).and_return(nil).once
-          expect(subject.valid?).to eq(true)
-        end
-      end
-
-      context "error is not nil" do
-        it "returns false" do
-          allow(subject).to receive(:error).and_return(Object.new).once
-          expect(subject.valid?).to eq(false)
-        end
-      end
-    end
-  end
-end

data/spec/lib/oauth/base_response_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper_integration'
-
-module Doorkeeper::OAuth
-  describe BaseResponse do
-    subject do
-      BaseResponse.new
-    end
-
-    describe "#body" do
-      it "returns an empty Hash" do
-        expect(subject.body).to eq({})
-      end
-    end
-
-    describe "#description" do
-      it "returns an empty String" do
-        expect(subject.description).to eq("")
-      end
-    end
-
-    describe "#headers" do
-      it "returns an empty Hash" do
-        expect(subject.headers).to eq({})
-      end
-    end
-
-    describe "#redirectable?" do
-      it "returns false" do
-        expect(subject.redirectable?).to eq(false)
-      end
-    end
-
-    describe "#redirect_uri" do
-      it "returns an empty String" do
-        expect(subject.redirect_uri).to eq("")
-      end
-    end
-
-    describe "#status" do
-      it "returns :ok" do
-        expect(subject.status).to eq(:ok)
-      end
-    end
-  end
-end

data/spec/lib/oauth/client/credentials_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-require 'active_support/core_ext/string'
-require 'doorkeeper/oauth/client'
-
-class Doorkeeper::OAuth::Client
-  describe Credentials do
-    let(:client_id) { 'some-uid' }
-    let(:client_secret) { 'some-secret' }
-
-    it 'is blank when the uid in credentials is blank' do
-      expect(Credentials.new(nil, nil)).to be_blank
-      expect(Credentials.new(nil, 'something')).to be_blank
-      expect(Credentials.new('something', nil)).to be_present
-      expect(Credentials.new('something', 'something')).to be_present
-    end
-
-    describe :from_request do
-      let(:request) { double.as_null_object }
-
-      let(:method) do
-        ->(_request) { return 'uid', 'secret' }
-      end
-
-      it 'accepts anything that responds to #call' do
-        expect(method).to receive(:call).with(request)
-        Credentials.from_request request, method
-      end
-
-      it 'delegates methods received as symbols to Credentials class' do
-        expect(Credentials).to receive(:from_params).with(request)
-        Credentials.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)
-        Credentials.from_request request, ->(_) {}, method, not_called_method
-      end
-
-      it 'returns new Credentials' do
-        credentials = Credentials.from_request request, method
-        expect(credentials).to be_a(Credentials)
-      end
-
-      it 'returns uid and secret from extractor method' do
-        credentials = Credentials.from_request request, method
-        expect(credentials.uid).to    eq('uid')
-        expect(credentials.secret).to eq('secret')
-      end
-    end
-
-    describe :from_params do
-      it 'returns credentials from parameters when Authorization header is not available' do
-        request     = double parameters: { client_id: client_id, client_secret: client_secret }
-        uid, secret = Credentials.from_params(request)
-
-        expect(uid).to    eq('some-uid')
-        expect(secret).to eq('some-secret')
-      end
-
-      it 'is blank when there are no credentials' do
-        request     = double parameters: {}
-        uid, secret = Credentials.from_params(request)
-
-        expect(uid).to    be_blank
-        expect(secret).to be_blank
-      end
-    end
-
-    describe :from_basic do
-      let(:credentials) { Base64.encode64("#{client_id}:#{client_secret}") }
-
-      it 'decodes the credentials' do
-        request     = double authorization: "Basic #{credentials}"
-        uid, secret = Credentials.from_basic(request)
-
-        expect(uid).to    eq('some-uid')
-        expect(secret).to eq('some-secret')
-      end
-
-      it 'is blank if Authorization is not Basic' do
-        request     = double authorization: "#{credentials}"
-        uid, secret = Credentials.from_basic(request)
-
-        expect(uid).to    be_blank
-        expect(secret).to be_blank
-      end
-    end
-  end
-end

data/spec/lib/oauth/client_credentials/creator_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper_integration'
-
-class Doorkeeper::OAuth::ClientCredentialsRequest
-  describe Creator do
-    let(:client) { FactoryBot.create :application }
-    let(:scopes) { Doorkeeper::OAuth::Scopes.from_string('public') }
-
-    it 'creates a new token' do
-      expect do
-        subject.call(client, scopes)
-      end.to change { Doorkeeper::AccessToken.count }.by(1)
-    end
-
-    context "when reuse_access_token is true" do
-      it "returns the existing valid token" do
-        allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(true)
-        existing_token = subject.call(client, scopes)
-
-        result = subject.call(client, scopes)
-
-        expect(Doorkeeper::AccessToken.count).to eq(1)
-        expect(result).to eq(existing_token)
-      end
-    end
-
-    context "when reuse_access_token is false" do
-      it "returns a new token" do
-        allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(false)
-        existing_token = subject.call(client, scopes)
-
-        result = subject.call(client, scopes)
-
-        expect(Doorkeeper::AccessToken.count).to eq(2)
-        expect(result).not_to eq(existing_token)
-      end
-    end
-
-    it 'returns false if creation fails' do
-      expect(Doorkeeper::AccessToken).to receive(:find_or_create_for).and_return(false)
-      created = subject.call(client, scopes)
-      expect(created).to be_falsey
-    end
-  end
-end

data/spec/lib/oauth/client_credentials/issuer_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-require 'active_support/all'
-require 'doorkeeper/oauth/client_credentials/issuer'
-
-class Doorkeeper::OAuth::ClientCredentialsRequest
-  describe Issuer do
-    let(:creator) { double :acces_token_creator }
-    let(:server) do
-      double(
-        :server,
-        access_token_expires_in: 100,
-        custom_access_token_expires_in: ->(_app) { nil }
-      )
-    end
-    let(:validation) { double :validation, valid?: true }
-
-    subject { Issuer.new(server, validation) }
-
-    describe :create do
-      let(:client) { double :client, id: 'some-id' }
-      let(:scopes) { 'some scope' }
-
-      it 'creates and sets the token' do
-        expect(creator).to receive(:call).and_return('token')
-        subject.create client, scopes, creator
-
-        expect(subject.token).to eq('token')
-      end
-
-      it 'creates with correct token parameters' do
-        expect(creator).to receive(:call).with(
-          client,
-          scopes,
-          expires_in: 100,
-          use_refresh_token: false
-        )
-
-        subject.create client, scopes, creator
-      end
-
-      it 'has error set to :server_error if creator fails' do
-        expect(creator).to receive(:call).and_return(false)
-        subject.create client, scopes, creator
-
-        expect(subject.error).to eq(:server_error)
-      end
-
-      context 'when validation fails' do
-        before do
-          allow(validation).to receive(:valid?).and_return(false)
-          allow(validation).to receive(:error).and_return(:validation_error)
-          expect(creator).not_to receive(:create)
-        end
-
-        it 'has error set from validation' do
-          subject.create client, scopes, creator
-          expect(subject.error).to eq(:validation_error)
-        end
-
-        it 'returns false' do
-          expect(subject.create(client, scopes, creator)).to be_falsey
-        end
-      end
-
-      context 'with custom expirations' do
-        let(:custom_ttl) { 1233 }
-        let(:server) do
-          double(
-            :server,
-            custom_access_token_expires_in: ->(_app) { custom_ttl }
-          )
-        end
-
-        it 'creates with correct token parameters' do
-          expect(creator).to receive(:call).with(
-            client,
-            scopes,
-            expires_in: custom_ttl,
-            use_refresh_token: false
-          )
-          subject.create client, scopes, creator
-        end
-      end
-    end
-  end
-end

data/spec/lib/oauth/client_credentials/validation_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'active_support/all'
-require 'doorkeeper/oauth/client_credentials/validation'
-
-class Doorkeeper::OAuth::ClientCredentialsRequest
-  describe Validation do
-    let(:server)      { double :server, scopes: nil }
-    let(:application) { double scopes: nil }
-    let(:client)      { double application: application }
-    let(:request)     { double :request, client: client, scopes: nil }
-
-    subject { Validation.new(server, request) }
-
-    it 'is valid with valid request' do
-      expect(subject).to be_valid
-    end
-
-    it 'is invalid when client is not present' do
-      allow(request).to receive(:client).and_return(nil)
-      expect(subject).not_to be_valid
-    end
-
-    context 'with scopes' do
-      it 'is invalid when scopes are not included in the server' do
-        server_scopes = Doorkeeper::OAuth::Scopes.from_string 'email'
-        allow(server).to receive(:scopes).and_return(server_scopes)
-        allow(request).to receive(:scopes).and_return(
-          Doorkeeper::OAuth::Scopes.from_string 'invalid')
-        expect(subject).not_to be_valid
-      end
-
-      context 'with application scopes' do
-        it 'is valid when scopes are included in the application' do
-          application_scopes = Doorkeeper::OAuth::Scopes.from_string 'app'
-          server_scopes = Doorkeeper::OAuth::Scopes.from_string 'email app'
-          allow(application).to receive(:scopes).and_return(application_scopes)
-          allow(server).to receive(:scopes).and_return(server_scopes)
-          allow(request).to receive(:scopes).and_return(application_scopes)
-          expect(subject).to be_valid
-        end
-
-        it 'is invalid when scopes are not included in the application' do
-          application_scopes = Doorkeeper::OAuth::Scopes.from_string 'app'
-          server_scopes = Doorkeeper::OAuth::Scopes.from_string 'email app'
-          allow(application).to receive(:scopes).and_return(application_scopes)
-          allow(server).to receive(:scopes).and_return(server_scopes)
-          allow(request).to receive(:scopes).and_return(
-            Doorkeeper::OAuth::Scopes.from_string 'email')
-          expect(subject).not_to be_valid
-        end
-      end
-    end
-  end
-end