doorkeeper 5.0.3 → 5.1.0

data/spec/lib/oauth/scopes_spec.rb

@@ -1,113 +1,115 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 module Doorkeeper::OAuth
   describe Scopes do
-    describe '#add' do
-      it 'allows you to add scopes with symbols' do
+    describe "#add" do
+      it "allows you to add scopes with symbols" do
         subject.add :public
-        expect(subject.all).to eq(['public'])
+        expect(subject.all).to eq(["public"])
       end
 
-      it 'allows you to add scopes with strings' do
-        subject.add 'public'
-        expect(subject.all).to eq(['public'])
+      it "allows you to add scopes with strings" do
+        subject.add "public"
+        expect(subject.all).to eq(["public"])
       end
 
-      it 'do not add already included scopes' do
+      it "do not add already included scopes" do
         subject.add :public
         subject.add :public
-        expect(subject.all).to eq(['public'])
+        expect(subject.all).to eq(["public"])
       end
     end
 
-    describe '#exists' do
+    describe "#exists" do
       before do
         subject.add :public
       end
 
-      it 'returns true if scope with given name is present' do
-        expect(subject.exists?('public')).to be_truthy
+      it "returns true if scope with given name is present" do
+        expect(subject.exists?("public")).to be_truthy
       end
 
-      it 'returns false if scope with given name does not exist' do
-        expect(subject.exists?('other')).to be_falsey
+      it "returns false if scope with given name does not exist" do
+        expect(subject.exists?("other")).to be_falsey
       end
 
-      it 'handles symbols' do
+      it "handles symbols" do
         expect(subject.exists?(:public)).to be_truthy
         expect(subject.exists?(:other)).to be_falsey
       end
     end
 
-    describe '.from_string' do
-      let(:string) { 'public write' }
+    describe ".from_string" do
+      let(:string) { "public write" }
 
       subject { Scopes.from_string(string) }
 
       it { expect(subject).to be_a(Scopes) }
 
-      describe '#all' do
-        it 'should be an array of the expected scopes' do
+      describe "#all" do
+        it "should be an array of the expected scopes" do
           scopes_array = subject.all
           expect(scopes_array.size).to eq(2)
-          expect(scopes_array).to include('public')
-          expect(scopes_array).to include('write')
+          expect(scopes_array).to include("public")
+          expect(scopes_array).to include("write")
         end
       end
     end
 
-    describe '#+' do
-      it 'can add to another scope object' do
-        scopes = Scopes.from_string('public') + Scopes.from_string('admin')
+    describe "#+" do
+      it "can add to another scope object" do
+        scopes = Scopes.from_string("public") + Scopes.from_string("admin")
         expect(scopes.all).to eq(%w[public admin])
       end
 
-      it 'does not change the existing object' do
-        origin = Scopes.from_string('public')
-        expect(origin.to_s).to eq('public')
+      it "does not change the existing object" do
+        origin = Scopes.from_string("public")
+        expect(origin.to_s).to eq("public")
       end
 
-      it 'can add an array to a scope object' do
-        scopes = Scopes.from_string('public') + ['admin']
+      it "can add an array to a scope object" do
+        scopes = Scopes.from_string("public") + ["admin"]
         expect(scopes.all).to eq(%w[public admin])
       end
 
-      it 'raises an error if cannot handle addition' do
+      it "raises an error if cannot handle addition" do
         expect do
-          Scopes.from_string('public') + 'admin'
+          Scopes.from_string("public") + "admin"
         end.to raise_error(NoMethodError)
       end
     end
 
-    describe '#&' do
-      it 'can get intersection with another scope object' do
-        scopes = Scopes.from_string('public admin') & Scopes.from_string('write admin')
+    describe "#&" do
+      it "can get intersection with another scope object" do
+        scopes = Scopes.from_string("public admin") & Scopes.from_string("write admin")
         expect(scopes.all).to eq(%w[admin])
       end
 
-      it 'does not change the existing object' do
-        origin = Scopes.from_string('public admin')
-        origin & Scopes.from_string('write admin')
-        expect(origin.to_s).to eq('public admin')
+      it "does not change the existing object" do
+        origin = Scopes.from_string("public admin")
+        origin & Scopes.from_string("write admin")
+        expect(origin.to_s).to eq("public admin")
       end
 
-      it 'can get intersection with an array' do
-        scopes = Scopes.from_string('public admin') & %w[write admin]
+      it "can get intersection with an array" do
+        scopes = Scopes.from_string("public admin") & %w[write admin]
         expect(scopes.all).to eq(%w[admin])
       end
     end
 
-    describe '#==' do
-      it 'is equal to another set of scopes' do
-        expect(Scopes.from_string('public')).to eq(Scopes.from_string('public'))
+    describe "#==" do
+      it "is equal to another set of scopes" do
+        expect(Scopes.from_string("public")).to eq(Scopes.from_string("public"))
       end
 
-      it 'is equal to another set of scopes with no particular order' do
-        expect(Scopes.from_string('public write')).to eq(Scopes.from_string('write public'))
+      it "is equal to another set of scopes with no particular order" do
+        expect(Scopes.from_string("public write")).to eq(Scopes.from_string("write public"))
       end
 
-      it 'differs from another set of scopes when scopes are not the same' do
-        expect(Scopes.from_string('public write')).not_to eq(Scopes.from_string('write'))
+      it "differs from another set of scopes when scopes are not the same" do
+        expect(Scopes.from_string("public write")).not_to eq(Scopes.from_string("write"))
       end
 
       it "does not raise an error when compared to a non-enumerable object" do
@@ -115,31 +117,31 @@ module Doorkeeper::OAuth
       end
     end
 
-    describe '#has_scopes?' do
-      subject { Scopes.from_string('public admin') }
+    describe "#has_scopes?" do
+      subject { Scopes.from_string("public admin") }
 
-      it 'returns true when at least one scope is included' do
-        expect(subject.has_scopes?(Scopes.from_string('public'))).to be_truthy
+      it "returns true when at least one scope is included" do
+        expect(subject.has_scopes?(Scopes.from_string("public"))).to be_truthy
       end
 
-      it 'returns true when all scopes are included' do
-        expect(subject.has_scopes?(Scopes.from_string('public admin'))).to be_truthy
+      it "returns true when all scopes are included" do
+        expect(subject.has_scopes?(Scopes.from_string("public admin"))).to be_truthy
       end
 
-      it 'is true if all scopes are included in any order' do
-        expect(subject.has_scopes?(Scopes.from_string('admin public'))).to be_truthy
+      it "is true if all scopes are included in any order" do
+        expect(subject.has_scopes?(Scopes.from_string("admin public"))).to be_truthy
       end
 
-      it 'is false if no scopes are included' do
-        expect(subject.has_scopes?(Scopes.from_string('notexistent'))).to be_falsey
+      it "is false if no scopes are included" do
+        expect(subject.has_scopes?(Scopes.from_string("notexistent"))).to be_falsey
       end
 
-      it 'returns false when any scope is not included' do
-        expect(subject.has_scopes?(Scopes.from_string('public nope'))).to be_falsey
+      it "returns false when any scope is not included" do
+        expect(subject.has_scopes?(Scopes.from_string("public nope"))).to be_falsey
       end
 
-      it 'is false if no scopes are included even for existing ones' do
-        expect(subject.has_scopes?(Scopes.from_string('public admin notexistent'))).to be_falsey
+      it "is false if no scopes are included even for existing ones" do
+        expect(subject.has_scopes?(Scopes.from_string("public admin notexistent"))).to be_falsey
       end
     end
   end

data/spec/lib/oauth/token_request_spec.rb

@@ -1,18 +1,20 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 module Doorkeeper::OAuth
   describe TokenRequest do
     let :application do
-      FactoryBot.create(:application, scopes: 'public')
+      FactoryBot.create(:application, scopes: "public")
     end
 
     let :pre_auth do
       double(
         :pre_auth,
         client: application,
-        redirect_uri: 'http://tst.com/cb',
+        redirect_uri: "http://tst.com/cb",
         state: nil,
-        scopes: Scopes.from_string('public'),
+        scopes: Scopes.from_string("public"),
         error: nil,
         authorizable?: true
       )
@@ -26,70 +28,123 @@ module Doorkeeper::OAuth
       TokenRequest.new(pre_auth, owner)
     end
 
-    it 'creates an access token' do
+    it "creates an access token" do
       expect do
         subject.authorize
       end.to change { Doorkeeper::AccessToken.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 token when not authorizable' do
+    it "does not create token when not authorizable" do
       allow(pre_auth).to receive(:authorizable?).and_return(false)
       expect { subject.authorize }.not_to(change { Doorkeeper::AccessToken.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
 
-    context 'with custom expirations' do
-      before do
-        Doorkeeper.configure do
-          orm DOORKEEPER_ORM
-          custom_access_token_expires_in do |context|
-            context.grant_type == Doorkeeper::OAuth::IMPLICIT ? 1234 : nil
+    describe "with custom expiration" do
+      context "when proper TTL returned" do
+        before do
+          Doorkeeper.configure do
+            orm DOORKEEPER_ORM
+            custom_access_token_expires_in do |context|
+              context.grant_type == Doorkeeper::OAuth::IMPLICIT ? 1234 : nil
+            end
           end
         end
+
+        it "should use the custom ttl" do
+          subject.authorize
+          token = Doorkeeper::AccessToken.first
+          expect(token.expires_in).to eq(1234)
+        end
       end
 
-      it 'should use the custom ttl' do
-        subject.authorize
-        token = Doorkeeper::AccessToken.first
-        expect(token.expires_in).to eq(1234)
+      context "when nil TTL returned" do
+        before do
+          Doorkeeper.configure do
+            orm DOORKEEPER_ORM
+            access_token_expires_in 654
+            custom_access_token_expires_in do |_context|
+              nil
+            end
+          end
+        end
+
+        it "should fallback to access_token_expires_in" do
+          subject.authorize
+          token = Doorkeeper::AccessToken.first
+          expect(token.expires_in).to eq(654)
+        end
+      end
+
+      context "when infinite TTL returned" do
+        before do
+          Doorkeeper.configure do
+            orm DOORKEEPER_ORM
+            access_token_expires_in 654
+            custom_access_token_expires_in do |_context|
+              Float::INFINITY
+            end
+          end
+        end
+
+        it "should fallback to access_token_expires_in" do
+          subject.authorize
+          token = Doorkeeper::AccessToken.first
+          expect(token.expires_in).to be_nil
+        end
       end
     end
 
-    context 'token reuse' do
-      it 'creates a new token if there are no matching tokens' do
+    context "token reuse" do
+      it "creates a new token if there are no matching tokens" do
         allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(true)
         expect do
           subject.authorize
         end.to change { Doorkeeper::AccessToken.count }.by(1)
       end
 
-      it 'creates a new token if scopes do not match' do
+      it "creates a new token if scopes do not match" do
         allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(true)
         FactoryBot.create(:access_token, application_id: pre_auth.client.id,
-                                         resource_owner_id: owner.id, scopes: '')
+                                         resource_owner_id: owner.id, scopes: "")
         expect do
           subject.authorize
         end.to change { Doorkeeper::AccessToken.count }.by(1)
       end
 
-      it 'skips token creation if there is a matching one' do
+      it "skips token creation if there is a matching one reusable" do
         allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(true)
         allow(application.scopes).to receive(:has_scopes?).and_return(true)
         allow(application.scopes).to receive(:all?).and_return(true)
 
         FactoryBot.create(:access_token, application_id: pre_auth.client.id,
-                                         resource_owner_id: owner.id, scopes: 'public')
+                                         resource_owner_id: owner.id, scopes: "public")
 
         expect { subject.authorize }.not_to(change { Doorkeeper::AccessToken.count })
       end
+
+      it "creates new token if there is a matching one but non reusable" do
+        allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(true)
+        allow(application.scopes).to receive(:has_scopes?).and_return(true)
+        allow(application.scopes).to receive(:all?).and_return(true)
+
+        FactoryBot.create(:access_token, application_id: pre_auth.client.id,
+                                         resource_owner_id: owner.id, scopes: "public")
+
+        allow_any_instance_of(Doorkeeper::AccessToken).to receive(:reusable?).and_return(false)
+
+        expect do
+          subject.authorize
+        end.to change { Doorkeeper::AccessToken.count }.by(1)
+      end
     end
   end
 end

data/spec/lib/oauth/token_response_spec.rb

@@ -1,83 +1,85 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 module Doorkeeper::OAuth
   describe TokenResponse do
     subject { TokenResponse.new(double.as_null_object) }
 
-    it 'includes access token response headers' do
+    it "includes access token response headers" do
       headers = subject.headers
-      expect(headers.fetch('Cache-Control')).to eq('no-store')
-      expect(headers.fetch('Pragma')).to eq('no-cache')
+      expect(headers.fetch("Cache-Control")).to eq("no-store")
+      expect(headers.fetch("Pragma")).to eq("no-cache")
     end
 
-    it 'status is ok' do
+    it "status is ok" do
       expect(subject.status).to eq(:ok)
     end
 
-    describe '.body' do
+    describe ".body" 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
+               plaintext_token: "some-token",
+               expires_in: "3600",
+               expires_in_seconds: "300",
+               scopes_string: "two scopes",
+               plaintext_refresh_token: "some-refresh-token",
+               token_type: "bearer",
+               created_at: 0
       end
 
       subject { TokenResponse.new(access_token).body }
 
-      it 'includes :access_token' do
-        expect(subject['access_token']).to eq('some-token')
+      it "includes :access_token" do
+        expect(subject["access_token"]).to eq("some-token")
       end
 
-      it 'includes :token_type' do
-        expect(subject['token_type']).to eq('bearer')
+      it "includes :token_type" do
+        expect(subject["token_type"]).to eq("bearer")
       end
 
       # expires_in_seconds is returned as `expires_in` in order to match
       # the OAuth spec (section 4.2.2)
-      it 'includes :expires_in' do
-        expect(subject['expires_in']).to eq('300')
+      it "includes :expires_in" do
+        expect(subject["expires_in"]).to eq("300")
       end
 
-      it 'includes :scope' do
-        expect(subject['scope']).to eq('two scopes')
+      it "includes :scope" do
+        expect(subject["scope"]).to eq("two scopes")
       end
 
-      it 'includes :refresh_token' do
-        expect(subject['refresh_token']).to eq('some-refresh-token')
+      it "includes :refresh_token" do
+        expect(subject["refresh_token"]).to eq("some-refresh-token")
       end
 
-      it 'includes :created_at' do
-        expect(subject['created_at']).to eq(0)
+      it "includes :created_at" do
+        expect(subject["created_at"]).to eq(0)
       end
     end
 
-    describe '.body filters out empty values' do
+    describe ".body filters out empty values" do
       let(:access_token) do
         double :access_token,
-               token:              'some-token',
-               expires_in_seconds: '',
-               scopes_string:      '',
-               refresh_token:      '',
-               token_type:         'bearer',
-               created_at:         0
+               plaintext_token: "some-token",
+               expires_in_seconds: "",
+               scopes_string: "",
+               plaintext_refresh_token: "",
+               token_type: "bearer",
+               created_at: 0
       end
 
       subject { TokenResponse.new(access_token).body }
 
-      it 'includes :expires_in' do
-        expect(subject['expires_in']).to be_nil
+      it "includes :expires_in" do
+        expect(subject["expires_in"]).to be_nil
       end
 
-      it 'includes :scope' do
-        expect(subject['scope']).to be_nil
+      it "includes :scope" do
+        expect(subject["scope"]).to be_nil
       end
 
-      it 'includes :refresh_token' do
-        expect(subject['refresh_token']).to be_nil
+      it "includes :refresh_token" do
+        expect(subject["refresh_token"]).to be_nil
       end
     end
   end