doorkeeper 5.2.6 → 5.3.3

data/spec/lib/oauth/base_request_spec.rb

@@ -2,220 +2,222 @@
 
 require "spec_helper"
 
-module Doorkeeper::OAuth
-  describe BaseRequest do
-    let(:access_token) do
-      double :access_token,
-             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
+describe Doorkeeper::OAuth::BaseRequest do
+  let(:access_token) do
+    double :access_token,
+           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
 
-    let(:client) { double :client, id: "1" }
+  let(:client) { double :client, id: "1" }
 
-    let(:scopes_array) { %w[public write] }
+  let(:scopes_array) { %w[public write] }
 
-    let(:server) do
-      double :server,
-             access_token_expires_in: 100,
-             custom_access_token_expires_in: ->(_context) { nil },
-             refresh_token_enabled?: false
-    end
+  let(:server) do
+    double :server,
+           access_token_expires_in: 100,
+           custom_access_token_expires_in: ->(_context) { nil },
+           refresh_token_enabled?: false
+  end
+
+  before do
+    allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(true)
+  end
+
+  subject do
+    described_class.new
+  end
 
+  describe "#authorize" do
     before do
-      allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(true)
+      allow(subject).to receive(:access_token).and_return(access_token)
     end
 
-    subject do
-      BaseRequest.new
+    it "validates itself" do
+      expect(subject).to receive(:validate).once
+      subject.authorize
     end
 
-    describe "#authorize" do
+    context "valid" do
       before do
-        allow(subject).to receive(:access_token).and_return(access_token)
+        allow(subject).to receive(:valid?).and_return(true)
       end
 
-      it "validates itself" do
-        expect(subject).to receive(:validate).once
+      it "calls callback methods" do
+        expect(subject).to receive(:before_successful_response).once
+        expect(subject).to receive(:after_successful_response).once
         subject.authorize
       end
 
-      context "valid" do
-        before do
-          allow(subject).to receive(:valid?).and_return(true)
-        end
+      it "returns a TokenResponse object" do
+        result = subject.authorize
 
-        it "calls callback methods" do
-          expect(subject).to receive(:before_successful_response).once
-          expect(subject).to receive(:after_successful_response).once
-          subject.authorize
+        expect(result).to be_an_instance_of(Doorkeeper::OAuth::TokenResponse)
+        expect(result.body).to eq(
+          Doorkeeper::OAuth::TokenResponse.new(access_token).body,
+        )
+      end
+    end
+
+    context "invalid" do
+      context "with error other than invalid_request" 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 a TokenResponse object" do
+        it "returns an ErrorResponse object" do
           result = subject.authorize
 
-          expect(result).to be_an_instance_of(TokenResponse)
+          expect(result).to be_an_instance_of(Doorkeeper::OAuth::ErrorResponse)
+
           expect(result.body).to eq(
-            TokenResponse.new(access_token).body
+            error: :server_error,
+            error_description: translated_error_message(:server_error),
+            state: "hello",
           )
         end
       end
 
-      context "invalid" do
-        context "with error other than invalid_request" 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
-            result = subject.authorize
-
-            expect(result).to be_an_instance_of(ErrorResponse)
-
-            expect(result.body).to eq(
-              error: :server_error,
-              error_description: translated_error_message(:server_error),
-              state: "hello"
-            )
-          end
+      context "with invalid_request error" do
+        before do
+          allow(subject).to receive(:valid?).and_return(false)
+          allow(subject).to receive(:error).and_return(:invalid_request)
+          allow(subject).to receive(:state).and_return("hello")
         end
 
-        context "with invalid_request error" do
-          before do
-            allow(subject).to receive(:valid?).and_return(false)
-            allow(subject).to receive(:error).and_return(:invalid_request)
-            allow(subject).to receive(:state).and_return("hello")
-          end
-
-          it "returns an InvalidRequestResponse object" do
-            result = subject.authorize
+        it "returns an InvalidRequestResponse object" do
+          result = subject.authorize
 
-            expect(result).to be_an_instance_of(InvalidRequestResponse)
+          expect(result).to be_an_instance_of(Doorkeeper::OAuth::InvalidRequestResponse)
 
-            expect(result.body).to eq(
-              error: :invalid_request,
-              error_description: translated_invalid_request_error_message(:unknown, :unknown),
-              state: "hello"
-            )
-          end
+          expect(result.body).to eq(
+            error: :invalid_request,
+            error_description: translated_invalid_request_error_message(:unknown, :unknown),
+            state: "hello",
+          )
         end
       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
+  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
+      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
-        )
+  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
+      expect(result).to be_an_instance_of(Doorkeeper::AccessToken)
+    end
 
-      it "respects custom_access_token_expires_in" do
-        server = double(:server,
-                        access_token_expires_in: 100,
-                        custom_access_token_expires_in: ->(context) { context.scopes == "public" ? 500 : nil },
-                        refresh_token_enabled?: false)
+    it "respects custom_access_token_expires_in" do
+      server = double(
+        :server,
+        access_token_expires_in: 100,
+        custom_access_token_expires_in: ->(context) { context.scopes == "public" ? 500 : nil },
+        refresh_token_enabled?: false,
+      )
 
-        allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(true)
+      allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(true)
 
-        result = subject.find_or_create_access_token(
-          client,
-          "1",
-          "public",
-          server
-        )
-        expect(result.expires_in).to eql(500)
-      end
+      result = subject.find_or_create_access_token(
+        client,
+        "1",
+        "public",
+        server,
+      )
+      expect(result.expires_in).to eql(500)
+    end
 
-      it "respects use_refresh_token with a block" do
-        server = double(:server,
-                        access_token_expires_in: 100,
-                        custom_access_token_expires_in: ->(_context) { nil },
-                        refresh_token_enabled?: lambda { |context|
-                          context.scopes == "public"
-                        })
-
-        allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(true)
-
-        result = subject.find_or_create_access_token(
-          client,
-          "1",
-          "public",
-          server
-        )
-        expect(result.refresh_token).to_not be_nil
+    it "respects use_refresh_token with a block" do
+      server = double(
+        :server,
+        access_token_expires_in: 100,
+        custom_access_token_expires_in: ->(_context) { nil },
+        refresh_token_enabled?: lambda { |context|
+          context.scopes == "public"
+        },
+      )
 
-        result = subject.find_or_create_access_token(
-          client,
-          "1",
-          "private",
-          server
-        )
-        expect(result.refresh_token).to be_nil
-      end
+      allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(true)
+
+      result = subject.find_or_create_access_token(
+        client,
+        "1",
+        "public",
+        server,
+      )
+      expect(result.refresh_token).to_not be_nil
+
+      result = subject.find_or_create_access_token(
+        client,
+        "1",
+        "private",
+        server,
+      )
+      expect(result.refresh_token).to be_nil
     end
+  end
 
-    describe "#scopes" do
-      context "@original_scopes is present" do
-        before do
-          subject.instance_variable_set(:@original_scopes, "public write")
-        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
+      it "returns array of @original_scopes" do
+        result = subject.scopes
 
-          expect(result).to eq(scopes_array)
-        end
+        expect(result).to eq(scopes_array)
       end
+    end
 
-      context "@original_scopes is not present" do
-        before do
-          subject.instance_variable_set(:@original_scopes, "")
-        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
+      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
+        result = subject.scopes
 
-          expect(result).to eq(scopes_array)
-        end
+        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
+  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
+    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

data/spec/lib/oauth/base_response_spec.rb

@@ -2,46 +2,44 @@
 
 require "spec_helper"
 
-module Doorkeeper::OAuth
-  describe BaseResponse do
-    subject do
-      BaseResponse.new
-    end
+describe Doorkeeper::OAuth::BaseResponse do
+  subject do
+    Doorkeeper::OAuth::BaseResponse.new
+  end
 
-    describe "#body" do
-      it "returns an empty Hash" do
-        expect(subject.body).to eq({})
-      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
+  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
+  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
+  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
+  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
+  describe "#status" do
+    it "returns :ok" do
+      expect(subject.status).to eq(:ok)
     end
   end
 end

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

@@ -14,7 +14,7 @@ class Doorkeeper::OAuth::Client
       expect(Credentials.new("something", "something")).to be_present
     end
 
-    describe :from_request do
+    describe ".from_request" do
       let(:request) { double.as_null_object }
 
       let(:method) do

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

@@ -31,17 +31,31 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
       end
 
       context "when existing token has not crossed token_reuse_limit" do
-        it "returns the existing valid token" do
+        let!(:existing_token) { subject.call(client, scopes, expires_in: 1000) }
+
+        before do
           allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(true)
           allow(Doorkeeper.configuration).to receive(:token_reuse_limit).and_return(50)
-          existing_token = subject.call(client, scopes, expires_in: 1000)
-
           allow_any_instance_of(Doorkeeper::AccessToken).to receive(:expires_in_seconds).and_return(600)
+        end
+
+        it "returns the existing valid token" do
           result = subject.call(client, scopes, expires_in: 1000)
 
           expect(Doorkeeper::AccessToken.count).to eq(1)
           expect(result).to eq(existing_token)
         end
+
+        context "and when revoke_previous_client_credentials_token is true" do
+          before do
+            allow(Doorkeeper.configuration).to receive(:revoke_previous_client_credentials_token).and_return(false)
+          end
+
+          it "does not revoke the existing valid token" do
+            subject.call(client, scopes, expires_in: 1000)
+            expect(existing_token.reload).not_to be_revoked
+          end
+        end
       end
 
       context "when existing token has crossed token_reuse_limit" do
@@ -55,7 +69,6 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
 
           expect(Doorkeeper::AccessToken.count).to eq(2)
           expect(result).not_to eq(existing_token)
-          expect(existing_token.reload).to be_revoked
         end
       end
 
@@ -70,7 +83,6 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
 
           expect(Doorkeeper::AccessToken.count).to eq(2)
           expect(result).not_to eq(existing_token)
-          expect(existing_token.reload).to be_revoked
         end
       end
     end
@@ -84,10 +96,35 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
 
         expect(Doorkeeper::AccessToken.count).to eq(2)
         expect(result).not_to eq(existing_token)
+      end
+    end
+
+    context "when revoke_previous_client_credentials_token is true" do
+      let!(:existing_token) { subject.call(client, scopes, expires_in: 1000) }
+
+      before do
+        allow(Doorkeeper.configuration).to receive(:revoke_previous_client_credentials_token).and_return(true)
+      end
+
+      it "revokes the existing token" do
+        subject.call(client, scopes, expires_in: 1000)
         expect(existing_token.reload).to be_revoked
       end
     end
 
+    context "when revoke_previous_client_credentials_token is false" do
+      let!(:existing_token) { subject.call(client, scopes, expires_in: 1000) }
+
+      before do
+        allow(Doorkeeper.configuration).to receive(:revoke_previous_client_credentials_token).and_return(false)
+      end
+
+      it "does not revoke the existing token" do
+        subject.call(client, scopes, expires_in: 1000)
+        expect(existing_token.reload).not_to be_revoked
+      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)

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

@@ -8,16 +8,16 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
     let(:server) do
       double(
         :server,
-        access_token_expires_in: 100
+        access_token_expires_in: 100,
       )
     end
-    let(:validation) { double :validation, valid?: true }
+    let(:validator) { double :validator, valid?: true }
 
     before do
       allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(false)
     end
 
-    subject { Issuer.new(server, validation) }
+    subject { Issuer.new(server, validator) }
 
     describe :create do
       let(:client) { double :client, id: "some-id" }
@@ -35,7 +35,7 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
           client,
           scopes,
           expires_in: 100,
-          use_refresh_token: false
+          use_refresh_token: false,
         )
 
         subject.create client, scopes, creator
@@ -48,14 +48,14 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
         expect(subject.error).to eq(:server_error)
       end
 
-      context "when validation fails" do
+      context "when validator fails" do
         before do
-          allow(validation).to receive(:valid?).and_return(false)
-          allow(validation).to receive(:error).and_return(:validation_error)
+          allow(validator).to receive(:valid?).and_return(false)
+          allow(validator).to receive(:error).and_return(:validation_error)
           expect(creator).not_to receive(:create)
         end
 
-        it "has error set from validation" do
+        it "has error set from validator" do
           subject.create client, scopes, creator
           expect(subject.error).to eq(:validation_error)
         end
@@ -65,7 +65,7 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
         end
       end
 
-      context "with custom expirations" do
+      context "with custom expiration" do
         let(:custom_ttl_grant) { 1234 }
         let(:custom_ttl_scope) { 1235 }
         let(:custom_scope) { "special" }
@@ -79,7 +79,7 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
               elsif context.grant_type == Doorkeeper::OAuth::CLIENT_CREDENTIALS
                 custom_ttl_grant
               end
-            }
+            },
           )
         end
 
@@ -92,7 +92,7 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
             client,
             scopes,
             expires_in: custom_ttl_grant,
-            use_refresh_token: false
+            use_refresh_token: false,
           )
           subject.create client, scopes, creator
         end
@@ -102,7 +102,7 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
             client,
             custom_scope,
             expires_in: custom_ttl_scope,
-            use_refresh_token: false
+            use_refresh_token: false,
           )
           subject.create client, custom_scope, creator
         end

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

@@ -3,13 +3,13 @@
 require "spec_helper"
 
 class Doorkeeper::OAuth::ClientCredentialsRequest
-  describe Validation do
+  describe Validator 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) }
+    subject { described_class.new(server, request) }
 
     it "is valid with valid request" do
       expect(subject).to be_valid
@@ -26,7 +26,7 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
         allow(request).to receive(:grant_type).and_return(Doorkeeper::OAuth::CLIENT_CREDENTIALS)
         allow(server).to receive(:scopes).and_return(server_scopes)
         allow(request).to receive(:scopes).and_return(
-          Doorkeeper::OAuth::Scopes.from_string("invalid")
+          Doorkeeper::OAuth::Scopes.from_string("invalid"),
         )
         expect(subject).not_to be_valid
       end
@@ -49,7 +49,7 @@ class Doorkeeper::OAuth::ClientCredentialsRequest
           allow(request).to receive(:grant_type).and_return(Doorkeeper::OAuth::CLIENT_CREDENTIALS)
           allow(server).to receive(:scopes).and_return(server_scopes)
           allow(request).to receive(:scopes).and_return(
-            Doorkeeper::OAuth::Scopes.from_string("email")
+            Doorkeeper::OAuth::Scopes.from_string("email"),
           )
           expect(subject).not_to be_valid
         end