doorkeeper 5.1.0.rc2 → 5.1.0

data/spec/lib/oauth/client_credentials_integration_spec.rb

@@ -1,13 +1,15 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 module Doorkeeper::OAuth
   describe ClientCredentialsRequest do
     let(:server) { Doorkeeper.configuration }
 
-    context 'with a valid request' do
+    context "with a valid request" do
       let(:client) { FactoryBot.create :application }
 
-      it 'issues an access token' do
+      it "issues an access token" do
         request = ClientCredentialsRequest.new(server, client, {})
         expect do
           request.authorize
@@ -15,8 +17,8 @@ module Doorkeeper::OAuth
       end
     end
 
-    describe 'with an invalid request' do
-      it 'does not issue an access token' do
+    describe "with an invalid request" do
+      it "does not issue an access token" do
         request = ClientCredentialsRequest.new(server, nil, {})
         expect do
           request.authorize

data/spec/lib/oauth/client_credentials_request_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 module Doorkeeper::OAuth
   describe ClientCredentialsRequest do
@@ -10,71 +12,75 @@ module Doorkeeper::OAuth
       )
     end
 
-    let(:application)   { FactoryBot.create(:application, scopes: '') }
+    let(:application)   { FactoryBot.create(:application, scopes: "") }
     let(:client)        { double :client, application: application }
     let(:token_creator) { double :issuer, create: true, token: double }
 
+    before do
+      allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(true)
+    end
+
     subject { ClientCredentialsRequest.new(server, client) }
 
     before do
       subject.issuer = token_creator
     end
 
-    it 'issues an access token for the current client' do
+    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
+    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
+    context "if issue was not created" do
       before do
         subject.issuer = double create: false, error: :invalid
       end
 
-      it 'has an error response' do
+      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
+      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') }
+    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
+      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')
+      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'))
+        expect(token_creator).to receive(:create).with(client, Doorkeeper::OAuth::Scopes.from_string("email"))
         subject.authorize
       end
     end
 
-    context 'with restricted client' do
+    context "with restricted client" do
       let(:default_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string('public email')
+        Doorkeeper::OAuth::Scopes.from_string("public email")
       end
       let(:server_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string('public email phone')
+        Doorkeeper::OAuth::Scopes.from_string("public email phone")
       end
       let(:client_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string('public phone')
+        Doorkeeper::OAuth::Scopes.from_string("public phone")
       end
 
       before do
@@ -85,18 +91,18 @@ module Doorkeeper::OAuth
         allow(client).to receive(:id).and_return(nil)
       end
 
-      it 'delegates the error to issuer if no scope was requested' do
+      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')
+      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')
+        expect(subject.response.token.scopes_string).to eq("phone")
       end
     end
   end

data/spec/lib/oauth/client_spec.rb

@@ -1,34 +1,36 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 module Doorkeeper::OAuth
   describe Client do
     describe :find do
       let(:method) { double }
 
-      it 'finds the client via uid' do
+      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)
+        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
+      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')
+      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(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')
+      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(authenticator).to receive(:call).with("some-uid", "some-secret").and_return(nil)
         expect(Client.authenticate(credentials, authenticator)).to be_nil
       end
     end

data/spec/lib/oauth/code_request_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 module Doorkeeper::OAuth
   describe CodeRequest do
@@ -6,7 +8,7 @@ module Doorkeeper::OAuth
       double(
         :pre_auth,
         client: double(:application, id: 9990),
-        redirect_uri: 'http://tst.com/cb',
+        redirect_uri: "http://tst.com/cb",
         scopes: nil,
         state: nil,
         error: nil,
@@ -22,22 +24,22 @@ module Doorkeeper::OAuth
       CodeRequest.new(pre_auth, owner)
     end
 
-    it 'creates an access grant' do
+    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
+    it "returns a code response" do
       expect(subject.authorize).to be_a(CodeResponse)
     end
 
-    it 'does not create grant when not authorizable' do
+    it "does not create grant when not authorizable" do
       allow(pre_auth).to receive(:authorizable?).and_return(false)
       expect { subject.authorize }.not_to(change { Doorkeeper::AccessGrant.count })
     end
 
-    it 'returns a error response' do
+    it "returns a error response" do
       allow(pre_auth).to receive(:authorizable?).and_return(false)
       expect(subject.authorize).to be_a(ErrorResponse)
     end

data/spec/lib/oauth/code_response_spec.rb

@@ -1,17 +1,19 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+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
+      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',
+              redirect_uri: "http://tst.com/cb",
               state: nil,
-              scopes: Scopes.from_string('public')
+              scopes: Scopes.from_string("public")
             )
           end
 
@@ -24,8 +26,8 @@ module Doorkeeper
 
           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')
+          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

data/spec/lib/oauth/error_response_spec.rb

@@ -1,13 +1,15 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 module Doorkeeper::OAuth
   describe ErrorResponse do
-    describe '#status' do
-      it 'should have a status of bad_request' do
+    describe "#status" do
+      it "should have a status of bad_request" do
         expect(subject.status).to eq(:bad_request)
       end
 
-      it 'should have a status of unauthorized for an invalid_client error' do
+      it "should have a status of unauthorized for an invalid_client error" do
         subject = described_class.new(name: :invalid_client)
 
         expect(subject.status).to eq(:unauthorized)
@@ -15,42 +17,42 @@ module Doorkeeper::OAuth
     end
 
     describe :from_request do
-      it 'has the error 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
+      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
+      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
+    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
+    describe ".body" do
       subject { ErrorResponse.new(name: :some_error, state: :some_state).body }
 
-      describe '#body' do
+      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
+    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' }
+      it { expect(subject).to include "WWW-Authenticate" }
 
       describe "WWW-Authenticate header" do
         subject { error_response.headers["WWW-Authenticate"] }

data/spec/lib/oauth/error_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 module Doorkeeper::OAuth
   describe Error do
@@ -8,7 +10,7 @@ module Doorkeeper::OAuth
     it { expect(subject).to respond_to(:state) }
 
     describe :description do
-      it 'is translated from translation messages' do
+      it "is translated from translation messages" do
         expect(I18n).to receive(:translate).with(
           :some_error,
           scope: %i[doorkeeper errors messages],

data/spec/lib/oauth/forbidden_token_response_spec.rb

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

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

@@ -1,92 +1,94 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 module Doorkeeper::OAuth::Helpers
-  describe ScopeChecker, '.valid?' do
+  describe ScopeChecker, ".valid?" do
     let(:server_scopes) { Doorkeeper::OAuth::Scopes.new }
 
-    it 'is valid if scope is present' do
+    it "is valid if scope is present" do
       server_scopes.add :scope
-      expect(ScopeChecker.valid?(scope_str: 'scope', server_scopes: server_scopes)).to be_truthy
+      expect(ScopeChecker.valid?(scope_str: "scope", server_scopes: server_scopes)).to be_truthy
     end
 
-    it 'is invalid if includes tabs space' do
+    it "is invalid if includes tabs space" do
       expect(ScopeChecker.valid?(scope_str: "\tsomething", server_scopes: server_scopes)).to be_falsey
     end
 
-    it 'is invalid if scope is not present' do
+    it "is invalid if scope is not present" do
       expect(ScopeChecker.valid?(scope_str: nil, server_scopes: server_scopes)).to be_falsey
     end
 
-    it 'is invalid if scope is blank' do
-      expect(ScopeChecker.valid?(scope_str: ' ', server_scopes: server_scopes)).to be_falsey
+    it "is invalid if scope is blank" do
+      expect(ScopeChecker.valid?(scope_str: " ", server_scopes: server_scopes)).to be_falsey
     end
 
-    it 'is invalid if includes return space' do
+    it "is invalid if includes return space" do
       expect(ScopeChecker.valid?(scope_str: "scope\r", server_scopes: server_scopes)).to be_falsey
     end
 
-    it 'is invalid if includes new lines' do
+    it "is invalid if includes new lines" do
       expect(ScopeChecker.valid?(scope_str: "scope\nanother", server_scopes: server_scopes)).to be_falsey
     end
 
-    it 'is invalid if any scope is not included in server scopes' do
-      expect(ScopeChecker.valid?(scope_str: 'scope another', server_scopes: server_scopes)).to be_falsey
+    it "is invalid if any scope is not included in server scopes" do
+      expect(ScopeChecker.valid?(scope_str: "scope another", server_scopes: server_scopes)).to be_falsey
     end
 
-    context 'with application_scopes' do
+    context "with application_scopes" do
       let(:server_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string 'common svr'
+        Doorkeeper::OAuth::Scopes.from_string "common svr"
       end
       let(:application_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string 'app123'
+        Doorkeeper::OAuth::Scopes.from_string "app123"
       end
 
-      it 'is valid if scope is included in the application scope list' do
-        expect(ScopeChecker.valid?(scope_str: 'app123',
+      it "is valid if scope is included in the application scope list" do
+        expect(ScopeChecker.valid?(scope_str: "app123",
                                    server_scopes: server_scopes,
                                    app_scopes: application_scopes)).to be_truthy
       end
 
-      it 'is invalid if any scope is not included in the application' do
-        expect(ScopeChecker.valid?(scope_str: 'svr',
+      it "is invalid if any scope is not included in the application" do
+        expect(ScopeChecker.valid?(scope_str: "svr",
                                    server_scopes: server_scopes,
                                    app_scopes: application_scopes)).to be_falsey
       end
     end
 
-    context 'with grant_type' do
+    context "with grant_type" do
       let(:server_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string 'scope1 scope2'
+        Doorkeeper::OAuth::Scopes.from_string "scope1 scope2"
       end
 
-      context 'with scopes_by_grant_type not configured for grant_type' do
-        it 'is valid if the scope is in server scopes' do
-          expect(ScopeChecker.valid?(scope_str: 'scope1',
+      context "with scopes_by_grant_type not configured for grant_type" do
+        it "is valid if the scope is in server scopes" do
+          expect(ScopeChecker.valid?(scope_str: "scope1",
                                      server_scopes: server_scopes,
                                      grant_type: Doorkeeper::OAuth::PASSWORD)).to be_truthy
         end
 
-        it 'is invalid if the scope is not in server scopes' do
-          expect(ScopeChecker.valid?(scope_str: 'unknown',
+        it "is invalid if the scope is not in server scopes" do
+          expect(ScopeChecker.valid?(scope_str: "unknown",
                                      server_scopes: server_scopes,
                                      grant_type: Doorkeeper::OAuth::PASSWORD)).to be_falsey
         end
       end
 
-      context 'when scopes_by_grant_type configured for grant_type' do
+      context "when scopes_by_grant_type configured for grant_type" do
         before do
-          allow(Doorkeeper.configuration).to receive(:scopes_by_grant_type).
-            and_return(password: [:scope1])
+          allow(Doorkeeper.configuration).to receive(:scopes_by_grant_type)
+            .and_return(password: [:scope1])
         end
 
-        it 'is valid if the scope is permitted for grant_type' do
-          expect(ScopeChecker.valid?(scope_str: 'scope1',
+        it "is valid if the scope is permitted for grant_type" do
+          expect(ScopeChecker.valid?(scope_str: "scope1",
                                      server_scopes: server_scopes,
                                      grant_type: Doorkeeper::OAuth::PASSWORD)).to be_truthy
         end
 
-        it 'is invalid if the scope is permitted for grant_type' do
-          expect(ScopeChecker.valid?(scope_str: 'scope2',
+        it "is invalid if the scope is permitted for grant_type" do
+          expect(ScopeChecker.valid?(scope_str: "scope2",
                                      server_scopes: server_scopes,
                                      grant_type: Doorkeeper::OAuth::PASSWORD)).to be_falsey
         end