passwd 0.1.3 → 0.4.0

data/spec/passwd/base_spec.rb

@@ -1,224 +0,0 @@
-# coding: utf-8
-
-require "spec_helper"
-
-describe Passwd do
-  describe "extended Base" do
-    describe "#create" do
-      context "without arguments" do
-        let(:password) {Passwd.create}
-
-        it "TmpConfig should not be generated" do
-          Passwd::TmpConfig.should_not_receive(:new)
-          expect{password}.not_to raise_error
-        end
-
-        it "created password should be String object" do
-          expect(password.is_a? String).to be_true
-        end
-
-        it "created password length should be default length" do
-          expect(password.size).to eq(8)
-        end
-      end
-
-      context "with arguments" do
-        it "TmpConfig should be generated" do
-          tmp_config = double("tmp_config mock", length: 8, letters: ["a", "b"])
-          Passwd::TmpConfig.should_receive(:new).and_return(tmp_config)
-          expect{Passwd.create(length: 10)}.not_to raise_error
-        end
-
-        it "password was created specified characters" do
-          expect(Passwd.create(length: 10).size).to eq(10)
-        end
-
-        it "password create without lower case" do
-          expect(("a".."z").to_a.include? Passwd.create(lower: false)).to be_false
-        end
-
-        it "password create without upper case" do
-          expect(("A".."Z").to_a.include? Passwd.create(upper: false)).to be_false
-        end
-
-        it "password create without number" do
-          expect(("0".."9").to_a.include? Passwd.create(number: false)).to be_false
-        end
-      end
-    end
-
-    describe "#auth" do
-      let!(:password) do
-        password = Passwd.create
-        salt_hash = Passwd.hashing(Time.now.to_s)
-        password_hash = Passwd.hashing("#{salt_hash}#{password}")
-        {text: password, salt: salt_hash, hash: password_hash}
-      end
-
-      it "return true with valid password" do
-        expect(Passwd.auth(password[:text], password[:salt], password[:hash])).to be_true
-      end
-
-      it "return false with invalid password" do
-        expect(Passwd.auth("invalid", password[:salt], password[:hash])).to be_false
-      end
-
-      it "should create exception if not specified arguments" do
-        expect(proc{Passwd.auth}).to raise_error
-      end
-    end
-
-    describe "#hashing" do
-      it "return hashed password" do
-        Digest::SHA1.should_receive(:hexdigest).with("secret").and_return("hash")
-        expect(Passwd.hashing("secret")).to eq("hash")
-      end
-
-      it "should create exception if not specified argument" do
-        expect(proc{Passwd.hashing}).to raise_error
-      end
-    end
-
-    describe "#confirm_check" do
-      context "with out policy check" do
-        it "return false if password don't match" do
-          expect(Passwd.confirm_check("secret", "invalid")).to be_false
-        end
-
-        it "return true if password matches" do
-          expect(Passwd.confirm_check("secret", "secret")).to be_true
-        end
-      end
-
-      context "with policy check" do
-        it "return false if invalid password by policy" do
-          expect(Passwd.confirm_check("secret", "secret", true)).to be_false
-        end
-
-        it "return true if valid password by policy" do
-          expect(Passwd.confirm_check("secretpass", "secretpass", true)).to be_false
-        end
-      end
-    end
-
-    describe "#configure" do
-      it "return configuration object" do
-        expect(Passwd.configure.is_a? Passwd::Config).to be_true
-      end
-
-      it "set config value from block" do
-        Passwd.configure do |c|
-          c.length = 10
-        end
-        expect(Passwd.configure.length).not_to eq(8)
-        expect(Passwd.configure.length).to eq(10)
-      end
-
-      it "set config value from hash" do
-        Passwd.configure length: 20
-        expect(Passwd.config.length).not_to eq(8)
-        expect(Passwd.config.length).to eq(20)
-      end
-
-      it "alias of configure as config" do
-        expect(Passwd.configure.object_id).to eq(Passwd.config.object_id)
-      end
-    end
-
-    describe "#policy_configure" do
-      it "return policy object" do
-        expect(Passwd.policy_configure.is_a? Passwd::Policy).to be_true
-      end
-
-      it "set policy value from block" do
-        Passwd.policy_configure do |c|
-          c.min_length = 10
-        end
-        expect(Passwd.policy_configure.min_length).not_to eq(8)
-        expect(Passwd.policy_configure.min_length).to eq(10)
-      end
-    end
-
-    describe "#policy_check" do
-      it "Policy#valid? should be called" do
-        Passwd::Policy.instance.should_receive(:valid?).with("secret1234" ,Passwd::Config.instance)
-        expect(Passwd.policy_check("secret1234")).not_to raise_error
-      end
-    end
-
-    describe "#reset_policy" do
-      let(:policy) {Passwd::Policy.instance}
-      
-      before {
-        policy.configure do |c|
-          c.min_length = 20
-          c.require_lower = false
-          c.require_upper = true
-          c.require_number = false
-        end
-        Passwd.reset_policy
-      }
-
-      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 "upper should be a default" do
-        expect(policy.require_upper).to be_false
-      end
-
-      it "number should be a default" do
-        expect(policy.require_number).to be_true
-      end
-    end
-
-    describe "#reset_config" do
-      let(:config) {Passwd::Config.instance}
-      
-      before {
-        config.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
-        Passwd.reset_config
-      }
-
-      it "length should be a default" do
-        expect(config.length).to eq(8)
-      end
-
-      it "lower should be a default" do
-        expect(config.lower).to be_true
-      end
-
-      it "upper should be a default" do
-        expect(config.upper).to be_true
-      end
-
-      it "number should be a default" do
-        expect(config.number).to be_true
-      end
-
-      it "letters_lower should be a default" do
-        expect(config.letters_lower).to eq(("a".."z").to_a)
-      end
-
-      it "letters_upper should be a default" do
-        expect(config.letters_upper).to eq(("A".."Z").to_a)
-      end
-
-      it "letters_number should be a default" do
-        expect(config.letters_number).to eq(("0".."9").to_a)
-      end
-    end
-  end
-end

data/spec/passwd/configuration/config_spec.rb

@@ -1,242 +0,0 @@
-# coding: utf-8
-
-require "spec_helper"
-
-describe Passwd::Config do
-  let(:config) {Passwd::Config.instance}
-
-  describe "defined accessors" do
-    it "defined length" do
-      expect(config.respond_to? :length).to be_true
-    end
-
-    it "defined lower" do
-      expect(config.respond_to? :lower).to be_true
-    end
-
-    it "defined upper" do
-      expect(config.respond_to? :upper).to be_true
-    end
-
-    it "defined number" do
-      expect(config.respond_to? :number).to be_true
-    end
-
-    it "defined letters_lower" do
-      expect(config.respond_to? :letters_lower).to be_true
-    end
-
-    it "defined letters_upper" do
-      expect(config.respond_to? :letters_upper).to be_true
-    end
-
-    it "defined letters_number" do
-      expect(config.respond_to? :letters_number).to be_true
-    end
-  end
-
-  describe "#initialize" do
-    it "length should be a default" do
-      expect(config.length).to eq(8)
-    end
-
-    it "lower should be a default" do
-      expect(config.lower).to be_true
-    end
-
-    it "upper should be a default" do
-      expect(config.upper).to be_true
-    end
-
-    it "number should be a default" do
-      expect(config.number).to be_true
-    end
-
-    it "letters_lower should be a default" do
-      expect(config.letters_lower).to eq(("a".."z").to_a)
-    end
-
-    it "letters_upper should be a default" do
-      expect(config.letters_upper).to eq(("A".."Z").to_a)
-    end
-
-    it "letters_number should be a default" do
-      expect(config.letters_number).to eq(("0".."9").to_a)
-    end
-  end
-
-  describe "#configure" do
-    before {
-      config.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
-    }
-
-    it "set length from block" do
-      expect(config.length).to eq(20)
-    end
-
-    it "set lower from block" do
-      expect(config.lower).to be_false
-    end
-
-    it "set upper from block" do
-      expect(config.upper).to be_false
-    end
-
-    it "set number from block" do
-      expect(config.number).to be_false
-    end
-
-    it "set letters_lower from block" do
-      expect(config.letters_lower).to eq(["a"])
-    end
-
-    it "set letters_upper from block" do
-      expect(config.letters_upper).to eq(["A"])
-    end
-
-    it "set letters_number from block" do
-      expect(config.letters_number).to eq(["0"])
-    end
-
-    it "raise error unknown setting" do
-      expect {
-        config.configure do |c|
-          c.unknown = true
-        end
-      }.to raise_error
-    end
-  end
-
-  describe "#merge" do
-    it "set length from hash" do
-      config.merge(length: 10)
-      expect(config.length).to eq(10)
-    end
-
-    it "set lower from hash" do
-      config.merge(lower: false)
-      expect(config.lower).to be_false
-    end
-
-    it "set upper from hash" do
-      config.merge(upper: false)
-      expect(config.upper).to be_false
-    end
-
-    it "set number from hash" do
-      config.merge(number: false)
-      expect(config.number).to be_false
-    end
-
-    it "set letters_lower from hash" do
-      config.merge(letters_lower: ["a"])
-      expect(config.letters_lower).to eq(["a"])
-    end
-
-    it "set letters_upper from hash" do
-      config.merge(letters_upper: ["A"])
-      expect(config.letters_upper).to eq(["A"])
-    end
-
-    it "set letters_number from hash" do
-      config.merge(letters_number: ["0"])
-      expect(config.letters_number).to eq(["0"])
-    end
-
-    it "raise error unknown setting" do
-      expect {
-        config.merge(unknown: true)
-      }.to raise_error
-    end
-  end
-
-  describe "#letters" do
-    it "return Array object" do
-      expect(config.letters.is_a? Array).to be_true
-    end
-
-    it "all elements of the string" do
-      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(config.letters).to eq(all_letters)
-    end
-
-    it "return except for the lower case" do
-      config.merge(lower: false)
-      expect(config.letters.include? "a").to be_false
-    end
-
-    it "return except for the upper case" do
-      config.merge(upper: false)
-      expect(config.letters.include? "A").to be_false
-    end
-
-    it "return except for the number case" do
-      config.merge(number: false)
-      expect(config.letters.include? "0").to be_false
-    end
-
-    it "raise error if letters is empty" do
-      config.merge(lower: false, upper: false, number: false)
-      expect {
-        config.letters
-      }.to raise_error
-    end
-  end
-
-  describe "#reset" do
-    before {
-      config.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
-      config.reset
-    }
-
-    it "length should be a default" do
-      expect(config.length).to eq(8)
-    end
-
-    it "lower should be a default" do
-      expect(config.lower).to be_true
-    end
-
-    it "upper should be a default" do
-      expect(config.upper).to be_true
-    end
-
-    it "number should be a default" do
-      expect(config.number).to be_true
-    end
-
-    it "letters_lower should be a default" do
-      expect(config.letters_lower).to eq(("a".."z").to_a)
-    end
-
-    it "letters_upper should be a default" do
-      expect(config.letters_upper).to eq(("A".."Z").to_a)
-    end
-
-    it "letters_number should be a default" do
-      expect(config.letters_number).to eq(("0".."9").to_a)
-    end
-  end
-end