From bfec7d5f7c656773ff51911e9c8c74dfbf1bfa64 Mon Sep 17 00:00:00 2001
From: i2bskn <i2bskn@gmail.com>
Date: Tue, 2 Sep 2014 01:46:18 +0900
Subject: [PATCH] fix specs (RSpec 2 => 3)

---
 Rakefile                                     |  2 +-
 spec/passwd/active_record_spec.rb            | 67 +++++++++----------
 spec/passwd/base_spec.rb                     | 49 +++++++-------
 spec/passwd/configuration/config_spec.rb     | 51 +++++++--------
 spec/passwd/configuration/policy_spec.rb     | 40 ++++++------
 spec/passwd/configuration/tmp_config_spec.rb | 68 ++++++++++----------
 spec/passwd/password_spec.rb                 | 11 ++--
 spec/spec_helper.rb                          |  1 -
 8 files changed, 141 insertions(+), 148 deletions(-)

diff --git a/Rakefile b/Rakefile
index e618eb9..25e1c41 100644
--- a/Rakefile
+++ b/Rakefile
@@ -3,7 +3,7 @@ require "rspec/core/rake_task"
 
 desc "Run all specs"
 RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = ["-c", "-fs"]
+  t.rspec_opts = %w(--color --format documentation)
 end
 
 task :default => :spec
diff --git a/spec/passwd/active_record_spec.rb b/spec/passwd/active_record_spec.rb
index 7daa424..135f0be 100644
--- a/spec/passwd/active_record_spec.rb
+++ b/spec/passwd/active_record_spec.rb
@@ -12,7 +12,7 @@ class User
 
   describe ".#included" do
     it "define singleton methods" do
-      expect(User.respond_to? :define_column).to be_true
+      expect(User.respond_to? :define_column).to be_truthy
     end
   end
 
@@ -21,19 +21,19 @@ class User
       let(:user) {User.new}
 
       it "define singleton methods" do
-        expect(User.respond_to? :authenticate).to be_true
+        expect(User.respond_to? :authenticate).to be_truthy
       end
 
       it "define authenticate method" do
-        expect(user.respond_to? :authenticate).to be_true
+        expect(user.respond_to? :authenticate).to be_truthy
       end
 
       it "define set_password method" do
-        expect(user.respond_to? :set_password).to be_true
+        expect(user.respond_to? :set_password).to be_truthy
       end
 
       it "define update_password" do
-        expect(user.respond_to? :update_password).to be_true
+        expect(user.respond_to? :update_password).to be_truthy
       end
     end
   end
@@ -42,25 +42,24 @@ class User
     describe ".#authenticate" do
       let!(:record) {
         record = double("record mock")
-        record.stub(:salt).and_return(salt)
-        record.stub(:password).and_return(password_hash)
+        allow(record).to receive_messages(salt: salt, password: password_hash)
         response = [record]
-        User.stub(:where).and_return(response)
+        allow(User).to receive(:where) {response}
         record
       }
 
       it "user should be returned if authentication is successful" do
-        User.should_receive(:where)
+        expect(User).to receive(:where)
         expect(User.authenticate("valid_id", password_text)).to eq(record)
       end
 
       it "should return nil if authentication failed" do
-        User.should_receive(:where)
+        expect(User).to receive(:where)
         expect(User.authenticate("valid_id", "invalid_secret")).to be_nil
       end
 
       it "should return nil if user not found" do
-        User.should_receive(:where).with(:email => "invalid_id").and_return([])
+        expect(User).to receive(:where).with(email: "invalid_id") {[]}
         expect(User.authenticate("invalid_id", password_text)).to be_nil
       end
     end
@@ -68,38 +67,37 @@ class User
     describe "#authenticate" do
       let!(:user) {
         user = User.new
-        user.stub(:salt).and_return(salt)
-        user.stub(:password).and_return(password_hash)
+        allow(user).to receive_messages(salt: salt, password: password_hash)
         user
       }
 
       it "should return true if authentication is successful" do
-        expect(user.authenticate(password_text)).to be_true
+        expect(user.authenticate(password_text)).to be_truthy
       end
 
       it "should return false if authentication failed" do
-        expect(user.authenticate("invalid_pass")).to be_false
+        expect(user.authenticate("invalid_pass")).to be_falsey
       end
     end
 
     describe "#set_password" do
       let!(:user) {
         user = User.new
-        user.stub(:salt).and_return(salt)
+        allow(user).to receive(:salt) {salt}
         user
       }
 
       it "should return set password" do
-        user.should_receive(:salt=).with(salt)
-        user.should_receive(:password=).with(Passwd.hashing("#{salt}#{password_text}"))
+        expect(user).to receive(:salt=).with(salt)
+        expect(user).to receive(:password=).with(Passwd.hashing("#{salt}#{password_text}"))
         expect(user.set_password(password_text)).to eq(password_text)
       end
 
       it "should set random password if not specified" do
-        user.should_receive(:salt=).with(salt)
+        expect(user).to receive(:salt=).with(salt)
         random_password = Passwd.create
-        Passwd.should_receive(:create).and_return(random_password)
-        user.should_receive(:password=).with(Passwd.hashing("#{salt}#{random_password}"))
+        expect(Passwd).to receive(:create) {random_password}
+        expect(user).to receive(:password=).with(Passwd.hashing("#{salt}#{random_password}"))
         user.set_password
       end
 
@@ -107,11 +105,11 @@ class User
         mail_addr = "foo@example.com"
         time_now = Time.now
         salt2 = Passwd.hashing("#{mail_addr}#{time_now.to_s}")
-        Time.stub(:now).and_return(time_now)
-        user.stub(:email).and_return(mail_addr)
-        user.should_receive(:salt).and_return(nil)
-        user.should_receive(:salt=).with(salt2)
-        user.should_receive(:password=).with(Passwd.hashing("#{salt2}#{password_text}"))
+        allow(Time).to receive(:now) {time_now}
+        allow(user).to receive(:email) {mail_addr}
+        expect(user).to receive(:salt) {nil}
+        expect(user).to receive(:salt=).with(salt2)
+        expect(user).to receive(:password=).with(Passwd.hashing("#{salt2}#{password_text}"))
         user.set_password(password_text)
       end
     end
@@ -119,21 +117,21 @@ class User
     describe "#update_password" do
       let!(:user) {
         user = User.new
-        user.stub(:salt).and_return(salt)
-        user.stub(:password).and_return(password_hash)
+        allow(user).to receive(:salt) {salt}
+        allow(user).to receive(:password) {password_hash}
         user
       }
 
       context "without policy check" do
         it "should return update password" do
           pass = "new_password"
-          user.should_receive(:set_password).with(pass).and_return(pass)
+          expect(user).to receive(:set_password).with(pass) {pass}
           expect(user.update_password(password_text, pass)).to eq(pass)
         end
 
         it "should generate exception if authentication failed" do
-          Passwd.should_receive(:auth).and_return(false)
-          user.should_not_receive(:set_password)
+          expect(Passwd).to receive(:auth) {false}
+          expect(user).not_to receive(:set_password)
           expect {
             user.update_password("invalid_password", "new_password")
           }.to raise_error(Passwd::AuthError)
@@ -143,14 +141,14 @@ class User
       context "with policy check" do
         it "should return update password" do
           pass = "new_password"
-          Passwd.should_receive(:policy_check).and_return(true)
-          user.should_receive(:set_password).with(pass).and_return(pass)
+          expect(Passwd).to receive(:policy_check) {true}
+          expect(user).to receive(:set_password).with(pass) {pass}
           expect(user.update_password(password_text, pass, true)).to eq(pass)
         end
 
         it "should generate exception if policy not match" do
           pass = "new_password"
-          Passwd.should_receive(:policy_check).and_return(false)
+          expect(Passwd).to receive(:policy_check) {false}
           expect {
             user.update_password(password_text, pass, true)
             }.to raise_error(Passwd::PolicyNotMatch)
@@ -159,4 +157,3 @@ class User
     end
   end
 end
-
diff --git a/spec/passwd/base_spec.rb b/spec/passwd/base_spec.rb
index e9bd554..d968ea2 100644
--- a/spec/passwd/base_spec.rb
+++ b/spec/passwd/base_spec.rb
@@ -7,12 +7,12 @@
         let(:password) {Passwd.create}
 
         it "TmpConfig should not be generated" do
-          Passwd::TmpConfig.should_not_receive(:new)
+          expect(Passwd::TmpConfig).not_to 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
+          expect(password.is_a? String).to be_truthy
         end
 
         it "created password length should be default length" do
@@ -23,7 +23,7 @@
       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::TmpConfig).to receive(:new) {tmp_config}
           expect{Passwd.create(length: 10)}.not_to raise_error
         end
 
@@ -32,15 +32,15 @@
         end
 
         it "password create without lower case" do
-          expect(("a".."z").to_a.include? Passwd.create(lower: false)).to be_false
+          expect(("a".."z").to_a.include? Passwd.create(lower: false)).to be_falsey
         end
 
         it "password create without upper case" do
-          expect(("A".."Z").to_a.include? Passwd.create(upper: false)).to be_false
+          expect(("A".."Z").to_a.include? Passwd.create(upper: false)).to be_falsey
         end
 
         it "password create without number" do
-          expect(("0".."9").to_a.include? Passwd.create(number: false)).to be_false
+          expect(("0".."9").to_a.include? Passwd.create(number: false)).to be_falsey
         end
       end
     end
@@ -54,11 +54,11 @@
       end
 
       it "return true with valid password" do
-        expect(Passwd.auth(password[:text], password[:salt], password[:hash])).to be_true
+        expect(Passwd.auth(password[:text], password[:salt], password[:hash])).to be_truthy
       end
 
       it "return false with invalid password" do
-        expect(Passwd.auth("invalid", password[:salt], password[:hash])).to be_false
+        expect(Passwd.auth("invalid", password[:salt], password[:hash])).to be_falsey
       end
 
       it "should create exception if not specified arguments" do
@@ -68,7 +68,7 @@
 
     describe "#hashing" do
       it "should call SHA512.#hexdigest" do
-        Digest::SHA512.should_receive(:hexdigest)
+        expect(Digest::SHA512).to receive(:hexdigest)
         Passwd.hashing("secret")
       end
 
@@ -96,24 +96,24 @@
         end
 
         it "return true if password matches" do
-          expect(Passwd.confirm_check("secret", "secret")).to be_true
+          expect(Passwd.confirm_check("secret", "secret")).to be_truthy
         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
+          expect(Passwd.confirm_check("secret", "secret", true)).to be_falsey
         end
 
         it "return true if valid password by policy" do
-          expect(Passwd.confirm_check("secretpass", "secretpass", true)).to be_false
+          expect(Passwd.confirm_check("secretpass", "secretpass", true)).to be_falsey
         end
       end
     end
 
     describe "#configure" do
       it "return configuration object" do
-        expect(Passwd.configure.is_a? Passwd::Config).to be_true
+        expect(Passwd.configure.is_a? Passwd::Config).to be_truthy
       end
 
       it "set config value from block" do
@@ -137,7 +137,7 @@
 
     describe "#policy_configure" do
       it "return policy object" do
-        expect(Passwd.policy_configure.is_a? Passwd::Policy).to be_true
+        expect(Passwd.policy_configure.is_a? Passwd::Policy).to be_truthy
       end
 
       it "set policy value from block" do
@@ -151,14 +151,14 @@
 
     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
+        expect(Passwd::Policy.instance).to receive(:valid?).with("secret1234" ,Passwd::Config.instance)
+        Passwd.policy_check("secret1234")
       end
     end
 
     describe "#reset_policy" do
       let(:policy) {Passwd::Policy.instance}
-      
+
       before {
         policy.configure do |c|
           c.min_length = 20
@@ -174,21 +174,21 @@
       end
 
       it "require_lower should be a default" do
-        expect(policy.require_lower).to be_true
+        expect(policy.require_lower).to be_truthy
       end
 
       it "upper should be a default" do
-        expect(policy.require_upper).to be_false
+        expect(policy.require_upper).to be_falsey
       end
 
       it "number should be a default" do
-        expect(policy.require_number).to be_true
+        expect(policy.require_number).to be_truthy
       end
     end
 
     describe "#reset_config" do
       let(:config) {Passwd::Config.instance}
-      
+
       before {
         config.configure do |c|
           c.length = 20
@@ -207,15 +207,15 @@
       end
 
       it "lower should be a default" do
-        expect(config.lower).to be_true
+        expect(config.lower).to be_truthy
       end
 
       it "upper should be a default" do
-        expect(config.upper).to be_true
+        expect(config.upper).to be_truthy
       end
 
       it "number should be a default" do
-        expect(config.number).to be_true
+        expect(config.number).to be_truthy
       end
 
       it "letters_lower should be a default" do
@@ -232,4 +232,3 @@
     end
   end
 end
-
diff --git a/spec/passwd/configuration/config_spec.rb b/spec/passwd/configuration/config_spec.rb
index 6b9a01a..815ced0 100644
--- a/spec/passwd/configuration/config_spec.rb
+++ b/spec/passwd/configuration/config_spec.rb
@@ -5,35 +5,35 @@
 
   describe "defined accessors" do
     it "defined algorithm" do
-      expect(config.respond_to? :algorithm).to be_true
+      expect(config.respond_to? :algorithm).to be_truthy
     end
 
     it "defined length" do
-      expect(config.respond_to? :length).to be_true
+      expect(config.respond_to? :length).to be_truthy
     end
 
     it "defined lower" do
-      expect(config.respond_to? :lower).to be_true
+      expect(config.respond_to? :lower).to be_truthy
     end
 
     it "defined upper" do
-      expect(config.respond_to? :upper).to be_true
+      expect(config.respond_to? :upper).to be_truthy
     end
 
     it "defined number" do
-      expect(config.respond_to? :number).to be_true
+      expect(config.respond_to? :number).to be_truthy
     end
 
     it "defined letters_lower" do
-      expect(config.respond_to? :letters_lower).to be_true
+      expect(config.respond_to? :letters_lower).to be_truthy
     end
 
     it "defined letters_upper" do
-      expect(config.respond_to? :letters_upper).to be_true
+      expect(config.respond_to? :letters_upper).to be_truthy
     end
 
     it "defined letters_number" do
-      expect(config.respond_to? :letters_number).to be_true
+      expect(config.respond_to? :letters_number).to be_truthy
     end
   end
 
@@ -47,15 +47,15 @@
     end
 
     it "lower should be a default" do
-      expect(config.lower).to be_true
+      expect(config.lower).to be_truthy
     end
 
     it "upper should be a default" do
-      expect(config.upper).to be_true
+      expect(config.upper).to be_truthy
     end
 
     it "number should be a default" do
-      expect(config.number).to be_true
+      expect(config.number).to be_truthy
     end
 
     it "letters_lower should be a default" do
@@ -89,15 +89,15 @@
     end
 
     it "set lower from block" do
-      expect(config.lower).to be_false
+      expect(config.lower).to be_falsey
     end
 
     it "set upper from block" do
-      expect(config.upper).to be_false
+      expect(config.upper).to be_falsey
     end
 
     it "set number from block" do
-      expect(config.number).to be_false
+      expect(config.number).to be_falsey
     end
 
     it "set letters_lower from block" do
@@ -129,17 +129,17 @@
 
     it "set lower from hash" do
       config.merge(lower: false)
-      expect(config.lower).to be_false
+      expect(config.lower).to be_falsey
     end
 
     it "set upper from hash" do
       config.merge(upper: false)
-      expect(config.upper).to be_false
+      expect(config.upper).to be_falsey
     end
 
     it "set number from hash" do
       config.merge(number: false)
-      expect(config.number).to be_false
+      expect(config.number).to be_falsey
     end
 
     it "set letters_lower from hash" do
@@ -166,12 +166,12 @@
 
   describe "#letters" do
     it "return Array object" do
-      expect(config.letters.is_a? Array).to be_true
+      expect(config.letters.is_a? Array).to be_truthy
     end
 
     it "all elements of the string" do
       config.letters.each do |l|
-        expect(l.is_a? String).to be_true
+        expect(l.is_a? String).to be_truthy
       end
     end
 
@@ -182,17 +182,17 @@
 
     it "return except for the lower case" do
       config.merge(lower: false)
-      expect(config.letters.include? "a").to be_false
+      expect(config.letters.include? "a").to be_falsey
     end
 
     it "return except for the upper case" do
       config.merge(upper: false)
-      expect(config.letters.include? "A").to be_false
+      expect(config.letters.include? "A").to be_falsey
     end
 
     it "return except for the number case" do
       config.merge(number: false)
-      expect(config.letters.include? "0").to be_false
+      expect(config.letters.include? "0").to be_falsey
     end
 
     it "raise error if letters is empty" do
@@ -222,15 +222,15 @@
     end
 
     it "lower should be a default" do
-      expect(config.lower).to be_true
+      expect(config.lower).to be_truthy
     end
 
     it "upper should be a default" do
-      expect(config.upper).to be_true
+      expect(config.upper).to be_truthy
     end
 
     it "number should be a default" do
-      expect(config.number).to be_true
+      expect(config.number).to be_truthy
     end
 
     it "letters_lower should be a default" do
@@ -246,4 +246,3 @@
     end
   end
 end
-
diff --git a/spec/passwd/configuration/policy_spec.rb b/spec/passwd/configuration/policy_spec.rb
index 049a9f8..59acc94 100644
--- a/spec/passwd/configuration/policy_spec.rb
+++ b/spec/passwd/configuration/policy_spec.rb
@@ -5,19 +5,19 @@
 
   describe "defined accessors" do
     it "defined min_length" do
-      expect(policy.respond_to? :min_length).to be_true
+      expect(policy.respond_to? :min_length).to be_truthy
     end
 
     it "defined require_lower" do
-      expect(policy.respond_to? :require_lower).to be_true
+      expect(policy.respond_to? :require_lower).to be_truthy
     end
 
     it "defined require_upper" do
-      expect(policy.respond_to? :require_upper).to be_true
+      expect(policy.respond_to? :require_upper).to be_truthy
     end
 
     it "defined require_number" do
-      expect(policy.respond_to? :require_number).to be_true
+      expect(policy.respond_to? :require_number).to be_truthy
     end
   end
 
@@ -27,15 +27,15 @@
     end
 
     it "require_lower should be a default" do
-      expect(policy.require_lower).to be_true
+      expect(policy.require_lower).to be_truthy
     end
 
     it "require_upper should be a default" do
-      expect(policy.require_upper).to be_false
+      expect(policy.require_upper).to be_falsey
     end
 
     it "require_number should be a default" do
-      expect(policy.require_number).to be_true
+      expect(policy.require_number).to be_truthy
     end
   end
 
@@ -54,15 +54,15 @@
     end
 
     it "set require_lower from block" do
-      expect(policy.require_lower).to be_false
+      expect(policy.require_lower).to be_falsey
     end
 
     it "set require_upper from block" do
-      expect(policy.require_upper).to be_true
+      expect(policy.require_upper).to be_truthy
     end
 
     it "set require_number from block" do
-      expect(policy.require_number).to be_false
+      expect(policy.require_number).to be_falsey
     end
   end
 
@@ -70,34 +70,34 @@
     let(:config) {Passwd::Config.instance}
 
     it "valid password should be valid" do
-      expect(policy.valid?("secret1234", config)).to be_true
+      expect(policy.valid?("secret1234", config)).to be_truthy
     end
 
     it "short password should not valid" do
-      expect(policy.valid?("short1", config)).to be_false
+      expect(policy.valid?("short1", config)).to be_falsey
     end
 
     it "password should not valid if not contain lower case" do
-      expect(policy.valid?("NOTLOWER12", config)).to be_false
+      expect(policy.valid?("NOTLOWER12", config)).to be_falsey
     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
+      expect(policy.valid?("notupper12", config)).to be_falsey
     end
 
     it "password should not valid if not contain number" do
-      expect(policy.valid?("notnumber", config)).to be_false
+      expect(policy.valid?("notnumber", config)).to be_falsey
     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
+      expect(policy.include_char?(("a".."z").to_a, "contains")).to be_truthy
     end
 
     it "should be return false if not contains" do
-      expect(policy.include_char?(("a".."z").to_a, "NOTCONTAINS")).to be_false
+      expect(policy.include_char?(("a".."z").to_a, "NOTCONTAINS")).to be_falsey
     end
   end
 
@@ -117,15 +117,15 @@
     end
 
     it "require_lower should be a default" do
-      expect(policy.require_lower).to be_true
+      expect(policy.require_lower).to be_truthy
     end
 
     it "require_upper should be a default" do
-      expect(policy.require_upper).to be_false
+      expect(policy.require_upper).to be_falsey
     end
 
     it "require_number should be a default" do
-      expect(policy.require_number).to be_true
+      expect(policy.require_number).to be_truthy
     end
   end
 end
diff --git a/spec/passwd/configuration/tmp_config_spec.rb b/spec/passwd/configuration/tmp_config_spec.rb
index 9eb04a3..7eba00a 100644
--- a/spec/passwd/configuration/tmp_config_spec.rb
+++ b/spec/passwd/configuration/tmp_config_spec.rb
@@ -9,35 +9,35 @@ def tmp_config(options={})
 
   describe "defined accessors" do
     it "defined algorithm" do
-      expect(config.respond_to? :algorithm).to be_true
+      expect(config.respond_to? :algorithm).to be_truthy
     end
 
     it "defined length" do
-      expect(tmp_config.respond_to? :length).to be_true
+      expect(tmp_config.respond_to? :length).to be_truthy
     end
 
     it "defined lower" do
-      expect(tmp_config.respond_to? :lower).to be_true
+      expect(tmp_config.respond_to? :lower).to be_truthy
     end
 
     it "defined upper" do
-      expect(tmp_config.respond_to? :upper).to be_true
+      expect(tmp_config.respond_to? :upper).to be_truthy
     end
 
     it "defined number" do
-      expect(tmp_config.respond_to? :number).to be_true
+      expect(tmp_config.respond_to? :number).to be_truthy
     end
 
     it "defined letters_lower" do
-      expect(tmp_config.respond_to? :letters_lower).to be_true
+      expect(tmp_config.respond_to? :letters_lower).to be_truthy
     end
 
     it "defined letters_upper" do
-      expect(tmp_config.respond_to? :letters_upper).to be_true
+      expect(tmp_config.respond_to? :letters_upper).to be_truthy
     end
 
     it "defined letters_number" do
-      expect(tmp_config.respond_to? :letters_number).to be_true
+      expect(tmp_config.respond_to? :letters_number).to be_truthy
     end
   end
 
@@ -52,15 +52,15 @@ def tmp_config(options={})
       end
 
       it "lower should be a default" do
-        expect(tmp_config.lower).to be_true
+        expect(tmp_config.lower).to be_truthy
       end
 
       it "upper should be a default" do
-        expect(tmp_config.upper).to be_true
+        expect(tmp_config.upper).to be_truthy
       end
 
       it "number should be a default" do
-        expect(tmp_config.number).to be_true
+        expect(tmp_config.number).to be_truthy
       end
 
       it "letters_lower should be a default" do
@@ -83,18 +83,18 @@ def tmp_config(options={})
       end
 
       it "lower should be a specified params" do
-        expect(tmp_config(lower: false).lower).to be_false
-        expect(config.lower).to be_true
+        expect(tmp_config(lower: false).lower).to be_falsey
+        expect(config.lower).to be_truthy
       end
 
       it "upper should be a specified params" do
-        expect(tmp_config(upper: false).upper).to be_false
-        expect(config.upper).to be_true
+        expect(tmp_config(upper: false).upper).to be_falsey
+        expect(config.upper).to be_truthy
       end
 
       it "number should be a specified params" do
-        expect(tmp_config(number: false).number).to be_false
-        expect(config.number).to be_true
+        expect(tmp_config(number: false).number).to be_falsey
+        expect(config.number).to be_truthy
       end
 
       it "letters_lower should be a specified params" do
@@ -135,18 +135,18 @@ def tmp_config(options={})
     end
 
     it "set lower from block" do
-      expect(changed_tmp_config.lower).to be_false
-      expect(config.lower).to be_true
+      expect(changed_tmp_config.lower).to be_falsey
+      expect(config.lower).to be_truthy
     end
 
     it "set upper from block" do
-      expect(changed_tmp_config.upper).to be_false
-      expect(config.upper).to be_true
+      expect(changed_tmp_config.upper).to be_falsey
+      expect(config.upper).to be_truthy
     end
 
     it "set number from block" do
-      expect(changed_tmp_config.number).to be_false
-      expect(config.number).to be_true
+      expect(changed_tmp_config.number).to be_falsey
+      expect(config.number).to be_truthy
     end
 
     it "set letters_lower from block" do
@@ -184,20 +184,20 @@ def tmp_config(options={})
 
     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
+      expect(default_tmp_config.lower).to be_falsey
+      expect(config.lower).to be_truthy
     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
+      expect(default_tmp_config.upper).to be_falsey
+      expect(config.upper).to be_truthy
     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
+      expect(default_tmp_config.number).to be_falsey
+      expect(config.number).to be_truthy
     end
 
     it "set letters_lower from hash" do
@@ -227,12 +227,12 @@ def tmp_config(options={})
 
   describe "#letters" do
     it "return Array object" do
-      expect(tmp_config.letters.is_a? Array).to be_true
+      expect(tmp_config.letters.is_a? Array).to be_truthy
     end
 
     it "all elements of the string" do
       tmp_config.letters.each do |l|
-        expect(l.is_a? String).to be_true
+        expect(l.is_a? String).to be_truthy
       end
     end
 
@@ -242,15 +242,15 @@ def tmp_config(options={})
     end
 
     it "return except for the lower case" do
-      expect(tmp_config(lower: false).letters.include? "a").to be_false
+      expect(tmp_config(lower: false).letters.include? "a").to be_falsey
     end
 
     it "return except for the upper case" do
-      expect(tmp_config(upper: false).letters.include? "A").to be_false
+      expect(tmp_config(upper: false).letters.include? "A").to be_falsey
     end
 
     it "return except for the number case" do
-      expect(tmp_config(number: false).letters.include? "0").to be_false
+      expect(tmp_config(number: false).letters.include? "0").to be_falsey
     end
 
     it "raise error if letters is empty" do
diff --git a/spec/passwd/password_spec.rb b/spec/passwd/password_spec.rb
index 241306c..1007bdb 100644
--- a/spec/passwd/password_spec.rb
+++ b/spec/passwd/password_spec.rb
@@ -7,13 +7,13 @@
     context "with default params" do
       let!(:password_text) {
         password_text = Passwd.create
-        Passwd.should_receive(:create).and_return(password_text)
+        expect(Passwd).to receive(:create) {password_text}
         password_text
       }
 
       let!(:time_now) {
         time_now = Time.now
-        Time.should_receive(:now).and_return(time_now)
+        expect(Time).to receive(:now) {time_now}
         time_now
       }
 
@@ -41,7 +41,7 @@
       let(:salt_text) {"salt"}
       let!(:time_now) {
         time_now = Time.now
-        Time.stub(:create).and_return(time_now)
+        allow(Time).to receive(:create) {time_now}
         time_now
       }
 
@@ -138,12 +138,11 @@
 
   describe "#==" do
     it "return true with valid password" do
-      expect(password == password.text).to be_true
+      expect(password == password.text).to be_truthy
     end
 
     it "return false with invalid password" do
-      expect(password == "secret").to be_false
+      expect(password == "secret").to be_falsey
     end
   end
 end
-
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index c3ce7fb..832c1a0 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -21,4 +21,3 @@
     Passwd::Policy.instance.reset
   end
 end
-