sorcery 0.8.4 → 0.8.6

data/spec/shared_examples/controller_activity_logging_shared_examples.rb

@@ -0,0 +1,125 @@
+shared_examples_for "controller_activity_logging" do
+
+  before(:all) do
+    sorcery_reload!([:activity_logging])
+  end
+
+  specify { expect(subject).to respond_to(:current_users) }
+  let(:user) { create_new_user }
+
+  before(:each) { user }
+
+  it "'current_users' is empty when no users are logged in" do
+    expect(subject.current_users.size).to eq 0
+  end
+
+  it "logs login time on login" do
+    now = Time.now.in_time_zone
+    login_user
+
+    expect(user.last_login_at).not_to be_nil
+    expect(user.last_login_at.utc.to_s).to be >= now.utc.to_s
+    expect(user.last_login_at.utc.to_s).to be <= (now.utc+2).to_s
+  end
+
+  it "logs logout time on logout" do
+    login_user
+    now = Time.now.in_time_zone
+    logout_user
+
+    expect(User.last.last_logout_at).not_to be_nil
+
+    expect(User.last.last_logout_at.utc.to_s).to be >= now.utc.to_s
+    expect(User.last.last_logout_at.utc.to_s).to be <= (now+2).utc.to_s
+  end
+
+  it "logs last activity time when logged in" do
+    sorcery_controller_property_set(:register_last_activity_time, true)
+
+    login_user
+    now = Time.now.in_time_zone
+    get :some_action
+
+    last_activity_at = User.last.last_activity_at
+
+    expect(last_activity_at).to be_present
+    expect(last_activity_at.utc.to_s).to be >= now.utc.to_s
+    expect(last_activity_at.utc.to_s).to be <= (now+2).utc.to_s
+  end
+
+  it "logs last IP address when logged in" do
+    login_user
+    get :some_action
+
+    expect(User.last.last_login_from_ip_address).to eq "0.0.0.0"
+  end
+
+  it "updates nothing but activity fields" do
+    original_user_name = User.last.username
+    login_user
+    get :some_action_making_a_non_persisted_change_to_the_user
+
+    expect(User.last.username).to eq original_user_name
+  end
+
+  it "'current_users' holds the user object when 1 user is logged in" do
+    login_user
+    get :some_action
+
+    expect(subject.current_users).to match([User.find(user.id)])
+  end
+
+  it "'current_users' shows all current_users, whether they have logged out before or not." do
+    user1 = create_new_user({:username => 'gizmo1', :email => "bla1@bla.com", :password => 'secret1'})
+    login_user(user1)
+    get :some_action
+    clear_user_without_logout
+    user2 = create_new_user({:username => 'gizmo2', :email => "bla2@bla.com", :password => 'secret2'})
+    login_user(user2)
+    get :some_action
+    clear_user_without_logout
+    user3 = create_new_user({:username => 'gizmo3', :email => "bla3@bla.com", :password => 'secret3'})
+    login_user(user3)
+    get :some_action
+
+    expect(subject.current_users.size).to eq 3
+    expect(subject.current_users[0]).to eq User.find(user1.id)
+    expect(subject.current_users[1]).to eq User.find(user2.id)
+    expect(subject.current_users[2]).to eq User.find(user3.id)
+  end
+
+  it "does not register login time if configured so" do
+    sorcery_controller_property_set(:register_login_time, false)
+    now = Time.now.in_time_zone
+    login_user
+
+    expect(user.last_login_at).to be_nil
+  end
+
+  it "does not register logout time if configured so" do
+    sorcery_controller_property_set(:register_logout_time, false)
+    now = Time.now.in_time_zone
+    login_user
+    logout_user
+
+    expect(user.last_logout_at).to be_nil
+  end
+
+  it "does not register last activity time if configured so" do
+    sorcery_controller_property_set(:register_last_activity_time, false)
+    now = Time.now.in_time_zone
+    login_user
+    get :some_action
+
+    expect(user.last_activity_at).to be_nil
+  end
+
+  it "does not register last IP address if configured so" do
+    sorcery_controller_property_set(:register_last_ip_address, false)
+    ip_address = "127.0.0.1"
+    login_user
+    get :some_action
+
+    expect(user.last_activity_at).to be_nil
+  end
+end

data/spec/shared_examples/controller_oauth2_shared_examples.rb

@@ -1,56 +1,52 @@
-shared_examples_for "oauth2_controller" do
-  describe "using 'create_from'" do
+shared_examples_for 'oauth2_controller' do
+  describe 'using create_from' do
     before(:each) do
       stub_all_oauth2_requests!
       User.delete_all
       Authentication.delete_all
     end
 
-    it "should create a new user" do
+    it 'creates a new user' do
       sorcery_model_property_set(:authentications_class, Authentication)
-      sorcery_controller_external_property_set(:facebook, :user_info_mapping, {:username => "name"})
-      lambda do
-        get :test_create_from_provider, :provider => "facebook"
-      end.should change(User, :count).by(1)
-      User.first.username.should == "Noam Ben Ari"
+      sorcery_controller_external_property_set(:facebook, :user_info_mapping, { username: 'name' })
+
+      expect { get :test_create_from_provider, provider: 'facebook' }.to change { User.count }.by 1
+      expect(User.first.username).to eq 'Noam Ben Ari'
     end
 
-    it "should support nested attributes" do
+    it 'supports nested attributes' do
       sorcery_model_property_set(:authentications_class, Authentication)
-      sorcery_controller_external_property_set(:facebook, :user_info_mapping, {:username => "hometown/name"})
-      lambda do
-        get :test_create_from_provider, :provider => "facebook"
-      end.should change(User, :count).by(1)
-      User.first.username.should == "Haifa, Israel"
+      sorcery_controller_external_property_set(:facebook, :user_info_mapping, { username: 'hometown/name' })
+
+      expect { get :test_create_from_provider, provider: 'facebook' }.to change { User.count }.by(1)
+      expect(User.first.username).to eq 'Haifa, Israel'
     end
 
-    it "should not crash on missing nested attributes" do
+    it 'does not crash on missing nested attributes' do
       sorcery_model_property_set(:authentications_class, Authentication)
-      sorcery_controller_external_property_set(:facebook, :user_info_mapping, {:username => "name", :created_at => "does/not/exist"})
-      lambda do
-        get :test_create_from_provider, :provider => "facebook"
-      end.should change(User, :count).by(1)
-      User.first.username.should == "Noam Ben Ari"
-      User.first.created_at.should_not be_nil
+      sorcery_controller_external_property_set(:facebook, :user_info_mapping, { username: 'name', created_at: 'does/not/exist' })
+
+      expect { get :test_create_from_provider, provider: 'facebook' }.to change { User.count }.by 1
+      expect(User.first.username).to eq 'Noam Ben Ari'
+      expect(User.first.created_at).not_to be_nil
     end
-   
-    describe "with a block" do
-      
+
+    describe 'with a block' do
+
       before(:each) do
-        user = User.new(:username => 'Noam Ben Ari')
-        user.save!(:validate => false)
-        user.authentications.create(:provider => 'twitter', :uid => '456')
+        user = User.new(username: 'Noam Ben Ari')
+        user.save!(validate: false)
+        user.authentications.create(provider: 'twitter', uid: '456')
       end
-      
-      it "should not create user" do
+
+      it 'does not create user' do
         sorcery_model_property_set(:authentications_class, Authentication)
-        sorcery_controller_external_property_set(:facebook, :user_info_mapping, {:username => "name"})
-        lambda do
-          # test_create_from_provider_with_block in controller will check for uniqueness of username
-          get :test_create_from_provider_with_block, :provider => "facebook"
-        end.should_not change(User, :count)
+        sorcery_controller_external_property_set(:facebook, :user_info_mapping, { username: 'name' })
+
+        # test_create_from_provider_with_block in controller will check for uniqueness of username
+        expect { get :test_create_from_provider_with_block, provider: 'facebook' }.not_to change { User.count }
       end
-    
+
     end
   end
-end
+end

data/spec/shared_examples/controller_oauth_shared_examples.rb

@@ -5,51 +5,58 @@ shared_examples_for "oauth_controller" do
       User.delete_all
       Authentication.delete_all
     end
-      
-    it "should create a new user" do
+
+    it "creates a new user" do
       sorcery_model_property_set(:authentications_class, Authentication)
       sorcery_controller_external_property_set(:twitter, :user_info_mapping, {:username => "screen_name"})
-      lambda do
-        get :test_create_from_provider, :provider => "twitter"
-      end.should change(User, :count).by(1)
-      User.first.username.should == "nbenari"
+
+      expect { get :test_create_from_provider, :provider => "twitter" }.to change { User.count }.by 1
+      expect(User.first.username).to eq "nbenari"
     end
-    
-    it "should support nested attributes" do
+
+    it "supports nested attributes" do
       sorcery_model_property_set(:authentications_class, Authentication)
       sorcery_controller_external_property_set(:twitter, :user_info_mapping, {:username => "status/text"})
-      lambda do
-        get :test_create_from_provider, :provider => "twitter"
-      end.should change(User, :count).by(1)
-      User.first.username.should == "coming soon to sorcery gem: twitter and facebook authentication support."
+
+      expect { get :test_create_from_provider, :provider => "twitter" }.to change { User.count }.by 1
+      expect(User.first.username).to eq "coming soon to sorcery gem: twitter and facebook authentication support."
     end
-    
-    it "should not crash on missing nested attributes" do
+
+    it "does not crash on missing nested attributes" do
       sorcery_model_property_set(:authentications_class, Authentication)
       sorcery_controller_external_property_set(:twitter, :user_info_mapping, {:username => "status/text", :created_at => "does/not/exist"})
-      lambda do
-        get :test_create_from_provider, :provider => "twitter"
-      end.should change(User, :count).by(1)
-      User.first.username.should == "coming soon to sorcery gem: twitter and facebook authentication support."
-      User.first.created_at.should_not be_nil
+
+      expect { get :test_create_from_provider, :provider => "twitter" }.to change { User.count }.by 1
+      expect(User.first.username).to eq "coming soon to sorcery gem: twitter and facebook authentication support."
+      expect(User.first.created_at).not_to be_nil
     end
-    
+
+    it "binds new provider" do
+      sorcery_model_property_set(:authentications_class, UserProvider)
+
+      current_user = custom_create_new_external_user(:facebook, UserProvider)
+      login_user(current_user)
+
+      expect { get :test_add_second_provider, :provider => "twitter" }.to change { UserProvider.count }.by 1
+      expect(UserProvider.where(:user_id => current_user.id).size).to eq 2
+      expect(User.count).to eq 1
+    end
+
     describe "with a block" do
-      
+
       before(:each) do
         user = User.new(:username => 'nbenari')
         user.save!(:validate => false)
         user.authentications.create(:provider => 'github', :uid => '456')
       end
-      
-      it "should not create user" do
+
+      it "does not create user" do
         sorcery_model_property_set(:authentications_class, Authentication)
         sorcery_controller_external_property_set(:twitter, :user_info_mapping, {:username => "screen_name"})
-        lambda do
-          get :test_create_from_provider_with_block, :provider => "twitter"
-        end.should_not change(User, :count)
+
+        expect { get :test_create_from_provider_with_block, :provider => "twitter" }.not_to change { User.count }
       end
-    
+
     end
   end
-end
+end

data/spec/shared_examples/controller_shared_examples.rb

@@ -0,0 +1,203 @@
+shared_examples_for "sorcery_controller" do
+
+  describe "plugin configuration" do
+    before(:all) do
+      sorcery_reload!
+    end
+
+    after(:each) do
+      Sorcery::Controller::Config.reset!
+      sorcery_reload!
+    end
+
+    it "enables configuration option 'user_class'" do
+      sorcery_controller_property_set(:user_class, "TestUser")
+
+      expect(Sorcery::Controller::Config.user_class).to eq "TestUser"
+    end
+
+    it "enables configuration option 'not_authenticated_action'" do
+      sorcery_controller_property_set(:not_authenticated_action, :my_action)
+
+      expect(Sorcery::Controller::Config.not_authenticated_action).to eq :my_action
+    end
+
+  end
+
+  # ----------------- PLUGIN ACTIVATED -----------------------
+  context "when activated with sorcery" do
+    let!(:user) { create_new_user }
+
+    before(:all) do
+      sorcery_reload!
+      User.delete_all
+    end
+
+    after(:each) do
+      Sorcery::Controller::Config.reset!
+      sorcery_reload!
+      User.delete_all
+      sorcery_controller_property_set(:user_class, User)
+      sorcery_model_property_set(:username_attribute_names, [:email])
+    end
+
+    specify { should respond_to(:login) }
+
+    specify { should respond_to(:logout) }
+
+    specify { should respond_to(:logged_in?) }
+
+    specify { should respond_to(:current_user) }
+
+    it "login(username,password) returns the user when success and set the session with user.id" do
+      get :test_login, :email => 'bla@bla.com', :password => 'secret'
+
+      expect(assigns[:user]).to eq user
+      expect(session[:user_id]).to eq user.id
+    end
+
+    it "login(email,password) returns the user when success and set the session with user.id" do
+      get :test_login, :email => 'bla@bla.com', :password => 'secret'
+
+      expect(assigns[:user]).to eq user
+      expect(session[:user_id]).to eq user.id
+    end
+
+    it "login(username,password) returns nil and not set the session when failure" do
+      get :test_login, :email => 'bla@bla.com', :password => 'opensesame!'
+
+      expect(assigns[:user]).to be_nil
+      expect(session[:user_id]).to be_nil
+    end
+
+    it "login(email,password) returns the user when success and set the session with the _csrf_token" do
+      get :test_login, :email => 'bla@bla.com', :password => 'secret'
+
+      expect(session[:_csrf_token]).not_to be_nil
+    end
+
+    it "login(username,password) returns nil and not set the session when upper case username" do
+      skip('DM Adapter dependant') if SORCERY_ORM == :datamapper
+      get :test_login, :email => 'BLA@BLA.COM', :password => 'secret'
+
+      expect(assigns[:user]).to be_nil
+      expect(session[:user_id]).to be_nil
+    end
+
+    it "login(username,password) returns the user and set the session with user.id when upper case username and config is downcase before authenticating" do
+      sorcery_model_property_set(:downcase_username_before_authenticating, true)
+      get :test_login, :email => 'BLA@BLA.COM', :password => 'secret'
+
+      expect(assigns[:user]).to eq user
+      expect(session[:user_id]).to eq user.id
+    end
+
+    it "login(username,password) returns nil and not set the session when user was created with upper case username, config is default, and log in username is lower case" do
+      skip('DM Adapter dependant') if SORCERY_ORM == :datamapper
+      create_new_user({:username => "", :email => "BLA1@BLA.COM", :password => 'secret1'})
+      get :test_login, :email => 'bla1@bla.com', :password => 'secret1'
+
+      expect(assigns[:user]).to be_nil
+      expect(session[:user_id]).to be_nil
+    end
+
+    it "login(username,password) returns the user and set the session with user.id when user was created with upper case username and config is downcase before authenticating" do
+      skip('DM Adapter dependant') if SORCERY_ORM == :datamapper
+      sorcery_model_property_set(:downcase_username_before_authenticating, true)
+      new_user = create_new_user({:username => "", :email => "BLA1@BLA.COM", :password => 'secret1'})
+      get :test_login, :email => 'bla1@bla.com', :password => 'secret1'
+
+      expect(assigns[:user]).to eq new_user
+      expect(session[:user_id]).to eq new_user.id
+    end
+
+    it "logout clears the session" do
+      cookies[:remember_me_token] = nil
+      session[:user_id] = user.id
+      get :test_logout
+
+      expect(session[:user_id]).to be_nil
+    end
+
+    it "logged_in? returns true if logged in" do
+      session[:user_id] = user.id
+
+      expect(subject.logged_in?).to be true
+    end
+
+    it "logged_in? returns false if not logged in" do
+      session[:user_id] = nil
+
+      expect(subject.logged_in?).to be false
+    end
+
+    it "current_user returns the user instance if logged in" do
+      create_new_user
+      session[:user_id] = user.id
+
+      2.times { expect(subject.current_user).to eq user } # memoized!
+    end
+
+    it "current_user returns false if not logged in" do
+      session[:user_id] = nil
+
+      2.times { expect(subject.current_user).to be_nil } # memoized!
+    end
+
+    specify { should respond_to(:require_login) }
+
+    it "calls the configured 'not_authenticated_action' when authenticate before_filter fails" do
+      session[:user_id] = nil
+      sorcery_controller_property_set(:not_authenticated_action, :test_not_authenticated_action)
+      get :test_logout
+
+      expect(response.body).to eq "test_not_authenticated_action"
+    end
+
+    it "require_login before_filter saves the url that the user originally wanted" do
+      get :some_action
+
+      expect(session[:return_to_url]).to eq "http://test.host/some_action"
+      expect(response).to redirect_to("http://test.host/")
+    end
+
+    it "require_login before_filter does not save the url that the user originally wanted upon all non-get http methods" do
+      [:post, :put, :delete].each do |m|
+        self.send(m, :some_action)
+
+        expect(session[:return_to_url]).to be_nil
+      end
+    end
+
+    it "on successful login the user is redirected to the url he originally wanted" do
+      session[:return_to_url] = "http://test.host/some_action"
+      post :test_return_to, :email => 'bla@bla.com', :password => 'secret'
+
+      expect(response).to redirect_to("http://test.host/some_action")
+      expect(flash[:notice]).to eq "haha!"
+    end
+
+
+    # --- auto_login(user) ---
+    specify { should respond_to(:auto_login) }
+
+    it "auto_login(user) los in a user instance" do
+      session[:user_id] = nil
+      subject.auto_login(user)
+
+      expect(subject.logged_in?).to be true
+    end
+
+    it "auto_login(user) works even if current_user was already set to false" do
+      get :test_logout
+
+      expect(session[:user_id]).to be_nil
+      expect(subject.current_user).to be_nil
+
+      get :test_auto_login
+
+      expect(assigns[:result]).to eq User.first
+    end
+  end
+
+end