使用shoulda在Rails模型上重构rspec测试

Question

通过回答关于属性可访问性测试的另一个StackOverflow问题(并认为它们非常棒)来了解shoulda-matchers后,我决定尝试重构我在The Rails Tutorial中所做的模型测试,试图使它们更加简洁和彻底.我这样做是由于从文档模块的一些灵感和,以及这个StackOverflow的答案就在模型结构早该测试.但是,还有一些我不确定的事情,我想知道如何使这些测试更好. Shoulda::Matchers::ActiveRecordShoulda::Matchers::ActiveModel

我将使用Rails教程中的用户规范作为我的示例,因为它是最详细的,并涵盖了许多可以改进的领域.以下代码示例已从原始user_spec.rb更改,并将代码替换为describe "micropost associations"行.针对user.rb模型的规范测试及其工厂在factories.rb中定义.

规格/型号/ user_spec.rb

# == Schema Information
#
# Table name: users
#
#  id              :integer          not null, primary key
#  name            :string(255)
#  email           :string(255)
#  created_at      :datetime         not null
#  updated_at      :datetime         not null
#  password_digest :string(255)
#  remember_token  :string(255)
#  admin           :boolean          default(FALSE)
#
# Indexes
#
#  index_users_on_email           (email) UNIQUE
#  index_users_on_remember_token  (remember_token)
#

require 'spec_helper'

describe User do

  let(:user) { FactoryGirl.create(:user) }

  subject { user }

  describe "database schema" do
    it { should have_db_column(:id).of_type(:integer)
                              .with_options(null: false) }
    it { should have_db_column(:name).of_type(:string) }
    it { should have_db_column(:email).of_type(:string) }
    it { should have_db_column(:created_at).of_type(:datetime)
                              .with_options(null: false) }
    it { should have_db_column(:updated_at).of_type(:datetime)
                              .with_options(null: false) }
    it { should have_db_column(:password_digest).of_type(:string) }
    it { should have_db_column(:remember_token).of_type(:string) }
    it { should have_db_column(:admin).of_type(:boolean)
                              .with_options(default: false) }
    it { should have_db_index(:email).unique(true) }
    it { should have_db_index(:remember_token) }
  end

  describe "associations" do
    it { should have_many(:microposts).dependent(:destroy) }
    it { should have_many(:relationships).dependent(:destroy) }
    it { should have_many(:followed_users).through(:relationships) }
    it { should have_many(:reverse_relationships).class_name("Relationship")
                         .dependent(:destroy) }
    it { should have_many(:followers).through(:reverse_relationships) }
  end

  describe "model attributes" do
    it { should respond_to(:name) }
    it { should respond_to(:email) }
    it { should respond_to(:password_digest) }
    it { should respond_to(:remember_token) }
    it { should respond_to(:admin) }
    it { should respond_to(:microposts) }
    it { should respond_to(:relationships) }
    it { should respond_to(:followed_users) }
    it { should respond_to(:reverse_relationships) }
    it { should respond_to(:followers) }
  end

  describe "virtual attributes and methods from has_secure_password" do
    it { should respond_to(:password) }
    it { should respond_to(:password_confirmation) }
    it { should respond_to(:authenticate) }
  end

  describe "accessible attributes" do
    it { should_not allow_mass_assignment_of(:password_digest) }
    it { should_not allow_mass_assignment_of(:remember_token) }
    it { should_not allow_mass_assignment_of(:admin) }
  end

  describe "instance methods" do
    it { should respond_to(:feed) }
    it { should respond_to(:following?) }
    it { should respond_to(:follow!) }
    it { should respond_to(:unfollow!) }
  end

  describe "initial state" do
    it { should be_valid }
    it { should_not be_admin }
    its(:remember_token) { should_not be_blank }
    its(:email) { should_not =~ /\p{Upper}/ }
  end

  describe "validations" do
    context "for name" do
      it { should validate_presence_of(:name) }
      it { should_not allow_value(" ").for(:name) }
      it { should ensure_length_of(:name).is_at_most(50) }
    end

    context "for email" do
      it { should validate_presence_of(:email) }
      it { should_not allow_value(" ").for(:email) }
      it { should validate_uniqueness_of(:email).case_insensitive }

      context "when email format is invalid" do
        addresses = %w[user@foo,com user_at_foo.org example.user@foo.]
        addresses.each do |invalid_address|
          it { should_not allow_value(invalid_address).for(:email) }
        end
      end

      context "when email format is 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|
          it { should allow_value(valid_address).for(:email) }
        end
      end
    end

    context "for password" do
      it { should ensure_length_of(:password).is_at_least(6) }
      it { should_not allow_value(" ").for(:password) }

      context "when password doesn't match confirmation" do
        it { should_not allow_value("mismatch").for(:password) }
      end
    end

    context "for password_confirmation" do
      it { should validate_presence_of(:password_confirmation) }
    end
  end

  # ...
end

关于这些测试的一些具体问题:

1. 是否值得测试数据库模式？上面提到的StackOverflow答案中的注释说"我只测试与行为相关的事情,我不考虑列的存在或索引行为.数据库列不会消失,除非有人故意删除它们,但是你通过代码审查和信任可以防止这种情况",我同意这一点,但有没有任何正当理由可以测试数据库模式的结构,从而证明Shoulda::Matchers::ActiveRecord模块的存在 ？也许只是重要的指标值得测试......？
2. 这些should have_many测试是否"associations"取代了相应的should respond_to测试"model attributes"？我无法判断should have_many测试是has_many在模型文件中查找相关声明还是实际执行相同的功能should respond_to.
3. 您是否有任何其他意见/建议可以使这些测试在内容和结构上更加简洁/可读/彻底？

Answer 1

1) Shoulda::Matchers::ActiveRecord 模块不仅仅包含列和索引匹配器。我会稍微研究一下包含的课程，看看你能找到什么。这就是 等 的have_many来源belong_to。但郑重声明，我认为其中的大部分内容没有什么价值。

2）是的，诸如have_many测试之类的宏不仅仅是模型是否响应方法。从源代码中，您可以准确地看到它正在测试什么：

def matches?(subject)
  @subject = subject
  association_exists? &&
    macro_correct? &&
    foreign_key_exists? &&
    through_association_valid? &&
    dependent_correct? &&
    class_name_correct? &&
    order_correct? &&
    conditions_correct? &&
    join_table_exists? &&
    validate_correct?
end

3）使测试更具可读性和/或更简洁绝对是一个需要回答的主观问题。每个人都会根据他们的背景和经验给你不同的答案。我个人会放弃所有测试respond_to并用有价值的测试替换它们。当有人查看您的测试时，他们应该能够理解该类的公共 API。当我看到你的对象对“以下？”之类的内容做出响应时，我可以做出假设，但并不真正知道它的含义。这需要争论吗？它返回一个布尔值吗？是物体跟随某物，还是某物跟随物体？