puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/confine/exists_spec.rb

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

data/spec/unit/confine/feature_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/confine/feature'
@@ -22,7 +23,7 @@ describe Puppet::Confine::Feature do
     end
 
     it "should use the Puppet features instance to test validity" do
-      expect(Puppet.features).to receive(:myfeature?)
+      Puppet.features.expects(:myfeature?)
       @confine.valid?
     end
 
@@ -47,12 +48,9 @@ describe Puppet::Confine::Feature do
     confines << Puppet::Confine::Feature.new(%w{two})
     confines << Puppet::Confine::Feature.new(%w{three four})
 
-    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)
+    features = mock 'feature'
+    features.stub_everything
+    Puppet.stubs(:features).returns 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,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/confine/true'
@@ -11,33 +12,6 @@ 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")
@@ -45,7 +19,7 @@ describe Puppet::Confine::True do
     end
 
     it "should use the 'pass?' method to test validity" do
-      expect(@confine).to receive(:pass?).with("foo")
+      @confine.expects(:pass?).with("foo")
       @confine.valid?
     end
 
@@ -64,14 +38,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}
-    expect(@confine).to receive(:pass?).exactly(4).times.and_return(true, false, true, false)
+    @confine.expects(:pass?).times(4).returns(true).returns(false).returns(true).returns(false)
     expect(@confine.summary).to eq(2)
   end
 
   it "should summarize multiple instances by summing their summaries" do
-    c1 = double('1', :summary => 1)
-    c2 = double('2', :summary => 2)
-    c3 = double('3', :summary => 3)
+    c1 = mock '1', :summary => 1
+    c2 = mock '2', :summary => 2
+    c3 = mock '3', :summary => 3
 
     expect(Puppet::Confine::True.summarize([c1, c2, c3])).to eq(6)
   end

data/spec/unit/confine/variable_spec.rb

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

data/spec/unit/confine_collection_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/confine_collection'
@@ -17,20 +18,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 = 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)
+      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
 
       Puppet::ConfineCollection.new("label").confine :foo => %w{my values}
     end
 
     it "should copy its label to the confine instance" do
-      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 = mock 'confine'
+      test_class = mock 'test_class'
+      test_class.expects(:new).returns confine
+      Puppet::Confine.expects(:test).returns test_class
 
-      expect(confine).to receive(:label=).with("label")
+      confine.expects(:label=).with("label")
 
       Puppet::ConfineCollection.new("label").confine :foo => %w{my values}
     end
@@ -38,8 +39,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})
-        expect(confine).to receive(:name=).with(:foo)
-        expect(confine.class).to receive(:new).with(%w{my values}).and_return(confine)
+        confine.expects(:name=).with(:foo)
+        confine.class.expects(:new).with(%w{my values}).returns confine
         Puppet::ConfineCollection.new("label").confine(:foo => %w{my values})
       end
     end
@@ -47,8 +48,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)
-        expect(confine).to receive(:for_binary=).with(true)
-        expect(Puppet::Confine.test(:exists)).to receive(:new).with(:bar).and_return(confine)
+        confine.expects(:for_binary=).with true
+        Puppet::Confine.test(:exists).expects(:new).with(:bar).returns confine
         Puppet::ConfineCollection.new("label").confine :exists => :bar, :for_binary => true
       end
     end
@@ -59,11 +60,11 @@ describe Puppet::ConfineCollection do
   end
 
   it "should be valid if all confines pass" do
-    c1 = double('c1', :valid? => true, :label= => nil)
-    c2 = double('c2', :valid? => true, :label= => nil)
+    c1 = stub 'c1', :valid? => true, :label= => nil
+    c2 = stub 'c2', :valid? => true, :label= => nil
 
-    expect(Puppet::Confine.test(:true)).to receive(:new).and_return(c1)
-    expect(Puppet::Confine.test(:false)).to receive(:new).and_return(c2)
+    Puppet::Confine.test(:true).expects(:new).returns(c1)
+    Puppet::Confine.test(:false).expects(:new).returns(c2)
 
     confiner = Puppet::ConfineCollection.new("label")
     confiner.confine :true => :bar, :false => :bee
@@ -72,11 +73,11 @@ describe Puppet::ConfineCollection do
   end
 
   it "should not be valid if any confines fail" do
-    c1 = double('c1', :valid? => true, :label= => nil)
-    c2 = double('c2', :valid? => false, :label= => nil)
+    c1 = stub 'c1', :valid? => true, :label= => nil
+    c2 = stub 'c2', :valid? => false, :label= => nil
 
-    expect(Puppet::Confine.test(:true)).to receive(:new).and_return(c1)
-    expect(Puppet::Confine.test(:false)).to receive(:new).and_return(c2)
+    Puppet::Confine.test(:true).expects(:new).returns(c1)
+    Puppet::Confine.test(:false).expects(:new).returns(c2)
 
     confiner = Puppet::ConfineCollection.new("label")
     confiner.confine :true => :bar, :false => :bee
@@ -99,32 +100,32 @@ describe Puppet::ConfineCollection do
 
     it "should add each test type's summary to the hash" do
       @confiner.confine :true => :bar, :false => :bee
-      expect(Puppet::Confine.test(:true)).to receive(:summarize).and_return(:tsumm)
-      expect(Puppet::Confine.test(:false)).to receive(:summarize).and_return(:fsumm)
+      Puppet::Confine.test(:true).expects(:summarize).returns :tsumm
+      Puppet::Confine.test(:false).expects(:summarize).returns :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
-      expect(Puppet::Confine.test(:true)).to receive(:summarize).and_return(0)
-      expect(Puppet::Confine.test(:false)).to receive(:summarize).and_return(:fsumm)
+      Puppet::Confine.test(:true).expects(:summarize).returns 0
+      Puppet::Confine.test(:false).expects(:summarize).returns :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
-      expect(Puppet::Confine.test(:true)).to receive(:summarize).and_return([])
-      expect(Puppet::Confine.test(:false)).to receive(:summarize).and_return(:fsumm)
+      Puppet::Confine.test(:true).expects(:summarize).returns []
+      Puppet::Confine.test(:false).expects(:summarize).returns :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
-      expect(Puppet::Confine.test(:true)).to receive(:summarize).and_return({})
-      expect(Puppet::Confine.test(:false)).to receive(:summarize).and_return(:fsumm)
+      Puppet::Confine.test(:true).expects(:summarize).returns({})
+      Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
 
       expect(@confiner.summary).to eq({:false => :fsumm})
     end