Michael Hartl Rails 教程：assert_not 与它应该做的完全相反，我不明白为什么

Question

tl;dr Valid names don't get written to the database because the test fails, and invalid names do get written to the database because the test passes.

Edit: For clarification about the project and my question in general: As described in the book, this User model is set up as the beginning stages to allow a website user to eventually log in to a website. The database columns would be "name" and "email", and each row would be one user (assuming the user name and email were valid). I've edited my original post below for further clarification, and all edits are in italics.

Additionally, please only respond if you can explain the code as is in my post--don't suggest adding additional code to make it work. The textbook I'm working from asserts that this code should work as is, yet it seems to evaluate to the opposite that it should. Lastly, if you know other links that explain this in more detail, that is helpful; however, I have already read apidock , RoR API , and most of the SO links that show up in a Google search, and none have been helpful in explicating this problem.

I'm working through Michael Hartl's Ruby on Rails Tutorial. I'm in chapter 6 working through validation tests and I'm stuck on the validation for the presence of a name. It seems to be doing exactly the opposite of what the tutorial says it should do (ie, validating a non-valid name entry), even though I've followed the tutorial exactly. I've also searched the web and SO for more details on how assert_not works, but can't find any helpful details. Here's the process I've went through.

1. Add a test that we know will fail:

    require 'test_helper' class UserTest < ActiveSupport::TestCase def setup @user = User.new(name: "Example User", email: "user@example.com") end # resolves to true and passes test "should be valid" do assert @user.valid? end test "name should be present" do @user.name = " " assert_not @user.valid? end end

So far so good. I understand this code perfectly well, and although the second test's wording is awkward, I interpret assert_not @user.valid? to work like this: @user.valid? evaluates to true, since no validations have been set up, so the test thinks a name with all blank spaces is valid. This is preceded by an assert_not which converts a true value to false, and makes the test fail.

2. We add a validation test:

    class User < ActiveRecord::Base validates :name, presence: true end

This sets a validation rule for the User model that ensures the :name object has content and is not nil, an empty string, or blank space. Still good so far.

3. Here's where things get tricky. At this point, the expression @user.valid? in our test should (and does) evaluate to false, since the validation rule won't allow a :name with only spaces in it. I've added comments alongside this code to help my mind see what values are assigned and evaluated in this process:

    test "name should be present" do @user.name = " " # => name: " " email: "example@example.com" assert_not @user.valid? # => assert_not false => true end

@user.valid? evaluates to false, which makes the entire assert_not expression evaluate to true, and thus the test passes. In pseudocode, this line could translate thusly: assert_not (is the user valid? no) ==> assert_not(false) ==> true . Similarly, "We do not assert that the user is false", which evaluates to true.

This is where my problem is: The test passes on an invalid value for :name , thus allowing a name consisting of blank spaces to be written to the database, when that's exactly the opposite of what we are trying to achieve, namely, preventing blank names from being written to db.

4. Conversely, I worked out this logic with a valid name:

    test "name should be present" do # => name: "Example User" email: "example@example.com" assert_not @user.valid? # assert_not true => false end

In this case, since @user.valid? evaluates to true (since "Example User" is a valid name), assert_not @user.valid? evaluates to false, the test fails, and our valid name does not get written to the database. In pseudocode, this line could translate thusly: assert_not (is the user valid? yes) ==> assert_not(true) ==> false . Similarly, "We do not assert that the user is true", which evaluates to false. Because the test evaluates to false (even with a true/valid user name), this valid name is not written to the database.

If someone could explain how this makes any sense, I'd greatly appreciate it, and detailed answers walking me through it would be even better.

Answer 1

The test passes on an invalid value for :name, thus allowing a name consisting of blank spaces to be written to the database...

assert_not returns true (same as test passing) if the expression that follows, @user.valid? , returns false. In effect the test in section 3 says: We're not asserting that the user is valid. Since that expectation/assertion is correct, it returns true and the test passes. Nothing has been saved to the database.

Answer 2

You can add a validation as you add a string " " consist two spaces

  class User < ActiveRecord::Base
   validates :name, presence: true, allow_blank: false
   validate :name_of_valid

   def name_of_valid
    self.errors.add :base, 'My string can not be empty' if self.name == "   " 
   end
end

and then

test "name should be present" do
    @user.name = "   "
    # => name: "   " email: "example@example.com"
    assert_not @user.valid? 
    # => assert_not true 
end

Answer 3

I had the same problem. Only with presence: true the test fails and when I add allow_blank: false it passes.