include 匹配器

使用 include 匹配器指定集合包含一个或多个预期对象。 如果给定集合中的任何对象通过指定的匹配器，则它会成功。 这适用于响应 #include? 的任何对象（例如字符串或数组）

  expect("a string").to include("a")
  expect("a string").to include(/a|str/).twice
  expect("a string").to include("str", "g")
  expect("a string").not_to include("foo")

  expect([1, 2]).to include(1)
  expect([1, 2]).to include(1, 2)
  expect([1, 2]).to include(a_kind_of(Integer))
  expect([1, 2]).to include(be_odd.and be < 10 )
  expect([1, 2]).to include(be_odd)
  expect([1, 2]).to include(be < 10).at_least(2).times
  expect([1, 2]).not_to include(17)

匹配器还为哈希提供了灵活的处理方式

  expect(:a => 1, :b => 2).to include(:a)
  expect(:a => 1, :b => 2).to include(:a, :b)
  expect(:a => 1, :b => 2).to include(:a => 1)
  expect(:a => 1, :b => 2).to include(:b => 2, :a => 1)
  expect(:a => 1, :b => 2).to include(match(/b/) => 2)
  expect(:a => 1, :b => 2).to include(match(/b/) => be_even)
  expect(:a => 1, :b => 2).not_to include(:c)
  expect(:a => 1, :b => 2).not_to include(:a => 2)
  expect(:a => 1, :b => 2).not_to include(:c => 3)

数组用法

假设一个名为“arrayincludematcher_spec.rb”的文件，其中包含

RSpec.describe [1, 3, 7] do
  it { is_expected.to include(1) }
  it { is_expected.to include(3) }
  it { is_expected.to include(7) }
  it { is_expected.to include(1, 7) }
  it { is_expected.to include(1, 3, 7) }
  it { is_expected.to include(a_kind_of(Integer)) }
  it { is_expected.to include(be_odd.and be < 10) }
  it { is_expected.to include(be_odd).at_least(:twice) }
  it { is_expected.not_to include(be_even) }
  it { is_expected.not_to include(17) }
  it { is_expected.not_to include(43, 100) }

  # deliberate failures
  it { is_expected.to include(4) }
  it { is_expected.to include(be_even) }
  it { is_expected.to include(be_odd).at_most(2).times }
  it { is_expected.not_to include(1) }
  it { is_expected.not_to include(3) }
  it { is_expected.not_to include(7) }
  it { is_expected.not_to include(1, 3, 7) }

  # both of these should fail since it includes 1 but not 9
  it { is_expected.to include(1, 9) }
  it { is_expected.not_to include(1, 9) }
end

当我运行 rspec array_include_matcher_spec.rb

那么输出应该包含以下所有内容
20 个示例，9 个失败
预期 [1, 3, 7] 包含 4
预期 [1, 3, 7] 包含（为偶数）
预期 [1, 3, 7] 包含（为奇数）最多两次，但它包含 3 次
预期 [1, 3, 7] 不包含 1
预期 [1, 3, 7] 不包含 3
预期 [1, 3, 7] 不包含 7
预期 [1, 3, 7] 不包含 1、3 和 7
预期 [1, 3, 7] 包含 9
预期 [1, 3, 7] 不包含 1

字符串用法

假设一个名为“stringincludematcher_spec.rb”的文件，其中包含

RSpec.describe "a string" do
  it { is_expected.to include("str") }
  it { is_expected.to include("a", "str", "ng") }
  it { is_expected.to include(/a|str/).twice }
  it { is_expected.not_to include("foo") }
  it { is_expected.not_to include("foo", "bar") }

  # deliberate failures
  it { is_expected.to include("foo") }
  it { is_expected.not_to include("str") }
  it { is_expected.to include("str").at_least(:twice) }
  it { is_expected.to include("str", "foo") }
  it { is_expected.not_to include("str", "foo") }
end

当我运行 rspec string_include_matcher_spec.rb

那么输出应该包含以下所有内容
10 个示例，5 个失败
预期 “a string” 包含 “foo”
预期 “a string” 不包含 “str”
预期 “a string” 包含 “str” 至少两次，但它只包含一次
预期 “a string” 包含 “foo”
预期 “a string” 不包含 “str”

哈希用法

假设一个名为“hashincludematcher_spec.rb”的文件，其中包含

RSpec.describe :a => 7, :b => 5 do
  it { is_expected.to include(:a) }
  it { is_expected.to include(:b, :a) }
  it { is_expected.to include(:a => 7) }
  it { is_expected.to include(:b => 5, :a => 7) }
  it { is_expected.not_to include(:c) }
  it { is_expected.not_to include(:c, :d) }
  it { is_expected.not_to include(:d => 2) }
  it { is_expected.not_to include(:a => 5) }
  it { is_expected.not_to include(:b => 7, :a => 5) }

  # deliberate failures
  it { is_expected.not_to include(:a) }
  it { is_expected.not_to include(:b, :a) }
  it { is_expected.not_to include(:a => 7) }
  it { is_expected.not_to include(:a => 7, :b => 5) }
  it { is_expected.to include(:c) }
  it { is_expected.to include(:c, :d) }
  it { is_expected.to include(:d => 2) }
  it { is_expected.to include(:a => 5) }
  it { is_expected.to include(:a => 5, :b => 7) }

  # Mixed cases--the hash includes one but not the other.
  # All 4 of these cases should fail.
  it { is_expected.to include(:a, :d) }
  it { is_expected.not_to include(:a, :d) }
  it { is_expected.to include(:a => 7, :d => 3) }
  it { is_expected.not_to include(:a => 7, :d => 3) }
end

当我运行 rspec hash_include_matcher_spec.rb

那么输出应该包含以下所有内容
22 个示例，13 个失败
预期 {:a => 7, :b => 5} 不包含 :a
预期 {:a => 7, :b => 5} 不包含 :b 和 :a
预期 {:a => 7, :b => 5} 不包含 {:a => 7}
预期 {:a => 7, :b => 5} 不包含 {:a => 7, :b => 5}
预期 {:a => 7, :b => 5} 包含 :c
预期 {:a => 7, :b => 5} 包含 :c 和 :d
预期 {:a => 7, :b => 5} 包含 {:d => 2}
预期 {:a => 7, :b => 5} 包含 {:a => 5}
预期 {:a => 7, :b => 5} 包含 {:a => 5, :b => 7}
预期 {:a => 7, :b => 5} 包含 :d
预期 {:a => 7, :b => 5} 不包含 :a
预期 {:a => 7, :b => 5} 包含 {:d => 3}
预期 {:a => 7, :b => 5} 不包含 {:a => 7}

计数用法

假设一个名为“includematcherwithcountsspec.rb”的文件，其中包含

  RSpec.describe [{:c => 7}, {:a => 1}, {:b => 2}, {:c => 1}, {:a => 3}, {:c => 7}] do
    it { is_expected.to include(:b => 2).exactly(1).times }
    it { is_expected.to include(:b => 2).once }
    it { is_expected.to include(have_key(:a)).twice }
    it { is_expected.to include(have_key(:c)).at_least(2).times }
    it { is_expected.to include(have_key(:a)).at_least(:once) }
    it { is_expected.to include(have_key(:c)).at_least(:twice) }
    it { is_expected.to include(have_key(:d)).at_most(:once) }
    it { is_expected.to include(have_key(:b)).at_most(:twice) }

    # deliberate failures
    it { is_expected.not_to include(have_key(:b)).once }
    it { is_expected.not_to include(have_key(:a)).twice }
    it { is_expected.not_to include(have_key(:c)).at_least(2).times }
    it { is_expected.not_to include(have_key(:d)).at_most(:once) }
  end

当我运行 rspec include_matcher_with_counts_spec.rb

那么输出应该包含以下所有内容
12 个示例，4 个失败
预期 [{:c => 7}, {:a => 1}, {:b => 2}, {:c => 1}, {:a => 3}, {:c => 7}] 不包含 (具有键 :b) 一次
预期 [{:c => 7}, {:a => 1}, {:b => 2}, {:c => 1}, {:a => 3}, {:c => 7}] 不包含 (具有键 :a) 两次
预期 [{:c => 7}, {:a => 1}, {:b => 2}, {:c => 1}, {:a => 3}, {:c => 7}] 不包含 (具有键 :c) 至少两次
预期 [{:c => 7}, {:a => 1}, {:b => 2}, {:c => 1}, {:a => 3}, {:c => 7}] 不包含 (具有键 :d) 最多一次