simple_auth 2.0.4 → 3.0.0

data/lib/simple_auth/compat.rb

@@ -1,2 +0,0 @@
-require "simple_auth/compat/config"
-require "simple_auth/compat/active_record"

data/lib/simple_auth/compat/active_record.rb

@@ -1,28 +0,0 @@
-module SimpleAuth
-  def self.migrate_passwords!
-    require "ostruct"
-
-    generator = OpenStruct.new.extend(ActiveModel::SecurePassword::InstanceMethodsOnActivation)
-
-    Config.model_class.find_each do |record|
-      generator.password = record.password_hash
-
-      Config.model_class
-        .where(id: record.id)
-        .update_all(password_digest: generator.password_digest)
-    end
-  end
-
-  module ActiveRecord
-    module InstanceMethods
-      def password=(password)
-        super SimpleAuth::Config.crypter.call(password, password_salt)
-        @password = password
-      end
-
-      def authenticate(password)
-        super SimpleAuth::Config.crypter.call(password, password_salt)
-      end
-    end
-  end
-end

data/lib/simple_auth/compat/config.rb

@@ -1,17 +0,0 @@
-module SimpleAuth
-  class Config
-    # Generate the password hash. The specified block should expected
-    # the plain password and the password hash as block parameters.
-    cattr_accessor :crypter
-    @@crypter = proc do |password, salt|
-      Digest::SHA256.hexdigest [password, salt].join("--")
-    end
-
-    # Generate the password salt. The specified block should expect
-    # the ActiveRecord instance as block parameter.
-    cattr_accessor :salt
-    @@salt = proc do |record|
-      Digest::SHA256.hexdigest [Time.to_s, SecureRandom.hex(32)].join("--")
-    end
-  end
-end

data/lib/simple_auth/exceptions.rb

@@ -1,4 +0,0 @@
-module SimpleAuth
-  class RecordNotFound < StandardError; end
-  class NotAuthorized < StandardError; end
-end

data/lib/simple_auth/helper.rb

@@ -1,12 +0,0 @@
-module SimpleAuth
-  module Helper
-    # Renders the specified block for logged users.
-    #
-    #   <% when_logged do %>
-    #     <!-- content for logged users -->
-    #   <% end %>
-    def when_logged(&block)
-      capture(&block) if logged_in?
-    end
-  end
-end

data/lib/simple_auth/rspec.rb

@@ -1,29 +0,0 @@
-module SimpleAuth
-  module RSpec
-    # A simple helper to stub current session options.
-    #
-    #   simple_auth(:user => User.first) # the most common case
-    #   simple_auth(:authorized => false)
-    #   simple_auth(:session => mock("current_session", :valid? => false))
-    #
-    # This is how you set it up:
-    #
-    #   # spec/spec_helper.rb
-    #   require "simple_auth/rspec"
-    #   RSpec.configure {|c| c.include SimpleAuth::RSpec, :type => :controller}
-    #
-    def simple_auth(options = {})
-      options.reverse_merge!({
-        :session => double("current_session").as_null_object,
-        :authorized => true,
-        :user => double("current_user").as_null_object
-      })
-
-      controller.stub({
-        :current_user => options[:user],
-        :authorized? => options[:authorized],
-        :current_session => options[:session]
-      })
-    end
-  end
-end

data/locales/en.yml

@@ -1,5 +0,0 @@
-en:
-  simple_auth:
-    sessions:
-      need_to_be_logged: "You need to be logged"
-      invalid_credentials: "Invalid username or password"

data/locales/pt-BR.yml

@@ -1,5 +0,0 @@
-pt-BR:
-  simple_auth:
-    sessions:
-      need_to_be_logged: "Você precisa estar logado"
-      invalid_credentials: "Usuário ou senha inválidos"

data/spec/controllers/redirect_logged_user_spec.rb

@@ -1,87 +0,0 @@
-require "spec_helper"
-
-describe ApplicationController do
-  let(:user) {
-    User.create(
-      :login => "johndoe",
-      :email => "john@doe.com",
-      :password => "test",
-      :password_confirmation => "test"
-    )
-  }
-
-  context "redirecting logged users" do
-    context "using hash" do
-      controller ApplicationController do
-        redirect_logged_user :to => { :controller => "dashboard" }
-
-        def index
-          render :text => "Rendered"
-        end
-      end
-
-      it "redirects logged users" do
-        session[:user_id] = user.id
-        get :index
-
-        expect(response.code).to match(/302/)
-        expect(response).to redirect_to("/dashboard")
-      end
-    end
-
-    context "using block" do
-      controller ApplicationController do
-        redirect_logged_user :to => proc { dashboard_path }
-
-        def index
-          render :text => "Rendered"
-        end
-      end
-
-      it "redirects logged users" do
-        session[:user_id] = user.id
-        get :index
-
-        expect(response.code).to match(/302/)
-        expect(response).to redirect_to("/dashboard")
-      end
-    end
-
-    context "using configuration" do
-      controller ApplicationController do
-        redirect_logged_user
-
-        def index
-          render :text => "Rendered"
-        end
-      end
-
-      it "redirects logged users" do
-        SimpleAuth::Config.logged_url = proc { dashboard_path }
-        session[:user_id] = user.id
-        get :index
-
-        expect(response.code).to match(/302/)
-        expect(response).to redirect_to("/dashboard")
-      end
-    end
-
-    context "when unlogged" do
-      controller ApplicationController do
-        redirect_logged_user :to => { :controller => "dashboard" }
-
-        def index
-          render :text => "Rendered"
-        end
-      end
-
-      it "renders page" do
-        session[:user_id] = nil
-        get :index
-
-        expect(response.code).to match(/200/)
-        expect(response.body).to eq("Rendered")
-      end
-    end
-  end
-end

data/spec/controllers/require_logged_user_spec.rb

@@ -1,146 +0,0 @@
-require "spec_helper"
-
-describe ApplicationController do
-  let(:user) {
-    User.create(
-      :login => "johndoe",
-      :email => "john@doe.com",
-      :password => "test",
-      :password_confirmation => "test"
-    )
-  }
-
-  before do
-    session[:user_id] = {}
-  end
-
-  context "redirecting to requested page" do
-    controller ApplicationController do
-      require_logged_user :to => "/login"
-
-      def index
-        render :text => "Rendered"
-      end
-    end
-
-    it "keeps other session data" do
-      session[:skip_intro] = true
-      get :index
-      expect(session[:skip_intro]).to be_truthy
-    end
-
-    it "removes record id from session" do
-      session[:user_id] = 0
-      get :index
-      expect(session).not_to have_key(:user)
-    end
-
-    it "removes session id from session" do
-      session[:session_id] = "xSQR"
-      get :index
-      expect(session).not_to have_key(:session_id)
-    end
-
-    it "returns the request url" do
-      get :index, :some => "param"
-      expect(controller.send(:return_to, "/dashboard")).to eq("/anonymous?some=param")
-    end
-
-    it "returns the default url" do
-      expect(controller.send(:return_to, "/dashboard")).to eq("/dashboard")
-    end
-
-    it "sets return to" do
-      get :index, :some => "param"
-      expect(session[:return_to]).to eq("/anonymous?some=param")
-    end
-
-    it "removes return to from session" do
-      get :index, :some => "param"
-      controller.send(:return_to, "/dashboard")
-      expect(session[:return_to]).to be_nil
-    end
-
-    it "sets warning message" do
-      get :index
-      expect(flash[:alert]).to eq("You need to be logged")
-    end
-
-    it "redirects when user is not authorized on controller level" do
-      session[:user_id] = user.id
-      expect(@controller).to receive(:authorized?).and_return(false)
-
-      get :index
-      expect(response).to redirect_to("/login")
-    end
-
-    it "redirects when session is not valid" do
-      session[:user_id] = "invalid"
-
-      get :index
-      expect(response).to redirect_to("/login")
-    end
-
-    context "using hash" do
-      controller ApplicationController do
-        require_logged_user :to => {:controller => "session", :action => "new"}
-
-        def index
-          render :text => "Rendered"
-        end
-      end
-
-      it "is redirected" do
-        get :index
-        expect(response).to redirect_to("/login")
-      end
-    end
-
-    context "using block" do
-      controller ApplicationController do
-        require_logged_user :to => proc { login_path }
-
-        def index
-          render :text => "Rendered"
-        end
-      end
-
-      it "is redirected" do
-        get :index
-        expect(response).to redirect_to("/login")
-      end
-    end
-
-    context "using configuration" do
-      controller ApplicationController do
-        require_logged_user
-
-        def index
-          render :text => "Rendered"
-        end
-      end
-
-      it "is redirected" do
-        SimpleAuth::Config.login_url = "/login"
-        get :index
-        expect(response).to redirect_to("/login")
-      end
-    end
-  end
-
-  context "when logged" do
-    controller ApplicationController do
-      require_logged_user
-
-      def index
-        render :text => "Rendered"
-      end
-    end
-
-    it "renders page" do
-      session[:user_id] = user.id
-      get :index
-      expect(response.body).to eq("Rendered")
-    end
-  end
-end

data/spec/schema.rb

@@ -1,9 +0,0 @@
-ActiveRecord::Schema.define(:version => 0) do
-  create_table :users do |t|
-    t.string :email, :login, :password_digest, :username
-  end
-
-  create_table :customers do |t|
-    t.string :email, :login, :password_digest, :password_salt
-  end
-end

data/spec/simple_auth/active_record_spec.rb

@@ -1,146 +0,0 @@
-require "spec_helper"
-
-describe SimpleAuth::ActiveRecord do
-  let(:model) { User }
-  let(:model_name) { :user }
-  subject { model.new }
-
-  before do
-    SimpleAuth::Config.model = model_name
-  end
-
-  context "configuration" do
-    it "sets credentials" do
-      model.authentication do |config|
-        config.credentials = ["uid"]
-      end
-
-      expect(SimpleAuth::Config.credentials).to eq(["uid"])
-    end
-
-    it "automatically sets model" do
-      model.authentication do |config|
-        config.model = nil
-      end
-
-      expect(SimpleAuth::Config.model).to eq(model_name)
-    end
-  end
-
-  context "new record" do
-    before do
-      expect(subject).not_to be_valid
-    end
-
-    it "requires password", if: $rails_version >= "4.0" do
-      expect(subject.errors[:password]).not_to be_empty
-    end
-
-    it "requires password", if: $rails_version < "4.0" do
-      expect(subject.errors[:password_digest]).not_to be_empty
-    end
-
-    it "requires password to be at least 4-chars long" do
-      subject.password = "123"
-      expect(subject).not_to be_valid
-      expect(subject.errors[:password]).not_to be_empty
-    end
-
-    it "requires password confirmation", if: $rails_version >= "4.0" do
-      user = User.create(password: "test", password_confirmation: "invalid")
-      expect(user.errors[:password_confirmation]).not_to be_empty
-    end
-
-    it "requires password confirmation", if: $rails_version < "4.0" do
-      user = User.create(password: "test", password_confirmation: "invalid")
-      expect(user.errors[:password]).not_to be_empty
-    end
-  end
-
-  context "ignoring validations" do
-    it "ignores validations", if: $rails_version >= "4.0" do
-      person = Person.new
-      expect(person).to be_valid
-    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 "requires password", if: $rails_version >= "4.0" do
-      user = User.create(password: nil)
-      expect(user.errors[:password]).not_to be_empty
-    end
-
-    it "requires password", if: $rails_version < "4.0" do
-      user = User.create(password: nil)
-      expect(user.errors[:password_digest]).not_to be_empty
-    end
-
-    it "authenticates using email" do
-      expect(model.authenticate("john@doe.com", "test")).to eq(subject)
-    end
-
-    it "authenticates using login" do
-      expect(model.authenticate("johndoe", "test")).to eq(subject)
-    end
-
-    it "authenticates using custom attribute" do
-      SimpleAuth::Config.credentials = [:username]
-      expect(model.authenticate("john", "test")).to eq(subject)
-    end
-
-    it "doesn't authenticate using invalid credential" do
-      expect(model.authenticate("invalid", "test")).to be_nil
-    end
-
-    it "doesn't authenticate using wrong password" do
-      expect(model.authenticate("johndoe", "invalid")).not_to be
-    end
-
-    it "returns nil when no user has been found" do
-      expect(model.find_by_credential("invalid")).to be_nil
-    end
-
-    it "raises error when no user has been found" do
-      expect {
-        model.find_by_credential!("invalid")
-      }.to raise_error(SimpleAuth::RecordNotFound)
-    end
-
-    it "skips password length validation when no password is set" do
-      expect {
-        subject.username = "jd"
-        subject.save!
-      }.not_to raise_error
-    end
-
-    it "enforces password length when password is set" do
-      subject.password = "a"
-      subject.valid?
-      expect(subject.errors[:password]).to have(1).item
-    end
-
-    it "accepts valid password" do
-      subject.password = "test"
-      subject.valid?
-      expect(subject.errors[:password]).to be_empty
-    end
-
-    it "returns user" do
-      expect(model.find_by_credential(subject.email)).to eq(subject)
-      expect(model.find_by_credential!(subject.email)).to eq(subject)
-    end
-  end
-end