passwd 0.2.0 → 0.3.0

data/spec/passwd/active_record_ext_spec.rb

@@ -1,80 +0,0 @@
-require "spec_helper"
-
-describe Passwd::ActiveRecordExt do
-  describe ".with_authenticate" do
-    it { expect(ActiveRecord::Base).to respond_to(:with_authenticate) }
-
-    context User do
-      let(:new_pass) { "NewPassw0rd" }
-      let(:password) { Passwd::Password.new }
-      let(:user) {
-        User.create(
-          name: "i2bskn",
-          email: "i2bskn@example.com",
-          salt: password.salt.hash,
-          password: password.hash
-        )
-      }
-
-      it { is_expected.to respond_to(:passwd) }
-      it { is_expected.to respond_to(:authenticate) }
-      it { expect(User).to respond_to(:authenticate) }
-      it { is_expected.to respond_to(:set_password) }
-      it { is_expected.to respond_to(:update_password) }
-
-      context "#passwd" do
-        after { user.passwd }
-
-        it { expect(user.passwd.is_a?(Passwd::Password)).to be_truthy }
-        it { expect(user).to receive(:reload) }
-        it { expect(Passwd::Password).to receive(:from_hash) }
-
-        it {
-          user = User.new
-          expect(user).to receive(:set_password)
-          user.passwd
-        }
-      end
-
-      context ".authenticate" do
-        before { user }
-
-        it { expect(User.authenticate("i2bskn@example.com", password.plain)).not_to be_falsy }
-        it { expect(User.authenticate("i2bskn@example.com", "invalid")).to be_falsy }
-      end
-
-      context "#authenticate" do
-        it { expect(user.authenticate(password.plain)).not_to be_falsy }
-        it { expect(user.authenticate("invalid")).to be_falsy }
-      end
-
-      context "#set_password" do
-        it { expect { user.set_password }.to change { user.password } }
-        it { expect { user.set_password(new_pass) }.to change { user.password } }
-      end
-
-      context "#update_password" do
-        before { user }
-
-        it {
-          expect {
-            user.update_password(password.plain, new_pass)
-          }.to change { user.password }
-        }
-
-        it {
-          expect {
-            user.update_password(password.plain, "secret", true)
-          }.to raise_error(Passwd::PolicyNotMatch)
-        }
-
-        it {
-          expect {
-            user.update_password("invalid", new_pass)
-          }.to raise_error(Passwd::AuthenticationFails)
-        }
-      end
-    end
-  end
-end
-

data/spec/passwd/base_spec.rb

@@ -1,60 +0,0 @@
-require "spec_helper"
-
-describe Passwd::Base do
-  let(:plain) { "secret" }
-
-  context "#random" do
-    it { expect(Passwd).to respond_to(:random) }
-    it { expect(Passwd.random.is_a?(String)).to be_truthy }
-    it { expect(Passwd.random.size).to eq(Passwd::PwConfig.length) }
-    it { expect(Passwd.random(lower: false)).not_to include(*"a".."z") }
-    it { expect(Passwd.random(upper: false)).not_to include(*"A".."Z") }
-    it { expect(Passwd.random(number: false)).not_to include(*"0".."9") }
-
-    it {
-      length = Passwd::PwConfig.length + 1
-      expect(Passwd.random(length: length).size).to eq(length)
-    }
-
-    it {
-      lower = ["a"]
-      expect(
-        Passwd.random(letters_lower: lower, upper: false, number: false)
-          .chars.uniq
-      ).to eq(lower)
-    }
-  end
-
-  context "#digest" do
-    it { expect(Passwd.respond_to?(:digest)).to be_truthy }
-    it { expect(Passwd.digest(plain).is_a?(String)).to be_truthy }
-    it { expect(Passwd.digest(plain)).not_to eq(plain) }
-
-    it {
-      hashed = Passwd.send(:algorithm, Passwd::PwConfig.algorithm).hexdigest plain
-      expect(Passwd.digest(plain)).to eq(hashed)
-    }
-
-    it {
-      not_default = :md5
-      hashed = Passwd.send(:algorithm, not_default).hexdigest plain
-      expect(Passwd.digest(plain, not_default)).to eq(hashed)
-    }
-  end
-
-  context "#algorithm" do
-    it { expect(Passwd.send(:algorithm, :sha1)).to eq(Digest::SHA1) }
-    it { expect(Passwd.send(:algorithm, :sha256)).to eq(Digest::SHA256) }
-    it { expect(Passwd.send(:algorithm, :sha384)).to eq(Digest::SHA384) }
-    it { expect(Passwd.send(:algorithm, :sha512)).to eq(Digest::SHA512) }
-    it { expect(Passwd.send(:algorithm, :md5)).to eq(Digest::MD5) }
-    it { expect(Passwd.send(:algorithm, :rmd160)).to eq(Digest::RMD160) }
-
-    it {
-      expect {
-        Passwd.send(:algorithm, :unknowAn)
-      }.to raise_error
-    }
-  end
-end
-

data/spec/passwd/configuration_spec.rb

@@ -1,50 +0,0 @@
-require "spec_helper"
-
-describe Passwd::Configuration do
-  describe "#initialize" do
-    subject { Passwd::PwConfig }
-    # defined options
-    it { is_expected.to respond_to(:algorithm) }
-    it { is_expected.to respond_to(:length) }
-    it { is_expected.to respond_to(:policy) }
-    it { is_expected.to respond_to(:stretching) }
-    it { is_expected.to respond_to(:lower) }
-    it { is_expected.to respond_to(:upper) }
-    it { is_expected.to respond_to(:number) }
-    it { is_expected.to respond_to(:letters_lower) }
-    it { is_expected.to respond_to(:letters_upper) }
-    it { is_expected.to respond_to(:letters_number) }
-
-    # default settings
-    it { is_expected.to have_attributes(algorithm: :sha512) }
-    it { is_expected.to have_attributes(length: 8) }
-    it { is_expected.to satisfy {|v| v.policy.is_a?(Passwd::Policy) } }
-    it { is_expected.to have_attributes(stretching: nil) }
-    it { is_expected.to have_attributes(lower: true) }
-    it { is_expected.to have_attributes(upper: true) }
-    it { is_expected.to have_attributes(number: true) }
-    it { is_expected.to have_attributes(letters_lower: [*"a".."z"]) }
-    it { is_expected.to have_attributes(letters_upper: [*"A".."Z"]) }
-    it { is_expected.to have_attributes(letters_number: [*"0".."9"]) }
-  end
-
-  describe "Writable" do
-    subject { Passwd }
-
-    it {
-      klass = Class.new { extend Passwd::Configuration::Writable }
-      expect(defined?(klass::PwConfig)).to be_truthy
-    }
-
-    it { is_expected.to respond_to(:configure) }
-    it { is_expected.to respond_to(:policy_configure) }
-  end
-
-  describe "Accessible" do
-    it {
-      klass = Class.new { include Passwd::Configuration::Accessible }
-      expect(klass::PwConfig.is_a?(Passwd::Configuration)).to be_truthy
-    }
-  end
-end
-

data/spec/passwd/password_spec.rb

@@ -1,156 +0,0 @@
-require "spec_helper"
-
-describe Passwd::Password do
-  let!(:pswd) { Passwd::Password.new }
-
-  describe "#initialize" do
-    context "without argument" do
-      subject { Passwd::Password.new }
-
-      it { is_expected.not_to have_attributes(plain: nil) }
-      it { is_expected.not_to have_attributes(hash: nil) }
-      it { is_expected.not_to have_attributes(salt: nil) }
-      it { is_expected.to satisfy {|v| v.salt.is_a?(Passwd::Salt) } }
-    end
-
-    context "with plain" do
-      subject { Passwd::Password.new(plain: pswd.plain) }
-
-      it { is_expected.to have_attributes(plain: pswd.plain) }
-      it { is_expected.not_to have_attributes(hash: nil) }
-      it { is_expected.not_to have_attributes(salt: nil) }
-      it { is_expected.to satisfy {|v| v.salt.is_a?(Passwd::Salt) } }
-    end
-
-    context "with plain and salt_plain" do
-      subject { Passwd::Password.new(plain: pswd.plain, salt_plain: pswd.salt.plain) }
-
-      it { is_expected.to have_attributes(plain: pswd.plain) }
-      it { is_expected.to have_attributes(hash: pswd.hash) }
-      it { is_expected.to satisfy {|v| v.salt.plain == pswd.salt.plain } }
-      it { is_expected.to satisfy {|v| v.salt.hash == pswd.salt.hash } }
-    end
-
-    context "with plain and salt_hash" do
-      subject { Passwd::Password.new(plain: pswd.plain, salt_hash: pswd.salt.hash) }
-
-      it { is_expected.to have_attributes(plain: pswd.plain) }
-      it { is_expected.to have_attributes(hash: pswd.hash) }
-      it { is_expected.to satisfy {|v| v.salt.plain.nil? } }
-      it { is_expected.to satisfy {|v| v.salt.hash == pswd.salt.hash } }
-    end
-
-    context "with hash and salt_hash" do
-      subject { Passwd::Password.new(hash: pswd.hash, salt_hash: pswd.salt.hash) }
-
-      it { is_expected.to have_attributes(plain: nil) }
-      it { is_expected.to have_attributes(hash: pswd.hash) }
-      it { is_expected.to satisfy {|v| v.salt.plain.nil? } }
-      it { is_expected.to satisfy {|v| v.salt.hash == pswd.salt.hash } }
-    end
-
-    it {
-      expect {
-        Passwd::Password.new(hash: pswd.hash)
-      }.to raise_error(ArgumentError)
-    }
-  end
-
-  describe "#update_plain" do
-    it {
-      expect(pswd).to receive(:rehash)
-      pswd.update_plain("secret")
-      expect(pswd).to have_attributes(plain: "secret")
-    }
-
-    it {
-      expect {
-        pswd.update_plain("secret")
-      }.to change { pswd.plain }
-    }
-  end
-
-  describe "#update_hash" do
-    it {
-      expect(pswd).not_to receive(:rehash)
-      pswd.update_hash("hashed", "salt")
-      expect(pswd).to have_attributes(hash: "hashed")
-      expect(pswd.salt).to have_attributes(hash: "salt")
-    }
-
-    it {
-      expect {
-        pswd.update_hash("hashed", "salt")
-      }.to change { pswd.plain }
-    }
-  end
-
-  describe "#match?" do
-    it { expect(pswd.match?(pswd.plain)).to be_truthy }
-
-    it {
-      invalid = [pswd.plain, "invalid"].join
-      expect(pswd.match?(invalid)).to be_falsy
-    }
-  end
-
-  describe "#==" do
-    it {
-      expect(pswd).to receive(:match?)
-      pswd == pswd.plain
-    }
-  end
-
-  describe "#valid?" do
-    it {
-      pswd.update_plain("ValidPassw0rd")
-      expect(pswd.valid?).to be_truthy
-    }
-
-    it {
-      pswd.update_plain("a" * (Passwd::PwConfig.policy.min_length - 1))
-      expect(pswd.valid?).to be_falsy
-    }
-
-    it {
-      pswd.update_hash("hashed", "salt")
-      expect {
-        pswd.valid?
-      }.to raise_error(Passwd::PasswdError)
-    }
-  end
-
-  describe "#default_options" do
-    it {
-      expect(pswd.send(:default_options)).to satisfy {|v| v.has_key?(:plain) }
-    }
-  end
-
-  describe "#include_char?" do
-    it {
-      pswd.update_plain("secret")
-      expect(pswd.send(:include_char?, ["s"])).to be_truthy
-    }
-
-    it {
-      expect {
-        pswd.update_hash("hashed", "salt")
-        pswd.send(:include_char?, [])
-      }.to raise_error(Passwd::PasswdError)
-    }
-  end
-
-  describe ".from_plain" do
-    it {
-      expect(Passwd::Password).to receive(:new)
-      Passwd::Password.from_plain("secret")
-    }
-  end
-
-  describe ".from_hash" do
-    it {
-      expect(Passwd::Password).to receive(:new)
-      Passwd::Password.from_hash("hashed", "salt")
-    }
-  end
-end

data/spec/spec_helper.rb

@@ -1,34 +0,0 @@
-require "simplecov"
-require "coveralls"
-Coveralls.wear!
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-]
-
-SimpleCov.start do
-  add_filter "spec"
-  add_filter ".bundle"
-  add_filter "example"
-end
-
-ENV["RAILS_ENV"] ||= "test"
-require File.expand_path("../../example/config/environment", __FILE__)
-require "passwd"
-
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
-
-RSpec.configure do |config|
-  config.order = "random"
-
-  config.before :all do
-    require "db/schema"
-  end
-
-  config.after :each do
-    Passwd::PwConfig.reset
-    DataUtil.clear
-  end
-end
-

data/spec/support/data_util.rb

@@ -1,11 +0,0 @@
-class DataUtil
-  TARGETS = %w(User)
-
-  def self.clear
-    models.each(&:delete_all)
-  end
-
-  def self.models
-    TARGETS.map(&:constantize)
-  end
-end

data/spec/support/paths.rb

@@ -1,2 +0,0 @@
-$:.unshift(Rails.root.to_s) unless $:.include?(Rails.root.to_s)
-