passwd 0.1.3 → 0.4.0

data/spec/passwd/configuration/policy_spec.rb

@@ -1,133 +0,0 @@
-# coding: utf-8
-
-require "spec_helper"
-
-describe Passwd::Policy do
-  let(:policy) {Passwd::Policy.instance}
-
-  describe "defined accessors" do
-    it "defined min_length" do
-      expect(policy.respond_to? :min_length).to be_true
-    end
-
-    it "defined require_lower" do
-      expect(policy.respond_to? :require_lower).to be_true
-    end
-
-    it "defined require_upper" do
-      expect(policy.respond_to? :require_upper).to be_true
-    end
-
-    it "defined require_number" do
-      expect(policy.respond_to? :require_number).to be_true
-    end
-  end
-
-  describe "#initialize" do
-    it "min_length should be a default" do
-      expect(policy.min_length).to eq(8)
-    end
-
-    it "require_lower should be a default" do
-      expect(policy.require_lower).to be_true
-    end
-
-    it "require_upper should be a default" do
-      expect(policy.require_upper).to be_false
-    end
-
-    it "require_number should be a default" do
-      expect(policy.require_number).to be_true
-    end
-  end
-
-  describe "#configure" do
-    before {
-      policy.configure do |c|
-        c.min_length = 20
-        c.require_lower = false
-        c.require_upper = true
-        c.require_number = false
-      end
-    }
-
-    it "set min_length from block" do
-      expect(policy.min_length).to eq(20)
-    end
-
-    it "set require_lower from block" do
-      expect(policy.require_lower).to be_false
-    end
-
-    it "set require_upper from block" do
-      expect(policy.require_upper).to be_true
-    end
-
-    it "set require_number from block" do
-      expect(policy.require_number).to be_false
-    end
-  end
-
-  describe "#valid?" do
-    let(:config) {Passwd::Config.instance}
-
-    it "valid password should be valid" do
-      expect(policy.valid?("secret1234", config)).to be_true
-    end
-
-    it "short password should not valid" do
-      expect(policy.valid?("short1", config)).to be_false
-    end
-
-    it "password should not valid if not contain lower case" do
-      expect(policy.valid?("NOTLOWER12", config)).to be_false
-    end
-
-    it "password should not valid if not contain upper case" do
-      policy.configure {|c| c.require_upper = true}
-      expect(policy.valid?("notupper12", config)).to be_false
-    end
-
-    it "password should not valid if not contain number" do
-      expect(policy.valid?("notnumber", config)).to be_false
-    end
-  end
-
-  describe "#include_char?" do
-    it "should be return true if contains" do
-      expect(policy.include_char?(("a".."z").to_a, "contains")).to be_true
-    end
-
-    it "should be return false if not contains" do
-      expect(policy.include_char?(("a".."z").to_a, "NOTCONTAINS")).to be_false
-    end
-  end
-
-  describe "#reset" do
-    before {
-      policy.configure do |c|
-        c.min_length = 20
-        c.require_lower = false
-        c.require_upper = true
-        c.require_number = false
-      end
-      policy.reset
-    }
-
-    it "min_length should be a default" do
-      expect(policy.min_length).to eq(8)
-    end
-
-    it "require_lower should be a default" do
-      expect(policy.require_lower).to be_true
-    end
-
-    it "require_upper should be a default" do
-      expect(policy.require_upper).to be_false
-    end
-
-    it "require_number should be a default" do
-      expect(policy.require_number).to be_true
-    end
-  end
-end

data/spec/passwd/configuration/tmp_config_spec.rb

@@ -1,257 +0,0 @@
-# coding: utf-8
-
-require "spec_helper"
-
-describe Passwd::TmpConfig do
-  let(:config) {Passwd::Config.instance}
-
-  def tmp_config(options={})
-    Passwd::TmpConfig.new(Passwd::Config.instance, options)
-  end
-
-  describe "defined accessors" do
-    it "defined length" do
-      expect(tmp_config.respond_to? :length).to be_true
-    end
-
-    it "defined lower" do
-      expect(tmp_config.respond_to? :lower).to be_true
-    end
-
-    it "defined upper" do
-      expect(tmp_config.respond_to? :upper).to be_true
-    end
-
-    it "defined number" do
-      expect(tmp_config.respond_to? :number).to be_true
-    end
-
-    it "defined letters_lower" do
-      expect(tmp_config.respond_to? :letters_lower).to be_true
-    end
-
-    it "defined letters_upper" do
-      expect(tmp_config.respond_to? :letters_upper).to be_true
-    end
-
-    it "defined letters_number" do
-      expect(tmp_config.respond_to? :letters_number).to be_true
-    end
-  end
-
-  describe "#initialize" do
-    context "with empty options" do
-      it "length should be a default" do
-        expect(tmp_config.length).to eq(8)
-      end
-
-      it "lower should be a default" do
-        expect(tmp_config.lower).to be_true
-      end
-
-      it "upper should be a default" do
-        expect(tmp_config.upper).to be_true
-      end
-
-      it "number should be a default" do
-        expect(tmp_config.number).to be_true
-      end
-
-      it "letters_lower should be a default" do
-        expect(tmp_config.letters_lower).to eq(("a".."z").to_a)
-      end
-
-      it "letters_upper should be a default" do
-        expect(tmp_config.letters_upper).to eq(("A".."Z").to_a)
-      end
-
-      it "letters_number should be a default" do
-        expect(tmp_config.letters_number).to eq(("0".."9").to_a)
-      end
-    end
-
-    context "with options" do
-      it "length should be a specified params" do
-        expect(tmp_config(length: 10).length).to eq(10)
-        expect(config.length).to eq(8)
-      end
-
-      it "lower should be a specified params" do
-        expect(tmp_config(lower: false).lower).to be_false
-        expect(config.lower).to be_true
-      end
-
-      it "upper should be a specified params" do
-        expect(tmp_config(upper: false).upper).to be_false
-        expect(config.upper).to be_true
-      end
-
-      it "number should be a specified params" do
-        expect(tmp_config(number: false).number).to be_false
-        expect(config.number).to be_true
-      end
-
-      it "letters_lower should be a specified params" do
-        expect(tmp_config(letters_lower: ["a"]).letters_lower).to eq(["a"])
-        expect(config.letters_lower).to eq(("a".."z").to_a)
-      end
-
-      it "letters_upper should be a specified params" do
-        expect(tmp_config(letters_upper: ["A"]).letters_upper).to eq(["A"])
-        expect(config.letters_upper).to eq(("A".."Z").to_a)
-      end
-
-      it "letters_number should be a specified params" do
-        expect(tmp_config(letters_number: ["0"]).letters_number).to eq(["0"])
-        expect(config.letters_number).to eq(("0".."9").to_a)
-      end
-    end
-  end
-
-  describe "#configure" do
-    let(:changed_tmp_config) do
-      tconf = tmp_config
-      tconf.configure do |c|
-        c.length = 20
-        c.lower = false
-        c.upper = false
-        c.number = false
-        c.letters_lower = ["a"]
-        c.letters_upper = ["A"]
-        c.letters_number = ["0"]
-      end
-      tconf
-    end
-
-    it "set length from block" do
-      expect(changed_tmp_config.length).to eq(20)
-      expect(config.length).to eq(8)
-    end
-
-    it "set lower from block" do
-      expect(changed_tmp_config.lower).to be_false
-      expect(config.lower).to be_true
-    end
-
-    it "set upper from block" do
-      expect(changed_tmp_config.upper).to be_false
-      expect(config.upper).to be_true
-    end
-
-    it "set number from block" do
-      expect(changed_tmp_config.number).to be_false
-      expect(config.number).to be_true
-    end
-
-    it "set letters_lower from block" do
-      expect(changed_tmp_config.letters_lower).to eq(["a"])
-      expect(config.letters_lower).to eq(("a".."z").to_a)
-    end
-
-    it "set letters_upper from block" do
-      expect(changed_tmp_config.letters_upper).to eq(["A"])
-      expect(config.letters_upper).to eq(("A".."Z").to_a)
-    end
-
-    it "set letters_number from block" do
-      expect(changed_tmp_config.letters_number).to eq(["0"])
-      expect(config.letters_number).to eq(("0".."9").to_a)
-    end
-
-    it "raise error unknown setting" do
-      expect {
-        tmp_config.configure do |c|
-          c.unknown = true
-        end
-      }.to raise_error
-    end
-  end
-
-  describe "#merge" do
-    let(:default_tmp_config) {tmp_config}
-
-    it "set length from hash" do
-      default_tmp_config.merge(length: 10)
-      expect(default_tmp_config.length).to eq(10)
-      expect(config.length).to eq(8)
-    end
-
-    it "set lower from hash" do
-      default_tmp_config.merge(lower: false)
-      expect(default_tmp_config.lower).to be_false
-      expect(config.lower).to be_true
-    end
-
-    it "set upper from hash" do
-      default_tmp_config.merge(upper: false)
-      expect(default_tmp_config.upper).to be_false
-      expect(config.upper).to be_true
-    end
-
-    it "set number from hash" do
-      default_tmp_config.merge(number: false)
-      expect(default_tmp_config.number).to be_false
-      expect(config.number).to be_true
-    end
-
-    it "set letters_lower from hash" do
-      default_tmp_config.merge(letters_lower: ["a"])
-      expect(default_tmp_config.letters_lower).to eq(["a"])
-      expect(config.letters_lower).to eq(("a".."z").to_a)
-    end
-
-    it "set letters_upper from hash" do
-      default_tmp_config.merge(letters_upper: ["A"])
-      expect(default_tmp_config.letters_upper).to eq(["A"])
-      expect(config.letters_upper).to eq(("A".."Z").to_a)
-    end
-
-    it "set letters_number from hash" do
-      default_tmp_config.merge(letters_number: ["0"])
-      expect(default_tmp_config.letters_number).to eq(["0"])
-      expect(config.letters_number).to eq(("0".."9").to_a)
-    end
-
-    it "raise error unknown setting" do
-      expect {
-        tmp_config.merge(unknown: true)
-      }.to raise_error
-    end
-  end
-
-  describe "#letters" do
-    it "return Array object" do
-      expect(tmp_config.letters.is_a? Array).to be_true
-    end
-
-    it "all elements of the string" do
-      tmp_config.letters.each do |l|
-        expect(l.is_a? String).to be_true
-      end
-    end
-
-    it "return all letters" do
-      all_letters = ("a".."z").to_a.concat(("A".."Z").to_a).concat(("0".."9").to_a)
-      expect(tmp_config.letters).to eq(all_letters)
-    end
-
-    it "return except for the lower case" do
-      expect(tmp_config(lower: false).letters.include? "a").to be_false
-    end
-
-    it "return except for the upper case" do
-      expect(tmp_config(upper: false).letters.include? "A").to be_false
-    end
-
-    it "return except for the number case" do
-      expect(tmp_config(number: false).letters.include? "0").to be_false
-    end
-
-    it "raise error if letters is empty" do
-      tconf = tmp_config(lower: false, upper: false, number: false)
-      expect {
-        tconf.letters
-      }.to raise_error
-    end
-  end
-end

data/spec/passwd/password_spec.rb

@@ -1,150 +0,0 @@
-# coding: utf-8
-
-require "spec_helper"
-
-describe Passwd::Password do
-  let(:password) {Passwd::Password.new}
-
-  describe "#initialize" do
-    context "with default params" do
-      let!(:password_text) {
-        password_text = Passwd.create
-        Passwd.should_receive(:create).and_return(password_text)
-        password_text
-      }
-
-      let!(:time_now) {
-        time_now = Time.now
-        Time.should_receive(:now).and_return(time_now)
-        time_now
-      }
-
-      it "@text should be a random password" do
-        expect(password.text.size).to eq(8)
-        expect(password.text).to eq(password_text)
-      end
-
-      it "@salt_text should be a auto created" do
-        expect(password.salt_text).to eq(time_now.to_s)
-      end
-
-      it "@salt_hash should be a hashed salt" do
-        expect(password.salt_hash).to eq(Passwd.hashing(time_now.to_s))
-      end
-
-      it "@password_hash should be a hashed password with salt" do
-        password_hash = Passwd.hashing("#{Passwd.hashing(time_now.to_s)}#{password_text}")
-        expect(password.hash).to eq(password_hash)
-      end
-    end
-
-    context "with custom params" do
-      let(:password_text) {Passwd.create}
-      let(:salt_text) {"salt"}
-      let!(:time_now) {
-        time_now = Time.now
-        Time.stub(:create).and_return(time_now)
-        time_now
-      }
-
-      it "@text is specified password" do
-        password = Passwd::Password.new(password: password_text)
-        expect(password.text).to eq(password_text)
-      end
-
-      it "@hash is hash of specified password" do
-        password = Passwd::Password.new(password: password_text)
-        password_hash = Passwd.hashing("#{Passwd.hashing(time_now.to_s)}#{password_text}")
-        expect(password.hash).to eq(password_hash)
-      end
-
-      it "@salt_text is specified salt" do
-        password = Passwd::Password.new(salt_text: salt_text)
-        expect(password.salt_text).to eq(salt_text)
-      end
-
-      it "@salt_hash is hash of specified salt" do
-        salt_hash = Passwd.hashing(salt_text)
-        password = Passwd::Password.new(salt_text: salt_text)
-        expect(password.salt_hash).to eq(salt_hash)
-      end
-    end
-  end
-
-  describe "#text=" do
-    it "@text is changed" do
-      old_password = password.text
-      password.text = password.text.reverse
-      expect(password.text).not_to eq(old_password)
-    end
-
-    it "@hash is changed" do
-      old_hash = password.hash
-      new_password = password.text = password.text.reverse
-      expect(password.hash).not_to eq(old_hash)
-      expect(password.hash).to eq(Passwd.hashing("#{password.salt_hash}#{new_password}"))
-    end
-  end
-
-  describe "#hash=" do
-    it "@text is nil" do
-      password.hash = Passwd.hashing("secret")
-      expect(password.text).to be_nil
-    end
-
-    it "@hash is changed" do
-      old_hash = password.hash
-      password.hash = Passwd.hashing("secret")
-      expect(password.hash).not_to eq(old_hash)
-    end
-  end
-
-  describe "#salt_text=" do
-    it "@salt_text is changed" do
-      old_salt = password.salt_text
-      password.salt_text = "salt"
-      expect(password.salt_text).not_to eq(old_salt)
-    end
-
-    it "@salt_hash is changed" do
-      old_salt = password.salt_hash
-      password.salt_text = "salt"
-      expect(password.salt_hash).not_to eq(old_salt)
-    end
-
-    it "@hash is changed" do
-      old_hash = password.hash
-      password.salt_text = "salt"
-      expect(password.hash).not_to eq(old_hash)
-    end
-  end
-
-  describe "#salt_hash=" do
-    it "@salt_text is nil" do
-      password.salt_hash = Passwd.hashing("salt")
-      expect(password.salt_text).to eq(nil)
-    end
-
-    it "@salt_hash is changed" do
-      old_salt_hash = password.salt_hash
-      password.salt_hash = Passwd.hashing("salt")
-      expect(password.salt_hash).not_to eq(old_salt_hash)
-    end
-
-    it "@hash is changed" do
-      old_hash = password.hash
-      password.salt_hash = Passwd.hashing("salt")
-      expect(password.hash).not_to eq(old_hash)
-    end
-  end
-
-  describe "#==" do
-    it "return true with valid password" do
-      expect(password == password.text).to be_true
-    end
-
-    it "return false with invalid password" do
-      expect(password == "secret").to be_false
-    end
-  end
-end