rspec-puppet-utils 2.0.6 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA512: 
-  metadata.gz: 106fa2607e4f29ce28dee277ad33e57af9172a0950ff6d7e1603aced6853511a71dc826e56e9224865d8671437a1e531b6d64fc89f5551b5e7224a062988d88c
-  data.tar.gz: faa7027e9499454bf5ae605921f64356485385025b5da3b290bf2bb37cd48435237d42cbf8d185f99d56d5a17e2c9ad6d754c7e242b829e31dc52a2b9e9a9b61
 SHA1: 
-  metadata.gz: f268650abcc12899be821391c1c8442983cbecb8
-  data.tar.gz: 962eb0d4da79073e942b5e8000a34abf2b5eb491
+  metadata.gz: e9e1b2ce2d09e5a50fff68ae9cc3f1e7e639ec18
+  data.tar.gz: c8184a93084596ce109c344c438107a4914f4cfc
+SHA512: 
+  metadata.gz: e51385d1bdf52f5ade7292fc13cf3b58f27008db4db08ff9c4fb056af3d091042054b3b75737530f26bfbe7ed27d3c98149fa84137823ddb9635ae0ad01c4a77
+  data.tar.gz: 7aa2fe95f16d78ea0382451c6b9de02c3fb2286193f445d74a4c7df308da7d0d7bca6dfd935d334ecadbd8a2448202a0ad024dc9b80974aa3a82bfcf4250b712

data/README.md

@@ -8,6 +8,14 @@ See [release notes](../../wiki/Release-Notes) about latest version
 
 ### MockFunction
 
+#####Update:
+
+As of version 2.1.0 the `#stub` and `#expect` methods have been superseded by `#stubbed` and `#expected` so that you can use parameter matchers. The only difference in usage from previous versions is that the methods take a set of parameters rather than a single array (e.g. `f.expected.with(1, 2, 3)` instead of `f.expect.with([1, 2, 3])`)
+
+The change is backwards compatible so `#stub` and `#expect` are still available and function as before
+
+#####Usage:
+
 The basic usage is to create your mock function with `MockFunction.new` and then use `mocha` to stub any particular calls that you need
 
 ```ruby
@@ -16,14 +24,13 @@ require 'spec_helper'
 describe 'foo::bar' do
 
   let!(:add_stuff) { MockFunction.new('add_stuff') { |f|
-      f.stub.with([1, 2]).returns(3)
+      f.stubbed.with(1, 2).returns(3)
     }
   }
 
   it 'should do something with add_stuff' do
     # Specific stub for this test
-    add_stuff.stub.with([]).returns(nil)
-    ...
+    add_stuff.stubbed.with(2, 3).returns(5)
     ...
   end
 end
@@ -37,8 +44,8 @@ MockFunction.new('func', {:type => :statement})
 You can mock Hiera:
 ```ruby
 MockFunction.new('hiera') { |f|
-  f.stub.with(['non-ex']).raises(Puppet::ParseError.new('Key not found'))
-  f.stub.with(['db-password']).returns('password1')
+  f.stubbed.with('non-ex').raises(Puppet::ParseError.new('Key not found'))
+  f.stubbed.with('db-password').returns('password1')
 }
 ```
 You handle when the functions are created yourself, e.g. you can assign it to a local variable `func = MockFunction...` create it in a before block `before(:each) do MockFunction... end` or use let `let!(:func) { MockFunction... }`
@@ -48,15 +55,15 @@ If you use let, **use `let!()` and not `let()`**, this is because lets are lazy-
 Also if you use `let` when mocking hiera, **you can't use `:hiera` as the name due to conflicts** so you have to do something like `let!(:mock_hiera) { MockFunction.new('hiera') }`
 
 #####Mocha stubs and expects:
-`f.stub` and `f.expect` are helper methods for `f.stubs(:call)` and `f.expects(:call)`
+`f.stubbed` and `f.expected` are helper methods for `f.stubs(:execute)` and `f.expects(:execute)`
 
-Internally `#expect` will clear the rspec-puppet catalog cache. This is because rspec-puppet will only re-compile the catalog for a test if `:title`, `:params`, or `:facts` are changed. This means that if you setup an expectaion in a test, it might not be satisfied because the catalog was already compiled for a previous test, and so the functions weren't called!
+Internally `#expected` will clear the rspec-puppet catalog cache. This is because rspec-puppet will only re-compile the catalog for a test if `:title`, `:params`, or `:facts` are changed. This means that if you setup an expectaion in a test, it might not be satisfied because the catalog was already compiled for a previous test, and so the functions weren't called!
 
-Clearing the cache ensures tests aren't coupled and order dependent. The downside is that the catalog isn't cached and has to be re-compiled which slows down your tests. If you're concerned about performance and you are explicitly changing `:title`, `:params`, or `:facts` for a test, you can keep the cache intact with `f.expect(:keep_cache)`
+Clearing the cache ensures tests aren't coupled and order dependent. The downside is that the catalog isn't cached and has to be re-compiled which slows down your tests. If you're concerned about performance and you are explicitly changing `:title`, `:params`, or `:facts` for a test, you can keep the cache intact with `f.expected(:keep_cache)`
 
 #####Notes:
-- You always stub the `call` method as that gets called internally
-- The `call` method takes an array of arguments
+- You always stub the `execute` method as that gets called internally
+- The `execute` method takes a set of arguments instead of an array of arguments
 
 ### TemplateHarness
 

data/Rakefile

@@ -1,6 +1,6 @@
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
-RSpec::Core::RakeTask.new(:rspec)
+RSpec::Core::RakeTask.new(:spec)
 
-task :build => :rspec
+task :build => :spec

data/lib/mock_function.rb

@@ -16,22 +16,33 @@ module RSpecPuppetUtils
     def initialize(name, options = {})
       parse_options! options
       this = self
-      Puppet::Parser::Functions.newfunction(name.to_sym, options) { |args| this.call args}
+      Puppet::Parser::Functions.newfunction(name.to_sym, options) { |args| this.call args }
       yield self if block_given?
+    end
 
-      if options[:type] == :statement
-        # call is called on statement function incase expects(:call) is needed
-        # The method is defined incase expects(:call) isn't used
-        def this.call args
-          args
-        end
-      end
+    def call(args)
+      execute *args
+    end
+
+    def execute(*args)
+      args
+    end
+
+    def stubbed
+      self.stubs(:execute)
+    end
+
+    def expected(*args)
+      RSpec::Puppet::Support.clear_cache unless args.include? :keep_cache
+      self.expects(:execute)
     end
 
+    # Use stubbed instead, see readme
     def stub
       self.stubs(:call)
     end
 
+    # Use expected instead, see readme
     def expect(*args)
       RSpec::Puppet::Support.clear_cache unless args.include? :keep_cache
       self.expects(:call)

data/rspec-puppet-utils.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |gem|
   gem.name          = 'rspec-puppet-utils'
-  gem.version       = '2.0.6'
+  gem.version       = '2.1.0'
   gem.description   = 'Helper classes for mock/stub functions, templates and hierdata'
   gem.summary       = ''
   gem.author        = 'Tom Poulton'

data/spec/classes/mock_function_spec.rb

@@ -14,39 +14,39 @@ describe MockFunction do
     func_name = 'my_func'
     func_sym  = func_name.to_sym
 
-    it 'should add new function to puppet' do
+    it 'adds new function to puppet' do
       name = 'mock_func'
       func = MockFunction.new name
       expect(Puppet::Parser::Functions.function(name.to_sym)).to eq "function_#{name}"
     end
 
-    it 'should default to :rvalue type' do
+    it 'defaults to :rvalue type' do
       func = MockFunction.new func_name
       expect(Puppet::Parser::Functions.rvalue?(func_sym)).to eq true
     end
 
-    it 'should default to :rvalue type if missing from options' do
+    it 'defaults to :rvalue type if missing from options' do
       func = MockFunction.new func_name, {}
       expect(Puppet::Parser::Functions.rvalue?(func_sym)).to eq true
     end
 
-    it 'should allow type to be set' do
+    it 'allows type to be set' do
       func = MockFunction.new func_name, {:type => :statement}
       expect(Puppet::Parser::Functions.rvalue?(func_sym)).to eq false
     end
 
-    it 'should only allow :rvalue or :statement for type' do
+    it 'only allows :rvalue or :statement for type' do
       expect {
         MockFunction.new func_name, {:type => :error}
       }.to raise_error ArgumentError, 'Type should be :rvalue or :statement, not error'
     end
 
-    it 'should allow arity to be set' do
+    it 'allows arity to be set' do
       func = MockFunction.new func_name, {:arity => 3}
       expect(Puppet::Parser::Functions.arity(func_sym)).to eq 3
     end
 
-    it 'should only allow arity to be an integer' do
+    it 'only allows arity to be an integer' do
       expect {
         MockFunction.new func_name, {:arity => 'oops'}
       }.to raise_error ArgumentError, 'arity should be an integer'
@@ -58,33 +58,80 @@ describe MockFunction do
 
     let(:func) { MockFunction.new('func') }
 
-    it 'should not be defined by default' do
-      expect(func.respond_to?(:call)).to eq false
-    end
-
-    it 'should be stubable' do
+    it 'is stubable' do
       func.stubs(:call)
       expect(func.respond_to?(:call)).to eq true
     end
 
-    it 'should be called by puppet function' do
+    it 'is called by puppet function' do
       func.stubs(:call).returns('penguin')
       result = scope.function_func []
       expect(result).to eq 'penguin'
     end
 
-    it 'should be passed puppet function args' do
+    it 'is passed puppet function args' do
       func.expects(:call).with([1, 2, 3]).once
       scope.function_func [1, 2, 3]
     end
 
+    it 'passes function args to execute method' do
+      func.expects(:execute).with(1, 2, 3)
+      func.call [1, 2, 3]
+    end
+
+  end
+
+  describe '#stubbed' do
+
+    let(:func) { MockFunction.new('func') }
+
+    it 'stubs #execute' do
+      expectation = func.stubbed
+      expect(expectation).to be_a Mocha::Expectation
+      expect(expectation.matches_method? :execute).to eq true
+    end
+
+  end
+
+  describe '#expected' do
+
+    let(:func) { MockFunction.new('func') }
+
+    it 'registers expect on #execute' do
+      expectation = func.expected
+      expect(expectation).to be_a Mocha::Expectation
+      expect(expectation.matches_method? :execute).to eq true
+      func.execute # satisfy the expect we just created on #execute!
+    end
+
+    it 'clears rspec puppet cache' do
+      RSpec::Puppet::Support.expects(:clear_cache).once
+      func.expected
+      func.execute # satisfy the expect we just created on #execute!
+    end
+
+    it 'works with parameter matchers' do
+      func.expected.with(regexp_matches(/thing/), anything)
+      scope.function_func ['something', 1234]
+    end
+
+    context 'when :keep_cache is set' do
+
+      it 'does not clear rspec puppet cache' do
+        RSpec::Puppet::Support.expects(:clear_cache).never
+        func.expected(:keep_cache)
+        func.execute # satisfy the expect we just created on #execute!
+      end
+
+    end
+
   end
 
   describe '#stub' do
 
     let(:func) { MockFunction.new('func') }
 
-    it 'should stub #call' do
+    it 'stubs #call' do
       expectation = func.stub
       expect(expectation).to be_a Mocha::Expectation
       expect(expectation.matches_method? :call).to eq true
@@ -96,14 +143,14 @@ describe MockFunction do
 
     let(:func) { MockFunction.new('func') }
 
-    it 'should register expect on #call' do
+    it 'registers expect on #call' do
       expectation = func.expect
       expect(expectation).to be_a Mocha::Expectation
       expect(expectation.matches_method? :call).to eq true
       func.call [nil] # satisfy the expect we just created on #call!
     end
 
-    it 'should clear rspec puppet cache' do
+    it 'clears rspec puppet cache' do
       RSpec::Puppet::Support.expects(:clear_cache).once
       func.expect
       func.call [nil] # satisfy the expect we just created on #call!
@@ -111,7 +158,7 @@ describe MockFunction do
 
     context 'when :keep_cache is set' do
 
-      it 'should not clear rspec puppet cache' do
+      it 'does not clear rspec puppet cache' do
         RSpec::Puppet::Support.expects(:clear_cache).never
         func.expect(:keep_cache)
         func.call [nil] # satisfy the expect we just created on #call!
@@ -125,13 +172,13 @@ describe MockFunction do
 
     let!(:statement) { MockFunction.new 'statement', {:type => :statement} }
 
-    it 'should not raise error' do
+    it 'does not raise error' do
       expect {
         scope.function_statement []
       }.to_not raise_error
     end
 
-    it 'should respond to #call' do
+    it 'responds to #call' do
       expect(statement.respond_to? :call).to eq true
     end
 
@@ -139,13 +186,13 @@ describe MockFunction do
 
   context 'when :type => :rvalue' do
 
-    it 'should allow setup stubs' do
+    it 'allows setup stubs' do
       func = MockFunction.new('func') { |f| f.stubs(:call).returns('badger') }
       result = func.call
       expect(result).to eq 'badger'
     end
 
-    it 'should return values defined by a "let"' do
+    it 'returns values defined by a "let"' do
       result = []
       expect {
         func = MockFunction.new('func') { |f| f.stubs(:call).returns(values_from_let) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rspec-puppet-utils
 version: !ruby/object:Gem::Version 
-  version: 2.0.6
+  version: 2.1.0
 platform: ruby
 authors: 
 - Tom Poulton
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2015-01-16 00:00:00 Z
+date: 2015-07-28 00:00:00 Z
 dependencies: []
 
 description: Helper classes for mock/stub functions, templates and hierdata