puppet 5.3.4 → 6.29.0

data/spec/unit/confine/exists_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/confine/exists'
@@ -16,12 +15,12 @@ describe Puppet::Confine::Exists do
   it "should not pass if exists is nil" do
     confine = Puppet::Confine::Exists.new(nil)
     confine.label = ":exists => nil"
-    confine.expects(:pass?).with(nil)
+    expect(confine).to receive(:pass?).with(nil)
     expect(confine).not_to be_valid
   end
 
   it "should use the 'pass?' method to test validity" do
-    @confine.expects(:pass?).with("/my/file")
+    expect(@confine).to receive(:pass?).with("/my/file")
     @confine.valid?
   end
 
@@ -30,12 +29,12 @@ describe Puppet::Confine::Exists do
   end
 
   it "should return false if the value does not point to a file" do
-    Puppet::FileSystem.expects(:exist?).with("/my/file").returns false
+    expect(Puppet::FileSystem).to receive(:exist?).with("/my/file").and_return(false)
     expect(@confine.pass?("/my/file")).to be_falsey
   end
 
   it "should return true if the value points to a file" do
-    Puppet::FileSystem.expects(:exist?).with("/my/file").returns true
+    expect(Puppet::FileSystem).to receive(:exist?).with("/my/file").and_return(true)
     expect(@confine.pass?("/my/file")).to be_truthy
   end
 
@@ -44,36 +43,39 @@ describe Puppet::Confine::Exists do
   end
 
   describe "and the confine is for binaries" do
-    before { @confine.stubs(:for_binary).returns true }
+    before do
+      allow(@confine).to receive(:for_binary).and_return(true)
+    end
+
     it "should use its 'which' method to look up the full path of the file" do
-      @confine.expects(:which).returns nil
+      expect(@confine).to receive(:which).and_return(nil)
       @confine.pass?("/my/file")
     end
 
     it "should return false if no executable can be found" do
-      @confine.expects(:which).with("/my/file").returns nil
+      expect(@confine).to receive(:which).with("/my/file").and_return(nil)
       expect(@confine.pass?("/my/file")).to be_falsey
     end
 
     it "should return true if the executable can be found" do
-      @confine.expects(:which).with("/my/file").returns "/my/file"
+      expect(@confine).to receive(:which).with("/my/file").and_return("/my/file")
       expect(@confine.pass?("/my/file")).to be_truthy
     end
   end
 
   it "should produce a summary containing all missing files" do
-    Puppet::FileSystem.stubs(:exist?).returns true
-    Puppet::FileSystem.expects(:exist?).with("/two").returns false
-    Puppet::FileSystem.expects(:exist?).with("/four").returns false
+    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+    expect(Puppet::FileSystem).to receive(:exist?).with("/two").and_return(false)
+    expect(Puppet::FileSystem).to receive(:exist?).with("/four").and_return(false)
 
     confine = Puppet::Confine::Exists.new %w{/one /two /three /four}
     expect(confine.summary).to eq(%w{/two /four})
   end
 
   it "should summarize multiple instances by returning a flattened array of their summaries" do
-    c1 = mock '1', :summary => %w{one}
-    c2 = mock '2', :summary => %w{two}
-    c3 = mock '3', :summary => %w{three}
+    c1 = double('1', :summary => %w{one})
+    c2 = double('2', :summary => %w{two})
+    c3 = double('3', :summary => %w{three})
 
     expect(Puppet::Confine::Exists.summarize([c1, c2, c3])).to eq(%w{one two three})
   end

data/spec/unit/confine/false_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/confine/false'
@@ -12,13 +11,40 @@ describe Puppet::Confine::False do
     expect { Puppet::Confine.new }.to raise_error(ArgumentError)
   end
 
+  describe "when passing in a lambda as a value for lazy evaluation" do
+    it "should accept it" do
+      confine = Puppet::Confine::False.new(lambda { false })
+      expect(confine.values).to eql([false])
+    end
+
+    describe "when enforcing cache-positive behavior" do
+      def cached_value_of(confine)
+        confine.instance_variable_get(:@cached_value)
+      end
+
+      it "should cache a false value" do
+        confine = Puppet::Confine::False.new(lambda { false })
+        confine.values
+
+        expect(cached_value_of(confine)).to eql([false])
+      end
+
+      it "should not cache a true value" do
+        confine = Puppet::Confine::False.new(lambda { true })
+        confine.values
+
+        expect(cached_value_of(confine)).to be_nil
+      end
+    end
+  end
+
   describe "when testing values" do
     before { @confine = Puppet::Confine::False.new("foo") }
 
     it "should use the 'pass?' method to test validity" do
       @confine = Puppet::Confine::False.new("foo")
       @confine.label = "eh"
-      @confine.expects(:pass?).with("foo")
+      expect(@confine).to receive(:pass?).with("foo")
       @confine.valid?
     end
 
@@ -38,14 +64,14 @@ describe Puppet::Confine::False do
 
   it "should be able to produce a summary with the number of incorrectly true values" do
     confine = Puppet::Confine::False.new %w{one two three four}
-    confine.expects(:pass?).times(4).returns(true).returns(false).returns(true).returns(false)
+    expect(confine).to receive(:pass?).exactly(4).times.and_return(true, false, true, false)
     expect(confine.summary).to eq(2)
   end
 
   it "should summarize multiple instances by summing their summaries" do
-    c1 = mock '1', :summary => 1
-    c2 = mock '2', :summary => 2
-    c3 = mock '3', :summary => 3
+    c1 = double('1', :summary => 1)
+    c2 = double('2', :summary => 2)
+    c3 = double('3', :summary => 3)
 
     expect(Puppet::Confine::False.summarize([c1, c2, c3])).to eq(6)
   end

data/spec/unit/confine/feature_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/confine/feature'
@@ -23,7 +22,7 @@ describe Puppet::Confine::Feature do
     end
 
     it "should use the Puppet features instance to test validity" do
-      Puppet.features.expects(:myfeature?)
+      Puppet.features.add(:myfeature) do true end
       @confine.valid?
     end
 
@@ -48,9 +47,12 @@ describe Puppet::Confine::Feature do
     confines << Puppet::Confine::Feature.new(%w{two})
     confines << Puppet::Confine::Feature.new(%w{three four})
 
-    features = mock 'feature'
-    features.stub_everything
-    Puppet.stubs(:features).returns features
+    features = double('feature')
+    allow(features).to receive(:one?)
+    allow(features).to receive(:two?)
+    allow(features).to receive(:three?)
+    allow(features).to receive(:four?)
+    allow(Puppet).to receive(:features).and_return(features)
 
     expect(Puppet::Confine::Feature.summarize(confines).sort).to eq(%w{one two three four}.sort)
   end

data/spec/unit/confine/true_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/confine/true'
@@ -12,6 +11,33 @@ describe Puppet::Confine::True do
     expect { Puppet::Confine::True.new }.to raise_error(ArgumentError)
   end
 
+  describe "when passing in a lambda as a value for lazy evaluation" do
+    it "should accept it" do
+      confine = Puppet::Confine::True.new(lambda { true })
+      expect(confine.values).to eql([true])
+    end
+
+    describe "when enforcing cache-positive behavior" do
+      def cached_value_of(confine)
+        confine.instance_variable_get(:@cached_value)
+      end
+
+      it "should cache a true value" do
+        confine = Puppet::Confine::True.new(lambda { true })
+        confine.values
+
+        expect(cached_value_of(confine)).to eql([true])
+      end
+
+      it "should not cache a false value" do
+        confine = Puppet::Confine::True.new(lambda { false })
+        confine.values
+
+        expect(cached_value_of(confine)).to be_nil
+      end
+    end
+  end
+
   describe "when testing values" do
     before do
       @confine = Puppet::Confine::True.new("foo")
@@ -19,7 +45,7 @@ describe Puppet::Confine::True do
     end
 
     it "should use the 'pass?' method to test validity" do
-      @confine.expects(:pass?).with("foo")
+      expect(@confine).to receive(:pass?).with("foo")
       @confine.valid?
     end
 
@@ -38,14 +64,14 @@ describe Puppet::Confine::True do
 
   it "should produce the number of false values when asked for a summary" do
     @confine = Puppet::Confine::True.new %w{one two three four}
-    @confine.expects(:pass?).times(4).returns(true).returns(false).returns(true).returns(false)
+    expect(@confine).to receive(:pass?).exactly(4).times.and_return(true, false, true, false)
     expect(@confine.summary).to eq(2)
   end
 
   it "should summarize multiple instances by summing their summaries" do
-    c1 = mock '1', :summary => 1
-    c2 = mock '2', :summary => 2
-    c3 = mock '3', :summary => 3
+    c1 = double('1', :summary => 1)
+    c2 = double('2', :summary => 2)
+    c3 = double('3', :summary => 3)
 
     expect(Puppet::Confine::True.summarize([c1, c2, c3])).to eq(6)
   end

data/spec/unit/confine/variable_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/confine/variable'
@@ -27,37 +26,37 @@ describe Puppet::Confine::Variable do
     end
 
     it "should use settings if the variable name is a valid setting" do
-      Puppet.settings.expects(:valid?).with(:myvar).returns true
-      Puppet.settings.expects(:value).with(:myvar).returns "foo"
+      expect(Puppet.settings).to receive(:valid?).with(:myvar).and_return(true)
+      expect(Puppet.settings).to receive(:value).with(:myvar).and_return("foo")
       @confine.valid?
     end
 
     it "should use Facter if the variable name is not a valid setting" do
-      Puppet.settings.expects(:valid?).with(:myvar).returns false
-      Facter.expects(:value).with(:myvar).returns "foo"
+      expect(Puppet.settings).to receive(:valid?).with(:myvar).and_return(false)
+      expect(Facter).to receive(:value).with(:myvar).and_return("foo")
       @confine.valid?
     end
 
     it "should be valid if the value matches the facter value" do
-      @confine.expects(:test_value).returns "foo"
+      expect(@confine).to receive(:test_value).and_return("foo")
 
       expect(@confine).to be_valid
     end
 
     it "should return false if the value does not match the facter value" do
-      @confine.expects(:test_value).returns "fee"
+      expect(@confine).to receive(:test_value).and_return("fee")
 
       expect(@confine).not_to be_valid
     end
 
     it "should be case insensitive" do
-      @confine.expects(:test_value).returns "FOO"
+      expect(@confine).to receive(:test_value).and_return("FOO")
 
       expect(@confine).to be_valid
     end
 
     it "should not care whether the value is a string or symbol" do
-      @confine.expects(:test_value).returns "FOO"
+      expect(@confine).to receive(:test_value).and_return("FOO")
 
       expect(@confine).to be_valid
     end
@@ -72,7 +71,7 @@ describe Puppet::Confine::Variable do
 
     it "should be valid if the test value matches any of the provided values" do
       @confine = Puppet::Confine::Variable.new(%w{bar bee})
-      @confine.expects(:test_value).returns "bee"
+      expect(@confine).to receive(:test_value).and_return("bee")
       expect(@confine).to be_valid
     end
   end
@@ -81,13 +80,13 @@ describe Puppet::Confine::Variable do
     it "should return a hash of failing variables and their values" do
       c1 = Puppet::Confine::Variable.new("one")
       c1.name = "uno"
-      c1.expects(:valid?).returns false
+      expect(c1).to receive(:valid?).and_return(false)
       c2 = Puppet::Confine::Variable.new("two")
       c2.name = "dos"
-      c2.expects(:valid?).returns true
+      expect(c2).to receive(:valid?).and_return(true)
       c3 = Puppet::Confine::Variable.new("three")
       c3.name = "tres"
-      c3.expects(:valid?).returns false
+      expect(c3).to receive(:valid?).and_return(false)
 
       expect(Puppet::Confine::Variable.summarize([c1, c2, c3])).to eq({"uno" => %w{one}, "tres" => %w{three}})
     end
@@ -95,10 +94,10 @@ describe Puppet::Confine::Variable do
     it "should combine the values of multiple confines with the same fact" do
       c1 = Puppet::Confine::Variable.new("one")
       c1.name = "uno"
-      c1.expects(:valid?).returns false
+      expect(c1).to receive(:valid?).and_return(false)
       c2 = Puppet::Confine::Variable.new("two")
       c2.name = "uno"
-      c2.expects(:valid?).returns false
+      expect(c2).to receive(:valid?).and_return(false)
 
       expect(Puppet::Confine::Variable.summarize([c1, c2])).to eq({"uno" => %w{one two}})
     end

data/spec/unit/confine_collection_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/confine_collection'
@@ -18,20 +17,20 @@ describe Puppet::ConfineCollection do
 
   describe "when creating confine instances" do
     it "should create an instance of the named test with the provided values" do
-      test_class = mock 'test_class'
-      test_class.expects(:new).with(%w{my values}).returns(stub('confine', :label= => nil))
-      Puppet::Confine.expects(:test).with(:foo).returns test_class
+      test_class = double('test_class')
+      expect(test_class).to receive(:new).with(%w{my values}).and_return(double('confine', :label= => nil))
+      expect(Puppet::Confine).to receive(:test).with(:foo).and_return(test_class)
 
       Puppet::ConfineCollection.new("label").confine :foo => %w{my values}
     end
 
     it "should copy its label to the confine instance" do
-      confine = mock 'confine'
-      test_class = mock 'test_class'
-      test_class.expects(:new).returns confine
-      Puppet::Confine.expects(:test).returns test_class
+      confine = double('confine')
+      test_class = double('test_class')
+      expect(test_class).to receive(:new).and_return(confine)
+      expect(Puppet::Confine).to receive(:test).and_return(test_class)
 
-      confine.expects(:label=).with("label")
+      expect(confine).to receive(:label=).with("label")
 
       Puppet::ConfineCollection.new("label").confine :foo => %w{my values}
     end
@@ -39,8 +38,8 @@ describe Puppet::ConfineCollection do
     describe "and the test cannot be found" do
       it "should create a Facter test with the provided values and set the name to the test name" do
         confine = Puppet::Confine.test(:variable).new(%w{my values})
-        confine.expects(:name=).with(:foo)
-        confine.class.expects(:new).with(%w{my values}).returns confine
+        expect(confine).to receive(:name=).with(:foo)
+        expect(confine.class).to receive(:new).with(%w{my values}).and_return(confine)
         Puppet::ConfineCollection.new("label").confine(:foo => %w{my values})
       end
     end
@@ -48,8 +47,8 @@ describe Puppet::ConfineCollection do
     describe "and the 'for_binary' option was provided" do
       it "should mark the test as a binary confine" do
         confine = Puppet::Confine.test(:exists).new(:bar)
-        confine.expects(:for_binary=).with true
-        Puppet::Confine.test(:exists).expects(:new).with(:bar).returns confine
+        expect(confine).to receive(:for_binary=).with(true)
+        expect(Puppet::Confine.test(:exists)).to receive(:new).with(:bar).and_return(confine)
         Puppet::ConfineCollection.new("label").confine :exists => :bar, :for_binary => true
       end
     end
@@ -60,11 +59,11 @@ describe Puppet::ConfineCollection do
   end
 
   it "should be valid if all confines pass" do
-    c1 = stub 'c1', :valid? => true, :label= => nil
-    c2 = stub 'c2', :valid? => true, :label= => nil
+    c1 = double('c1', :valid? => true, :label= => nil)
+    c2 = double('c2', :valid? => true, :label= => nil)
 
-    Puppet::Confine.test(:true).expects(:new).returns(c1)
-    Puppet::Confine.test(:false).expects(:new).returns(c2)
+    expect(Puppet::Confine.test(:true)).to receive(:new).and_return(c1)
+    expect(Puppet::Confine.test(:false)).to receive(:new).and_return(c2)
 
     confiner = Puppet::ConfineCollection.new("label")
     confiner.confine :true => :bar, :false => :bee
@@ -73,11 +72,11 @@ describe Puppet::ConfineCollection do
   end
 
   it "should not be valid if any confines fail" do
-    c1 = stub 'c1', :valid? => true, :label= => nil
-    c2 = stub 'c2', :valid? => false, :label= => nil
+    c1 = double('c1', :valid? => true, :label= => nil)
+    c2 = double('c2', :valid? => false, :label= => nil)
 
-    Puppet::Confine.test(:true).expects(:new).returns(c1)
-    Puppet::Confine.test(:false).expects(:new).returns(c2)
+    expect(Puppet::Confine.test(:true)).to receive(:new).and_return(c1)
+    expect(Puppet::Confine.test(:false)).to receive(:new).and_return(c2)
 
     confiner = Puppet::ConfineCollection.new("label")
     confiner.confine :true => :bar, :false => :bee
@@ -100,32 +99,32 @@ describe Puppet::ConfineCollection do
 
     it "should add each test type's summary to the hash" do
       @confiner.confine :true => :bar, :false => :bee
-      Puppet::Confine.test(:true).expects(:summarize).returns :tsumm
-      Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
+      expect(Puppet::Confine.test(:true)).to receive(:summarize).and_return(:tsumm)
+      expect(Puppet::Confine.test(:false)).to receive(:summarize).and_return(:fsumm)
 
       expect(@confiner.summary).to eq({:true => :tsumm, :false => :fsumm})
     end
 
     it "should not include tests that return 0" do
       @confiner.confine :true => :bar, :false => :bee
-      Puppet::Confine.test(:true).expects(:summarize).returns 0
-      Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
+      expect(Puppet::Confine.test(:true)).to receive(:summarize).and_return(0)
+      expect(Puppet::Confine.test(:false)).to receive(:summarize).and_return(:fsumm)
 
       expect(@confiner.summary).to eq({:false => :fsumm})
     end
 
     it "should not include tests that return empty arrays" do
       @confiner.confine :true => :bar, :false => :bee
-      Puppet::Confine.test(:true).expects(:summarize).returns []
-      Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
+      expect(Puppet::Confine.test(:true)).to receive(:summarize).and_return([])
+      expect(Puppet::Confine.test(:false)).to receive(:summarize).and_return(:fsumm)
 
       expect(@confiner.summary).to eq({:false => :fsumm})
     end
 
     it "should not include tests that return empty hashes" do
       @confiner.confine :true => :bar, :false => :bee
-      Puppet::Confine.test(:true).expects(:summarize).returns({})
-      Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
+      expect(Puppet::Confine.test(:true)).to receive(:summarize).and_return({})
+      expect(Puppet::Confine.test(:false)).to receive(:summarize).and_return(:fsumm)
 
       expect(@confiner.summary).to eq({:false => :fsumm})
     end

data/spec/unit/confine_spec.rb

@@ -1,8 +1,13 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/confine'
 
+class Puppet::TestConfine < Puppet::Confine
+  def pass?(value)
+    false
+  end
+end
+
 describe Puppet::Confine do
   it "should require a value" do
     expect { Puppet::Confine.new }.to raise_error(ArgumentError)
@@ -34,44 +39,61 @@ describe Puppet::Confine do
 
   describe "when testing all values" do
     before do
-      @confine = Puppet::Confine.new(%w{a b c})
+      @confine = Puppet::TestConfine.new(%w{a b c})
       @confine.label = "foo"
     end
 
     it "should be invalid if any values fail" do
-      @confine.stubs(:pass?).returns true
-      @confine.expects(:pass?).with("b").returns false
+      allow(@confine).to receive(:pass?).and_return(true)
+      expect(@confine).to receive(:pass?).with("b").and_return(false)
       expect(@confine).not_to be_valid
     end
 
     it "should be valid if all values pass" do
-      @confine.stubs(:pass?).returns true
+      allow(@confine).to receive(:pass?).and_return(true)
       expect(@confine).to be_valid
     end
 
     it "should short-cut at the first failing value" do
-      @confine.expects(:pass?).once.returns false
+      expect(@confine).to receive(:pass?).once.and_return(false)
       @confine.valid?
     end
 
     it "should log failing confines with the label and message" do
-      @confine.stubs(:pass?).returns false
-      @confine.expects(:message).returns "My message"
-      @confine.expects(:label).returns "Mylabel"
-      Puppet.expects(:debug).with("Mylabel: My message")
+      Puppet[:log_level] = 'debug'
+      allow(@confine).to receive(:pass?).and_return(false)
+      expect(@confine).to receive(:message).and_return("My message")
+      expect(@confine).to receive(:label).and_return("Mylabel")
+      expect(Puppet).to receive(:debug) { |&b| expect(b.call).to eq("Mylabel: My message") }
       @confine.valid?
     end
   end
 
   describe "when testing the result of the values" do
-    before { @confine = Puppet::Confine.new(%w{a b c d}) }
+    before { @confine = Puppet::TestConfine.new(%w{a b c d}) }
 
     it "should return an array with the result of the test for each value" do
-      @confine.stubs(:pass?).returns true
-      @confine.expects(:pass?).with("b").returns false
-      @confine.expects(:pass?).with("d").returns false
+      allow(@confine).to receive(:pass?).and_return(true)
+      expect(@confine).to receive(:pass?).with("b").and_return(false)
+      expect(@confine).to receive(:pass?).with("d").and_return(false)
 
       expect(@confine.result).to eq([true, false, true, false])
     end
   end
+
+  describe "when requiring" do
+    it "does not cache failed requires when always_retry_plugins is true" do
+      Puppet[:always_retry_plugins] = true
+      expect(Puppet::Confine).to receive(:require).with('puppet/confine/osfamily').twice.and_raise(LoadError)
+      Puppet::Confine.test(:osfamily)
+      Puppet::Confine.test(:osfamily)
+    end
+
+    it "caches failed requires when always_retry_plugins is false" do
+      Puppet[:always_retry_plugins] = false
+      expect(Puppet::Confine).to receive(:require).with('puppet/confine/osfamily').once.and_raise(LoadError)
+      Puppet::Confine.test(:osfamily)
+      Puppet::Confine.test(:osfamily)
+    end
+  end
 end

data/spec/unit/confiner_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/confiner'
@@ -22,15 +21,15 @@ describe Puppet::Confiner do
   end
 
   it "should delegate its confine method to its confine collection" do
-    coll = mock 'collection'
-    @object.stubs(:confine_collection).returns coll
-    coll.expects(:confine).with(:foo => :bar, :bee => :baz)
+    coll = double('collection')
+    allow(@object).to receive(:confine_collection).and_return(coll)
+    expect(coll).to receive(:confine).with(:foo => :bar, :bee => :baz)
     @object.confine(:foo => :bar, :bee => :baz)
   end
 
   it "should create a new confine collection if one does not exist" do
-    Puppet::ConfineCollection.expects(:new).with("mylabel").returns "mycoll"
-    @object.expects(:to_s).returns "mylabel"
+    expect(Puppet::ConfineCollection).to receive(:new).with("mylabel").and_return("mycoll")
+    expect(@object).to receive(:to_s).and_return("mylabel")
     expect(@object.confine_collection).to eq("mycoll")
   end
 
@@ -40,22 +39,22 @@ describe Puppet::Confiner do
 
   describe "when testing suitability" do
     before do
-      @coll = mock 'collection'
-      @object.stubs(:confine_collection).returns @coll
+      @coll = double('collection')
+      allow(@object).to receive(:confine_collection).and_return(@coll)
     end
 
     it "should return true if the confine collection is valid" do
-      @coll.expects(:valid?).returns true
+      expect(@coll).to receive(:valid?).and_return(true)
       expect(@object).to be_suitable
     end
 
     it "should return false if the confine collection is invalid" do
-      @coll.expects(:valid?).returns false
+      expect(@coll).to receive(:valid?).and_return(false)
       expect(@object).not_to be_suitable
     end
 
     it "should return the summary of the confine collection if a long result is asked for" do
-      @coll.expects(:summary).returns "myresult"
+      expect(@coll).to receive(:summary).and_return("myresult")
       expect(@object.suitable?(false)).to eq("myresult")
     end
   end