rspec-puppet 2.11.1 → 3.0.0.rc.1

data/lib/rspec-puppet/matchers/create_generic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 require 'rspec-puppet/matchers/parameter_matcher'
 
@@ -22,21 +24,21 @@ module RSpec::Puppet
         @befores = []
       end
 
-      def with(*args, &block)
+      def with(*args)
         params = args.shift
-        @expected_params = @expected_params | params.to_a
+        @expected_params |= params.to_a
         self
       end
 
       def only_with(*args, &block)
         params = args.shift
-        @expected_params_count = (@expected_params_count || 0) + params.select { |_, v| !v.nil? }.size
-        self.with(params, &block)
+        @expected_params_count = (@expected_params_count || 0) + params.compact.size
+        with(params, &block)
       end
 
-      def without(*args, &block)
+      def without(*args)
         params = args.shift
-        @expected_undef_params = @expected_undef_params | Array(params)
+        @expected_undef_params |= Array(params)
         self
       end
 
@@ -61,16 +63,17 @@ module RSpec::Puppet
       end
 
       def method_missing(method, *args, &block)
-        if method.to_s =~ /^with_/
+        case method.to_s
+        when /^with_/
           param = method.to_s.gsub(/^with_/, '')
           @expected_params << [param, args[0]]
           self
-        elsif method.to_s =~ /^only_with_/
+        when /^only_with_/
           param = method.to_s.gsub(/^only_with_/, '')
           @expected_params_count = (@expected_params_count || 0) + 1
           @expected_params << [param, args[0]]
           self
-        elsif method.to_s =~ /^without_/
+        when /^without_/
           param = method.to_s.gsub(/^without_/, '')
           @expected_undef_params << [param, args[0]]
           self
@@ -95,21 +98,19 @@ module RSpec::Puppet
             end
           end
 
-          if resource.builtin_type?
-            namevar = resource.resource_type.key_attributes.first.to_s
-          else
-            namevar = 'name'
-          end
+          namevar = if resource.builtin_type?
+                      resource.resource_type.key_attributes.first.to_s
+                    else
+                      'name'
+                    end
 
-          unless @expected_params.any? { |param| param.first.to_s == namevar }
-            rsrc_hsh.delete(namevar.to_sym) if rsrc_hsh.has_key?(namevar.to_sym)
+          if @expected_params.none? { |param| param.first.to_s == namevar } && rsrc_hsh.key?(namevar.to_sym)
+            rsrc_hsh.delete(namevar.to_sym)
           end
 
-          if @expected_params_count
-            unless rsrc_hsh.size == @expected_params_count
-              ret = false
-              (@errors ||= []) << "exactly #{@expected_params_count} parameters but the catalogue contains #{rsrc_hsh.size}"
-            end
+          if @expected_params_count && rsrc_hsh.size != @expected_params_count
+            ret = false
+            (@errors ||= []) << "exactly #{@expected_params_count} parameters but the catalogue contains #{rsrc_hsh.size}"
           end
 
           check_params(rsrc_hsh, @expected_params, :should) if @expected_params.any?
@@ -133,46 +134,40 @@ module RSpec::Puppet
 
       def description
         values = []
-        value_str_prefix = "with"
+        value_str_prefix = 'with'
 
-        if @expected_params_count
-          values << "exactly #{@expected_params_count} parameters"
-        end
+        values << "exactly #{@expected_params_count} parameters" if @expected_params_count
 
-        if @expected_params.any?
-          values.concat(generate_param_list(@expected_params, :should))
-        end
+        values.concat(generate_param_list(@expected_params, :should)) if @expected_params.any?
 
-        if @expected_undef_params.any?
-          values.concat(generate_param_list(@expected_undef_params, :not))
-        end
+        values.concat(generate_param_list(@expected_undef_params, :not)) if @expected_undef_params.any?
 
         if @notifies.any?
-          value_str_prefix = "that notifies"
+          value_str_prefix = 'that notifies'
           values = @notifies
         end
 
         if @subscribes.any?
-          value_str_prefix = "that subscribes to"
+          value_str_prefix = 'that subscribes to'
           values = @subscribes
         end
 
         if @requires.any?
-          value_str_prefix = "that requires"
+          value_str_prefix = 'that requires'
           values = @requires
         end
 
         if @befores.any?
-          value_str_prefix = "that comes before"
+          value_str_prefix = 'that comes before'
           values = @befores
         end
 
         unless values.empty?
-          if values.length == 1
-            value_str = " #{value_str_prefix} #{values.first}"
-          else
-            value_str = " #{value_str_prefix} #{values[0..-2].join(", ")} and #{values[-1]}"
-          end
+          value_str = if values.length == 1
+                        " #{value_str_prefix} #{values.first}"
+                      else
+                        " #{value_str_prefix} #{values[0..-2].join(', ')} and #{values[-1]}"
+                      end
         end
 
         "contain #{@referenced_type}[#{@title}]#{value_str}"
@@ -191,41 +186,42 @@ module RSpec::Puppet
       end
 
       def expected
-        @errors.map {|e| e.expected if e.respond_to?(:expected)}.compact.join("\n\n")
+        @errors.filter_map { |e| e.expected if e.respond_to?(:expected) }.join("\n\n")
       end
 
       def actual
-        @errors.map {|e| e.actual if e.respond_to?(:actual)}.compact.join("\n\n")
+        @errors.filter_map { |e| e.actual if e.respond_to?(:actual) }.join("\n\n")
       end
 
       private
+
       def referenced_type(type)
-        type.split('__').map { |r| r.capitalize }.join('::')
+        type.split('__').map(&:capitalize).join('::')
       end
 
       def errors
-        @errors.empty? ? "" : " with #{@errors.join(', and parameter ')}"
+        @errors.empty? ? '' : " with #{@errors.join(', and parameter ')}"
       end
 
       def generate_param_list(list, type)
         output = []
         list.each do |param, value|
           if value.nil?
-            output << "#{param.to_s} #{type == :not ? 'un' : ''}defined"
+            output << "#{param} #{type == :not ? 'un' : ''}defined"
           else
             a = type == :not ? '!' : '='
             b = value.is_a?(Regexp) ? '~' : '>'
-            if param.to_s == 'content' and value.is_a?( String )
-              output << "#{param.to_s} #{type == :not ? 'not ' : ''} supplied string"
-            else
-              output << "#{param.to_s} #{a}#{b} #{value.inspect}"
-            end
+            output << if (param.to_s == 'content') && value.is_a?(String)
+                        "#{param} #{type == :not ? 'not ' : ''} supplied string"
+                      else
+                        "#{param} #{a}#{b} #{value.inspect}"
+                      end
           end
         end
         output
       end
 
-      def check_befores(catalogue, resource)
+      def check_befores(_catalogue, resource)
         @befores.each do |ref|
           unless precedes?(resource, canonicalize_resource(ref))
             @errors << BeforeRelationshipError.new(resource.to_ref, ref)
@@ -233,7 +229,7 @@ module RSpec::Puppet
         end
       end
 
-      def check_requires(catalogue, resource)
+      def check_requires(_catalogue, resource)
         @requires.each do |ref|
           unless precedes?(canonicalize_resource(ref), resource)
             @errors << RequireRelationshipError.new(resource.to_ref, ref)
@@ -241,7 +237,7 @@ module RSpec::Puppet
         end
       end
 
-      def check_notifies(catalogue, resource)
+      def check_notifies(_catalogue, resource)
         @notifies.each do |ref|
           unless notifies?(resource, canonicalize_resource(ref))
             @errors << NotifyRelationshipError.new(resource.to_ref, ref)
@@ -249,7 +245,7 @@ module RSpec::Puppet
         end
       end
 
-      def check_subscribes(catalogue, resource)
+      def check_subscribes(_catalogue, resource)
         @subscribes.each do |ref|
           unless notifies?(canonicalize_resource(ref), resource)
             @errors << SubscribeRelationshipError.new(resource.to_ref, ref)
@@ -269,13 +265,13 @@ module RSpec::Puppet
         res = resource_from_ref(resource_ref(resource))
         if res.nil?
           resource = Struct.new(:type, :title).new(*@catalogue.title_key_for_ref(resource)) if resource.is_a?(String)
-          res = @catalogue.resource_keys.select { |type, name|
+          res = @catalogue.resource_keys.select do |type, _name|
             type == resource.type
-          }.map { |type, name|
+          end.filter_map do |type, name|
             @catalogue.resource(type, name)
-          }.compact.find { |cat_res|
+          end.find do |cat_res|
             cat_res.builtin_type? && cat_res.uniqueness_key.first == resource.title
-          }
+          end
         end
         res
       end
@@ -290,31 +286,31 @@ module RSpec::Puppet
         return results unless resource
 
         # guard to prevent infinite recursion
-        if visited.include?(resource.object_id)
-          return [canonicalize_resource_ref(resource)]
-        else
-          visited << resource.object_id
-        end
+        return [canonicalize_resource_ref(resource)] if visited.include?(resource.object_id)
+
+        visited << resource.object_id
 
         Array[resource[type]].flatten.compact.each do |r|
           results << canonicalize_resource_ref(r)
           results << relationship_refs(r, type, visited)
 
           res = canonicalize_resource(r)
-          if res && res.builtin_type?
+          if res&.builtin_type?
             results << res.to_ref
             results << "#{res.type.to_s.capitalize}[#{res.uniqueness_key.first}]"
           end
         end
 
         # Add auto* (autorequire etc) if any
-        if [:before, :notify, :require, :subscribe].include?(type)
+        if %i[before notify require subscribe].include?(type)
           func = "eachauto#{type}".to_sym
           if resource.resource_type.respond_to?(func)
             resource.resource_type.send(func) do |t, b|
               Array(resource.to_ral.instance_eval(&b)).each do |dep|
+                next if dep.nil?
+
                 res = "#{t.to_s.capitalize}[#{dep}]"
-                if r = relationship_refs(res, type, visited)
+                if (r = relationship_refs(res, type, visited))
                   results << res
                   results << r
                 end
@@ -345,7 +341,7 @@ module RSpec::Puppet
         end
 
         # Nothing found
-        return false
+        false
       end
 
       def notifies?(first, second)
@@ -356,14 +352,12 @@ module RSpec::Puppet
             notify_refs = relationship_refs(u, :notify)
             subscribe_refs = relationship_refs(v, :subscribe)
 
-            if notify_refs.include?(v.to_ref) || subscribe_refs.include?(u.to_ref)
-              return true
-            end
+            return true if notify_refs.include?(v.to_ref) || subscribe_refs.include?(u.to_ref)
           end
         end
 
         # Nothing found
-        return false
+        false
       end
 
       # @param resource [Hash<Symbol, Object>] The resource in the catalog
@@ -373,15 +367,11 @@ module RSpec::Puppet
         list.each do |param, value|
           param = param.to_sym
 
-          if value.nil? then
-            unless resource[param].nil?
-              @errors << "#{param} undefined but it is set to #{resource[param].inspect}"
-            end
+          if value.nil?
+            @errors << "#{param} undefined but it is set to #{resource[param].inspect}" unless resource[param].nil?
           else
             m = ParameterMatcher.new(param, value, type)
-            unless m.matches?(resource)
-              @errors.concat m.errors
-            end
+            @errors.concat m.errors unless m.matches?(resource)
           end
         end
       end

data/lib/rspec-puppet/matchers/dynamic_matchers.rb

@@ -1,9 +1,18 @@
+# frozen_string_literal: true
+
 module RSpec::Puppet
   module ManifestMatchers
     def method_missing(method, *args, &block)
-      return RSpec::Puppet::ManifestMatchers::CreateGeneric.new(method, *args, &block) if method.to_s =~ /^(create|contain)_/
-      return RSpec::Puppet::ManifestMatchers::CountGeneric.new(nil, args[0], method) if method.to_s =~ /^have_.+_count$/
+      if /^(create|contain)_/.match?(method.to_s)
+        return RSpec::Puppet::ManifestMatchers::CreateGeneric.new(method, *args,
+                                                                  &block)
+      end
+      if /^have_.+_count$/.match?(method.to_s)
+        return RSpec::Puppet::ManifestMatchers::CountGeneric.new(nil, args[0],
+                                                                 method)
+      end
       return RSpec::Puppet::ManifestMatchers::Compile.new if method == :compile
+
       super
     end
   end
@@ -11,6 +20,7 @@ module RSpec::Puppet
   module FunctionMatchers
     def method_missing(method, *args, &block)
       return RSpec::Puppet::FunctionMatchers::Run.new if method == :run
+
       super
     end
   end
@@ -18,6 +28,7 @@ module RSpec::Puppet
   module TypeMatchers
     def method_missing(method, *args, &block)
       return RSpec::Puppet::TypeMatchers::CreateGeneric.new(method, *args, &block) if method == :be_valid_type
+
       super
     end
   end

data/lib/rspec-puppet/matchers/include_class.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module RSpec::Puppet
   module ManifestMatchers
     extend RSpec::Matchers::DSL
 
     matcher :include_class do |expected_class|
       match do |catalogue|
-        RSpec.deprecate('include_class()', :replacement => 'contain_class()')
+        RSpec.deprecate('include_class()', replacement: 'contain_class()')
         catalogue.call.classes.include?(expected_class)
       end
 
@@ -13,11 +15,11 @@ module RSpec::Puppet
       end
 
       if RSpec::Version::STRING < '3'
-        failure_message_for_should do |actual|
+        failure_message_for_should do |_actual|
           "expected that the catalogue would include Class[#{expected_class}]"
         end
       else
-        failure_message do |actual|
+        failure_message do |_actual|
           "expected that the catalogue would include Class[#{expected_class}]"
         end
       end
@@ -30,6 +32,5 @@ module RSpec::Puppet
         true
       end
     end
-
   end
 end

data/lib/rspec-puppet/matchers/parameter_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec::Puppet
   module ManifestMatchers
     class ParameterMatcher
@@ -7,7 +9,9 @@ module RSpec::Puppet
       # @param value [Object] The expected data to match the parameter against
       # @param type [:should, :not] Whether the given parameter should match
       def initialize(parameter, value, type)
-        @parameter, @value, @type = parameter, value, type
+        @parameter = parameter
+        @value = value
+        @type = type
 
         @should_match = (type == :should)
 
@@ -31,9 +35,7 @@ module RSpec::Puppet
 
         retval = check(expected, actual)
 
-        unless retval
-          @errors << MatchError.new(@parameter, expected, actual, !@should_match)
-        end
+        @errors << MatchError.new(@parameter, expected, actual, !@should_match) unless retval
 
         retval
       end
@@ -53,6 +55,7 @@ module RSpec::Puppet
       # @return [true, false] If the resource matched
       def check(expected, actual)
         return false if !expected.is_a?(Proc) && actual.nil? && !expected.nil?
+
         case expected
         when Proc
           check_proc(expected, actual)
@@ -84,16 +87,14 @@ module RSpec::Puppet
       # key in the expected hash, there's a stringified key in the actual hash
       # with a matching value.
       def check_hash(expected, actual)
-        op = @should_match ? :"==" : :"!="
+        op = @should_match ? :'==' : :'!='
 
         unless actual.class.send(op, expected.class)
           @errors << MatchError.new(@parameter, expected, actual, !@should_match)
           return false
         end
 
-        unless expected.keys.size.send(op, actual.keys.size)
-          return false
-        end
+        return false unless expected.keys.size.send(op, actual.keys.size)
 
         expected.keys.all? do |key|
           check(expected[key], actual[key])
@@ -101,16 +102,14 @@ module RSpec::Puppet
       end
 
       def check_array(expected, actual)
-        op = @should_match ? :"==" : :"!="
+        op = @should_match ? :'==' : :'!='
 
         unless actual.class.send(op, expected.class)
           @errors << MatchError.new(@parameter, expected, actual, !@should_match)
           return false
         end
 
-        unless expected.size.send(op, actual.size)
-          return false
-        end
+        return false unless expected.size.send(op, actual.size)
 
         (0...expected.size).all? do |index|
           check(expected[index], actual[index])

data/lib/rspec-puppet/matchers/raise_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec::Puppet
   module GenericMatchers
     # Due to significant code base depending on the
@@ -16,7 +18,9 @@ module RSpec::Puppet
       end
     end
 
-    def raise_error(error=defined?(RSpec::Matchers::BuiltIn::RaiseError::UndefinedValue) ? RSpec::Matchers::BuiltIn::RaiseError::UndefinedValue : nil, message=nil, &block)
+    def raise_error(
+      error = defined?(RSpec::Matchers::BuiltIn::RaiseError::UndefinedValue) ? RSpec::Matchers::BuiltIn::RaiseError::UndefinedValue : nil, message = nil, &block
+    )
       RaiseError.new(error, message, &block)
     end
   end

data/lib/rspec-puppet/matchers/run.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec::Puppet
   module FunctionMatchers
     class Run
@@ -15,32 +17,33 @@ module RSpec::Puppet
 
         if @has_expected_error
           if @has_returned
-            return false
+            false
           elsif @actual_error.is_a?(@expected_error)
             case @expected_error_message
             when nil
-              return true
+              true
             when Regexp
-              return !!(@actual_error.message =~ @expected_error_message)
+              !(@actual_error.message =~ @expected_error_message).nil?
             else
-              return @actual_error.message == @expected_error_message
+              @actual_error.message == @expected_error_message
             end
           else # error did not match
-            return false
+            false
           end
         elsif @has_expected_return
-          if !@has_returned
-            return false
+          return false unless @has_returned
+
+          case @expected_return
+          when Regexp
+            !(@actual_return =~ @expected_return).nil?
+          when RSpec::Mocks::ArgumentMatchers::KindOf, RSpec::Matchers::AliasedMatcher
+            @expected_return === @actual_return
           else
-            case @expected_return
-            when Regexp
-              return !!(@actual_return =~ @expected_return)
-            else
-              return @actual_return == @expected_return
-            end
+            @actual_return == @expected_return
           end
+
         else
-          return @has_returned
+          @has_returned
         end
       end
 
@@ -60,30 +63,30 @@ module RSpec::Puppet
       def and_return(value)
         @has_expected_return = true
         @expected_return = value
-        if value.is_a? Regexp
-          @desc = "match #{value.inspect}"
-        else
-          @desc = "return #{value.inspect}"
-        end
+        @desc = if value.is_a? Regexp
+                  "match #{value.inspect}"
+                else
+                  "return #{value.inspect}"
+                end
         self
       end
 
-      def and_raise_error(error_or_message, message=nil)
+      def and_raise_error(error_or_message, message = nil)
         @has_expected_error = true
         case error_or_message
         when String, Regexp
-          @expected_error, @expected_error_message = Exception, error_or_message
+          @expected_error = Exception
+          @expected_error_message = error_or_message
         else
-          @expected_error, @expected_error_message = error_or_message, message
+          @expected_error = error_or_message
+          @expected_error_message = message
         end
 
         if @expected_error_message.is_a? Regexp
           @desc = "raise an #{@expected_error} with the message matching #{@expected_error_message.inspect}"
         else
           @desc = "raise an #{@expected_error}"
-          unless @expected_error_message.nil?
-            @desc += "with the message #{@expected_error_message.inspect}"
-          end
+          @desc += "with the message #{@expected_error_message.inspect}" unless @expected_error_message.nil?
         end
         self
       end
@@ -113,6 +116,7 @@ module RSpec::Puppet
       end
 
       private
+
       def func_name
         @func_obj.func_name
       end
@@ -130,30 +134,25 @@ module RSpec::Puppet
           else
             " instead of #{@actual_error.class.inspect}(#{@actual_error})\n#{@actual_error.backtrace.join("\n")}"
           end
-        else # function has returned
-          if @has_expected_error
-            " instead of returning #{@actual_return.inspect}"
-          else
-            " instead of #{@actual_return.inspect}"
-          end
+        elsif @has_expected_error # function has returned
+          " instead of returning #{@actual_return.inspect}"
+        else
+          " instead of #{@actual_return.inspect}"
         end
       end
 
-      def failure_message_generic(type, func_obj)
-        message = "expected #{func_name}(#{func_params}) to "
-        message << "not " if type == :should_not
+      def failure_message_generic(type, _func_obj)
+        # message is mutable
+        message = +"expected #{func_name}(#{func_params}) to "
+        message << 'not ' if type == :should_not
 
         if @has_expected_return
           message << "have returned #{@expected_return.inspect}"
+        elsif @has_expected_error
+          message << "have raised #{@expected_error.inspect}"
+          message << " matching #{@expected_error_message.inspect}" if @expected_error_message
         else
-          if @has_expected_error
-            message << "have raised #{@expected_error.inspect}"
-            if @expected_error_message
-              message << " matching #{@expected_error_message.inspect}"
-            end
-          else
-            message << "have run successfully"
-          end
+          message << 'have run successfully'
         end
         message << failure_message_actual(type)
       end