doorkeeper-mongodb 5.2.1 → 5.2.2

data/spec/lib/oauth/code_request_spec.rb

@@ -2,7 +2,11 @@
 
 require "spec_helper"
 
-describe Doorkeeper::OAuth::CodeRequest do
+RSpec.describe Doorkeeper::OAuth::CodeRequest do
+  subject do
+    described_class.new(pre_auth, owner)
+  end
+
   let(:pre_auth) do
     server = Doorkeeper.configuration
     allow(server)
@@ -26,10 +30,6 @@ describe Doorkeeper::OAuth::CodeRequest do
 
   let(:owner) { FactoryBot.create(:resource_owner) }
 
-  subject do
-    described_class.new(pre_auth, owner)
-  end
-
   context "when pre_auth is authorized" do
     it "creates an access grant and returns a code response" do
       expect { subject.authorize }.to change { Doorkeeper::AccessGrant.count }.by(1)

data/spec/lib/oauth/code_response_spec.rb

@@ -2,9 +2,11 @@
 
 require "spec_helper"
 
-describe Doorkeeper::OAuth::CodeResponse do
+RSpec.describe Doorkeeper::OAuth::CodeResponse do
   describe "#redirect_uri" do
     context "when generating the redirect URI for an implicit grant" do
+      subject { described_class.new(pre_auth, auth, response_on_fragment: true).redirect_uri }
+
       let :pre_auth do
         double(
           :pre_auth,
@@ -21,13 +23,11 @@ describe Doorkeeper::OAuth::CodeResponse do
 
       let :auth do
         Doorkeeper::OAuth::Authorization::Token.new(pre_auth, owner).tap do |c|
-          c.issue_token
+          c.issue_token!
           allow(c.token).to receive(:expires_in_seconds).and_return(3600)
         end
       end
 
-      subject { described_class.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

data/spec/lib/oauth/error_response_spec.rb

@@ -2,13 +2,13 @@
 
 require "spec_helper"
 
-describe Doorkeeper::OAuth::ErrorResponse do
+RSpec.describe Doorkeeper::OAuth::ErrorResponse do
   describe "#status" do
-    it "should have a status of bad_request" do
+    it "has 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 "has a status of unauthorized for an invalid_client error" do
       subject = described_class.new(name: :invalid_client)
 
       expect(subject.status).to eq(:unauthorized)
@@ -48,15 +48,16 @@ describe Doorkeeper::OAuth::ErrorResponse do
   end
 
   describe ".headers" do
-    let(:error_response) { described_class.new(name: :some_error, state: :some_state) }
     subject { error_response.headers }
 
+    let(:error_response) { described_class.new(name: :some_error, state: :some_state) }
+
     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("realm=\"#{error_response.send(:realm)}\"") }
       it { expect(subject).to include("error=\"#{error_response.name}\"") }
       it { expect(subject).to include("error_description=\"#{error_response.description}\"") }
     end

data/spec/lib/oauth/error_spec.rb

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-describe Doorkeeper::OAuth::Error do
+RSpec.describe Doorkeeper::OAuth::Error do
   subject(:error) { described_class.new(:some_error, :some_state) }
 
   it { expect(subject).to respond_to(:name) }

data/spec/lib/oauth/forbidden_token_response_spec.rb

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-describe Doorkeeper::OAuth::ForbiddenTokenResponse do
+RSpec.describe Doorkeeper::OAuth::ForbiddenTokenResponse do
   describe "#name" do
     it { expect(subject.name).to eq(:invalid_scope) }
   end
@@ -12,7 +12,7 @@ describe Doorkeeper::OAuth::ForbiddenTokenResponse do
   end
 
   describe ".from_scopes" do
-    it "should have a list of acceptable scopes" do
+    it "have a list of acceptable scopes" do
       response = described_class.from_scopes(["public"])
       expect(response.description).to include("public")
     end

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

@@ -8,31 +8,31 @@ module Doorkeeper::OAuth::Helpers
 
     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(described_class).to be_valid(scope_str: "scope", server_scopes: server_scopes)
     end
 
     it "is invalid if includes tabs space" do
-      expect(ScopeChecker.valid?(scope_str: "\tsomething", server_scopes: server_scopes)).to be_falsey
+      expect(described_class).not_to be_valid(scope_str: "\tsomething", server_scopes: server_scopes)
     end
 
     it "is invalid if scope is not present" do
-      expect(ScopeChecker.valid?(scope_str: nil, server_scopes: server_scopes)).to be_falsey
+      expect(described_class).not_to be_valid(scope_str: nil, server_scopes: server_scopes)
     end
 
     it "is invalid if scope is blank" do
-      expect(ScopeChecker.valid?(scope_str: " ", server_scopes: server_scopes)).to be_falsey
+      expect(described_class).not_to be_valid(scope_str: " ", server_scopes: server_scopes)
     end
 
     it "is invalid if includes return space" do
-      expect(ScopeChecker.valid?(scope_str: "scope\r", server_scopes: server_scopes)).to be_falsey
+      expect(described_class).not_to be_valid(scope_str: "scope\r", server_scopes: server_scopes)
     end
 
     it "is invalid if includes new lines" do
-      expect(ScopeChecker.valid?(scope_str: "scope\nanother", server_scopes: server_scopes)).to be_falsey
+      expect(described_class).not_to be_valid(scope_str: "scope\nanother", server_scopes: server_scopes)
     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
+      expect(described_class).not_to be_valid(scope_str: "scope another", server_scopes: server_scopes)
     end
 
     context "with application_scopes" do
@@ -44,19 +44,19 @@ module Doorkeeper::OAuth::Helpers
       end
 
       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
+        expect(described_class).to be_valid(
+          scope_str: "app123",
+          server_scopes: server_scopes,
+          app_scopes: application_scopes,
+        )
       end
 
       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
+        expect(described_class).not_to be_valid(
+          scope_str: "svr",
+          server_scopes: server_scopes,
+          app_scopes: application_scopes,
+        )
       end
     end
 
@@ -67,19 +67,19 @@ module Doorkeeper::OAuth::Helpers
 
       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
+          expect(described_class).to be_valid(
+            scope_str: "scope1",
+            server_scopes: server_scopes,
+            grant_type: Doorkeeper::OAuth::PASSWORD,
+          )
         end
 
         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
+          expect(described_class).not_to be_valid(
+            scope_str: "unknown",
+            server_scopes: server_scopes,
+            grant_type: Doorkeeper::OAuth::PASSWORD,
+          )
         end
       end
 
@@ -90,19 +90,19 @@ module Doorkeeper::OAuth::Helpers
         end
 
         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
+          expect(described_class).to be_valid(
+            scope_str: "scope1",
+            server_scopes: server_scopes,
+            grant_type: Doorkeeper::OAuth::PASSWORD,
+          )
         end
 
         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
+          expect(described_class).not_to be_valid(
+            scope_str: "scope2",
+            server_scopes: server_scopes,
+            grant_type: Doorkeeper::OAuth::PASSWORD,
+          )
         end
       end
     end

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

@@ -9,12 +9,12 @@ module Doorkeeper::OAuth::Helpers
     end
 
     it "is able to customize the generator method" do
-      token = UniqueToken.generate(generator: generator)
+      token = described_class.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)
+      token = described_class.generate(generator: generator, size: 2)
       expect(token).to eq("aa")
     end
   end

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

@@ -7,142 +7,142 @@ module Doorkeeper::OAuth::Helpers
     describe ".valid?" do
       it "is valid for valid uris" do
         uri = "http://app.co"
-        expect(URIChecker.valid?(uri)).to be_truthy
+        expect(described_class).to be_valid(uri)
       end
 
       it "is valid if include path param" do
         uri = "http://app.co/path"
-        expect(URIChecker.valid?(uri)).to be_truthy
+        expect(described_class).to be_valid(uri)
       end
 
       it "is valid if include query param" do
         uri = "http://app.co/?query=1"
-        expect(URIChecker.valid?(uri)).to be_truthy
+        expect(described_class).to be_valid(uri)
       end
 
       it "is invalid if uri includes fragment" do
         uri = "http://app.co/test#fragment"
-        expect(URIChecker.valid?(uri)).to be_falsey
+        expect(described_class).not_to be_valid(uri)
       end
 
       it "is invalid if scheme is missing" do
         uri = "app.co"
-        expect(URIChecker.valid?(uri)).to be_falsey
+        expect(described_class).not_to be_valid(uri)
       end
 
       it "is invalid if is a relative uri" do
         uri = "/abc/123"
-        expect(URIChecker.valid?(uri)).to be_falsey
+        expect(described_class).not_to be_valid(uri)
       end
 
       it "is invalid if is not a url" do
         uri = "http://"
-        expect(URIChecker.valid?(uri)).to be_falsey
+        expect(described_class).not_to be_valid(uri)
       end
 
       it "is invalid if localhost is resolved as as scheme (no scheme specified)" do
         uri = "localhost:8080"
-        expect(URIChecker.valid?(uri)).to be_falsey
+        expect(described_class).not_to be_valid(uri)
       end
 
       it "is invalid if scheme is missing #2" do
         uri = "app.co:80"
-        expect(URIChecker.valid?(uri)).to be_falsey
+        expect(described_class).not_to be_valid(uri)
       end
 
       it "is invalid if is not an uri" do
         uri = "   "
-        expect(URIChecker.valid?(uri)).to be_falsey
+        expect(described_class).not_to be_valid(uri)
       end
 
       it "is valid for custom schemes" do
         uri = "com.example.app:/test"
-        expect(URIChecker.valid?(uri)).to be_truthy
+        expect(described_class).to be_valid(uri)
       end
 
       it "is valid for custom schemes with authority marker (common misconfiguration)" do
         uri = "com.example.app://test"
-        expect(URIChecker.valid?(uri)).to be_truthy
+        expect(described_class).to be_valid(uri)
       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
+        expect(described_class).to be_matches(uri, client_uri)
       end
 
-      it "ignores query parameter on comparsion" do
+      it "ignores query parameter on comparison" do
         uri = "http://app.co/?query=hello"
         client_uri = "http://app.co"
-        expect(URIChecker.matches?(uri, client_uri)).to be_truthy
+        expect(described_class).to be_matches(uri, client_uri)
       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
+        expect(described_class).not_to be_matches(uri, client_uri)
       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
+        expect(described_class).not_to be_matches(uri, client_uri)
       end
 
-      context "loopback IP redirect URIs" do
+      context "when loopback IP redirect URIs" do
         it "ignores port for same URIs" do
           uri = "http://127.0.0.1:5555/auth/callback"
           client_uri = "http://127.0.0.1:48599/auth/callback"
-          expect(URIChecker.matches?(uri, client_uri)).to be_truthy
+          expect(described_class).to be_matches(uri, client_uri)
 
           uri = "http://[::1]:5555/auth/callback"
           client_uri = "http://[::1]:5555/auth/callback"
-          expect(URIChecker.matches?(uri, client_uri)).to be_truthy
+          expect(described_class).to be_matches(uri, client_uri)
         end
 
         it "doesn't ignore port for URIs with different queries" do
           uri = "http://127.0.0.1:5555/auth/callback"
           client_uri = "http://127.0.0.1:48599/auth/callback2"
-          expect(URIChecker.matches?(uri, client_uri)).to be_falsey
+          expect(described_class).not_to be_matches(uri, client_uri)
         end
       end
 
-      context "client registered query params" do
+      context "when client registered query params" do
         it "doesn't allow query being absent" do
           uri = "http://app.co"
           client_uri = "http://app.co/?vendorId=AJ4L7XXW9"
-          expect(URIChecker.matches?(uri, client_uri)).to be_falsey
+          expect(described_class).not_to be_matches(uri, client_uri)
         end
 
         it "is false if query values differ but key same" do
           uri = "http://app.co/?vendorId=pancakes"
           client_uri = "http://app.co/?vendorId=waffles"
-          expect(URIChecker.matches?(uri, client_uri)).to be_falsey
+          expect(described_class).not_to be_matches(uri, client_uri)
         end
 
         it "is false if query values same but key differs" do
           uri = "http://app.co/?foo=pancakes"
           client_uri = "http://app.co/?bar=pancakes"
-          expect(URIChecker.matches?(uri, client_uri)).to be_falsey
+          expect(described_class).not_to be_matches(uri, client_uri)
         end
 
         it "is false if query present and match, but unknown queries present" do
           uri = "http://app.co/?vendorId=pancakes&unknown=query"
           client_uri = "http://app.co/?vendorId=waffles"
-          expect(URIChecker.matches?(uri, client_uri)).to be_falsey
+          expect(described_class).not_to be_matches(uri, client_uri)
         end
 
         it "is true if queries are present and matche" do
           uri = "http://app.co/?vendorId=AJ4L7XXW9&foo=bar"
           client_uri = "http://app.co/?vendorId=AJ4L7XXW9&foo=bar"
-          expect(URIChecker.matches?(uri, client_uri)).to be_truthy
+          expect(described_class).to be_matches(uri, client_uri)
         end
 
         it "is true if queries are present, match and in different order" do
           uri = "http://app.co/?bing=bang&foo=bar"
           client_uri = "http://app.co/?foo=bar&bing=bang"
-          expect(URIChecker.matches?(uri, client_uri)).to be_truthy
+          expect(described_class).to be_matches(uri, client_uri)
         end
       end
     end
@@ -150,112 +150,112 @@ module Doorkeeper::OAuth::Helpers
     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
+        expect(described_class).to be_valid_for_authorization(uri, client_uri)
 
         uri = client_uri = "http://app.co/aaa?b=c"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_truthy
+        expect(described_class).to be_valid_for_authorization(uri, client_uri)
       end
 
       it "is true if uri includes blank query" do
         uri = client_uri = "http://app.co/aaa?"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_truthy
+        expect(described_class).to be_valid_for_authorization(uri, client_uri)
 
         uri = "http://app.co/aaa?"
         client_uri = "http://app.co/aaa"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_truthy
+        expect(described_class).to be_valid_for_authorization(uri, client_uri)
 
         uri = "http://app.co/aaa"
         client_uri = "http://app.co/aaa?"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_truthy
+        expect(described_class).to be_valid_for_authorization(uri, client_uri)
       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
+        expect(described_class).not_to be_valid_for_authorization(uri, client_uri)
       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
+        expect(described_class).to be_valid_for_authorization(uri, client_uri)
       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
+        expect(described_class).not_to be_valid_for_authorization(uri, client_uri)
       end
 
       it "is false if queries does not match" do
         uri = "http://app.co/aaa?pankcakes=abc"
         client_uri = "http://app.co/aaa?waffles=abc"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be false
+        expect(described_class.valid_for_authorization?(uri, client_uri)).to be false
       end
 
       it "calls .matches?" do
         uri = "http://app.co/aaa?pankcakes=abc"
         client_uri = "http://app.co/aaa?waffles=abc"
-        expect(URIChecker).to receive(:matches?).with(uri, client_uri).once
-        URIChecker.valid_for_authorization?(uri, client_uri)
+        expect(described_class).to receive(:matches?).with(uri, client_uri).once
+        described_class.valid_for_authorization?(uri, client_uri)
       end
 
       it "calls .valid?" do
         uri = "http://app.co/aaa?pankcakes=abc"
         client_uri = "http://app.co/aaa?waffles=abc"
-        expect(URIChecker).to receive(:valid?).with(uri).once
-        URIChecker.valid_for_authorization?(uri, client_uri)
+        expect(described_class).to receive(:valid?).with(uri).once
+        described_class.valid_for_authorization?(uri, client_uri)
       end
     end
 
     describe ".query_matches?" do
       it "is true if no queries" do
-        expect(URIChecker.query_matches?("", "")).to be_truthy
-        expect(URIChecker.query_matches?(nil, nil)).to be_truthy
+        expect(described_class).to be_query_matches("", "")
+        expect(described_class).to be_query_matches(nil, nil)
       end
 
       it "is true if same query" do
-        expect(URIChecker.query_matches?("foo", "foo")).to be_truthy
+        expect(described_class).to be_query_matches("foo", "foo")
       end
 
       it "is false if different query" do
-        expect(URIChecker.query_matches?("foo", "bar")).to be_falsey
+        expect(described_class).not_to be_query_matches("foo", "bar")
       end
 
       it "is true if same queries" do
-        expect(URIChecker.query_matches?("foo&bar", "foo&bar")).to be_truthy
+        expect(described_class).to be_query_matches("foo&bar", "foo&bar")
       end
 
       it "is true if same queries, different order" do
-        expect(URIChecker.query_matches?("foo&bar", "bar&foo")).to be_truthy
+        expect(described_class).to be_query_matches("foo&bar", "bar&foo")
       end
 
       it "is false if one different query" do
-        expect(URIChecker.query_matches?("foo&bang", "foo&bing")).to be_falsey
+        expect(described_class).not_to be_query_matches("foo&bang", "foo&bing")
       end
 
       it "is true if same query with same value" do
-        expect(URIChecker.query_matches?("foo=bar", "foo=bar")).to be_truthy
+        expect(described_class).to be_query_matches("foo=bar", "foo=bar")
       end
 
       it "is true if same queries with same values" do
-        expect(URIChecker.query_matches?("foo=bar&bing=bang", "foo=bar&bing=bang")).to be_truthy
+        expect(described_class).to be_query_matches("foo=bar&bing=bang", "foo=bar&bing=bang")
       end
 
       it "is true if same queries with same values, different order" do
-        expect(URIChecker.query_matches?("foo=bar&bing=bang", "bing=bang&foo=bar")).to be_truthy
+        expect(described_class).to be_query_matches("foo=bar&bing=bang", "bing=bang&foo=bar")
       end
 
       it "is false if same query with different value" do
-        expect(URIChecker.query_matches?("foo=bar", "foo=bang")).to be_falsey
+        expect(described_class).not_to be_query_matches("foo=bar", "foo=bang")
       end
 
       it "is false if some queries missing" do
-        expect(URIChecker.query_matches?("foo=bar", "foo=bar&bing=bang")).to be_falsey
+        expect(described_class).not_to be_query_matches("foo=bar", "foo=bar&bing=bang")
       end
 
       it "is false if some queries different value" do
-        expect(URIChecker.query_matches?("foo=bar&bing=bang", "foo=bar&bing=banana")).to be_falsey
+        expect(described_class).not_to be_query_matches("foo=bar&bing=bang", "foo=bar&bing=banana")
       end
     end
   end