doorkeeper 4.2.6 → 5.5.4

data/spec/lib/oauth/client_credentials_request_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-require 'active_support/all'
-require 'active_model'
-require 'doorkeeper/oauth/client_credentials_request'
-
-module Doorkeeper::OAuth
-  describe ClientCredentialsRequest do
-    let(:server) do
-      double(
-        default_scopes: nil,
-        custom_access_token_expires_in: ->(_app) { nil }
-      )
-    end
-    let(:application)   { double :application, scopes: Scopes.from_string('') }
-    let(:client)        { double :client, application: application }
-    let(:token_creator) { double :issuer, create: true, token: double }
-
-    subject { ClientCredentialsRequest.new(server, client) }
-
-    before do
-      subject.issuer = token_creator
-    end
-
-    it 'issues an access token for the current client' do
-      expect(token_creator).to receive(:create).with(client, nil)
-      subject.authorize
-    end
-
-    it 'has successful response when issue was created' do
-      subject.authorize
-      expect(subject.response).to be_a(TokenResponse)
-    end
-
-    context 'if issue was not created' do
-      before do
-        subject.issuer = double create: false, error: :invalid
-      end
-
-      it 'has an error response' do
-        subject.authorize
-        expect(subject.response).to be_a(Doorkeeper::OAuth::ErrorResponse)
-      end
-
-      it 'delegates the error to issuer' do
-        subject.authorize
-        expect(subject.error).to eq(:invalid)
-      end
-    end
-
-    context 'with scopes' do
-      let(:default_scopes) { Doorkeeper::OAuth::Scopes.from_string('public email') }
-
-      before do
-        allow(server).to receive(:default_scopes).and_return(default_scopes)
-      end
-
-      it 'issues an access token with default scopes if none was requested' do
-        expect(token_creator).to receive(:create).with(client, default_scopes)
-        subject.authorize
-      end
-
-      it 'issues an access token with requested scopes' do
-        subject = ClientCredentialsRequest.new(server, client, scope: 'email')
-        subject.issuer = token_creator
-        expect(token_creator).to receive(:create).with(client, Doorkeeper::OAuth::Scopes.from_string('email'))
-        subject.authorize
-      end
-    end
-
-    context 'with restricted client' do
-      let(:default_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string('public email')
-      end
-      let(:server_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string('public email phone')
-      end
-      let(:client_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string('public phone')
-      end
-
-      before do
-        allow(server).to receive(:default_scopes).and_return(default_scopes)
-        allow(server).to receive(:scopes).and_return(server_scopes)
-        allow(server).to receive(:access_token_expires_in).and_return(100)
-        allow(application).to receive(:scopes).and_return(client_scopes)
-        allow(client).to receive(:id).and_return(nil)
-      end
-
-      it 'delegates the error to issuer if no scope was requested' do
-        subject = ClientCredentialsRequest.new(server, client)
-        subject.authorize
-        expect(subject.response).to be_a(Doorkeeper::OAuth::ErrorResponse)
-        expect(subject.error).to eq(:invalid_scope)
-      end
-
-      it 'issues an access token with requested scopes' do
-        subject = ClientCredentialsRequest.new(server, client, scope: 'phone')
-        subject.authorize
-        expect(subject.response).to be_a(Doorkeeper::OAuth::TokenResponse)
-        expect(subject.response.token.scopes_string).to eq('phone')
-      end
-    end
-  end
-end

data/spec/lib/oauth/client_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/string'
-require 'doorkeeper/oauth/client'
-
-module Doorkeeper::OAuth
-  describe Client do
-    describe :find do
-      let(:method) { double }
-
-      it 'finds the client via uid' do
-        client = double
-        expect(method).to receive(:call).with('uid').and_return(client)
-        expect(Client.find('uid', method)).to be_a(Client)
-      end
-
-      it 'returns nil if client was not found' do
-        expect(method).to receive(:call).with('uid').and_return(nil)
-        expect(Client.find('uid', method)).to be_nil
-      end
-    end
-
-    describe :authenticate do
-      it 'returns the authenticated client via credentials' do
-        credentials = Client::Credentials.new('some-uid', 'some-secret')
-        authenticator = double
-        expect(authenticator).to receive(:call).with('some-uid', 'some-secret').and_return(double)
-        expect(Client.authenticate(credentials, authenticator)).to be_a(Client)
-      end
-
-      it 'returns nil if client was not authenticated' do
-        credentials = Client::Credentials.new('some-uid', 'some-secret')
-        authenticator = double
-        expect(authenticator).to receive(:call).with('some-uid', 'some-secret').and_return(nil)
-        expect(Client.authenticate(credentials, authenticator)).to be_nil
-      end
-    end
-  end
-end

data/spec/lib/oauth/code_request_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper_integration'
-
-module Doorkeeper::OAuth
-  describe CodeRequest do
-    let(:pre_auth) do
-      double(
-        :pre_auth,
-        client: double(:application, id: 9990),
-        redirect_uri: 'http://tst.com/cb',
-        scopes: nil,
-        state: nil,
-        error: nil,
-        authorizable?: true
-      )
-    end
-
-    let(:owner) { double :owner, id: 8900 }
-
-    subject do
-      CodeRequest.new(pre_auth, owner)
-    end
-
-    it 'creates an access grant' do
-      expect do
-        subject.authorize
-      end.to change { Doorkeeper::AccessGrant.count }.by(1)
-    end
-
-    it 'returns a code response' do
-      expect(subject.authorize).to be_a(CodeResponse)
-    end
-
-    it 'does not create grant when not authorizable' do
-      allow(pre_auth).to receive(:authorizable?).and_return(false)
-      expect do
-        subject.authorize
-      end.to_not change { Doorkeeper::AccessGrant.count }
-    end
-
-    it 'returns a error response' do
-      allow(pre_auth).to receive(:authorizable?).and_return(false)
-      expect(subject.authorize).to be_a(ErrorResponse)
-    end
-  end
-end

data/spec/lib/oauth/code_response_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-module Doorkeeper
-  module OAuth
-    describe CodeResponse do
-      describe '.redirect_uri' do
-        context 'when generating the redirect URI for an implicit grant' do
-          let :pre_auth do
-            double(
-              :pre_auth,
-              client: double(:application, id: 1),
-              redirect_uri: 'http://tst.com/cb',
-              state: nil,
-              scopes: Scopes.from_string('public'),
-            )
-          end
-
-          let :auth do
-            Authorization::Token.new(pre_auth, double(id: 1)).tap do |c|
-              c.issue_token
-              allow(c.token).to receive(:expires_in_seconds).and_return(3600)
-            end
-          end
-
-          subject { CodeResponse.new(pre_auth, auth, response_on_fragment: true).redirect_uri }
-
-          it 'includes the remaining TTL of the token relative to the time the token was generated' do
-            expect(subject).to include('expires_in=3600')
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/oauth/error_response_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-require 'active_model'
-require 'doorkeeper/oauth/error'
-require 'doorkeeper/oauth/error_response'
-
-module Doorkeeper::OAuth
-  describe ErrorResponse do
-    describe '#status' do
-      it 'should have a status of unauthorized' do
-        expect(subject.status).to eq(:unauthorized)
-      end
-    end
-
-    describe :from_request do
-      it 'has the error from request' do
-        error = ErrorResponse.from_request double(error: :some_error)
-        expect(error.name).to eq(:some_error)
-      end
-
-      it 'ignores state if request does not respond to state' do
-        error = ErrorResponse.from_request double(error: :some_error)
-        expect(error.state).to be_nil
-      end
-
-      it 'has state if request responds to state' do
-        error = ErrorResponse.from_request double(error: :some_error, state: :hello)
-        expect(error.state).to eq(:hello)
-      end
-    end
-
-    it 'ignores empty error values' do
-      subject = ErrorResponse.new(error: :some_error, state: nil)
-      expect(subject.body).not_to have_key(:state)
-    end
-
-    describe '.body' do
-      subject { ErrorResponse.new(name: :some_error, state: :some_state).body }
-
-      describe '#body' do
-        it { expect(subject).to have_key(:error) }
-        it { expect(subject).to have_key(:error_description) }
-        it { expect(subject).to have_key(:state) }
-      end
-    end
-
-    describe '.headers' do
-      let(:error_response) { ErrorResponse.new(name: :some_error, state: :some_state) }
-      subject { error_response.headers }
-
-      it { expect(subject).to include 'WWW-Authenticate' }
-
-      describe "WWW-Authenticate header" do
-        subject { error_response.headers["WWW-Authenticate"] }
-
-        it { expect(subject).to include("realm=\"#{error_response.realm}\"") }
-        it { expect(subject).to include("error=\"#{error_response.name}\"") }
-        it { expect(subject).to include("error_description=\"#{error_response.description}\"") }
-      end
-    end
-  end
-end

data/spec/lib/oauth/error_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-require 'active_support/i18n'
-require 'doorkeeper/oauth/error'
-
-module Doorkeeper::OAuth
-  describe Error do
-    subject(:error) { Error.new(:some_error, :some_state) }
-
-    it { expect(subject).to respond_to(:name) }
-    it { expect(subject).to respond_to(:state) }
-
-    describe :description do
-      it 'is translated from translation messages' do
-        expect(I18n).to receive(:translate).with(
-          :some_error,
-          scope: [:doorkeeper, :errors, :messages],
-          default: :server_error
-        )
-        error.description
-      end
-    end
-  end
-end

data/spec/lib/oauth/forbidden_token_response_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-require 'active_model'
-require 'doorkeeper'
-require 'doorkeeper/oauth/forbidden_token_response'
-
-module Doorkeeper::OAuth
-  describe ForbiddenTokenResponse do
-    describe '#name' do
-      it  { expect(subject.name).to eq(:invalid_scope) }
-    end
-
-    describe '#status' do
-      it { expect(subject.status).to eq(:forbidden) }
-    end
-
-    describe :from_scopes do
-      it 'should have a list of acceptable scopes' do
-        response = ForbiddenTokenResponse.from_scopes(["public"])
-        expect(response.description).to include('public')
-      end
-    end
-  end
-end

data/spec/lib/oauth/helpers/scope_checker_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'active_support/core_ext/string'
-require 'doorkeeper/oauth/helpers/scope_checker'
-require 'doorkeeper/oauth/scopes'
-
-module Doorkeeper::OAuth::Helpers
-  describe ScopeChecker, '.valid?' do
-    let(:server_scopes) { Doorkeeper::OAuth::Scopes.new }
-
-    it 'is valid if scope is present' do
-      server_scopes.add :scope
-      expect(ScopeChecker.valid?('scope', server_scopes)).to be_truthy
-    end
-
-    it 'is invalid if includes tabs space' do
-      expect(ScopeChecker.valid?("\tsomething", server_scopes)).to be_falsey
-    end
-
-    it 'is invalid if scope is not present' do
-      expect(ScopeChecker.valid?(nil, server_scopes)).to be_falsey
-    end
-
-    it 'is invalid if scope is blank' do
-      expect(ScopeChecker.valid?(' ', server_scopes)).to be_falsey
-    end
-
-    it 'is invalid if includes return space' do
-      expect(ScopeChecker.valid?("scope\r", server_scopes)).to be_falsey
-    end
-
-    it 'is invalid if includes new lines' do
-      expect(ScopeChecker.valid?("scope\nanother", server_scopes)).to be_falsey
-    end
-
-    it 'is invalid if any scope is not included in server scopes' do
-      expect(ScopeChecker.valid?('scope another', server_scopes)).to be_falsey
-    end
-
-    context 'with application_scopes' do
-      let(:server_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string 'common svr'
-      end
-      let(:application_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string 'app123'
-      end
-
-      it 'is valid if scope is included in the application scope list' do
-        expect(ScopeChecker.valid?(
-          'app123',
-          server_scopes,
-          application_scopes
-        )).to be_truthy
-      end
-
-      it 'is invalid if any scope is not included in the application' do
-        expect(ScopeChecker.valid?(
-          'svr',
-          server_scopes,
-          application_scopes
-        )).to be_falsey
-      end
-    end
-  end
-end

data/spec/lib/oauth/helpers/unique_token_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'doorkeeper/oauth/helpers/unique_token'
-
-module Doorkeeper::OAuth::Helpers
-  describe UniqueToken do
-    let :generator do
-      ->(size) { 'a' * size }
-    end
-
-    it 'is able to customize the generator method' do
-      token = UniqueToken.generate(generator: generator)
-      expect(token).to eq('a' * 32)
-    end
-
-    it 'is able to customize the size of the token' do
-      token = UniqueToken.generate(generator: generator, size: 2)
-      expect(token).to eq('aa')
-    end
-  end
-end

data/spec/lib/oauth/helpers/uri_checker_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-require 'uri'
-require 'doorkeeper/oauth/helpers/uri_checker'
-
-module Doorkeeper::OAuth::Helpers
-  describe URIChecker do
-    describe '.valid?' do
-      it 'is valid for valid uris' do
-        uri = 'http://app.co'
-        expect(URIChecker.valid?(uri)).to be_truthy
-      end
-
-      it 'is valid if include path param' do
-        uri = 'http://app.co/path'
-        expect(URIChecker.valid?(uri)).to be_truthy
-      end
-
-      it 'is valid if include query param' do
-        uri = 'http://app.co/?query=1'
-        expect(URIChecker.valid?(uri)).to be_truthy
-      end
-
-      it 'is invalid if uri includes fragment' do
-        uri = 'http://app.co/test#fragment'
-        expect(URIChecker.valid?(uri)).to be_falsey
-      end
-
-      it 'is invalid if scheme is missing' do
-        uri = 'app.co'
-        expect(URIChecker.valid?(uri)).to be_falsey
-      end
-
-      it 'is invalid if is a relative uri' do
-        uri = '/abc/123'
-        expect(URIChecker.valid?(uri)).to be_falsey
-      end
-
-      it 'is invalid if is not a url' do
-        uri = 'http://'
-        expect(URIChecker.valid?(uri)).to be_falsey
-      end
-    end
-
-    describe '.matches?' do
-      it 'is true if both url matches' do
-        uri = client_uri = 'http://app.co/aaa'
-        expect(URIChecker.matches?(uri, client_uri)).to be_truthy
-      end
-
-      it 'ignores query parameter on comparsion' do
-        uri = 'http://app.co/?query=hello'
-        client_uri = 'http://app.co'
-        expect(URIChecker.matches?(uri, client_uri)).to be_truthy
-      end
-
-      it 'doesn\'t allow non-matching domains through' do
-        uri = 'http://app.abc/?query=hello'
-        client_uri = 'http://app.co'
-        expect(URIChecker.matches?(uri, client_uri)).to be_falsey
-      end
-
-      it 'doesn\'t allow non-matching domains that don\'t start at the beginning' do
-        uri = 'http://app.co/?query=hello'
-        client_uri = 'http://example.com?app.co=test'
-        expect(URIChecker.matches?(uri, client_uri)).to be_falsey
-      end
-    end
-
-    describe '.valid_for_authorization?' do
-      it 'is true if valid and matches' do
-        uri = client_uri = 'http://app.co/aaa'
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_truthy
-      end
-
-      it 'is false if valid and mismatches' do
-        uri = 'http://app.co/aaa'
-        client_uri = 'http://app.co/bbb'
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_falsey
-      end
-
-      it 'is true if valid and included in array' do
-        uri = 'http://app.co/aaa'
-        client_uri = "http://example.com/bbb\nhttp://app.co/aaa"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_truthy
-      end
-
-      it 'is false if valid and not included in array' do
-        uri = 'http://app.co/aaa'
-        client_uri = "http://example.com/bbb\nhttp://app.co/cc"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_falsey
-      end
-
-      it 'is true if valid and matches' do
-        uri = client_uri = 'http://app.co/aaa'
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be true
-      end
-
-      it 'is false if invalid' do
-        uri = client_uri = 'http://app.co/aaa?waffles=abc'
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be false
-      end
-    end
-  end
-end

data/spec/lib/oauth/invalid_token_response_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-require 'active_model'
-require 'doorkeeper'
-require 'doorkeeper/oauth/invalid_token_response'
-
-module Doorkeeper::OAuth
-  describe InvalidTokenResponse do
-    describe "#name" do
-      it  { expect(subject.name).to eq(:invalid_token) }
-    end
-
-    describe "#status" do
-      it { expect(subject.status).to eq(:unauthorized) }
-    end
-
-    describe :from_access_token do
-      let(:response) { InvalidTokenResponse.from_access_token(access_token) }
-
-      context "revoked" do
-        let(:access_token) { double(revoked?: true, expired?: true) }
-
-        it "sets a description" do
-          expect(response.description).to include("revoked")
-        end
-
-        it "sets the reason" do
-          expect(response.reason).to eq(:revoked)
-        end
-      end
-
-      context "expired" do
-        let(:access_token) { double(revoked?: false, expired?: true) }
-
-        it "sets a description" do
-          expect(response.description).to include("expired")
-        end
-
-        it "sets the reason" do
-          expect(response.reason).to eq(:expired)
-        end
-      end
-
-      context "unkown" do
-        let(:access_token) { double(revoked?: false, expired?: false) }
-
-        it "sets a description" do
-          expect(response.description).to include("invalid")
-        end
-
-        it "sets the reason" do
-          expect(response.reason).to eq(:unknown)
-        end
-      end
-    end
-  end
-end

data/spec/lib/oauth/password_access_token_request_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper_integration'
-
-module Doorkeeper::OAuth
-  describe PasswordAccessTokenRequest do
-    let(:server) do
-      double(
-        :server,
-        default_scopes: Doorkeeper::OAuth::Scopes.new,
-        access_token_expires_in: 2.hours,
-        refresh_token_enabled?: false,
-        custom_access_token_expires_in: ->(_app) { nil }
-      )
-    end
-    let(:client) { FactoryGirl.create(:application) }
-    let(:owner)  { double :owner, id: 99 }
-
-    subject do
-      PasswordAccessTokenRequest.new(server, client, owner)
-    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 a new token without a client' do
-      expect do
-        subject.client = nil
-        subject.authorize
-      end.to change { Doorkeeper::AccessToken.count }.by(1)
-    end
-
-    it 'does not issue a new token with an invalid client' do
-      expect do
-        subject.client = nil
-        subject.parameters = { client_id: 'bad_id' }
-        subject.authorize
-      end.to_not change { Doorkeeper::AccessToken.count }
-
-      expect(subject.error).to eq(:invalid_client)
-    end
-
-    it 'requires the owner' do
-      subject.resource_owner = nil
-      subject.validate
-      expect(subject.error).to eq(:invalid_grant)
-    end
-
-    it 'optionally accepts the client' do
-      subject.client = nil
-      expect(subject).to be_valid
-    end
-
-    it 'creates token even when there is already one (default)' do
-      FactoryGirl.create(:access_token, application_id: client.id, resource_owner_id: owner.id)
-      expect do
-        subject.authorize
-      end.to change { Doorkeeper::AccessToken.count }.by(1)
-    end
-
-    it 'skips token creation if there is already one' do
-      allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(true)
-      FactoryGirl.create(:access_token, application_id: client.id, resource_owner_id: owner.id)
-      expect do
-        subject.authorize
-      end.to_not change { Doorkeeper::AccessToken.count }
-    end
-
-    describe 'with scopes' do
-      subject do
-        PasswordAccessTokenRequest.new(server, client, owner, scope: 'public')
-      end
-
-      it 'validates the current scope' do
-        allow(server).to receive(:scopes).and_return(Doorkeeper::OAuth::Scopes.from_string('another'))
-        subject.validate
-        expect(subject.error).to eq(:invalid_scope)
-      end
-
-      it 'creates the token with scopes' do
-        allow(server).to receive(:scopes).and_return(Doorkeeper::OAuth::Scopes.from_string('public'))
-        expect do
-          subject.authorize
-        end.to change { Doorkeeper::AccessToken.count }.by(1)
-        expect(Doorkeeper::AccessToken.last.scopes).to include('public')
-      end
-    end
-  end
-end