doorkeeper-mongodb 5.2.1 → 5.2.3

data/spec/lib/oauth/authorization/uri_builder_spec.rb

@@ -2,38 +2,34 @@
 
 require "spec_helper"
 
-module Doorkeeper::OAuth::Authorization
-  describe URIBuilder do
-    subject { URIBuilder }
-
-    describe :uri_with_query do
-      it "returns the uri with query" do
-        uri = subject.uri_with_query "http://example.com/", parameter: "value"
-        expect(uri).to eq("http://example.com/?parameter=value")
-      end
+RSpec.describe Doorkeeper::OAuth::Authorization::URIBuilder do
+  describe ".uri_with_query" do
+    it "returns the uri with query" do
+      uri = described_class.uri_with_query "http://example.com/", parameter: "value"
+      expect(uri).to eq("http://example.com/?parameter=value")
+    end
 
-      it "rejects nil values" do
-        uri = subject.uri_with_query "http://example.com/", parameter: ""
-        expect(uri).to eq("http://example.com/?")
-      end
+    it "rejects nil values" do
+      uri = described_class.uri_with_query "http://example.com/", parameter: ""
+      expect(uri).to eq("http://example.com/?")
+    end
 
-      it "preserves original query parameters" do
-        uri = subject.uri_with_query "http://example.com/?query1=value", parameter: "value"
-        expect(uri).to match(/query1=value/)
-        expect(uri).to match(/parameter=value/)
-      end
+    it "preserves original query parameters" do
+      uri = described_class.uri_with_query "http://example.com/?query1=value", parameter: "value"
+      expect(uri).to match(/query1=value/)
+      expect(uri).to match(/parameter=value/)
     end
+  end
 
-    describe :uri_with_fragment do
-      it "returns uri with parameters as fragments" do
-        uri = subject.uri_with_fragment "http://example.com/", parameter: "value"
-        expect(uri).to eq("http://example.com/#parameter=value")
-      end
+  describe ".uri_with_fragment" do
+    it "returns uri with parameters as fragments" do
+      uri = described_class.uri_with_fragment "http://example.com/", parameter: "value"
+      expect(uri).to eq("http://example.com/#parameter=value")
+    end
 
-      it "preserves original query parameters" do
-        uri = subject.uri_with_fragment "http://example.com/?query1=value1", parameter: "value"
-        expect(uri).to eq("http://example.com/?query1=value1#parameter=value")
-      end
+    it "preserves original query parameters" do
+      uri = described_class.uri_with_fragment "http://example.com/?query1=value1", parameter: "value"
+      expect(uri).to eq("http://example.com/?query1=value1#parameter=value")
     end
   end
 end

data/spec/lib/oauth/authorization_code_request_spec.rb

@@ -2,7 +2,11 @@
 
 require "spec_helper"
 
-describe Doorkeeper::OAuth::AuthorizationCodeRequest do
+RSpec.describe Doorkeeper::OAuth::AuthorizationCodeRequest do
+  subject do
+    described_class.new(server, grant, client, params)
+  end
+
   let(:server) do
     double :server,
            access_token_expires_in: 2.days,
@@ -26,10 +30,6 @@ describe Doorkeeper::OAuth::AuthorizationCodeRequest do
     allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(true)
   end
 
-  subject do
-    described_class.new(server, grant, client, params)
-  end
-
   it "issues a new token for the client" do
     expect do
       subject.authorize
@@ -111,7 +111,7 @@ describe Doorkeeper::OAuth::AuthorizationCodeRequest do
       scopes: grant.scopes.to_s,
     )
 
-    expect { subject.authorize }.to_not(change { Doorkeeper::AccessToken.count })
+    expect { subject.authorize }.not_to(change { Doorkeeper::AccessToken.count })
   end
 
   it "creates token if there is a matching one but non reusable" do

data/spec/lib/oauth/base_request_spec.rb

@@ -2,7 +2,11 @@
 
 require "spec_helper"
 
-describe Doorkeeper::OAuth::BaseRequest do
+RSpec.describe Doorkeeper::OAuth::BaseRequest do
+  subject do
+    described_class.new
+  end
+
   let(:access_token) do
     double :access_token,
            plaintext_token: "some-token",
@@ -29,10 +33,6 @@ describe Doorkeeper::OAuth::BaseRequest 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(subject).to receive(:access_token).and_return(access_token)
@@ -43,7 +43,7 @@ describe Doorkeeper::OAuth::BaseRequest do
       subject.authorize
     end
 
-    context "valid" do
+    context "when valid" do
       before do
         allow(subject).to receive(:valid?).and_return(true)
       end
@@ -64,7 +64,7 @@ describe Doorkeeper::OAuth::BaseRequest do
       end
     end
 
-    context "invalid" do
+    context "when invalid" do
       context "with error other than invalid_request" do
         before do
           allow(subject).to receive(:valid?).and_return(false)
@@ -146,7 +146,7 @@ describe Doorkeeper::OAuth::BaseRequest do
         "public",
         server,
       )
-      expect(result.expires_in).to eql(500)
+      expect(result.expires_in).to be(500)
     end
 
     it "respects use_refresh_token with a block" do
@@ -167,7 +167,7 @@ describe Doorkeeper::OAuth::BaseRequest do
         "public",
         server,
       )
-      expect(result.refresh_token).to_not be_nil
+      expect(result.refresh_token).not_to be_nil
 
       result = subject.find_or_create_access_token(
         client,
@@ -180,7 +180,7 @@ describe Doorkeeper::OAuth::BaseRequest do
   end
 
   describe "#scopes" do
-    context "@original_scopes is present" do
+    context "when @original_scopes is present" do
       before do
         subject.instance_variable_set(:@original_scopes, "public write")
       end
@@ -192,7 +192,7 @@ describe Doorkeeper::OAuth::BaseRequest do
       end
     end
 
-    context "@original_scopes is not present" do
+    context "when @original_scopes is blank" do
       before do
         subject.instance_variable_set(:@original_scopes, "")
       end
@@ -207,20 +207,4 @@ describe Doorkeeper::OAuth::BaseRequest do
       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

data/spec/lib/oauth/base_response_spec.rb

@@ -2,9 +2,9 @@
 
 require "spec_helper"
 
-describe Doorkeeper::OAuth::BaseResponse do
+RSpec.describe Doorkeeper::OAuth::BaseResponse do
   subject do
-    Doorkeeper::OAuth::BaseResponse.new
+    described_class.new
   end
 
   describe "#body" do

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

@@ -8,10 +8,10 @@ class Doorkeeper::OAuth::Client
     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
+      expect(described_class.new(nil, nil)).to be_blank
+      expect(described_class.new(nil, "something")).to be_blank
+      expect(described_class.new("something", nil)).to be_present
+      expect(described_class.new("something", "something")).to be_present
     end
 
     describe ".from_request" do
@@ -23,66 +23,66 @@ class Doorkeeper::OAuth::Client
 
       it "accepts anything that responds to #call" do
         expect(method).to receive(:call).with(request)
-        Credentials.from_request request, method
+        described_class.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
+        expect(described_class).to receive(:from_params).with(request)
+        described_class.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
+        described_class.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)
+        credentials = described_class.from_request request, method
+        expect(credentials).to be_a(described_class)
       end
 
       it "returns uid and secret from extractor method" do
-        credentials = Credentials.from_request request, method
+        credentials = described_class.from_request request, method
         expect(credentials.uid).to    eq("uid")
         expect(credentials.secret).to eq("secret")
       end
     end
 
-    describe :from_params do
+    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)
+        request = double parameters: { client_id: client_id, client_secret: client_secret }
+        uid, secret = described_class.from_params(request)
 
-        expect(uid).to    eq("some-uid")
+        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)
+        request = double parameters: {}
+        uid, secret = described_class.from_params(request)
 
-        expect(uid).to    be_blank
+        expect(uid).to be_blank
         expect(secret).to be_blank
       end
     end
 
-    describe :from_basic do
+    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)
+        request = double authorization: "Basic #{credentials}"
+        uid, secret = described_class.from_basic(request)
 
-        expect(uid).to    eq("some-uid")
+        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.to_s
-        uid, secret = Credentials.from_basic(request)
+        request = double authorization: credentials.to_s
+        uid, secret = described_class.from_basic(request)
 
-        expect(uid).to    be_blank
+        expect(uid).to be_blank
         expect(secret).to be_blank
       end
     end

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

@@ -2,136 +2,134 @@
 
 require "spec_helper"
 
-class Doorkeeper::OAuth::ClientCredentialsRequest
-  describe Creator do
-    let(:client) { FactoryBot.create :application }
-    let(:scopes) { Doorkeeper::OAuth::Scopes.from_string("public") }
+RSpec.describe Doorkeeper::OAuth::ClientCredentials::Creator do
+  let(:client) { FactoryBot.create :application }
+  let(:scopes) { Doorkeeper::OAuth::Scopes.from_string("public") }
 
+  before do
+    default_scopes_exist :public
+  end
+
+  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
     before do
-      default_scopes_exist :public
+      allow(Doorkeeper.config).to receive(:reuse_access_token).and_return(true)
     end
 
-    it "creates a new token" do
-      expect do
-        subject.call(client, scopes)
-      end.to change { Doorkeeper::AccessToken.count }.by(1)
+    context "when expiration is disabled" do
+      it "returns the existing valid token" do
+        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 true" do
+    context "when existing token has not crossed token_reuse_limit" do
+      let!(:existing_token) { subject.call(client, scopes, expires_in: 1000) }
+
       before do
-        allow(Doorkeeper.config).to receive(:reuse_access_token).and_return(true)
+        allow(Doorkeeper.config).to receive(:token_reuse_limit).and_return(50)
+        allow_any_instance_of(Doorkeeper::AccessToken).to receive(:expires_in_seconds).and_return(600)
       end
 
-      context "when expiration is disabled" do
-        it "returns the existing valid token" do
-          existing_token = subject.call(client, scopes)
+      it "returns the existing valid token" do
+        result = subject.call(client, scopes, expires_in: 1000)
 
-          result = subject.call(client, scopes)
-
-          expect(Doorkeeper::AccessToken.count).to eq(1)
-          expect(result).to eq(existing_token)
-        end
+        expect(Doorkeeper::AccessToken.count).to eq(1)
+        expect(result).to eq(existing_token)
       end
 
-      context "when existing token has not crossed token_reuse_limit" do
-        let!(:existing_token) { subject.call(client, scopes, expires_in: 1000) }
-
+      context "when revoke_previous_client_credentials_token is false" do
         before do
-          allow(Doorkeeper.config).to receive(:token_reuse_limit).and_return(50)
-          allow_any_instance_of(Doorkeeper::AccessToken).to receive(:expires_in_seconds).and_return(600)
+          allow(Doorkeeper.config).to receive(:revoke_previous_client_credentials_token).and_return(false)
         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 false" do
-          before do
-            allow(Doorkeeper.config).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
-        it "returns a new token" do
-          allow(Doorkeeper.config).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(400)
-          result = subject.call(client, scopes, expires_in: 1000)
-
-          expect(Doorkeeper::AccessToken.count).to eq(2)
-          expect(result).not_to eq(existing_token)
+        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 been expired" do
-        it "returns a new token" do
-          allow(Doorkeeper.configuration).to receive(:token_reuse_limit).and_return(50)
-          existing_token = subject.call(client, scopes, expires_in: 1000)
+    context "when existing token has crossed token_reuse_limit" do
+      it "returns a new token" do
+        allow(Doorkeeper.config).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(:expired?).and_return(true)
-          result = subject.call(client, scopes, expires_in: 1000)
+        allow_any_instance_of(Doorkeeper::AccessToken).to receive(:expires_in_seconds).and_return(400)
+        result = subject.call(client, scopes, expires_in: 1000)
 
-          expect(Doorkeeper::AccessToken.count).to eq(2)
-          expect(result).not_to eq(existing_token)
-        end
+        expect(Doorkeeper::AccessToken.count).to eq(2)
+        expect(result).not_to eq(existing_token)
       end
     end
 
-    context "when reuse_access_token is false" do
-      before do
-        allow(Doorkeeper.config).to receive(:reuse_access_token).and_return(false)
-      end
-
+    context "when existing token has been expired" do
       it "returns a new token" do
-        existing_token = subject.call(client, scopes)
+        allow(Doorkeeper.configuration).to receive(:token_reuse_limit).and_return(50)
+        existing_token = subject.call(client, scopes, expires_in: 1000)
 
-        result = subject.call(client, scopes)
+        allow_any_instance_of(Doorkeeper::AccessToken).to receive(:expired?).and_return(true)
+        result = subject.call(client, scopes, expires_in: 1000)
 
         expect(Doorkeeper::AccessToken.count).to eq(2)
         expect(result).not_to eq(existing_token)
       end
     end
+  end
 
-    context "when revoke_previous_client_credentials_token is true" do
-      let!(:existing_token) { subject.call(client, scopes, expires_in: 1000) }
+  context "when reuse_access_token is false" do
+    before do
+      allow(Doorkeeper.config).to receive(:reuse_access_token).and_return(false)
+    end
 
-      before do
-        allow(Doorkeeper.configuration).to receive(:revoke_previous_client_credentials_token).and_return(true)
-      end
+    it "returns a new token" do
+      existing_token = subject.call(client, scopes)
 
-      it "revokes the existing token" do
-        subject.call(client, scopes, expires_in: 1000)
-        expect(existing_token.reload).to be_revoked
-      end
+      result = subject.call(client, scopes)
+
+      expect(Doorkeeper::AccessToken.count).to eq(2)
+      expect(result).not_to eq(existing_token)
     end
+  end
 
-    context "when revoke_previous_client_credentials_token is false" do
-      let!(:existing_token) { subject.call(client, scopes, expires_in: 1000) }
+  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(false)
-      end
+    before do
+      allow(Doorkeeper.configuration).to receive(:revoke_previous_client_credentials_token?).and_return(true)
+    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
+    it "revokes the existing token" do
+      subject.call(client, scopes, expires_in: 1000)
+      expect(existing_token.reload).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)
-      expect(created).to be_falsey
+  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)
+    expect(created).to be_falsey
+  end
 end