doorkeeper-mongodb 5.2.1 → 5.2.3

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

data/spec/lib/oauth/invalid_request_response_spec.rb

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-describe Doorkeeper::OAuth::InvalidRequestResponse do
+RSpec.describe Doorkeeper::OAuth::InvalidRequestResponse do
   describe "#name" do
     it { expect(subject.name).to eq(:invalid_request) }
   end
@@ -14,7 +14,7 @@ describe Doorkeeper::OAuth::InvalidRequestResponse do
   describe ".from_request" do
     let(:response) { described_class.from_request(request) }
 
-    context "missing param" do
+    context "when param missed" do
       let(:request) { double(missing_param: "some_param") }
 
       it "sets a description" do
@@ -28,7 +28,7 @@ describe Doorkeeper::OAuth::InvalidRequestResponse do
       end
     end
 
-    context "server doesn't support_pkce" do
+    context "when server doesn't support PKCE" do
       let(:request) { double(invalid_request_reason: :not_support_pkce) }
 
       it "sets a description" do
@@ -42,7 +42,7 @@ describe Doorkeeper::OAuth::InvalidRequestResponse do
       end
     end
 
-    context "request is not authorized" do
+    context "when request is not authorized" do
       let(:request) { double(invalid_request_reason: :request_not_authorized) }
 
       it "sets a description" do
@@ -56,7 +56,7 @@ describe Doorkeeper::OAuth::InvalidRequestResponse do
       end
     end
 
-    context "unknown reason" do
+    context "when unknown reason" do
       let(:request) { double(invalid_request_reason: :unknown_reason) }
 
       it "sets a description" do
@@ -65,7 +65,7 @@ describe Doorkeeper::OAuth::InvalidRequestResponse do
         )
       end
 
-      it "unknown reason" do
+      it "sets the reason to unknown" do
         expect(response.reason).to eq(:unknown_reason)
       end
     end

data/spec/lib/oauth/invalid_token_response_spec.rb

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-describe Doorkeeper::OAuth::InvalidTokenResponse do
+RSpec.describe Doorkeeper::OAuth::InvalidTokenResponse do
   describe "#name" do
     it { expect(subject.name).to eq(:invalid_token) }
   end
@@ -14,7 +14,7 @@ describe Doorkeeper::OAuth::InvalidTokenResponse do
   describe ".from_access_token" do
     let(:response) { described_class.from_access_token(access_token) }
 
-    context "revoked" do
+    context "when token revoked" do
       let(:access_token) { double(revoked?: true, expired?: true) }
 
       it "sets a description" do
@@ -26,7 +26,7 @@ describe Doorkeeper::OAuth::InvalidTokenResponse do
       end
     end
 
-    context "expired" do
+    context "when token expired" do
       let(:access_token) { double(revoked?: false, expired?: true) }
 
       it "sets a description" do
@@ -38,7 +38,7 @@ describe Doorkeeper::OAuth::InvalidTokenResponse do
       end
     end
 
-    context "unknown" do
+    context "when unknown" do
       let(:access_token) { double(revoked?: false, expired?: false) }
 
       it "sets a description" do

data/spec/lib/oauth/password_access_token_request_spec.rb

@@ -2,7 +2,11 @@
 
 require "spec_helper"
 
-describe Doorkeeper::OAuth::PasswordAccessTokenRequest do
+RSpec.describe Doorkeeper::OAuth::PasswordAccessTokenRequest do
+  subject do
+    described_class.new(server, client, owner)
+  end
+
   let(:server) do
     double(
       :server,
@@ -14,23 +18,20 @@ describe Doorkeeper::OAuth::PasswordAccessTokenRequest do
       },
     )
   end
-  let(:client) { FactoryBot.create(:application) }
-  let(:owner)  { FactoryBot.create(:resource_owner) }
+  let(:client) { Doorkeeper::OAuth::Client.new(FactoryBot.create(:application)) }
+  let(:application) { client.application }
+  let(:owner) { FactoryBot.build_stubbed(:resource_owner) }
 
   before do
     allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(true)
   end
 
-  subject do
-    described_class.new(server, client, owner)
-  end
-
   it "issues a new token for the client" do
     expect do
       subject.authorize
-    end.to change { client.reload.access_tokens.count }.by(1)
+    end.to change { application.reload.access_tokens.count }.by(1)
 
-    expect(client.reload.access_tokens.max_by(&:created_at).expires_in).to eq(1234)
+    expect(application.reload.access_tokens.max_by(&:created_at).expires_in).to eq(1234)
   end
 
   it "issues a new token without a client" do

data/spec/lib/oauth/pre_authorization_spec.rb

@@ -2,7 +2,11 @@
 
 require "spec_helper"
 
-describe Doorkeeper::OAuth::PreAuthorization do
+RSpec.describe Doorkeeper::OAuth::PreAuthorization do
+  subject do
+    described_class.new(server, attributes)
+  end
+
   let(:server) do
     server = Doorkeeper.configuration
     allow(server).to receive(:default_scopes).and_return(Doorkeeper::OAuth::Scopes.from_string("default"))
@@ -23,10 +27,6 @@ describe Doorkeeper::OAuth::PreAuthorization do
     }
   end
 
-  subject do
-    described_class.new(server, attributes)
-  end
-
   it "is authorizable when request is valid" do
     expect(subject).to be_authorizable
   end
@@ -77,7 +77,19 @@ describe Doorkeeper::OAuth::PreAuthorization do
     end
   end
 
-  context "client application does not restrict valid scopes" do
+  context "when grant flow is client credentials & redirect_uri is nil" do
+    before do
+      allow(server).to receive(:grant_flows).and_return(["client_credentials"])
+      allow(Doorkeeper.configuration).to receive(:allow_grant_flow_for_client?).and_return(false)
+      application.update_column :redirect_uri, nil
+    end
+
+    it "is not authorizable" do
+      expect(subject).not_to be_authorizable
+    end
+  end
+
+  context "when client application does not restrict valid scopes" do
     it "accepts valid scopes" do
       attributes[:scope] = "public"
       expect(subject).to be_authorizable
@@ -101,7 +113,7 @@ describe Doorkeeper::OAuth::PreAuthorization do
     end
   end
 
-  context "client application restricts valid scopes" do
+  context "when client application restricts valid scopes" do
     let(:application) do
       FactoryBot.create(:application, scopes: Doorkeeper::OAuth::Scopes.from_string("public nonsense"))
     end
@@ -118,7 +130,7 @@ describe Doorkeeper::OAuth::PreAuthorization do
 
     it "rejects (application level) non-valid scopes" do
       attributes[:scope] = "profile"
-      expect(subject).to_not be_authorizable
+      expect(subject).not_to be_authorizable
     end
 
     it "accepts scopes which are permitted for grant_type" do