clearance 2.10.0 → 2.11.0

data/spec/acceptance/clearance_installation_spec.rb

@@ -67,10 +67,10 @@ describe "Clearance Installation" do
   end
 
   def successfully(command, silent = true)
-    if silent
-      silencer = "1>/dev/null"
+    silencer = if silent
+      "1>/dev/null"
     else
-      silencer = ""
+      ""
     end
 
     return_value = system("#{command} #{silencer}")

data/spec/clearance/back_door_spec.rb

@@ -40,8 +40,8 @@ describe Clearance::BackDoor do
 
   it "can't be used outside the allowed environments" do
     with_environment("production") do
-      expect { Clearance::BackDoor.new(mock_app) }.
-        to raise_exception "Can't use auth backdoor outside of configured \
+      expect { Clearance::BackDoor.new(mock_app) }
+        .to raise_exception "Can't use auth backdoor outside of configured \
           environments (test, ci, development).".squish
     end
   end
@@ -65,15 +65,15 @@ describe Clearance::BackDoor do
 
     it "raises an error for a default allowed env" do
       with_environment("test") do
-        expect { Clearance::BackDoor.new(mock_app) }.
-          to raise_exception "BackDoor auth is disabled."
+        expect { Clearance::BackDoor.new(mock_app) }
+          .to raise_exception "BackDoor auth is disabled."
       end
     end
   end
 
   context "when the environments are not defaults" do
     before do
-      Clearance.configuration.allowed_backdoor_environments = ['demo']
+      Clearance.configuration.allowed_backdoor_environments = ["demo"]
     end
 
     it "can be used with configured allowed environments" do

data/spec/clearance/constraints/signed_in_spec.rb

@@ -1,55 +1,55 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Clearance::Constraints::SignedIn do
-  it 'returns true when user is signed in' do
+  it "returns true when user is signed in" do
     user = create(:user)
     constraint = Clearance::Constraints::SignedIn.new
     request = request_with_remember_token(user.remember_token)
     expect(constraint.matches?(request)).to eq true
   end
 
-  it 'returns false when user is not signed in' do
+  it "returns false when user is not signed in" do
     constraint = Clearance::Constraints::SignedIn.new
     request = request_without_remember_token
     expect(constraint.matches?(request)).to eq false
   end
 
-  it 'returns false when clearance session data is not present' do
+  it "returns false when clearance session data is not present" do
     constraint = Clearance::Constraints::SignedIn.new
     request = Rack::Request.new({})
     expect(constraint.matches?(request)).to eq false
   end
 
-  it 'yields a signed-in user to a provided block' do
-    user = create(:user, email: 'before@example.com')
+  it "yields a signed-in user to a provided block" do
+    user = create(:user, email: "before@example.com")
 
     constraint = Clearance::Constraints::SignedIn.new do |signed_in_user|
-      signed_in_user.update_attribute :email, 'after@example.com'
+      signed_in_user.update_attribute :email, "after@example.com"
     end
 
     constraint.matches?(request_with_remember_token(user.remember_token))
-    expect(user.reload.email).to eq 'after@example.com'
+    expect(user.reload.email).to eq "after@example.com"
   end
 
-  it 'does not yield a user if they are not signed in' do
-    user = create(:user, email: 'before@example.com')
+  it "does not yield a user if they are not signed in" do
+    user = create(:user, email: "before@example.com")
 
     constraint = Clearance::Constraints::SignedIn.new do |signed_in_user|
-      signed_in_user.update_attribute :email, 'after@example.com'
+      signed_in_user.update_attribute :email, "after@example.com"
     end
 
     constraint.matches?(request_without_remember_token)
-    expect(user.reload.email).to eq 'before@example.com'
+    expect(user.reload.email).to eq "before@example.com"
   end
 
-  it 'matches if the user-provided block returns true' do
+  it "matches if the user-provided block returns true" do
     user = create(:user)
     constraint = Clearance::Constraints::SignedIn.new { true }
     request = request_with_remember_token(user.remember_token)
     expect(constraint.matches?(request)).to eq true
   end
 
-  it 'does not match if the user-provided block returns false' do
+  it "does not match if the user-provided block returns false" do
     user = create(:user)
     constraint = Clearance::Constraints::SignedIn.new { false }
     request = request_with_remember_token(user.remember_token)

data/spec/clearance/constraints/signed_out_spec.rb

@@ -1,20 +1,20 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Clearance::Constraints::SignedOut do
-  it 'returns true when user is signed out' do
+  it "returns true when user is signed out" do
     constraint = Clearance::Constraints::SignedOut.new
     request = request_without_remember_token
     expect(constraint.matches?(request)).to eq true
   end
 
-  it 'returns false when user is not signed out' do
+  it "returns false when user is not signed out" do
     user = create(:user)
     constraint = Clearance::Constraints::SignedOut.new
     request = request_with_remember_token(user.remember_token)
     expect(constraint.matches?(request)).to eq false
   end
 
-  it 'returns true when clearance info is missing from request' do
+  it "returns true when clearance info is missing from request" do
     constraint = Clearance::Constraints::SignedOut.new
     request = Rack::Request.new({})
     expect(constraint.matches?(request)).to eq true

data/spec/clearance/default_sign_in_guard_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Clearance::DefaultSignInGuard do
-  context 'session is signed in' do
-    it 'returns success' do
+  context "session is signed in" do
+    it "returns success" do
       session = double("Session", signed_in?: true)
       guard = Clearance::DefaultSignInGuard.new(session)
 
@@ -10,8 +10,8 @@ describe Clearance::DefaultSignInGuard do
     end
   end
 
-  context 'session is not signed in' do
-    it 'returns failure' do
+  context "session is not signed in" do
+    it "returns failure" do
       session = double("Session", signed_in?: false)
       guard = Clearance::DefaultSignInGuard.new(session)
 
@@ -23,6 +23,6 @@ describe Clearance::DefaultSignInGuard do
   end
 
   def default_failure_message
-    I18n.t('flashes.failure_after_create').html_safe
+    I18n.t("flashes.failure_after_create").html_safe
   end
 end

data/spec/clearance/rack_session_spec.rb

@@ -1,21 +1,21 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Clearance::RackSession do
-  it 'injects a clearance session into the environment' do
-    headers = { 'X-Roaring-Lobster' => 'Red' }
+  it "injects a clearance session into the environment" do
+    headers = {"X-Roaring-Lobster" => "Red"}
     app = Rack::Builder.new do
       use Clearance::RackSession
       run lambda { |env| Rack::Response.new(env[:clearance], 200, headers).finish }
     end
 
-    env = Rack::MockRequest.env_for('/')
+    env = Rack::MockRequest.env_for("/")
     expected_session = "the session"
     allow(expected_session).to receive(:add_cookie_to_headers)
-    allow(expected_session).to receive(:authentication_successful?).
-      and_return(true)
-    allow(Clearance::Session).to receive(:new).
-      with(env).
-      and_return(expected_session)
+    allow(expected_session).to receive(:authentication_successful?)
+      .and_return(true)
+    allow(Clearance::Session).to receive(:new)
+      .with(env)
+      .and_return(expected_session)
 
     response = Rack::MockResponse.new(*app.call(env))
 

data/spec/clearance/session_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Clearance::Session do
   before { freeze_time }
@@ -7,7 +7,7 @@ describe Clearance::Session do
   let(:session) { Clearance::Session.new(env_without_remember_token) }
   let(:user) { create(:user) }
 
-  it 'finds a user from a cookie' do
+  it "finds a user from a cookie" do
     user = create(:user)
     env = env_with_remember_token(user.remember_token)
     session = Clearance::Session.new(env)
@@ -16,15 +16,15 @@ describe Clearance::Session do
     expect(session.current_user).to eq user
   end
 
-  it 'returns nil for an unknown user' do
-    env = env_with_remember_token('bogus')
+  it "returns nil for an unknown user" do
+    env = env_with_remember_token("bogus")
     session = Clearance::Session.new(env)
 
     expect(session).to be_signed_out
     expect(session.current_user).to be_nil
   end
 
-  it 'returns nil without a remember token' do
+  it "returns nil without a remember token" do
     expect(session).to be_signed_out
     expect(session.current_user).to be_nil
   end
@@ -71,7 +71,7 @@ describe Clearance::Session do
 
     context "signed cookie exists" do
       it "uses cookies.signed[remember_token]" do
-        cookie_jar = { "remember_token" => "signed cookie" }
+        cookie_jar = {"remember_token" => "signed cookie"}
         expect(session).to receive(:cookies).and_return(cookie_jar)
         expect(cookie_jar).to receive(:signed).and_return(cookie_jar)
 
@@ -81,7 +81,7 @@ describe Clearance::Session do
 
     context "signed cookie does not exist yet" do
       it "uses cookies[remember_token] instead" do
-        cookie_jar = { "remember_token" => "signed cookie" }
+        cookie_jar = {"remember_token" => "signed cookie"}
         # first call will try to get the signed cookie
         expect(session).to receive(:cookies).and_return(cookie_jar)
         # ... but signed_cookie doesn't exist
@@ -94,8 +94,8 @@ describe Clearance::Session do
     end
   end
 
-  describe '#sign_in' do
-    it 'sets current_user' do
+  describe "#sign_in" do
+    it "sets current_user" do
       user = build(:user)
 
       session.sign_in user
@@ -103,8 +103,8 @@ describe Clearance::Session do
       expect(session.current_user).to eq user
     end
 
-    context 'with a block' do
-      it 'passes the success status to the block when sign in succeeds' do
+    context "with a block" do
+      it "passes the success status to the block when sign in succeeds" do
         success_status = stub_status(Clearance::SuccessStatus, true)
         success_lambda = stub_callable
 
@@ -113,7 +113,7 @@ describe Clearance::Session do
         expect(success_lambda).to have_been_called.with(success_status)
       end
 
-      it 'passes the failure status to the block when sign in fails' do
+      it "passes the failure status to the block when sign in fails" do
         failure_status = stub_status(Clearance::FailureStatus, false)
         failure_lambda = stub_callable
 
@@ -135,17 +135,16 @@ describe Clearance::Session do
       end
     end
 
-    context 'with nil argument' do
-      it 'assigns current_user' do
+    context "with nil argument" do
+      it "assigns current_user" do
         session.sign_in nil
 
         expect(session.current_user).to be_nil
       end
     end
 
-    context 'with a sign in stack' do
-
-      it 'runs the first guard' do
+    context "with a sign in stack" do
+      it "runs the first guard" do
         guard = stub_sign_in_guard(succeed: true)
         user = build(:user)
 
@@ -154,13 +153,13 @@ describe Clearance::Session do
         expect(guard).to have_received(:call)
       end
 
-      it 'will not sign in the user if the guard stack fails' do
+      it "will not sign in the user if the guard stack fails" do
         stub_sign_in_guard(succeed: false)
         user = build(:user)
 
         session.sign_in user
 
-        expect(session.instance_variable_get("@cookies")).to be_nil
+        expect(session.instance_variable_get(:@cookies)).to be_nil
         expect(session.current_user).to be_nil
       end
 
@@ -174,23 +173,23 @@ describe Clearance::Session do
 
       def stub_default_sign_in_guard
         double("default_sign_in_guard").tap do |sign_in_guard|
-          allow(Clearance::DefaultSignInGuard).to receive(:new).
-            with(session).
-            and_return(sign_in_guard)
+          allow(Clearance::DefaultSignInGuard).to receive(:new)
+            .with(session)
+            .and_return(sign_in_guard)
         end
       end
 
       def stub_guard_class(guard)
         double("guard_class").tap do |guard_class|
-          allow(guard_class).to receive(:to_s).
-            and_return(guard_class)
+          allow(guard_class).to receive(:to_s)
+            .and_return(guard_class)
 
-          allow(guard_class).to receive(:constantize).
-            and_return(guard_class)
+          allow(guard_class).to receive(:constantize)
+            .and_return(guard_class)
 
-          allow(guard_class).to receive(:new).
-            with(session, stub_default_sign_in_guard).
-            and_return(guard)
+          allow(guard_class).to receive(:new)
+            .with(session, stub_default_sign_in_guard)
+            .and_return(guard)
         end
       end
 
@@ -204,25 +203,25 @@ describe Clearance::Session do
     end
   end
 
-  context 'if httponly is set' do
+  context "if httponly is set" do
     before do
       session.sign_in(user)
     end
 
-    it 'sets a httponly cookie' do
+    it "sets a httponly cookie" do
       session.add_cookie_to_headers
 
       expect(remember_token_cookie(session)[:httponly]).to be_truthy
     end
   end
 
-  context 'if httponly is not set' do
+  context "if httponly is not set" do
     before do
       Clearance.configuration.httponly = false
       session.sign_in(user)
     end
 
-    it 'sets a standard cookie' do
+    it "sets a standard cookie" do
       session.add_cookie_to_headers
 
       expect(remember_token_cookie(session)[:httponly]).to be_falsey
@@ -254,9 +253,9 @@ describe Clearance::Session do
     end
   end
 
-  describe 'remember token cookie expiration' do
-    context 'default configuration' do
-      it 'is set to 1 year from now' do
+  describe "remember token cookie expiration" do
+    context "default configuration" do
+      it "is set to 1 year from now" do
         user = double("User", remember_token: "123abc")
         session = Clearance::Session.new(env_without_remember_token)
         session.sign_in user
@@ -266,15 +265,15 @@ describe Clearance::Session do
       end
     end
 
-    context 'configured with lambda taking one argument' do
-      it 'it can use other cookies to set the value of the expires token' do
+    context "configured with lambda taking one argument" do
+      it "it can use other cookies to set the value of the expires token" do
         remembered_expires = 12.hours.from_now
         expires_at = ->(cookies) do
-          cookies['remember_me'] ? remembered_expires : nil
+          cookies["remember_me"] ? remembered_expires : nil
         end
         with_custom_expiration expires_at do
           user = double("User", remember_token: "123abc")
-          environment = env_with_cookies(remember_me: 'true')
+          environment = env_with_cookies(remember_me: "true")
           session = Clearance::Session.new(environment)
           session.sign_in user
           session.add_cookie_to_headers
@@ -287,26 +286,26 @@ describe Clearance::Session do
     end
   end
 
-  describe 'secure cookie option' do
-    context 'when not set' do
+  describe "secure cookie option" do
+    context "when not set" do
       before do
         session.sign_in(user)
       end
 
-      it 'sets a standard cookie' do
+      it "sets a standard cookie" do
         session.add_cookie_to_headers
 
         expect(remember_token_cookie(session)[:secure]).to be_falsey
       end
     end
 
-    context 'when set' do
+    context "when set" do
       before do
         Clearance.configuration.secure_cookie = true
         session.sign_in(user)
       end
 
-      it 'sets a secure cookie' do
+      it "sets a secure cookie" do
         session.add_cookie_to_headers
 
         expect(remember_token_cookie(session)[:secure]).to be_truthy
@@ -342,10 +341,10 @@ describe Clearance::Session do
       end
     end
 
-    context 'when not set' do
+    context "when not set" do
       before { session.sign_in(user) }
 
-      it 'sets a standard cookie' do
+      it "sets a standard cookie" do
         session.add_cookie_to_headers
 
         expect(remember_token_cookie(session)[:domain]).to be_nil
@@ -353,24 +352,24 @@ describe Clearance::Session do
     end
   end
 
-  describe 'cookie path option' do
-    context 'when not set' do
+  describe "cookie path option" do
+    context "when not set" do
       before { session.sign_in(user) }
 
-      it 'sets a standard cookie' do
+      it "sets a standard cookie" do
         session.add_cookie_to_headers
 
         expect(remember_token_cookie(session)[:domain]).to be_nil
       end
     end
 
-    context 'when set' do
+    context "when set" do
       before do
-        Clearance.configuration.cookie_path = '/user'
+        Clearance.configuration.cookie_path = "/user"
         session.sign_in(user)
       end
 
-      it 'sets a standard cookie' do
+      it "sets a standard cookie" do
         session.add_cookie_to_headers
 
         expect(remember_token_cookie(session)[:path]).to eq("/user")
@@ -378,7 +377,7 @@ describe Clearance::Session do
     end
   end
 
-  it 'does not set a remember token when signed out' do
+  it "does not set a remember token when signed out" do
     session = Clearance::Session.new(env_without_remember_token)
     session.add_cookie_to_headers
     expect(remember_token_cookie(session)).to be_nil
@@ -411,7 +410,7 @@ describe Clearance::Session do
         user = create(:user)
         env = env_with_remember_token(
           value: user.remember_token,
-          domain: domain,
+          domain: domain
         )
         session = Clearance::Session.new(env)
         cookie_jar = ActionDispatch::Request.new(env).cookie_jar
@@ -423,9 +422,9 @@ describe Clearance::Session do
       end
     end
 
-    context 'with callable cookie domain' do
-      it 'clears cookie' do
-        domain = '.example.com'
+    context "with callable cookie domain" do
+      it "clears cookie" do
+        domain = ".example.com"
         Clearance.configuration.cookie_domain = ->(_) { domain }
         user = create(:user)
         env = env_with_remember_token(
@@ -454,11 +453,11 @@ describe Clearance::Session do
   end
 
   def env_with_cookies(cookies)
-    Rack::MockRequest.env_for '/', 'HTTP_COOKIE' => serialize_cookies(cookies)
+    Rack::MockRequest.env_for "/", "HTTP_COOKIE" => serialize_cookies(cookies)
   end
 
   def env_with_remember_token(token)
-    env_with_cookies 'remember_token' => token
+    env_with_cookies "remember_token" => token
   end
 
   def env_without_remember_token
@@ -472,8 +471,7 @@ describe Clearance::Session do
       Rack::Utils.set_cookie_header! header, key, value
     end
 
-    cookie = header["set-cookie"] || header["Set-Cookie"]
-    cookie
+    header["set-cookie"] || header["Set-Cookie"]
   end
 
   def have_been_called

data/spec/clearance/sign_in_guard_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Clearance
   describe SignInGuard do
-    it 'handles success' do
+    it "handles success" do
       sign_in_guard = SignInGuard.new(double("session"))
       status = double("status")
       allow(SuccessStatus).to receive(:new).and_return(status)
@@ -10,18 +10,18 @@ module Clearance
       expect(sign_in_guard.success).to eq(status)
     end
 
-    it 'handles failure' do
+    it "handles failure" do
       sign_in_guard = SignInGuard.new(double("session"))
       status = double("status")
       failure_message = "Failed"
-      allow(FailureStatus).to receive(:new).
-        with(failure_message).
-        and_return(status)
+      allow(FailureStatus).to receive(:new)
+        .with(failure_message)
+        .and_return(status)
 
       expect(sign_in_guard.failure(failure_message)).to eq(status)
     end
 
-    it 'can proceed to the next guard' do
+    it "can proceed to the next guard" do
       guards = double("guards", call: true)
       sign_in_guard = SignInGuard.new(double("session"), guards)
       sign_in_guard.next_guard

data/spec/clearance/testing/controller_helpers_spec.rb

@@ -1,24 +1,25 @@
 require "spec_helper"
 
-describe Clearance::Testing::ControllerHelpers do
-  class TestClass
-    include Clearance::Testing::ControllerHelpers
-
-    def initialize
-      @request = Class.new do
-        def env
-          { clearance: Clearance::Session.new({}) }
-        end
-      end.new
-    end
+class TestClass
+  include Clearance::Testing::ControllerHelpers
+
+  def initialize
+    @request = Class.new do
+      def env
+        {clearance: Clearance::Session.new({})}
+      end
+    end.new
   end
+end
 
+MyUserModel = Class.new
+
+describe Clearance::Testing::ControllerHelpers do
   describe "#sign_in" do
     it "creates an instance of the clearance user model with FactoryBot" do
-      MyUserModel = Class.new
       allow(FactoryBot).to receive(:create)
-      allow(Clearance.configuration).to receive(:user_model).
-        and_return(MyUserModel)
+      allow(Clearance.configuration).to receive(:user_model)
+        .and_return(MyUserModel)
 
       TestClass.new.sign_in
 

data/spec/clearance/testing/deny_access_matcher_spec.rb

@@ -12,7 +12,7 @@ describe PretendFriendsController, type: :controller do
   before do
     Rails.application.routes.draw do
       resources :pretend_friends, only: :index
-      get "/sign_in"  => "clearance/sessions#new", as: "sign_in"
+      get "/sign_in" => "clearance/sessions#new", :as => "sign_in"
     end
   end
 

data/spec/clearance/testing/view_helpers_spec.rb

@@ -4,8 +4,8 @@ describe Clearance::Testing::ViewHelpers do
   describe "#sign_in" do
     it "sets the signed in user to a new user object" do
       user_model = Class.new
-      allow(Clearance.configuration).to receive(:user_model).
-        and_return(user_model)
+      allow(Clearance.configuration).to receive(:user_model)
+        .and_return(user_model)
 
       view = test_view_class.new
       view.sign_in

data/spec/clearance/token_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Clearance::Token do
-  it 'is a random hex string' do
-    token = 'my_token'
+  it "is a random hex string" do
+    token = "my_token"
     allow(SecureRandom).to receive(:hex).with(20).and_return(token)
 
     expect(Clearance::Token.new).to eq token