在 RSpec 中，特别是版本 >= 3，有什么区别:

• 使用allow 设置带有返回测试替身的参数的消息期望，然后使用expect 对返回的测试替身进行断言
• 只需使用expect 设置带有参数的期望并返回测试替身

还是只是语义？我知道用 expect 提供/指定返回值是 the syntax in RSpec mocks 2.13 ，但据我所知，the syntax changed in RSpec mocks 3使用允许。

但是，在下面的(传递的)示例代码中，使用 allow/expect 或仅使用 expect/and_return 似乎产生相同的结果。如果一种语法比另一种语法更受欢迎，也许我会期望有某种弃用通知，但由于没有，这两种语法似乎都被认为是有效的:

class Foo
  def self.bar(baz)
    # not important what happens to baz parameter
    # only important that it is passed in
    new
  end

  def qux
    # perform some action
  end
end

class SomethingThatCallsFoo
  def some_long_process(baz)
    # do some processing
    Foo.bar(baz).qux
    # do other processing
  end
end

describe SomethingThatCallsFoo do
  let(:foo_caller) { SomethingThatCallsFoo.new }

  describe '#some_long_process' do
    let(:foobar_result) { double('foobar_result') }
    let(:baz) { double('baz') }

    context 'using allow/expect' do
      before do
        allow(Foo).to receive(:bar).with(baz).and_return(foobar_result)
      end

      it 'calls qux method on result of Foo.bar(baz)' do
        expect(foobar_result).to receive(:qux)
        foo_caller.some_long_process(baz)
      end
    end

    context 'using expect/and_return' do
      it 'calls qux method on result of Foo.bar(baz)' do
        expect(Foo).to receive(:bar).with(baz).and_return(foobar_result)
        expect(foobar_result).to receive(:qux)
        foo_caller.some_long_process(baz)
      end
    end
  end
end

如果我通过将期望中传入的 baz 参数更改为不同的测试替身来故意使测试失败，则错误几乎相同:

  1) SomethingThatCallsFoo#some_long_process using allow/expect calls quux method on result of Foo.bar(baz)
     Failure/Error: Foo.bar(baz).qux
       <Foo (class)> received :bar with unexpected arguments
         expected: (#<RSpec::Mocks::Double:0x3fe97a0127fc @name="baz">)
              got: (#<RSpec::Mocks::Double:0x3fe97998540c @name=nil>)
        Please stub a default value first if message might be received with other args as well.
     # ./foo_test.rb:16:in `some_long_process'
     # ./foo_test.rb:35:in `block (4 levels) in <top (required)>'

  2) SomethingThatCallsFoo#some_long_process using expect/and_return calls quux method on result of Foo.bar(baz)
     Failure/Error: Foo.bar(baz).qux
       <Foo (class)> received :bar with unexpected arguments
         expected: (#<RSpec::Mocks::Double:0x3fe979935fd8 @name="baz">)
              got: (#<RSpec::Mocks::Double:0x3fe979cc5c0c @name=nil>)
     # ./foo_test.rb:16:in `some_long_process'
     # ./foo_test.rb:43:in `block (4 levels) in <top (required)>'

那么，这两个测试之间是否存在任何真正的差异，无论是结果还是表达的意图，或者仅仅是语义和/或个人偏好？ allow/expect 是否应该在 expect/and_return 上使用，因为它看起来像是替换语法，或者它们中的每一个都用于特定的测试场景吗？

更新

看完Mori's answer的，我从上面的示例代码中注释掉了 Foo.bar(baz).qux 行，并得到以下错误:

  1) SomethingThatCallsFoo#some_long_process using allow/expect calls qux method on result of Foo.bar(baz)
     Failure/Error: expect(foobar_result).to receive(:qux)
       (Double "foobar_result").qux(any args)
           expected: 1 time with any arguments
           received: 0 times with any arguments
     # ./foo_test.rb:34:in `block (4 levels) in <top (required)>'

  2) SomethingThatCallsFoo#some_long_process using expect/and_return calls qux method on result of Foo.bar(baz)
     Failure/Error: expect(Foo).to receive(:bar).with(baz).and_return(foobar_result)
       (<Foo (class)>).bar(#<RSpec::Mocks::Double:0x3fc211944fa4 @name="baz">)
           expected: 1 time with arguments: (#<RSpec::Mocks::Double:0x3fc211944fa4 @name="baz">)
           received: 0 times
     # ./foo_test.rb:41:in `block (4 levels) in <top (required)>'

• allow 规范失败，因为 foobar_result double 永远无法代表 Foo.bar(baz) 的结果，因此从来没有 #qux 调用它
• expect 规范在 Foo 从未接收到 .bar(baz) 时失败，所以我们甚至没有达到目的询问 foobar_result double

有道理:这不仅仅是语法更改，而且 expect/and_return 确实有不同于 allow/ 的目的期待。我真的应该检查最明显的地方:RSpec Mocks README ，特别是以下部分:

• Mock Objects and Test Stubs
• Test-Specific Extension
• Setting Responses

最佳答案

看经典文章Mocks Aren't Stubs . allow 生成 stub ，而 expect 生成模拟。那就是 allow 允许一个对象返回 X 而不是它会返回未 stub 的任何东西，并且 expect 是一个 allow plus 对某些状态或事件的期望。当你写作时

allow(Foo).to receive(:bar).with(baz).and_return(foobar_result)

...你告诉规范环境修改 Foo 以在接收到 :bar 和 baz 时返回 foobar_result 。但是当你写的时候

expect(Foo).to receive(:bar).with(baz).and_return(foobar_result) 

...您正在做同样的事情，并告诉规范失败除非 Foo 接收到 :bar 和 baz 。

要查看区别，请在 Foo 不 使用 baz 接收 :bar 的示例中尝试两者。

关于ruby - RSpec allow/expect 与 just expect/and_return，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28006913/