simple_auth 1.5.0 → 2.0.0

data/spec/simple_auth/helper_spec.rb

@@ -8,17 +8,17 @@ describe SimpleAuth::Helper do
     @helper.extend(ActionView::Helpers::CaptureHelper)
   end
 
-  it "should include module" do
+  it "includes module" do
     ApplicationController.included_modules.include?(SimpleAuth::Helper)
   end
 
-  it "should render block when user is logged" do
-    @helper.should_receive(:logged_in?).and_return(true)
-    @helper.when_logged { "logged" }.should == "logged"
+  it "renders block when user is logged" do
+    expect(@helper).to receive(:logged_in?).and_return(true)
+    expect(@helper.when_logged { "logged" }).to eq("logged")
   end
 
-  it "should not render block when user is unlogged" do
-    @helper.should_receive(:logged_in?).and_return(false)
-    @helper.when_logged { "logged" }.should be_nil
+  it "doesn't render block when user is unlogged" do
+    expect(@helper).to receive(:logged_in?).and_return(false)
+    expect(@helper.when_logged { "logged" }).to be_nil
   end
 end

data/spec/simple_auth/session_spec.rb

@@ -13,25 +13,25 @@ describe SimpleAuth::Session do
 
     @session = Hash.new
     @controller = ActionController::Base.new
-    @controller.stub :session => @session, :reset_session => nil
+    allow(@controller).to receive_messages :session => @session, :reset_session => nil
 
     SimpleAuth::Config.controller = @controller
     @user_session = SimpleAuth::Session.new(:credential => "johndoe", :password => "test")
   end
 
-  it "should not raise when trying to find a session without activating controller" do
+  it "doesn't raise when trying to find a session without activating controller" do
     SimpleAuth::Config.controller = nil
 
     expect {
-      SimpleAuth::Session.find.should be_nil
+      expect(SimpleAuth::Session.find).to be_nil
     }.to_not raise_error
   end
 
-  it "should return session key" do
+  it "returns session key" do
     SimpleAuth::Session.session_key == :user_id
   end
 
-  it "should return record id" do
+  it "returns record id" do
     @session[:user_id] = 42
     SimpleAuth::Session.record_id == 42
   end
@@ -41,56 +41,56 @@ describe SimpleAuth::Session do
       @user_session.save!
     end
 
-    it "should return existing session" do
+    it "returns existing session" do
       @user_session = SimpleAuth::Session.find
-      @user_session.should be_valid
-      @user_session.record.should == @user
+      expect(@user_session).to be_valid
+      expect(@user_session.record).to eq(@user)
     end
 
-    it "should not be new record" do
-      @user_session.should_not be_new_record
+    it "doesn't be new record" do
+      expect(@user_session).not_to be_new_record
     end
 
-    it "should be invalid when record is not authorized" do
-      @user_session.record.stub :authorized? => false
-      @user_session.should_not be_valid
+    it "is invalid when record is not authorized" do
+      allow(@controller).to receive_messages :authorized? => false
+      expect(@user_session).not_to be_valid
     end
 
-    it "should be valid when record is authorized" do
-      @user_session.record.stub :authorized? => true
-      @user_session.should be_valid
+    it "is valid when record is authorized" do
+      allow(@user_session.record).to receive_messages :authorized? => true
+      expect(@user_session).to be_valid
     end
 
-    it "should find record" do
-      @user_session.record.should == @user
+    it "finds record" do
+      expect(@user_session.record).to eq(@user)
     end
 
-    it "should be saved" do
-      @user_session.save.should be_true
+    it "is saved" do
+      expect(@user_session.save).to be_truthy
     end
 
-    it "should reset session before saving" do
+    it "resets session before saving" do
       @session[:session_id] = "xWA1"
       @user_session.save
-      @session.should_not have_key(:session_id)
+      expect(@session).not_to have_key(:session_id)
     end
 
-    it "should automatically save session when calling create!" do
+    it "automatically saves session when calling create!" do
       @user_session = SimpleAuth::Session.create!(:credential => "johndoe", :password => "test")
-      @user_session.should be_valid
-      @user_session.record.should == @user
-      @session[:user_id].should == @user.id
+      expect(@user_session).to be_valid
+      expect(@user_session.record).to eq(@user)
+      expect(@session[:user_id]).to eq(@user.id)
     end
 
-    it "should destroy session" do
-      @user_session.destroy.should be_true
-      @user_session.record.should be_nil
-      @session.should_not have_key(:user)
+    it "destroys session" do
+      expect(@user_session.destroy).to be_truthy
+      expect(@user_session.record).to be_nil
+      expect(@session).not_to have_key(:user)
     end
 
-    it "should initialize record session" do
+    it "initializes record session" do
       @user_session.save
-      @session[:user_id].should == @user.id
+      expect(@session[:user_id]).to eq(@user.id)
     end
   end
 
@@ -100,66 +100,66 @@ describe SimpleAuth::Session do
       @user_session.save
     end
 
-    it "should unset previous record id when is not valid" do
+    it "unsets previous record id when is not valid" do
       @session[:user_id] = 1
-      @user_session.should_not be_valid
-      @session.should_not have_key(:user)
+      expect(@user_session).not_to be_valid
+      expect(@session).not_to have_key(:user)
     end
 
-    it "should unset previous record id when is not saved" do
+    it "unsets previous record id when is not saved" do
       @session[:user_id] = 1
-      @user_session.save.should be_false
-      @session.should_not have_key(:user)
+      expect(@user_session.save).to be_falsey
+      expect(@session).not_to have_key(:user)
     end
 
-    it "should be new record" do
-      SimpleAuth::Session.new.should be_new_record
-      @user_session.should be_new_record
+    it "is new record" do
+      expect(SimpleAuth::Session.new).to be_new_record
+      expect(@user_session).to be_new_record
     end
 
-    it "should have error message" do
-      @user_session.errors.full_messages[0].should == "Invalid username or password"
+    it "has error message" do
+      expect(@user_session.errors.full_messages[0]).to eq("Invalid username or password")
     end
 
-    it "should not return error messages for attributes" do
-      @user_session.errors.on(:credential).should be_nil
-      @user_session.errors.on(:password).should be_nil
+    it "doesn't return error messages for attributes" do
+      expect(@user_session.errors.on(:credential)).to be_nil
+      expect(@user_session.errors.on(:password)).to be_nil
     end
 
-    it "should return empty array when trying to get errors by using hash syntax" do
-      @user_session.errors[:credential].should be_empty
-      @user_session.errors[:password].should be_empty
+    it "returns empty array when trying to get errors by using hash syntax" do
+      expect(@user_session.errors[:credential]).to be_empty
+      expect(@user_session.errors[:password]).to be_empty
     end
 
-    it "should have errors" do
-      @user_session.errors.should_not be_empty
+    it "has errors" do
+      expect(@user_session.errors).not_to be_empty
     end
 
-    it "should not find existing session" do
-      SimpleAuth::Session.find.should be_nil
+    it "doesn't find existing session" do
+      expect(SimpleAuth::Session.find).to be_nil
     end
 
-    it "should not find record" do
-      @user_session.record.should be_nil
+    it "doesn't find record" do
+      expect(@user_session.record).to be_nil
     end
 
-    it "should not be a valid session" do
-      @user_session.should_not be_valid
+    it "doesn't be a valid session" do
+      expect(@user_session).not_to be_valid
     end
 
-    it "should unset record store from session" do
-      @session.should_not have_key(:user)
+    it "unsets record store from session" do
+      expect(@session).not_to have_key(:user)
     end
 
-    it "should not be saved" do
-      @user_session.save.should be_false
+    it "doesn't be saved" do
+      expect(@user_session.save).to be_falsey
     end
 
-    it "should raise error with save!" do
+    it "raises error with save!" do
       expect { @user_session.save! }.to raise_error(SimpleAuth::NotAuthorized)
     end
 
-    it "should raise error with create!" do
+    it "raises error with create!" do
       expect { SimpleAuth::Session.create!({}) }.to raise_error(SimpleAuth::NotAuthorized)
     end
   end
@@ -169,27 +169,27 @@ describe SimpleAuth::Session do
       @user_session.save!
     end
 
-    it "should keep return to url" do
+    it "keeps return to url" do
       @session[:return_to] = "/some/path"
       @user_session.destroy
-      @session[:return_to].should == "/some/path"
+      expect(@session[:return_to]).to eq("/some/path")
     end
 
-    it "should remove record session" do
+    it "removes record session" do
       @user_session.destroy
-      @session.should_not have_key(:user_id)
+      expect(@session).not_to have_key(:user_id)
     end
 
-    it "should keep keys composed by user_*" do
+    it "keeps keys composed by user_*" do
       SimpleAuth::Config.wipeout_session = false
 
       @session[:user_friends_count] = 42
       @user_session.destroy
 
-      @session[:user_friends_count].should == 42
+      expect(@session[:user_friends_count]).to eq(42)
     end
 
-    it "should wipe out keys composed by user_*" do
+    it "erases keys composed by user_*" do
       SimpleAuth::Config.wipeout_session = true
 
       @session[:user_friends_count] = 100
@@ -197,16 +197,16 @@ describe SimpleAuth::Session do
 
       @user_session.destroy
 
-      @session.should_not have_key(:user_friends_count)
-      @session.should_not have_key(:user_preferred_number)
+      expect(@session).not_to have_key(:user_friends_count)
+      expect(@session).not_to have_key(:user_preferred_number)
     end
 
-    it "should unset current_user instance variable" do
+    it "unsets current_user instance variable" do
       @user_session.destroy
 
-      SimpleAuth::Config.controller.send(:current_user).should be_nil
-      SimpleAuth::Config.controller.instance_variable_get("@current_user").should be_nil
-      SimpleAuth::Config.controller.instance_variable_get("@current_session").should be_nil
+      expect(SimpleAuth::Config.controller.send(:current_user)).to be_nil
+      expect(SimpleAuth::Config.controller.instance_variable_get("@current_user")).to be_nil
+      expect(SimpleAuth::Config.controller.instance_variable_get("@current_session")).to be_nil
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,187 +1,21 @@
 ENV["RAILS_ENV"] = "test"
-require "bundler"
-Bundler.setup(:default, :development, :test)
+require "bundler/setup"
 Bundler.require
 
 I18n.load_path += Dir[File.expand_path("../../locales/*.yml", __FILE__)]
+I18n.enforce_available_locales = false
 
 require "rails"
 require "simple_auth"
 require File.dirname(__FILE__) + "/support/config/boot"
 require "rspec/rails"
-require "mongo_mapper"
 
 # Load database schema
 load File.dirname(__FILE__) + "/schema.rb"
 
-# Set up MongoDB connection
-MongoMapper.connection = Mongo::Connection.new("localhost")
-MongoMapper.database = "simple_auth"
-
 # Restore default configuration
 RSpec.configure do |config|
   config.before :each do
     load File.dirname(__FILE__) + "/../lib/simple_auth/config.rb"
   end
 end
-
-shared_examples_for "orm" do
-  before do
-    SimpleAuth::Config.model = model_name
-  end
-
-  context "configuration" do
-    it "should set credentials" do
-      model.authentication do |config|
-        config.credentials = ["uid"]
-      end
-
-      SimpleAuth::Config.credentials.should == ["uid"]
-    end
-
-    it "should automatically set model" do
-      model.authentication do |config|
-        config.model = nil
-      end
-
-      SimpleAuth::Config.model.should == model_name
-    end
-  end
-
-  context "new record" do
-    before do
-      subject.should_not be_valid
-    end
-
-    it "should require password" do
-      subject.errors[:password].should_not be_empty
-    end
-
-    it "should require password to be at least 4-chars long" do
-      subject.password = "123"
-      subject.should_not be_valid
-      subject.errors[:password].should_not be_empty
-    end
-
-    it "should require password confirmation not to be empty" do
-      subject.password_confirmation = ""
-      subject.errors[:password_confirmation].should_not be_empty
-    end
-
-    it "should require password confirmation not to be nil" do
-      subject.password_confirmation = nil
-      subject.errors[:password_confirmation].should_not be_empty
-    end
-
-    it "should unset password after saving" do
-      subject = model.new(:password => "test", :password_confirmation => "test")
-      subject.save
-      subject.password.should be_nil
-      subject.password_confirmation.should be_nil
-    end
-
-    it "should mark password as changed" do
-      subject = model.new(:password => "test")
-      subject.password_changed?.should be_true
-    end
-
-    it "should not mark password as changed" do
-      subject = model.new
-      subject.password_changed?.should be_false
-    end
-
-    it "should mark password as unchanged after saving" do
-      subject = model.new(:password => "test", :password_confirmation => "test")
-      subject.save
-      subject.password_changed?.should be_false
-    end
-  end
-
-  context "existing record" do
-    before do
-      model.delete_all
-      model.create(
-        :email => "john@doe.com",
-        :login => "johndoe",
-        :password => "test",
-        :password_confirmation => "test",
-        :username => "john"
-      )
-    end
-
-    subject { model.first }
-
-    it "should not require password when it hasn't changed" do
-      subject.login = "john"
-      subject.should be_valid
-    end
-
-    it "should require password when explicitly said so" do
-      subject.require_password!
-      subject.should_not be_valid
-      subject.errors[:password].should_not be_empty
-    end
-
-    it "should require password" do
-      subject.require_password?.should be_false
-      subject.require_password!
-      subject.require_password?.should be_true
-    end
-
-    it "should not require password after saving" do
-      subject.require_password!
-      subject.password = "newpass"
-      subject.password_confirmation = "newpass"
-      subject.save.should be_true
-      subject.require_password?.should be_false
-    end
-
-    it "should require password confirmation when it has changed" do
-      subject.password = "newpass"
-      subject.should_not be_valid
-      subject.errors[:password_confirmation].should_not be_empty
-    end
-
-    it "should require password when it has changed to blank" do
-      subject.password = nil
-      subject.should_not be_valid
-      subject.errors[:password].should_not be_empty
-    end
-
-    it "should authenticate using email" do
-      model.authenticate("john@doe.com", "test").should == subject
-    end
-
-    it "should authenticate using login" do
-      model.authenticate("johndoe", "test").should == subject
-    end
-
-    it "should authenticate using custom attribute" do
-      SimpleAuth::Config.credentials = [:username]
-      model.authenticate("john", "test").should == subject
-    end
-
-    it "should not authenticate using invalid credential" do
-      model.authenticate("invalid", "test").should be_nil
-    end
-
-    it "should not authenticate using wrong password" do
-      model.authenticate("johndoe", "invalid").should be_nil
-    end
-
-    it "should return nil when no user has been found" do
-      model.find_by_credential("invalid").should be_nil
-    end
-
-    it "should raise error when no user has been found" do
-      expect {
-        model.find_by_credential!("invalid")
-      }.to raise_error(SimpleAuth::RecordNotFound)
-    end
-
-    it "should return user" do
-      model.find_by_credential(subject.email).should == subject
-      model.find_by_credential!(subject.email).should == subject
-    end
-  end
-end