Michael Hartl撰写的Rails教程第6章验证用户

Question

I can't for the life of me seem to figure out why these three tests aren't passing. I'm pretty new with rails but I feel as though I've tried about everything, at least according to the tutorial. I'm sure its something obvious but my attempts to find an answer have been in vain. My failed tests are as follows(pulled from Michael Hartl's Rails Tutorial). Thanks.

Failures:

1) User when password is not present return value of authenticate method with valid password Failure/Error: it { should eq found_user.authenticate(@user.password) } NoMethodError: undefined method authenticate' for nil:NilClass # ./spec/models/user_spec.rb:94:in block (5 levels) in '

2) User when password is not present return value of authenticate method with invalid password Failure/Error: let(:user_for_invalid_password) { found_user.authenticate("invalid") } NoMethodError: undefined method authenticate' for nil:NilClass # ./spec/models/user_spec.rb:98:in block (5 levels) in ' # ./spec/models/user_spec.rb:100:in `block (5 levels) in '

3) User when password is not present return value of authenticate method with invalid password Failure/Error: let(:user_for_invalid_password) { found_user.authenticate("invalid") } NoMethodError: undefined method authenticate' for nil:NilClass # ./spec/models/user_spec.rb:98:in block (5 levels) in ' # ./spec/models/user_spec.rb:101:in `block (5 levels) in '

User_spec tests

require 'spec_helper'

describe User do

  before do 
    @user = User.new(name: "Example User", email: "user@example.com",
                      password: "foobar", password_confirmation: "foobar")
  end


  subject { @user }

  it { should respond_to(:name) }
  it { should respond_to(:email) }
  it { should respond_to(:password_digest) }
  it { should respond_to(:password) }
  it { should respond_to(:password_confirmation) }
  it { should respond_to(:authenticate) }

  it { should be_valid }

  describe "when name is not present" do
    before { @user.name = " " }
    it { should_not be_valid }
  end

  it "should be valid" do
    expect(@user).to be_valid
  end

  describe "when email is not present" do
    before { @user.email = " " }
    it { should_not be_valid }
  end

  describe "when name is too long" do
    before { @user.name = 'a' * 51 }
    it { should_not be_valid }
  end

  describe "when email format is invalid" do
  it "should be invalid" do
    addresses = %w[user@foo,com user_at_foo.org example.user@foo.
                   foo@bar_baz.com foo@bar+baz.com]
    addresses.each do |invalid_address|
      @user.email = invalid_address
      expect(@user).not_to be_valid
    end
  end
end

describe "when email format is valid" do
  it "should be valid" do
    addresses = %w[user@foo.COM A_US-ER@f.b.org frst.lst@foo.jp a+b@baz.cn]
    addresses.each do |valid_address|
      @user.email = valid_address
      expect(@user).to be_valid
    end
  end
end

describe "when email address is already taken" do
  before do
    user_with_same_email = @user.dup
    user_with_same_email.email = @user.email.upcase
    user_with_same_email.save
  end

  it { should_not be_valid }
  end

  describe "when password is not present" do
    before do
      @user = User.new(name:"Example User", email: "user@example.com",
                        password: " ", password_confirmation: " ")
    end
    it { should_not be_valid }


  describe "when password does not match confirmation" do
    before { @user.password_confirmation = "mismatch" }
    it { should_not be_valid }
  end

  describe "with a password thats too short" do
    before { @user.password = @user.password_confirmation = "a" * 5 }
    it { should be_invalid }
  end

  describe "return value of authenticate method" do
  before { @user.save }
  let(:found_user) { User.find_by(email: @user.email) }

  describe "with valid password" do
    it { should eq found_user.authenticate(@user.password) }
  end

  describe "with invalid password" do
    let(:user_for_invalid_password) { found_user.authenticate("invalid") }

    it { should_not eq user_for_invalid_password }
    specify { expect(user_for_invalid_password).to be_false }
  end
end

end end

User model

class User < ActiveRecord::Base 
  before_save { self.email = email.downcase }
  validates :name, presence: true, length: { maximum: 50 }
  VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
  validates :email, presence: true, format: { with: VALID_EMAIL_REGEX },
                    uniqueness: { case_sensitive: false }
  has_secure_password
  validates :password, length: { minimum: 6 }

end

Answer 1

You are getting the error as found_user is nil.

Thats because you are not closing when password is not present describe block properly. So what happens is, this invalid @user is set with a blank password and its been carried forward till your failing test case.

  describe "when password is not present" do
    before do
      @user = User.new(name:"Example User", email: "user@example.com",
                       password: " ", password_confirmation: " ")
    end
    it { should_not be_valid }
  end  ### Add end here

Also, remove the very last end from the bottom of the file.