doorkeeper 5.1.0.rc2 → 5.1.0

data/lib/generators/doorkeeper/views_generator.rb

@@ -2,14 +2,16 @@
 
 module Doorkeeper
   module Generators
+    # Generates doorkeeper views for Rails application
+    #
     class ViewsGenerator < ::Rails::Generators::Base
-      source_root File.expand_path('../../../app/views', __dir__)
+      source_root File.expand_path("../../../app/views", __dir__)
 
-      desc 'Copies default Doorkeeper views and layouts to your application.'
+      desc "Copies default Doorkeeper views and layouts to your application."
 
       def manifest
-        directory 'doorkeeper', 'app/views/doorkeeper'
-        directory 'layouts/doorkeeper', 'app/views/layouts/doorkeeper'
+        directory "doorkeeper", "app/views/doorkeeper"
+        directory "layouts/doorkeeper", "app/views/layouts/doorkeeper"
       end
     end
   end

data/spec/controllers/application_metal_controller_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper_integration'
+require "spec_helper_integration"
 
 describe Doorkeeper::ApplicationMetalController do
   controller(Doorkeeper::ApplicationMetalController) do
@@ -20,42 +20,42 @@ describe Doorkeeper::ApplicationMetalController do
     expect(i).to eq 1
   end
 
-  describe 'enforce_content_type' do
+  describe "enforce_content_type" do
     before { allow(Doorkeeper.configuration).to receive(:enforce_content_type).and_return(flag) }
 
-    context 'enabled' do
+    context "enabled" do
       let(:flag) { true }
 
-      it 'returns a 200 for the requests without body' do
+      it "returns a 200 for the requests without body" do
         get :index, params: {}
         expect(response).to have_http_status 200
       end
 
-      it 'returns a 200 for the requests with body and correct media type' do
+      it "returns a 200 for the requests with body and correct media type" do
         post :create, params: {}, as: :url_encoded_form
         expect(response).to have_http_status 200
       end
 
-      it 'returns a 415 for the requests with body and incorrect media type' do
+      it "returns a 415 for the requests with body and incorrect media type" do
         post :create, params: {}, as: :json
         expect(response).to have_http_status 415
       end
     end
 
-    context 'disabled' do
+    context "disabled" do
       let(:flag) { false }
 
-      it 'returns a 200 for the correct media type' do
+      it "returns a 200 for the correct media type" do
         get :index, as: :url_encoded_form
         expect(response).to have_http_status 200
       end
 
-      it 'returns a 200 for an incorrect media type' do
+      it "returns a 200 for an incorrect media type" do
         get :index, as: :json
         expect(response).to have_http_status 200
       end
 
-      it 'returns a 200 for the requests with body and incorrect media type' do
+      it "returns a 200 for the requests with body and incorrect media type" do
         post :create, params: {}, as: :json
         expect(response).to have_http_status 200
       end

data/spec/controllers/applications_controller_spec.rb

@@ -1,8 +1,10 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 module Doorkeeper
   describe ApplicationsController do
-    context 'JSON API' do
+    context "JSON API" do
       render_views
 
       before do
@@ -10,81 +12,81 @@ module Doorkeeper
         allow(Doorkeeper.configuration).to receive(:authenticate_admin).and_return(->(*) { true })
       end
 
-      it 'creates an application' do
+      it "creates an application" do
         expect do
           post :create, params: {
             doorkeeper_application: {
-              name: 'Example',
-              redirect_uri: 'https://example.com'
-            }, format: :json
+              name: "Example",
+              redirect_uri: "https://example.com",
+            }, format: :json,
           }
         end.to(change { Doorkeeper::Application.count })
 
         expect(response).to be_successful
 
-        expect(json_response).to include('id', 'name', 'uid', 'secret', 'redirect_uri', 'scopes')
+        expect(json_response).to include("id", "name", "uid", "secret", "redirect_uri", "scopes")
 
-        expect(json_response['name']).to eq('Example')
-        expect(json_response['redirect_uri']).to eq('https://example.com')
+        expect(json_response["name"]).to eq("Example")
+        expect(json_response["redirect_uri"]).to eq("https://example.com")
       end
 
-      it 'returns validation errors on wrong create params' do
+      it "returns validation errors on wrong create params" do
         expect do
           post :create, params: {
             doorkeeper_application: {
-              name: 'Example'
-            }, format: :json
+              name: "Example",
+            }, format: :json,
           }
         end.not_to(change { Doorkeeper::Application.count })
 
         expect(response).to have_http_status(422)
 
-        expect(json_response).to include('errors')
+        expect(json_response).to include("errors")
       end
 
-      it 'returns application info' do
-        application = FactoryBot.create(:application, name: 'Change me')
+      it "returns application info" do
+        application = FactoryBot.create(:application, name: "Change me")
 
         get :show, params: { id: application.id, format: :json }
 
         expect(response).to be_successful
 
-        expect(json_response).to include('id', 'name', 'uid', 'secret', 'redirect_uri', 'scopes')
+        expect(json_response).to include("id", "name", "uid", "secret", "redirect_uri", "scopes")
       end
 
-      it 'updates application' do
-        application = FactoryBot.create(:application, name: 'Change me')
+      it "updates application" do
+        application = FactoryBot.create(:application, name: "Change me")
 
         put :update, params: {
           id: application.id,
           doorkeeper_application: {
-            name: 'Example App',
-            redirect_uri: 'https://example.com'
-          }, format: :json
+            name: "Example App",
+            redirect_uri: "https://example.com",
+          }, format: :json,
         }
 
-        expect(application.reload.name).to eq 'Example App'
+        expect(application.reload.name).to eq "Example App"
 
-        expect(json_response).to include('id', 'name', 'uid', 'secret', 'redirect_uri', 'scopes')
+        expect(json_response).to include("id", "name", "uid", "secret", "redirect_uri", "scopes")
       end
 
-      it 'returns validation errors on wrong update params' do
-        application = FactoryBot.create(:application, name: 'Change me')
+      it "returns validation errors on wrong update params" do
+        application = FactoryBot.create(:application, name: "Change me")
 
         put :update, params: {
           id: application.id,
           doorkeeper_application: {
-            name: 'Example App',
-            redirect_uri: 'localhost:3000'
-          }, format: :json
+            name: "Example App",
+            redirect_uri: "localhost:3000",
+          }, format: :json,
         }
 
         expect(response).to have_http_status(422)
 
-        expect(json_response).to include('errors')
+        expect(json_response).to include("errors")
       end
 
-      it 'destroys an application' do
+      it "destroys an application" do
         application = FactoryBot.create(:application)
 
         delete :destroy, params: { id: application.id, format: :json }
@@ -94,38 +96,38 @@ module Doorkeeper
       end
     end
 
-    context 'when admin is not authenticated' do
+    context "when admin is not authenticated" do
       before do
         allow(Doorkeeper.configuration).to receive(:authenticate_admin).and_return(proc do
           redirect_to main_app.root_url
         end)
       end
 
-      it 'redirects as set in Doorkeeper.authenticate_admin' do
+      it "redirects as set in Doorkeeper.authenticate_admin" do
         get :index
         expect(response).to redirect_to(controller.main_app.root_url)
       end
 
-      it 'does not create application' do
+      it "does not create application" do
         expect do
           post :create, params: {
             doorkeeper_application: {
-              name: 'Example',
-              redirect_uri: 'https://example.com'
-            }
+              name: "Example",
+              redirect_uri: "https://example.com",
+            },
           }
         end.not_to(change { Doorkeeper::Application.count })
       end
     end
 
-    context 'when admin is authenticated' do
+    context "when admin is authenticated" do
       render_views
 
       before do
         allow(Doorkeeper.configuration).to receive(:authenticate_admin).and_return(->(*) { true })
       end
 
-      it 'sorts applications by created_at' do
+      it "sorts applications by created_at" do
         first_application = FactoryBot.create(:application)
         second_application = FactoryBot.create(:application)
         expect(Doorkeeper::Application).to receive(:ordered_by).and_call_original
@@ -136,42 +138,42 @@ module Doorkeeper
         expect(response.body).to have_selector("tbody tr:last-child#application_#{second_application.id}")
       end
 
-      it 'creates application' do
+      it "creates application" do
         expect do
           post :create, params: {
             doorkeeper_application: {
-              name: 'Example',
-              redirect_uri: 'https://example.com'
-            }
+              name: "Example",
+              redirect_uri: "https://example.com",
+            },
           }
         end.to change { Doorkeeper::Application.count }.by(1)
 
         expect(response).to be_redirect
       end
 
-      it 'does not allow mass assignment of uid or secret' do
+      it "does not allow mass assignment of uid or secret" do
         application = FactoryBot.create(:application)
         put :update, params: {
           id: application.id,
           doorkeeper_application: {
-            uid: '1A2B3C4D',
-            secret: '1A2B3C4D'
-          }
+            uid: "1A2B3C4D",
+            secret: "1A2B3C4D",
+          },
         }
 
-        expect(application.reload.uid).not_to eq '1A2B3C4D'
+        expect(application.reload.uid).not_to eq "1A2B3C4D"
       end
 
-      it 'updates application' do
+      it "updates application" do
         application = FactoryBot.create(:application)
         put :update, params: {
           id: application.id, doorkeeper_application: {
-            name: 'Example',
-            redirect_uri: 'https://example.com'
-          }
+            name: "Example",
+            redirect_uri: "https://example.com",
+          },
         }
 
-        expect(application.reload.name).to eq 'Example'
+        expect(application.reload.name).to eq "Example"
       end
     end
   end

data/spec/controllers/authorizations_controller_spec.rb

@@ -1,24 +1,15 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe Doorkeeper::AuthorizationsController, 'implicit grant flow' do
+require "spec_helper"
+
+describe Doorkeeper::AuthorizationsController, "implicit grant flow" do
   include AuthorizationRequestHelper
 
-  if Rails::VERSION::MAJOR >= 5
-    class ActionDispatch::TestResponse
-      def query_params
-        @query_params ||= begin
-          fragment = URI.parse(location).fragment
-          Rack::Utils.parse_query(fragment)
-        end
-      end
-    end
-  else
-    class ActionController::TestResponse
-      def query_params
-        @query_params ||= begin
-          fragment = URI.parse(location).fragment
-          Rack::Utils.parse_query(fragment)
-        end
+  class ActionDispatch::TestResponse
+    def query_params
+      @query_params ||= begin
+        fragment = URI.parse(location).fragment
+        Rack::Utils.parse_query(fragment)
       end
     end
   end
@@ -28,47 +19,50 @@ describe Doorkeeper::AuthorizationsController, 'implicit grant flow' do
   end
 
   let(:client)        { FactoryBot.create :application }
-  let(:user)          { User.create!(name: 'Joe', password: 'sekret') }
+  let(:user)          { User.create!(name: "Joe", password: "sekret") }
   let(:access_token)  { FactoryBot.build :access_token, resource_owner_id: user.id, application_id: client.id }
 
   before do
+    Doorkeeper.configure do
+      custom_access_token_expires_in(lambda do |context|
+        context.grant_type == Doorkeeper::OAuth::IMPLICIT ? 1234 : nil
+      end)
+    end
+
     allow(Doorkeeper.configuration).to receive(:grant_flows).and_return(["implicit"])
     allow(controller).to receive(:current_resource_owner).and_return(user)
-    allow(Doorkeeper.configuration).to receive(:custom_access_token_expires_in).and_return(proc { |context|
-      context.grant_type == Doorkeeper::OAuth::IMPLICIT ? 1234 : nil
-    })
   end
 
-  describe 'POST #create' do
+  describe "POST #create" do
     before do
-      post :create, params: { client_id: client.uid, response_type: 'token', redirect_uri: client.redirect_uri }
+      post :create, params: { client_id: client.uid, response_type: "token", redirect_uri: client.redirect_uri }
     end
 
-    it 'redirects after authorization' do
+    it "redirects after authorization" do
       expect(response).to be_redirect
     end
 
-    it 'redirects to client redirect uri' do
+    it "redirects to client redirect uri" do
       expect(response.location).to match(/^#{client.redirect_uri}/)
     end
 
-    it 'includes access token in fragment' do
-      expect(response.query_params['access_token']).to eq(Doorkeeper::AccessToken.first.token)
+    it "includes access token in fragment" do
+      expect(response.query_params["access_token"]).to eq(Doorkeeper::AccessToken.first.token)
     end
 
-    it 'includes token type in fragment' do
-      expect(response.query_params['token_type']).to eq('Bearer')
+    it "includes token type in fragment" do
+      expect(response.query_params["token_type"]).to eq("Bearer")
     end
 
-    it 'includes token expiration in fragment' do
-      expect(response.query_params['expires_in'].to_i).to eq(1234)
+    it "includes token expiration in fragment" do
+      expect(response.query_params["expires_in"].to_i).to eq(1234)
     end
 
-    it 'issues the token for the current client' do
+    it "issues the token for the current client" do
       expect(Doorkeeper::AccessToken.first.application_id).to eq(client.id)
     end
 
-    it 'issues the token for the current resource owner' do
+    it "issues the token for the current resource owner" do
       expect(Doorkeeper::AccessToken.first.resource_owner_id).to eq(user.id)
     end
   end
@@ -111,85 +105,85 @@ describe Doorkeeper::AuthorizationsController, 'implicit grant flow' do
     end
   end
 
-  describe 'POST #create with errors' do
+  describe "POST #create with errors" do
     before do
       default_scopes_exist :public
 
       post :create, params: {
         client_id: client.uid,
-        response_type: 'token',
-        scope: 'invalid',
-        redirect_uri: client.redirect_uri
+        response_type: "token",
+        scope: "invalid",
+        redirect_uri: client.redirect_uri,
       }
     end
 
-    it 'redirects after authorization' do
+    it "redirects after authorization" do
       expect(response).to be_redirect
     end
 
-    it 'redirects to client redirect uri' do
+    it "redirects to client redirect uri" do
       expect(response.location).to match(/^#{client.redirect_uri}/)
     end
 
-    it 'does not include access token in fragment' do
-      expect(response.query_params['access_token']).to be_nil
+    it "does not include access token in fragment" do
+      expect(response.query_params["access_token"]).to be_nil
     end
 
-    it 'includes error in fragment' do
-      expect(response.query_params['error']).to eq('invalid_scope')
+    it "includes error in fragment" do
+      expect(response.query_params["error"]).to eq("invalid_scope")
     end
 
-    it 'includes error description in fragment' do
-      expect(response.query_params['error_description']).to eq(translated_error_message(:invalid_scope))
+    it "includes error description in fragment" do
+      expect(response.query_params["error_description"]).to eq(translated_error_message(:invalid_scope))
     end
 
-    it 'does not issue any access token' do
+    it "does not issue any access token" do
       expect(Doorkeeper::AccessToken.all).to be_empty
     end
   end
 
-  describe 'POST #create in API mode with errors' do
+  describe "POST #create in API mode with errors" do
     before do
       allow(Doorkeeper.configuration).to receive(:api_only).and_return(true)
       default_scopes_exist :public
 
       post :create, params: {
         client_id: client.uid,
-        response_type: 'token',
-        scope: 'invalid',
-        redirect_uri: client.redirect_uri
+        response_type: "token",
+        scope: "invalid",
+        redirect_uri: client.redirect_uri,
       }
     end
 
     let(:response_json_body) { JSON.parse(response.body) }
-    let(:redirect_uri) { response_json_body['redirect_uri'] }
+    let(:redirect_uri) { response_json_body["redirect_uri"] }
 
-    it 'renders 400 error' do
+    it "renders 400 error" do
       expect(response.status).to eq 400
     end
 
-    it 'includes correct redirect URI' do
+    it "includes correct redirect URI" do
       expect(redirect_uri).to match(/^#{client.redirect_uri}/)
     end
 
-    it 'does not include access token in fragment' do
+    it "does not include access token in fragment" do
       expect(redirect_uri.match(/access_token=([a-f0-9]+)&?/)).to be_nil
     end
 
-    it 'includes error in redirect uri' do
-      expect(redirect_uri.match(/error=([a-z_]+)&?/)[1]).to eq 'invalid_scope'
+    it "includes error in redirect uri" do
+      expect(redirect_uri.match(/error=([a-z_]+)&?/)[1]).to eq "invalid_scope"
     end
 
-    it 'includes error description in redirect uri' do
+    it "includes error description in redirect uri" do
       expect(redirect_uri.match(/error_description=(.+)&?/)[1]).to_not be_nil
     end
 
-    it 'does not issue any access token' do
+    it "does not issue any access token" do
       expect(Doorkeeper::AccessToken.all).to be_empty
     end
   end
 
-  describe 'POST #create with application already authorized' do
+  describe "POST #create with application already authorized" do
     before do
       allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(true)
 
@@ -197,121 +191,121 @@ describe Doorkeeper::AuthorizationsController, 'implicit grant flow' do
 
       post :create, params: {
         client_id: client.uid,
-        response_type: 'token',
-        redirect_uri: client.redirect_uri
+        response_type: "token",
+        redirect_uri: client.redirect_uri,
       }
     end
 
-    it 'returns the existing access token in a fragment' do
-      expect(response.query_params['access_token']).to eq(access_token.token)
+    it "returns the existing access token in a fragment" do
+      expect(response.query_params["access_token"]).to eq(access_token.token)
     end
 
-    it 'does not creates a new access token' do
+    it "does not creates a new access token" do
       expect(Doorkeeper::AccessToken.count).to eq(1)
     end
   end
 
-  describe 'POST #create with callbacks' do
+  describe "POST #create with callbacks" do
     after do
-      client.update_attribute :redirect_uri, 'urn:ietf:wg:oauth:2.0:oob'
+      client.update_attribute :redirect_uri, "urn:ietf:wg:oauth:2.0:oob"
     end
 
-    describe 'when successful' do
+    describe "when successful" do
       after do
         post :create, params: {
           client_id: client.uid,
-          response_type: 'token',
-          redirect_uri: client.redirect_uri
+          response_type: "token",
+          redirect_uri: client.redirect_uri,
         }
       end
 
-      it 'should call :before_successful_authorization callback' do
+      it "should call :before_successful_authorization callback" do
         expect(Doorkeeper.configuration)
           .to receive_message_chain(:before_successful_authorization, :call).with(instance_of(described_class))
       end
 
-      it 'should call :after_successful_authorization callback' do
+      it "should call :after_successful_authorization callback" do
         expect(Doorkeeper.configuration)
           .to receive_message_chain(:after_successful_authorization, :call).with(instance_of(described_class))
       end
     end
 
-    describe 'with errors' do
+    describe "with errors" do
       after do
-        post :create, params: { client_id: client.uid, response_type: 'token', redirect_uri: 'bad_uri' }
+        post :create, params: { client_id: client.uid, response_type: "token", redirect_uri: "bad_uri" }
       end
 
-      it 'should not call :before_successful_authorization callback' do
+      it "should not call :before_successful_authorization callback" do
         expect(Doorkeeper.configuration).not_to receive(:before_successful_authorization)
       end
 
-      it 'should not call :after_successful_authorization callback' do
+      it "should not call :after_successful_authorization callback" do
         expect(Doorkeeper.configuration).not_to receive(:after_successful_authorization)
       end
     end
   end
 
-  describe 'GET #new token request with native url and skip_authorization true' do
+  describe "GET #new token request with native url and skip_authorization true" do
     before do
       allow(Doorkeeper.configuration).to receive(:skip_authorization).and_return(proc do
         true
       end)
 
-      client.update_attribute :redirect_uri, 'urn:ietf:wg:oauth:2.0:oob'
+      client.update_attribute :redirect_uri, "urn:ietf:wg:oauth:2.0:oob"
 
       get :new, params: {
         client_id: client.uid,
-        response_type: 'token',
-        redirect_uri: client.redirect_uri
+        response_type: "token",
+        redirect_uri: client.redirect_uri,
       }
     end
 
-    it 'should redirect immediately' do
+    it "should redirect immediately" do
       expect(response).to be_redirect
       expect(response.location).to match(%r{/oauth/token/info\?access_token=})
     end
 
-    it 'should not issue a grant' do
+    it "should not issue a grant" do
       expect(Doorkeeper::AccessGrant.count).to be 0
     end
 
-    it 'should issue a token' do
+    it "should issue a token" do
       expect(Doorkeeper::AccessToken.count).to be 1
     end
   end
 
-  describe 'GET #new code request with native url and skip_authorization true' do
+  describe "GET #new code request with native url and skip_authorization true" do
     before do
       allow(Doorkeeper.configuration).to receive(:grant_flows).and_return(%w[authorization_code])
       allow(Doorkeeper.configuration).to receive(:skip_authorization).and_return(proc do
         true
       end)
 
-      client.update_attribute :redirect_uri, 'urn:ietf:wg:oauth:2.0:oob'
+      client.update_attribute :redirect_uri, "urn:ietf:wg:oauth:2.0:oob"
 
       get :new, params: {
         client_id: client.uid,
-        response_type: 'code',
-        redirect_uri: client.redirect_uri
+        response_type: "code",
+        redirect_uri: client.redirect_uri,
       }
     end
 
-    it 'should redirect immediately' do
+    it "should redirect immediately" do
       expect(response).to be_redirect
       expect(response.location)
         .to match(%r{/oauth/authorize/native\?code=#{Doorkeeper::AccessGrant.first.token}})
     end
 
-    it 'should issue a grant' do
+    it "should issue a grant" do
       expect(Doorkeeper::AccessGrant.count).to be 1
     end
 
-    it 'should not issue a token' do
+    it "should not issue a token" do
       expect(Doorkeeper::AccessToken.count).to be 0
     end
   end
 
-  describe 'GET #new with skip_authorization true' do
+  describe "GET #new with skip_authorization true" do
     before do
       allow(Doorkeeper.configuration).to receive(:skip_authorization).and_return(proc do
         true
@@ -319,82 +313,82 @@ describe Doorkeeper::AuthorizationsController, 'implicit grant flow' do
 
       get :new, params: {
         client_id: client.uid,
-        response_type: 'token',
-        redirect_uri: client.redirect_uri
+        response_type: "token",
+        redirect_uri: client.redirect_uri,
       }
     end
 
-    it 'should redirect immediately' do
+    it "should redirect immediately" do
       expect(response).to be_redirect
       expect(response.location).to match(/^#{client.redirect_uri}/)
     end
 
-    it 'should issue a token' do
+    it "should issue a token" do
       expect(Doorkeeper::AccessToken.count).to be 1
     end
 
-    it 'includes token type in fragment' do
-      expect(response.query_params['token_type']).to eq('Bearer')
+    it "includes token type in fragment" do
+      expect(response.query_params["token_type"]).to eq("Bearer")
     end
 
-    it 'includes token expiration in fragment' do
-      expect(response.query_params['expires_in'].to_i).to eq(1234)
+    it "includes token expiration in fragment" do
+      expect(response.query_params["expires_in"].to_i).to eq(1234)
     end
 
-    it 'issues the token for the current client' do
+    it "issues the token for the current client" do
       expect(Doorkeeper::AccessToken.first.application_id).to eq(client.id)
     end
 
-    it 'issues the token for the current resource owner' do
+    it "issues the token for the current resource owner" do
       expect(Doorkeeper::AccessToken.first.resource_owner_id).to eq(user.id)
     end
   end
 
-  describe 'GET #new in API mode' do
+  describe "GET #new in API mode" do
     before do
       allow(Doorkeeper.configuration).to receive(:api_only).and_return(true)
 
       get :new, params: {
         client_id: client.uid,
-        response_type: 'token',
-        redirect_uri: client.redirect_uri
+        response_type: "token",
+        redirect_uri: client.redirect_uri,
       }
     end
 
-    it 'should render success' do
+    it "should render success" do
       expect(response).to be_successful
     end
 
     it "sets status to pre-authorization" do
-      expect(json_response["status"]).to eq(I18n.t('doorkeeper.pre_authorization.status'))
+      expect(json_response["status"]).to eq(I18n.t("doorkeeper.pre_authorization.status"))
     end
 
     it "sets correct values" do
-      expect(json_response['client_id']).to eq(client.uid)
-      expect(json_response['redirect_uri']).to eq(client.redirect_uri)
-      expect(json_response['state']).to be_nil
-      expect(json_response['response_type']).to eq('token')
-      expect(json_response['scope']).to eq('')
+      expect(json_response["client_id"]).to eq(client.uid)
+      expect(json_response["redirect_uri"]).to eq(client.redirect_uri)
+      expect(json_response["state"]).to be_nil
+      expect(json_response["response_type"]).to eq("token")
+      expect(json_response["scope"]).to eq("")
     end
   end
 
-  describe 'GET #new in API mode with skip_authorization true' do
+  describe "GET #new in API mode with skip_authorization true" do
     before do
       allow(Doorkeeper.configuration).to receive(:skip_authorization).and_return(proc { true })
       allow(Doorkeeper.configuration).to receive(:api_only).and_return(true)
 
       get :new, params: {
         client_id: client.uid,
-        response_type: 'token',
-        redirect_uri: client.redirect_uri
+        response_type: "token",
+        redirect_uri: client.redirect_uri,
       }
     end
 
-    it 'should render success' do
+    it "should render success" do
       expect(response).to be_successful
     end
 
-    it 'should issue a token' do
+    it "should issue a token" do
       expect(Doorkeeper::AccessToken.count).to be 1
     end
 
@@ -421,104 +415,104 @@ describe Doorkeeper::AuthorizationsController, 'implicit grant flow' do
     end
   end
 
-  describe 'GET #new with errors' do
+  describe "GET #new with errors" do
     before do
       default_scopes_exist :public
-      get :new, params: { an_invalid: 'request' }
+      get :new, params: { an_invalid: "request" }
     end
 
-    it 'does not redirect' do
+    it "does not redirect" do
       expect(response).to_not be_redirect
     end
 
-    it 'does not issue any token' do
+    it "does not issue any token" do
       expect(Doorkeeper::AccessGrant.count).to eq 0
       expect(Doorkeeper::AccessToken.count).to eq 0
     end
   end
 
-  describe 'GET #new in API mode with errors' do
+  describe "GET #new in API mode with errors" do
     let(:response_json_body) { JSON.parse(response.body) }
 
     before do
       default_scopes_exist :public
       allow(Doorkeeper.configuration).to receive(:api_only).and_return(true)
-      get :new, params: { an_invalid: 'request' }
+      get :new, params: { an_invalid: "request" }
     end
 
-    it 'should render bad request' do
+    it "should render bad request" do
       expect(response).to have_http_status(:bad_request)
     end
 
-    it 'includes error in body' do
-      expect(response_json_body['error']).to eq('unsupported_response_type')
+    it "includes error in body" do
+      expect(response_json_body["error"]).to eq("unsupported_response_type")
     end
 
-    it 'includes error description in body' do
-      expect(response_json_body['error_description'])
+    it "includes error description in body" do
+      expect(response_json_body["error_description"])
         .to eq(translated_error_message(:unsupported_response_type))
     end
 
-    it 'does not issue any token' do
+    it "does not issue any token" do
       expect(Doorkeeper::AccessGrant.count).to eq 0
       expect(Doorkeeper::AccessToken.count).to eq 0
     end
   end
 
-  describe 'GET #new with callbacks' do
+  describe "GET #new with callbacks" do
     after do
-      client.update_attribute :redirect_uri, 'urn:ietf:wg:oauth:2.0:oob'
-      get :new, params: { client_id: client.uid, response_type: 'token', redirect_uri: client.redirect_uri }
+      client.update_attribute :redirect_uri, "urn:ietf:wg:oauth:2.0:oob"
+      get :new, params: { client_id: client.uid, response_type: "token", redirect_uri: client.redirect_uri }
     end
 
-    describe 'when authorizing' do
+    describe "when authorizing" do
       before do
         allow(Doorkeeper.configuration).to receive(:skip_authorization).and_return(proc { true })
       end
 
-      it 'should call :before_successful_authorization callback' do
+      it "should call :before_successful_authorization callback" do
         expect(Doorkeeper.configuration)
           .to receive_message_chain(:before_successful_authorization, :call).with(instance_of(described_class))
       end
 
-      it 'should call :after_successful_authorization callback' do
+      it "should call :after_successful_authorization callback" do
         expect(Doorkeeper.configuration)
           .to receive_message_chain(:after_successful_authorization, :call).with(instance_of(described_class))
       end
     end
 
-    describe 'when not authorizing' do
+    describe "when not authorizing" do
       before do
         allow(Doorkeeper.configuration).to receive(:skip_authorization).and_return(proc { false })
       end
 
-      it 'should not call :before_successful_authorization callback' do
+      it "should not call :before_successful_authorization callback" do
         expect(Doorkeeper.configuration).not_to receive(:before_successful_authorization)
       end
 
-      it 'should not call :after_successful_authorization callback' do
+      it "should not call :after_successful_authorization callback" do
         expect(Doorkeeper.configuration).not_to receive(:after_successful_authorization)
       end
     end
 
-    describe 'when not authorizing in api mode' do
+    describe "when not authorizing in api mode" do
       before do
         allow(Doorkeeper.configuration).to receive(:skip_authorization).and_return(proc { false })
         allow(Doorkeeper.configuration).to receive(:api_only).and_return(true)
       end
 
-      it 'should not call :before_successful_authorization callback' do
+      it "should not call :before_successful_authorization callback" do
         expect(Doorkeeper.configuration).not_to receive(:before_successful_authorization)
       end
 
-      it 'should not call :after_successful_authorization callback' do
+      it "should not call :after_successful_authorization callback" do
         expect(Doorkeeper.configuration).not_to receive(:after_successful_authorization)
       end
     end
   end
 
-  describe 'authorize response memoization' do
-    it 'memoizes the result of the authorization' do
+  describe "authorize response memoization" do
+    it "memoizes the result of the authorization" do
       strategy = double(:strategy, authorize: true)
       expect(strategy).to receive(:authorize).once
       allow(controller).to receive(:strategy) { strategy }