rspec-puppet-yaml 0.1.0

data/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rspec/puppet/yaml"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rspec-puppet/matcher_helpers.rb

@@ -0,0 +1,326 @@
+module RSpec::Puppet
+  # A collection of static methods that simplify creating and building rodjek's
+  # RSpec::Puppet::*Matchers.  With `MatcherHelpers`, you need call only its
+  # `.get_matcher_for` function with arguments appropriate to the matcher you
+  # desire.  Otherwise, you have to know in advance which matcher you want and,
+  # at first, the relationship between method, matcher, and namespace just isn't
+  # always obvious.
+  #
+  # @see https://github.com/rodjek/rspec-puppet
+  class MatcherHelpers
+    # Attempts to create and return an appropriate RSpec::Puppet::*Matcher for a
+    # known matching method and its arguments.  If tests are provided and the
+    # matcher supports them, the matcher will be built up with the tests.
+    #
+    # @param method [Variant[String,Symbol]] A recognizable RSpec::Puppet
+    #  matcher; one of: contain_*, create_*, have_*_count, compile, run, or
+    #  be_valid_type (where * is a known resource type).
+    # @param args [Array[Any]] Arguments to pass to the matcher during
+    #  construction, if it accepts any.
+    # @param tests [Optional[Hash[Variant[String,Symbol],Any]]] Set of unit
+    #  tests to apply to the matcher, expressed as `:method_call => value(s)`
+    #  tuples.  Use `nil` as the value for method_calls that don't accept
+    #  arguments.
+    # @return [Object] An RSpec::Puppet matcher that knows how to handle
+    #  `method` and is loaded with `tests`.
+    # @raise [NameError] when `method` is unrecognizable.
+    def self.get_matcher_for(method, args, tests = {})
+      method_str = method.nil? ? 'nil' : method.to_s
+      method_sym = method.nil? ? :nil : method.to_sym
+
+      case method_str
+      when /^(contain|create)_.+$/
+        matcher = RSpec::Puppet::MatcherHelpers.get_contain_matcher(
+          method_sym,
+          args,
+          tests
+        )
+      when /^have_.+_count$/
+        matcher = RSpec::Puppet::MatcherHelpers.get_count_matcher(
+          method_sym,
+          args,
+          tests
+        )
+      when 'compile'
+        matcher = RSpec::Puppet::MatcherHelpers.get_compile_matcher(
+          method_sym,
+          args,
+          tests
+        )
+      when 'run'
+        matcher = RSpec::Puppet::MatcherHelpers.get_function_matcher(
+          method_sym,
+          args,
+          tests
+        )
+      when 'be_valid_type'
+        matcher = RSpec::Puppet::MatcherHelpers.get_type_matcher(
+          method_sym,
+          args,
+          tests
+        )
+      else
+        raise NameError, "Unknown matcher method:  #{method_str}.  See http://rspec-puppet.com/matchers/ for valid matchers."
+      end
+
+      matcher
+    end
+
+    # Gets a matcher for :create_* and :contain_* tests.
+    #
+    # @param method [Symbol] The full :create_* or :contain_* matcher type.
+    # @param args [Array[Any]] Must be at least an Array with one element and
+    #  the first element must be the title of the resource under test.  So, for
+    #  `package { 'my-package': ensure => 'latest', provider => 'apt' }`, this
+    #  must be set to `[ "my-package" ]`.
+    # @param tests [Optional[Hash[Variant[String,Symbol],Any]]] Set of unit
+    #  tests to apply to the matcher, expressed as `:method_call => value(s)`
+    #  tuples.  Use `nil` as the value for method_calls that don't accept
+    #  arguments.
+    # @raise [ArgumentError] when a resource title is not supplied at args[0].
+    #
+    # @example package { 'my-package': ensure => 'latest', provider => 'apt' }
+    #  # Using the all-in-one `with` test
+    #  matcher = RSpec::Puppet::MatcherHelpers.get_contain_matcher(
+    #    :contain_package,
+    #    [ 'my-package' ],
+    #    { :with => {
+    #      :ensure   => 'latest',
+    #      :provider => 'apt' }
+    #    }
+    #  )
+    #
+    #  # Using individual with_* tests
+    #  matcher = RSpec::Puppet::MatcherHelpers.get_contain_matcher(
+    #    :contain_package,
+    #    [ 'my-package' ],
+    #    { :with_ensure   => 'latest',
+    #      :with_provider => 'apt'
+    #    }
+    #  )
+    def self.get_contain_matcher(method, args, tests = {})
+      # For this matcher, args[0] must be a String value that is the title for
+      # the resource under test.
+      if args.nil? || !args
+        raise ArgumentError, "Contain/Create matchers require that the first argument be the title of the resource under test."
+      elsif !args.kind_of?(Array)
+        args = [ args.to_s ]
+      end
+
+      matcher = RSpec::Puppet::ManifestMatchers::CreateGeneric.new(
+        method,
+        args[0]
+      )
+
+      # Try to be lenient on the Hash requirement for tests
+      if tests.kind_of?(Array)
+        tests.each { |test| matcher.send(test.to_sym) }
+      elsif tests.is_a?(Hash)
+        tests.each do |k,v|
+          if v.nil? || 'nil' == v.to_s
+            matcher.send(k.to_sym)
+          else
+            matcher.send(k.to_sym, v)
+          end
+        end
+      elsif !tests.nil?
+        # Anything left is assumed to be an 'ensure' test
+        matcher.send(:with_ensure, tests)
+      end
+
+      matcher
+    end
+
+    # Gets a matcher for have_*_resource_count tests.
+    #
+    # @param method [Symbol] The full :have_*_resource_count matcher type.
+    # @param args [Variant[Integer,Array[Integer]]] May be either an Integer or
+    #  an Array with exactly one element that is an Integer.  This is the number
+    #  of the expected resource counted.
+    # @param tests [Optional[Hash[Variant[String,Symbol],Any]]] *IGNORED* in
+    #  this version!  Should this matcher ever later support additional tests,
+    #  this will become the set of unit tests to apply to the matcher, expressed
+    #  as `:method_call => value(s)`` tuples.  Use `nil` as the value for
+    #  method_calls that don't accept arguments.
+    #
+    # @example 1 package expected (count as an Array element)
+    #  matcher = RSpec::Puppet::MatcherHelpers.get_count_matcher(
+    #    :have_package_resource_count,
+    #    [ 1 ]
+    #  )
+    #
+    # @example 12 files expected (count as a bare Integer)
+    #  matcher = RSpec::Puppet::MatcherHelpers.get_count_matcher(
+    #    :have_file_resource_count,
+    #    12
+    #  )
+    def self.get_count_matcher(method, args, tests = {})
+      # This constructor is backward from all the rest and a bit qwirky in that
+      # it inexplicably expects method to be an Array and args to be an Integer
+      # rather than an Array like all the other matchers.  Further, this one
+      # expects to receive method twice, as the first and third parameters or
+      # part of method as the first and the whole method as the third or nil as
+      # the first and method as the third.  Quite qwirky, indeed!  This helper
+      # will steer clear of this qwirkiness by simply passing nil as the first
+      # and ensuring that args can be cast as an Integer.
+      begin
+        if args.kind_of?(Array)
+          # Assume the first element of an args array is the intended count
+          count = args[0].to_i
+        else
+          count = args.to_i
+        end
+      rescue
+        raise ArgumentError, "The argument to Count matchers must be a single Integer value."
+      end
+
+      RSpec::Puppet::ManifestMatchers::CountGeneric.new(
+        nil,
+        count,
+        method
+      )
+    end
+
+    # Gets a matcher for compile tests.
+    #
+    # @param method [Symbol] The :compile matcher type.
+    # @param args [Optional[Variant[Integer,Array[Integer]]]] **IGNORED** in
+    #  this version!  Should a future version of the compile matcher support
+    #  constructor arguments, this will become useful.
+    # @param tests [Optional[Hash[Variant[String,Symbol],Any]]] Set of unit
+    #  tests to apply to the matcher, expressed as `:method_call => value(s)`
+    #  tuples.  Use `nil` as the value for method_calls that don't accept
+    #  arguments.
+    #
+    # @example The class compiles with all dependencies, spelled out
+    #  matcher = RSpec::Puppet::MatcherHelpers.get_compile_matcher(
+    #    :compile,
+    #    nil,
+    #    { :with_all_deps => nil }
+    #  )
+    #
+    # @example The class compiles with all dependencies, simpler
+    #  matcher = RSpec::Puppet::MatcherHelpers.get_compile_matcher(
+    #    :compile,
+    #    nil,
+    #    true
+    #  )
+    def self.get_compile_matcher(method, args = [], tests = {})
+      matcher = RSpec::Puppet::ManifestMatchers::Compile.new
+
+      if tests.kind_of?(Array)
+        tests.each { |test| matcher.send(test.to_sym) }
+      elsif tests.is_a?(Hash)
+        tests.each do |k,v|
+          if v.nil? || 'nil' == v.to_s
+            matcher.send(k.to_sym)
+          else
+            matcher.send(k.to_sym, v)
+          end
+        end
+      elsif tests.is_a?(String) || tests.is_a?(Symbol)
+        matcher.send(tests)
+      elsif !tests.nil?
+        # Anything left is assumed to be a 'with_all_deps' test...
+        if tests
+          # ...as long as it is "truthy"
+          matcher.send(:with_all_deps)
+        end
+      end
+
+      matcher
+    end
+
+    # Gets a matcher for function (:run) tests.
+    #
+    # @param method [Symbol] The :run matcher type.
+    # @param args [Optional[Variant[Integer,Array[Integer]]]] **IGNORED** in
+    #  this version!  Should a future version of the compile matcher support
+    #  constructor arguments, this will become useful.
+    # @param tests [Optional[Variant[Symbol,String,Array[Any],Hash[Any,Any]]]]
+    #  Set of unit tests to apply to the matcher.  Many forms of expressing
+    #  these tests is supported, though the best fit is Array[Any], which is
+    #  passed as-is to the function under test as its parameters.
+    #
+    # @example Test a function that strips known extensions off file-names
+    #  matcher = RSpec::Puppet::MatcherHelpers.get_function_matcher(
+    #    :run,
+    #    nil,
+    #    [ '/some/arbitrary/path.ext', 'ext' ]
+    #  )
+    def self.get_function_matcher(method, args = [], tests = [])
+      matcher = RSpec::Puppet::FunctionMatchers::Run.new
+
+      if tests.is_a?(Hash)
+        tests.each do |k,v|
+          if v.nil? || 'nil' == v.to_s
+            matcher.send(k.to_sym)
+          else
+            matcher.send(k.to_sym, v)
+          end
+        end
+      elsif tests.is_a?(String) || tests.is_a?(Symbol)
+        matcher.send(tests)
+      elsif !tests.nil?
+        # Anything left is assumed to be a 'with_params' test, which expects an
+        # Array.
+        if tests.kind_of?(Array)
+          matcher.send(:with_params, tests)
+        else
+          matcher.send(:with_params, [tests])
+        end
+      end
+
+      matcher
+    end
+
+    # Gets a matcher for custom type (:be_valid_type) tests.
+    #
+    # @param method [Symbol] The :be_valid_type matcher type.
+    # @param args [Optional[Variant[Integer,Array[Integer]]]] **IGNORED** in
+    #  this version!  Should a future version of
+    #  RSpec::Puppet::TypeMatchers::CreateGeneric support constructor arguments,
+    #  this will become useful.
+    # @param tests [Optional[Hash[Variant[String,Symbol],Any]]] Set of unit
+    #  tests to apply to the matcher, expressed as `:method_call => value(s)`
+    #  tuples.  Use `nil` as the value for method_calls that don't accept
+    #  arguments.
+    #
+    # @example With a particular provider (simple)
+    #  matcher = RSpec::Puppet::MatcherHelpers.get_type_matcher(
+    #    :be_valid_type,
+    #    nil,
+    #    :apt
+    #  )
+    #
+    # @example With a particular provider (spelled out)
+    #  matcher = RSpec::Puppet::MatcherHelpers.get_type_matcher(
+    #    :be_valid_type,
+    #    nil,
+    #    { :with_provider => :apt }
+    #  )
+    def self.get_type_matcher(method, args = [], tests = {})
+      matcher = RSpec::Puppet::TypeMatchers::CreateGeneric.new(
+        method,
+        args
+      )
+
+      if tests.kind_of?(Array)
+        tests.each { |test| matcher.send(test.to_sym) }
+      elsif tests.is_a?(Hash)
+        tests.each do |k,v|
+          if v.nil? || 'nil' == v.to_s
+            matcher.send(k.to_sym)
+          else
+            matcher.send(k.to_sym, v)
+          end
+        end
+      elsif !tests.nil?
+        # Anything left is assumed to be a 'with_provider' test
+        matcher.send(:with_provider, tests)
+      end
+
+      matcher
+    end
+  end
+end

data/lib/rspec-puppet/support_copy.rb

@@ -0,0 +1,66 @@
+# I was *forced* to copy the `guess_type_from_path` and `ref` functions from
+# rspec-puppet/support (see the respective `see` references) and then slam
+# everything into the global scope because I couldn't find a Ruby way to call
+# these two function from my own namespaced code while keeping RSpec happy from
+# the namespaced context.  I tried a Class-based approach.  I tried a
+# Module-extend approach.  Neither worked well.  While I was able to make calls
+# to these rspec-puppet functions from the appropriate scope in either model,
+# doing so either broke RSpec's ability to find its own `it` or my namedspaced
+# `apply_content` method (Class) or function (Module).  I've now uterly burned
+# over 30 hours of my life on this problem, so I'm "throwing in the towel" and
+# just copying this code.  I'm DONE fighting with Ruby on this issue!  I'm sorry
+# I wasn't smart enough to appease Ruby.  Yes, it SUCKS to be blocked from using
+# an OOP model or any namespaces but I just can't find any other way to move
+# forward at this point...  if YOU (yes, YOU) can refactor the necessary code
+# into proper namespaces, then by all means; PLEASE feel free to open a Pull
+# Request that that effect.  I'd love to learn how you pull it off!
+module RSpec::Puppet end
+
+# Attempts to identify the nature of an entity-under-test from the path of the
+# spec file that defines its unit tests.
+#
+# License:  MIT
+# @author Tim Sharpe
+#
+# @param path [String] Fully-qualified path to the *_spec.rb file that defines
+#  RSpec (Puppet) tests.
+# @return [Symbol] Presumed nature of the entity-under-test.
+#
+# @see https://github.com/rodjek/rspec-puppet/blob/434653f8a143e047a082019975b66fb2323051eb/lib/rspec-puppet/support.rb#L25-L46
+def guess_type_from_path(path)
+  case path
+  when /spec\/defines/
+    :define
+  when /spec\/classes/
+    :class
+  when /spec\/functions/
+    :function
+  when /spec\/hosts/
+    :host
+  when /spec\/types/
+    :type
+  when /spec\/type_aliases/
+    :type_alias
+  when /spec\/provider/
+    :provider
+  when /spec\/applications/
+    :application
+  else
+    :unknown
+  end
+end
+
+# Helper to return a resource/node reference, so it gets translated in params to a raw string
+# without quotes.
+#
+# License:  MIT
+# @author Tim Sharpe
+#
+# @param [String] type reference type
+# @param [String] title reference title
+# @return [RSpec::Puppet::RawString] return a new RawString with the type/title populated correctly
+#
+# @see https://github.com/rodjek/rspec-puppet/blob/434653f8a143e047a082019975b66fb2323051eb/lib/rspec-puppet/support.rb#L404-L412
+def ref(type, title)
+  return RSpec::Puppet::RawString.new("#{type}['#{title}']")
+end

data/lib/rspec-puppet-yaml/data_helpers.rb

@@ -0,0 +1,176 @@
+module RSpec::Puppet
+  module Yaml
+    # A collection of static methods that help coerce data into simpler (to
+    # digest) forms.  This is necessitated primarily because YAML files can be
+    # written with either String or Symbol keys for the same value and because
+    # Hashes can be explicitly or implicitly named.
+    module DataHelpers
+      # Takes a Hash, checks it for a name attribute, and ensures that name
+      # is a string-named, 'name', attribute.  If the Hash has no identifyable
+      # name, an ArgumentError is raised.
+      #
+      # @param transform_hash [Hash] A Hash that may already have an explicit
+      #  name attribute in either string or symbol form, or a Hash with an
+      #  implicit name of form `{ 'implicit' => { key... => val... } }`.
+      # @return Hash The `transform_hash` with an explicit, string key 'name'
+      #  attribute.
+      # @raise ArgumentError when `transform_hash` has neither an implicit nor
+      #  explicit name.
+      def self.make_hash_name_explicit(transform_hash = {})
+        raise ArgumentError, "Cannot transform non-Hash data." unless transform_hash.is_a?(Hash)
+        transformed_hash = {}
+        hash_name        = RSpec::Puppet::Yaml::DataHelpers.get_named_value(
+          'name',
+          transform_hash
+        )
+
+        if hash_name.nil? || hash_name.empty?
+          # Could be an implicit name when { 'implicit' => { 'key' => 'val' } }
+          if 1 == transform_hash.keys.count
+            first_value = transform_hash.values[0]
+            if !first_value.nil? && !first_value.is_a?(Hash)
+              raise ArgumentError, "Cannot transform implicitly named Hash when its value is neither nil nor a Hash."
+            else
+              hash_name        = transform_hash.keys.first
+              hash_value       = first_value ||= {}
+              transformed_hash = hash_value
+                .select {|k,v| k != :name}
+                .merge({'name' => hash_name})
+            end
+          else
+            # No explicit or implicit name
+            raise ArgumentError, "Hash has neither an explicit nor implicit name."
+          end
+        else
+          transformed_hash = transform_hash
+            .select {|k,v| k != :name}
+            .merge({'name' => hash_name})
+        end
+
+        transformed_hash
+      end
+
+      # Condenses a collection of named Hashes into an Array-of-Hashes.
+      #
+      # Accepts Hashes-of-Hashes -- where each key is the entry's :name and --
+      # Arrays-of-Hashes -- where each Hash has a :name element -- returning
+      # both forms as an Array-of-Hashes with a guaranteed 'name' element.  Any
+      # entry without a :name or 'name' generates an exception.
+      #
+      # @param [Enum[String,Symbol]] key The name of the collection to copy.
+      # @param [Optional[Hash]] data The Hash to copy `key` from.
+      # @return [Array[Hash]] Array-of-Hashes, each with a 'name' attribute.
+      # @raise [ArgumentError] when an element has no name or is not a Hash.
+      def self.get_array_of_named_hashes(key, data = {})
+        coerced_hashes = []
+        hashes         = RSpec::Puppet::Yaml::DataHelpers.get_named_value(
+          key,
+          data,
+          {}
+        )
+        return coerced_hashes if hashes.empty?
+
+        # Supported Cases:
+        # 1. [{'this is a name' => {:key => val}}, {'this is also a name' => {:key => val}}]
+        # 2. {'this is a name' => {:key => value}, 'this is also a name' => {:key => value}}
+        # 3. [{:name => 'the name', :key => value}, {:name => 'another name', :key => value}]
+        # 4. {:name => 'the name', :key => value}
+        if hashes.kind_of?(Array)
+          hashes.each { |hash|
+            coerced_hashes << RSpec::Puppet::Yaml::DataHelpers
+              .make_hash_name_explicit(hash)
+          }
+        elsif hashes.is_a?(Hash)
+          # Supported Case 2 requires that each Hash attribute be a named Hash
+          # when there is no explicit name attribute.
+          if hashes.has_key?('name') || hashes.has_key?(:name)
+            coerced_hashes << RSpec::Puppet::Yaml::DataHelpers
+              .make_hash_name_explicit(hashes)
+          else
+            hashes.each do |k, v|
+              if v.nil?
+                coerced_hashes << { 'name' => k }
+              elsif !v.is_a?(Hash)
+                raise ArgumentError, "#{key} indicates a Hash but at least one of its attributes is neither a Hash nor nil."
+              else
+                coerced_hashes << v
+                  .select {|m, n| m != :name}
+                  .merge({'name' => k})
+              end
+            end
+          end
+        else
+          raise ArgumentError, "#{key} is for neither an Array nor a Hash value."
+        end
+
+        coerced_hashes
+      end
+
+      # Gets a named Hash child from a supplied Hash parent.
+      #
+      # Attempts to get an immediate child Hash from a parent Hash that is
+      # named according to a given key.  The key may be supplied in either
+      # String or Symbol form and both are searched for.  When both forms
+      # exist in the parent Hash, a shallow merge is attempted, favoring the
+      # String form.
+      #
+      # @param [Enum[String,Symbol]] key The name of the child Hash.
+      # @param [Optional[Hash]] data The parent Hash.
+      # @param [Optional[Hash]] default The result when `key` not found.
+      # @return [Hash] The selected child Hash if it exists, else `default`.
+      # @raise NameError when the value for `key` is not a Hash.
+      def self.get_named_hash(key, data = {}, default = {})
+        hash_value = RSpec::Puppet::Yaml::DataHelpers.get_named_value(
+          key, data, default
+        )
+        if !hash_value.is_a?(Hash)
+          raise NameError, "The value of #{key} is not a Hash."
+        end
+        hash_value
+      end
+
+      # Gets a named value from a Hash by its String and Symbol names.
+      #
+      # Searches a Hash for a key by both its String and Symbol names.  When
+      # both are found, they are merged as long as their values are both Hash
+      # (shallow) or Array (unique).  An exception is raised when the values are
+      # scalar or of different data types.
+      #
+      # @param [Enum[String,Symbol]] key The name of the child.
+      # @param [Optional[Hash]] data The parent Hash.
+      # @param [Optional[Hash]] default The result when `key` not found.
+      # @return [Any] The selected value if it exists, else `default`
+      # @raise NameError when both String and Symbol forms `key` exist but one
+      #  cannot be merged into the other.
+      def self.get_named_value(key, data = {}, default = nil)
+        return default unless !data.nil? && data.respond_to?(:has_key?)
+        str_key     = key.to_s
+        sym_key     = key.to_sym
+        has_str_key = data.has_key?(str_key)
+        has_sym_key = data.has_key?(sym_key)
+
+        if has_str_key && has_sym_key
+          str_value = data[str_key]
+          sym_value = data[sym_key]
+          if str_value.is_a?(Hash) && sym_value.is_a?(Hash)
+            begin
+              sym_value.merge(str_value)
+            rescue
+              raise NameError, "Both symbolic and string forms of '#{str_key}' Hash declarations exist but one cannot be merged into the other.  Pick one form or the other or ensure both are Hashes that can be merged."
+            end
+          elsif str_value.kind_of?(Array) && sym_value.kind_of?(Array)
+            str_value | sym_value
+          else
+            raise NameError, "Both symbolic and string forms of '#{str_key}' scalar declarations exist and they cannot be combined.  Pick one form or the other."
+          end
+        elsif has_str_key
+          data[str_key]
+        elsif has_sym_key
+          data[sym_key]
+        else
+          default
+        end
+      end
+    end
+  end
+end

data/lib/rspec-puppet-yaml/extenders.rb

@@ -0,0 +1,28 @@
+# Identifies a YAML data file based on the name of a *_spec.rb rspec file and
+# passes it to `parse_rspec_puppet_yaml` to initiate parsing.
+#
+# @param rspec_file Path to and name of the RSpec *_spec.rb file.  It is easiest
+#  to simply pass `__FILE__` to this function from that file.
+#
+# @example Typical use
+#  require 'spec_helper'
+#  parse_yaml_from_spec(__FILE__)
+#
+# @since 0.1.0
+def parse_yaml_from_spec(rspec_file)
+  if rspec_file =~ /^(.+)_spec\.rb$/
+    [ "#{$1}_spec.yaml",
+      "#{$1}_spec.yml",
+      "#{$1}.yaml",
+      "#{$1}.yml"
+    ].each do |yaml_file|
+      if File.exist?(yaml_file)
+        parse_rspec_puppet_yaml(yaml_file)
+      end
+    end
+  elsif rspec_file =~ /^(.+\.ya?ml)$/
+    parse_rspec_puppet_yaml($1)
+  else
+    parse_rspec_puppet_yaml(rspec_file)
+  end
+end