jump_in 0.0.1 → 0.0.2

data/spec/dummy/spec/classes/configuration_spec.rb

@@ -0,0 +1,34 @@
+require_relative '../spec_helper'
+
+class SomeController < ActionController::Base
+  include JumpIn
+end
+
+describe SomeController do
+
+  context "JumpIn.configure not run" do
+    it "has @conf with default values" do
+      expect(JumpIn.conf.permanent).to eq(false)
+      expect(JumpIn.conf.expires).to eq(20.years)
+      expect(JumpIn.conf.expiration_time).to eq(2.hours)
+    end
+  end
+
+  context "JumpIn.configure run" do
+    it "has @conf available with proper permanent" do
+      run_config(permanent: true)
+      expect(JumpIn.conf.permanent).to eq(true)
+    end
+
+    it "has @conf available with proper expires" do
+      run_config(expires: 5.years)
+      expect(JumpIn.conf.expires).to eq(5.years)
+    end
+
+    it "has @conf available with proper expiration_time" do
+      run_config(expiration_time: 5.hours)
+      expect(JumpIn.conf.expiration_time).to eq(5.hours)
+    end
+  end
+
+end

data/spec/dummy/spec/factories.rb

@@ -1,6 +1,6 @@
 FactoryGirl.define do
 
-  factory :user do
+  factory :user_with_secure_password do
     email "email@example.com"
     password "password"
     name "User"

data/spec/dummy/spec/modules/authentication_spec.rb

@@ -2,69 +2,74 @@ require_relative '../spec_helper'
 
 class AuthenticationController < ActionController::Base
   include JumpIn::Authentication
+  jumpin_use persistence: [:session, :cookies]
 end
 
 describe AuthenticationController, type: :controller do
-  let(:user) { FactoryGirl.create(:user) }
+  let(:user_wsp) { FactoryGirl.create(:user_with_secure_password) }
+  after(:all) { JumpIn.instance_variable_set('@configuration', nil) }
+
+  context ".jumpin_callback" do
+    it "it added default constants while including Session & Cookies" do
+      expect(subject.class.constants).to include(:ON_LOGIN)
+      expect(subject.class.constants).to include(:ON_LOGOUT)
+      expect(subject.class.constants).to include(:GET_CURRENT_USER)
+    end
+
+    it "creates constant with method if constant didn't exist" do
+      subject.class.jumpin_callback :a_callback, :method
+      expect(subject.class.const_get(:A_CALLBACK)).to eq([:method])
+    end
+
+    it 'adds method if constant existed' do
+      subject.class.const_set('B_CALLBACK', [:method_1])
+      subject.class.jumpin_callback :b_callback, :method_2
+      expect(subject.class.const_get(:B_CALLBACK)).to eq([:method_1, :method_2])
+    end
+  end
 
   context "#jump_in" do
     it "returns false if user logged_in" do
       allow_to_receive_logged_in_and_return(true)
-      expect(subject.jump_in(user: user, password: user.password)).to eq(false)
+      expect(subject.jump_in(user: user_wsp, password: user_wsp.password)).to eq(false)
     end
 
     it "calls detect_strategy with proper params" do
       allow_to_receive_logged_in_and_return(false)
-      expect(subject).to receive(:detected_strategy).with(user: user, params: { password: user.password }).
-        exactly(1).times.and_return(JumpIn::Authentication::ByPassword.new(user: user, params: { password: user.password }))
-      subject.jump_in(user: user, password: user.password)
+      expect(subject).to receive(:detected_strategy).with(user: user_wsp, auth_params: { password: user_wsp.password }).
+        exactly(1).times.and_return(JumpIn::Strategies::ByPassword.new(user: user_wsp, auth_params: { password: user_wsp.password }))
+      subject.jump_in(user: user_wsp, password: user_wsp.password)
+    end
+
+    it "raises an error when no strategy detected" do
+      allow_to_receive_logged_in_and_return(false)
+      expect { subject.jump_in(user: user_wsp) }.to raise_error(JumpIn::AuthenticationStrategyError, "No authentication strategy detected.")
     end
 
     it "returns false if user not logged_in and wrong login data provided" do
       allow_to_receive_logged_in_and_return(false)
-      expect(subject.jump_in(user: user, password:'something')).to eq(false)
+      expect(subject.jump_in(user: user_wsp, password:'something')).to eq(false)
     end
 
     context 'when user not logged_in and authentication successful' do
       it "returns true" do
         allow_to_receive_logged_in_and_return(false)
-        expect(subject.jump_in(user: user, password: user.password)).to eq(true)
-      end
-
-      it "calls 'login' with permanent=false for permanent false by default" do
-        allow_to_receive_logged_in_and_return(false)
-        expect(subject).to receive(:login).with(user:user, permanent:false, expires:nil).exactly(1).times.and_return(true)
-        subject.jump_in(user: user, password: user.password)
-      end
-
-      it "calls 'login' with permanent=false for permanent passed as false" do
-        allow_to_receive_logged_in_and_return(false)
-        expect(subject).to receive(:login).with(user:user, permanent:false, expires:nil).exactly(1).times.and_return(true)
-        subject.jump_in(user: user, password: user.password, permanent: false)
-      end
-
-      it "calls 'login' with permanent=true for permanent passed as true" do
-        allow_to_receive_logged_in_and_return(false)
-        expect(subject).to receive(:login).with(user:user, permanent:true, expires:nil).exactly(1).times.and_return(true)
-        subject.jump_in(user: user, password: user.password, permanent: true)
+        allow(subject).to receive(:login).with(user: user_wsp).and_return(true)
+        expect(subject.jump_in(user: user_wsp, password: user_wsp.password)).to eq(true)
       end
     end
   end
 
   context "#login" do
-    it "sets session when permanent not passed (default)" do
-      subject.login(user: user)
-      expect_only_session_set_for(user)
-    end
-
-    it "sets session when permanent passed as false" do
-      subject.login(user: user, permanent: false)
-      expect_only_session_set_for(user)
+    it "sets session when @configuration.permanent is false" do
+      subject.login(user: user_wsp)
+      expect_only_session_set_for(user_wsp)
     end
 
-    it "sets cookies when permanent passed as true" do
-      subject.login(user: user, permanent: true)
-      expect_only_cookies_set_for(user)
+    it "sets cookies when @configuration.permanent is true" do
+      run_config(permanent: true)
+      subject.login(user: user_wsp)
+      expect_only_cookies_set_for(user_wsp)
     end
 
     context 'sets proper value for cookies[:expires]' do
@@ -75,14 +80,16 @@ describe AuthenticationController, type: :controller do
         allow(@cookies).to receive(:signed).and_return(@cookies)
       end
 
-      it "sets 20 years if param not passed" do
-        subject.login(user: user, permanent: true)
+      it "sets 20 years if @configuration.expires not set" do
+        run_config(permanent: true)
+        subject.login(user: user_wsp)
         expect(@cookies.signed[:jump_in_class][:expires]).to be_between(Time.now + 19.years, Time.now + 21.years)
         expect(@cookies.signed[:jump_in_id][:expires]).to be_between(Time.now + 19.years, Time.now + 21.years)
       end
 
-      it "sets correct value if param passed" do
-        subject.login(user: user, permanent: true, expires: 2.hours)
+      it "sets correct value if @configuration.expires set" do
+        run_config(permanent: true, expires: 2.hours)
+        subject.login(user: user_wsp)
         expect(@cookies.signed[:jump_in_class][:expires]).to eq(@cookies.signed[:jump_in_id][:expires])
         expect(@cookies.signed[:jump_in_class][:expires]).to be_between(Time.now + 1.hours, Time.now + 3.hours)
         expect(@cookies.signed[:jump_in_id][:expires]).to be_between(Time.now + 1.hours, Time.now + 3.hours)
@@ -92,26 +99,26 @@ describe AuthenticationController, type: :controller do
 
   context "#jump_out" do
     it "clears session when session set" do
-      set_session(user)
-      expect_session_eq(klass: user.class.to_s, id: user.id)
+      set_session(user_wsp)
+      expect_session_eq(klass: user_wsp.class.to_s, id: user_wsp.id)
       subject.jump_out
       expect_session_eq(klass: nil, id: nil)
     end
 
     it "clears cookies when cookies set" do
-      set_cookies(user, nil)
-      expect_cookies_eq(klass: user.class.to_s, id: user.id)
+      set_cookies(user_wsp, nil)
+      expect_cookies_eq(klass: user_wsp.class.to_s, id: user_wsp.id)
       subject.jump_out
       expect_cookies_eq(klass: nil, id: nil)
     end
 
     it "returns true if logged out from session" do
-      set_session(user)
+      set_session(user_wsp)
       expect(subject.jump_out).to eq(true)
     end
 
     it "returns true if logged out from cookies" do
-      set_cookies(user, nil)
+      set_cookies(user_wsp, nil)
       expect(subject.jump_out).to eq(true)
     end
 
@@ -122,13 +129,13 @@ describe AuthenticationController, type: :controller do
 
   context "#current_user" do
     it "returns user based on session" do
-      set_session(user)
-      expect(subject.current_user).to eq(user)
+      set_session(user_wsp)
+      expect(subject.current_user).to eq(user_wsp)
     end
 
     it "returns user based on cookies" do
-      set_cookies(user, nil)
-      expect(subject.current_user).to eq(user)
+      set_cookies(user_wsp, nil)
+      expect(subject.current_user).to eq(user_wsp)
     end
 
     it "returns nil when session and cookie empty" do
@@ -138,12 +145,12 @@ describe AuthenticationController, type: :controller do
 
   context "#logged_in?" do
     it "returns true if current user is set in session" do
-      set_session(user)
+      set_session(user_wsp)
       expect(subject.logged_in?).to eq(true)
     end
 
     it "returns true if current user is set in cookies" do
-      set_cookies(user, nil)
+      set_cookies(user_wsp, nil)
       expect(subject.logged_in?).to eq(true)
     end
   end

data/spec/dummy/spec/modules/password_reset_spec.rb

@@ -1,41 +1,40 @@
 require_relative '../spec_helper'
-include ActiveSupport::Testing::TimeHelpers
 
 class PasswordResetController < ActionController::Base
   include JumpIn::PasswordReset
 end
 
 describe PasswordResetController, type: :controller do
-  let(:user) { FactoryGirl.create(:user) }
+  let(:user_wsp) { FactoryGirl.create(:user_with_secure_password) }
 
   context "#set_password_reset_for" do
     context "token not uniq_or_empty" do
       it "calls token_uniq_or_empty? with proper params" do
         token = 'token'
-        expect(subject).to receive_token_uniq_or_empty_and_return(user, token, false)
-        subject.set_password_reset_for(user:user, token:token)
+        expect(subject).to receive_token_uniq_or_empty_and_return(user_wsp, token, false)
+        subject.set_password_reset_for(user:user_wsp, token:token)
       end
 
       it "returns false if token not uniq_or_empty" do
         token = 'token'
-        allow(subject).to receive_token_uniq_or_empty_and_return(user, token, false)
-        expect(subject.set_password_reset_for(user:user, token:token)).to eq(false)
+        allow(subject).to receive_token_uniq_or_empty_and_return(user_wsp, token, false)
+        expect(subject.set_password_reset_for(user:user_wsp, token:token)).to eq(false)
       end
     end
 
     context "token uniq_or_empty" do
       it "calls set_token with given user & token if token uniq_or_empty" do
         token = 'token'
-        expect(subject).to receive_token_uniq_or_empty_and_return(user, token, true)
-        expect_set_token_and_return(user, token, true)
-        subject.set_password_reset_for(user:user, token:token)
+        expect(subject).to receive_token_uniq_or_empty_and_return(user_wsp, token, true)
+        expect_set_token_and_return(user_wsp, token, true)
+        subject.set_password_reset_for(user:user_wsp, token:token)
       end
 
       it "calls set_token with given user & token=nil if token uniq_or_empty & no token given" do
         token = nil
-        expect(subject).to receive_token_uniq_or_empty_and_return(user, token, true)
-        expect_set_token_and_return(user, token, true)
-        subject.set_password_reset_for(user:user)
+        expect(subject).to receive_token_uniq_or_empty_and_return(user_wsp, token, true)
+        expect_set_token_and_return(user_wsp, token, true)
+        subject.set_password_reset_for(user:user_wsp)
       end
     end
   end
@@ -43,28 +42,28 @@ describe PasswordResetController, type: :controller do
   context "#set_token" do
     it "set's given token as user.token" do
       token = 'token'
-      subject.set_token(user:user, token:token)
-      expect(user.password_reset_token).to eq(token)
+      subject.set_token(user:user_wsp, token:token)
+      expect(user_wsp.password_reset_token).to eq(token)
     end
 
     it "generates token for user if token=nil given" do
-      expect(user.password_reset_token).to eq(nil)
-      subject.set_token(user:user, token:nil)
-      expect(user.password_reset_token).to_not eq(nil)
+      expect(user_wsp.password_reset_token).to eq(nil)
+      subject.set_token(user:user_wsp, token:nil)
+      expect(user_wsp.password_reset_token).to_not eq(nil)
     end
   end
 
   context "#generate_unique_token_for" do
     it 'generates token' do
-      token = subject.generate_unique_token_for(user:user)
+      token = subject.generate_unique_token_for(user:user_wsp)
       expect(token).to_not eq(nil)
     end
 
     it 'calls methods #generate_token & #token_uniq?' do
       token = 'token'
       expect(subject).to receive(:generate_token).and_return(token)
-      expect(subject).to receive(:token_uniq?).with(user:user, token:token).and_return(true)
-      subject.generate_unique_token_for(user:user)
+      expect(subject).to receive(:token_uniq?).with(user:user_wsp, token:token).and_return(true)
+      subject.generate_unique_token_for(user:user_wsp)
     end
   end
 
@@ -77,130 +76,114 @@ describe PasswordResetController, type: :controller do
 
   context "#token_uniq_or_empty?" do
     it 'returns true if token is nil' do
-      expect(subject.token_uniq_or_empty?(user:user, token:nil)).to eq(true)
+      expect(subject.token_uniq_or_empty?(user:user_wsp, token:nil)).to eq(true)
     end
 
     it 'returns true if token given & unique' do
       token = 'token'
-      allow(subject).to receive(:token_uniq?).with(user:user, token:token).and_return(true)
-      expect(subject.token_uniq_or_empty?(user:user, token:token)).to eq(true)
+      allow(subject).to receive(:token_uniq?).with(user:user_wsp, token:token).and_return(true)
+      expect(subject.token_uniq_or_empty?(user:user_wsp, token:token)).to eq(true)
     end
 
     it 'returns false if token give & not unique' do
       token = 'token'
-      allow(subject).to receive(:token_uniq?).with(user:user, token:token).and_return(false)
-      expect(subject.token_uniq_or_empty?(user:user, token:token)).to eq(false)
+      allow(subject).to receive(:token_uniq?).with(user:user_wsp, token:token).and_return(false)
+      expect(subject.token_uniq_or_empty?(user:user_wsp, token:token)).to eq(false)
     end
   end
 
   context "#token_uniq?" do
     it 'returns true if token unique for user.class' do
       token = subject.generate_token
-      expect(subject.token_uniq?(user:user, token:token)).to eq(true)
+      expect(subject.token_uniq?(user:user_wsp, token:token)).to eq(true)
     end
 
     it 'returns false if token not unique for user.class' do
       token = subject.generate_token
-      user.update_attribute('password_reset_token', token)
-      expect(subject.token_uniq?(user:user, token:token)).to eq(false)
+      user_wsp.update_attribute('password_reset_token', token)
+      expect(subject.token_uniq?(user:user_wsp, token:token)).to eq(false)
     end
   end
 
   context "#password_reset_valid?" do
-    it "returns true for token valid with default expiration time(2.hours)" do
-      token = JumpIn::Tokenizer.generate_token
+    before(:each) { run_config(expiration_time: 2.hours) }
+    it "returns true for token valid" do
+      token = subject.generate_token
       expect(subject.password_reset_valid?(password_reset_token: token)).to eq(true)
     end
 
-    it "returns false for token too old with default expiration time(2.hours)" do
+    it "returns false for token too old" do
       token = ''
       travel_to(3.hours.ago) do
-        token = JumpIn::Tokenizer.generate_token
+        token = subject.generate_token
       end
       expect(subject.password_reset_valid?(password_reset_token: token)).to eq(false)
     end
-
-    it "returns true for token valid with custom expiration time(2.days)" do
-      token = ''
-      travel_to(1.day.ago) do
-        token = JumpIn::Tokenizer.generate_token
-      end
-      expect(subject.password_reset_valid?(password_reset_token: token, expiration_time: 2.days)).to eq(true)
-    end
-
-    it "returns false for token too old with custom expiration time(2.days)" do
-      token = ''
-      travel_to(3.days.ago) do
-        token = JumpIn::Tokenizer.generate_token
-      end
-      expect(subject.password_reset_valid?(password_reset_token: token, expiration_time: 2.days)).to eq(false)
-    end
-
   end
 
   context "#update_password_for" do
     let(:new_password) { 'new_secret_password'}
-    let!(:old_password_digest) { user.password_digest }
+    let!(:old_password_digest) { user_wsp.password_digest }
 
     it "updates password if token belongs to user and is not too old" do
-      user.update_attribute(:password_reset_token, JumpIn::Tokenizer.generate_token)
-      token = user.password_reset_token
-      allow_to_receive_token_correct_and_return(user, token, true)
+      user_wsp.update_attribute(:password_reset_token, subject.generate_token)
+      token = user_wsp.password_reset_token
+      allow_to_receive_token_correct_and_return(user_wsp, token, true)
 
       expect(
-        subject.update_password_for(user: user, password: new_password, password_confirmation: new_password, password_reset_token: token)
+        subject.update_password_for(user: user_wsp, password: new_password, password_confirmation: new_password, password_reset_token: token)
       ).to eq(true)
-      expect(user.password_digest).to_not eq(old_password_digest)
+      expect(user_wsp.password_digest).to_not eq(old_password_digest)
     end
 
     it "updates password if token belongs to user and is old" do
       travel_to(3.days.ago) do
-        user.update_attribute(:password_reset_token, JumpIn::Tokenizer.generate_token)
+        user_wsp.update_attribute(:password_reset_token, subject.generate_token)
       end
-      token = user.password_reset_token
-      allow_to_receive_token_correct_and_return(user, token, true)
+      token = user_wsp.password_reset_token
+      allow_to_receive_token_correct_and_return(user_wsp, token, true)
 
       expect(
-        subject.update_password_for(user: user, password: new_password, password_confirmation: new_password, password_reset_token: token)
+        subject.update_password_for(user: user_wsp, password: new_password, password_confirmation: new_password, password_reset_token: token)
       ).to eq(true)
-      expect(user.password_digest).to_not eq(old_password_digest)
+      expect(user_wsp.password_digest).to_not eq(old_password_digest)
     end
 
     it "does not update password and returns false if token does not belong to user" do
-      user.update_attribute(:password_reset_token, JumpIn::Tokenizer.generate_token)
-      token = JumpIn::Tokenizer.generate_token
-      allow_to_receive_token_correct_and_return(user, token, false)
+      user_wsp.update_attribute(:password_reset_token, subject.generate_token)
+      token = subject.generate_token
+      allow_to_receive_token_correct_and_return(user_wsp, token, false)
 
       expect(
-        subject.update_password_for(user: user, password: new_password, password_confirmation: new_password, password_reset_token: token)
+        subject.update_password_for(user: user_wsp, password: new_password, password_confirmation: new_password, password_reset_token: token)
       ).to eq(false)
-      expect(user.password_digest).to eq(old_password_digest)
+      expect(user_wsp.password_digest).to eq(old_password_digest)
     end
 
     it "does not update password and returns false if new password invalid" do
-      user.update_attribute(:password_reset_token, JumpIn::Tokenizer.generate_token)
-      token = user.password_reset_token
-      allow_to_receive_token_correct_and_return(user, token, true)
+      user_wsp.update_attribute(:password_reset_token, subject.generate_token)
+      token = user_wsp.password_reset_token
+      allow_to_receive_token_correct_and_return(user_wsp, token, true)
 
       expect(
-        subject.update_password_for(user: user, password: new_password, password_confirmation: 'password', password_reset_token: token)
+        subject.update_password_for(user: user_wsp, password: new_password, password_confirmation: 'password', password_reset_token: token)
       ).to eq(false)
-      user.reload
-      expect(user.password_digest).to eq(old_password_digest)
+      user_wsp.reload
+      expect(user_wsp.password_digest).to eq(old_password_digest)
     end
   end
 
   context "#token_correct?" do
     it "returns true if given token eq user.token" do
-      user.update_attribute(:password_reset_token, JumpIn::Tokenizer.generate_token)
-      token = user.password_reset_token
-      expect(subject.token_correct?(user_token:user.password_reset_token, received_token:token)).to eq(true)
+      user_wsp.update_attribute(:password_reset_token, subject.generate_token)
+      token = user_wsp.password_reset_token
+      expect(subject.token_correct?(user_token:user_wsp.password_reset_token, received_token:token)).to eq(true)
     end
 
     it "returns false if given token doesn't eq user.token" do
-      user.update_attribute(:password_reset_token, JumpIn::Tokenizer.generate_token)
-      token = JumpIn::Tokenizer.generate_token
-      expect(subject.token_correct?(user_token:user.password_reset_token, received_token:token)).to eq(false)
+      user_wsp.update_attribute(:password_reset_token, subject.generate_token)
+      token = subject.generate_token
+      expect(subject.token_correct?(user_token:user_wsp.password_reset_token, received_token:token)).to eq(false)
     end
   end
 end

data/spec/dummy/spec/modules/strategies_spec.rb

@@ -0,0 +1,71 @@
+require_relative '../spec_helper'
+
+include JumpIn::Strategies
+
+describe JumpIn::Strategies do
+
+  before(:all) do
+    class CustomStrategy < JumpIn::Strategies::Base
+      has_unique_attributes [:custom_attr]
+
+      def authenticate_user
+        @user.authenticate(@auth_params[:custom_attr]) ? true : false
+      end
+    end
+
+    class CustomUser
+      def authenticate(to_verify)
+        return true if to_verify == "authentication_pass"
+        false
+      end
+    end
+  end
+
+  after(:all) do
+    JumpIn::Strategies::Base::STRATEGIES.delete(CustomStrategy)
+    JumpIn::Strategies::Base::DETECTABLE_ATTRIBUTES.delete(CustomStrategy)
+  end
+
+  context ".inherited" do
+    it "STRATEGIES include default strategies" do
+      expect(JumpIn::Strategies::Base::STRATEGIES).to include(JumpIn::Strategies::ByPassword)
+    end
+
+    it "STRATEGIES include custom strategies" do
+      expect(JumpIn::Strategies::Base::STRATEGIES).to include(CustomStrategy)
+    end
+  end
+
+  context "#authenticate_user" do
+    it "calls custom authenticate method for custom strategy, returns true" do
+      custom_user = CustomUser.new
+      custom_strategy = CustomStrategy.new(
+        user: custom_user,
+        auth_params: { custom_attr: "authentication_pass" })
+      expect(custom_strategy.authenticate_user).to eq(true)
+    end
+
+    it "calls custom authenticate method for custom strategy, returns false" do
+      custom_user = CustomUser.new
+      custom_strategy = CustomStrategy.new(
+        user: custom_user,
+        auth_params: { custom_attr: "wrong_pass" })
+      expect(custom_strategy.authenticate_user).to eq(false)
+    end
+  end
+
+  context ".has_unique_attribute" do
+    it "adds strategy_unique_attribute to DETECTABLE_ATTRIBUTES" do
+      expect(JumpIn::Strategies::Base::DETECTABLE_ATTRIBUTES.values).to include([:custom_attr])
+    end
+
+    it "raises error when strategy_unique_attribute is not unique, removes strategy from STRATEGIES" do
+      expect {
+        class AnotherCustomStrategy < JumpIn::Strategies::Base
+          has_unique_attributes [:custom_attr]
+        end
+      }.to raise_error(JumpIn::AttributesNotUnique, 'Custom authentication strategy attribute is not unique.')
+      expect(JumpIn::Strategies::Base::STRATEGIES).to_not include(AnotherCustomStrategy)
+    end
+  end
+end

data/spec/dummy/spec/modules/tokenator_spec.rb

@@ -0,0 +1,46 @@
+require_relative '../spec_helper'
+
+class TokenatorController < ActionController::Base
+  include JumpIn::Tokenator
+end
+
+describe TokenatorController, type: :controller do
+  let(:random) { 'e3d6ce35f9f6f7ea696cd180' }
+  let(:time)   { Time.parse('2015-08-28T19:35:56+02:00') }
+  let(:token)  { "ZTNkNmNlMzVmOWY2ZjdlYTY5NmNkMTgwLjIwMTUtMDgtMjhUMTk6MzU6NTYrMDI6MDA=" }
+
+  context ".generate_token" do
+    it 'generates token' do
+      allow(SecureRandom).to receive(:hex).with(12).and_return(random)
+      generated_token = nil
+      travel_to time do
+        generated_token = subject.generate_token
+      end
+      expect(generated_token).to eq(token)
+    end
+  end
+
+  context ".decode_and_split_token" do
+    it "decodes valid token" do
+      expect(subject.decode_and_split_token(token)).to eq([random, time.xmlschema])
+    end
+
+    it "raises JumpIn error for invalid token" do
+      expect { subject.decode_and_split_token("invalid") }.to raise_error(JumpIn::InvalidTokenError, 'Invalid token passed.')
+    end
+  end
+
+  context ".decode_time" do
+    it "decodes time for valid token" do
+      expect(subject.decode_time(token)).to eq(time)
+    end
+
+    it "raises JumpIn error for invalid token" do
+      expect { subject.decode_time("invalid") }.to raise_error(JumpIn::InvalidTokenError, 'Invalid token passed.')
+    end
+
+    it "raises JumpIn error for random passed as token (no delimiter => no time to parse)" do
+      expect { subject.decode_time(random) }.to raise_error(JumpIn::InvalidTokenError, 'Invalid token passed.')
+    end
+  end
+end

data/spec/dummy/spec/rails_helper.rb

@@ -16,6 +16,7 @@ RSpec.configure do |config|
   # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
   config.fixture_path = "#{::Rails.root}/spec/fixtures"
   config.include FactoryGirl::Syntax::Methods
+  config.include ActiveSupport::Testing::TimeHelpers
 
   config.use_transactional_fixtures = true
 

data/spec/dummy/spec/support/common_methods.rb

@@ -1,3 +1,12 @@
+
+def run_config(permanent: false, expires: 20.years, expiration_time: 2.hours)
+  JumpIn.configure do |config|
+    config.permanent = permanent
+    config.expires = expires
+    config.expiration_time = expiration_time
+  end
+end
+
 # module Authentication
 
 def set_session(object)
@@ -53,12 +62,3 @@ def allow_to_receive_token_correct_and_return(user, token, boolean)
     with(user_token: user.password_reset_token, received_token: token).
     and_return(boolean)
 end
-
-# dummy App
-
-def log_in(email, password)
-  fill_in "session_email", with: email
-  fill_in "session_password", with: password
-  click_button "Log in"
-end
-