rspec-puppet-womble 0.1.6.womble1 → 0.1.6.womble2

data/lib/rspec-puppet/example.rb

@@ -0,0 +1,27 @@
+require 'rspec-puppet/support'
+require 'rspec-puppet/example/define_example_group'
+require 'rspec-puppet/example/class_example_group'
+require 'rspec-puppet/example/function_example_group'
+require 'rspec-puppet/example/host_example_group'
+
+RSpec::configure do |c|
+  def c.escaped_path(*parts)
+    Regexp.compile(parts.join('[\\\/]'))
+  end
+
+  c.include RSpec::Puppet::DefineExampleGroup, :type => :define, :example_group => {
+    :file_path => c.escaped_path(%w[spec defines])
+  }
+
+  c.include RSpec::Puppet::ClassExampleGroup, :type => :class, :example_group => {
+    :file_path => c.escaped_path(%w[spec classes])
+  }
+
+  c.include RSpec::Puppet::FunctionExampleGroup, :type => :puppet_function, :example_group => {
+    :file_path => c.escaped_path(%w[spec functions])
+  }
+
+  c.include RSpec::Puppet::HostExampleGroup, :type => :host, :example_group => {
+    :file_path => c.escaped_path(%w[spec hosts])
+  }
+end

data/lib/rspec-puppet/example/class_example_group.rb

@@ -0,0 +1,10 @@
+module RSpec::Puppet
+  module ClassExampleGroup
+    include RSpec::Puppet::ManifestMatchers
+    include RSpec::Puppet::Support
+
+    def subject
+      @catalogue ||= catalogue(:class)
+    end
+  end
+end

data/lib/rspec-puppet/example/define_example_group.rb

@@ -0,0 +1,10 @@
+module RSpec::Puppet
+  module DefineExampleGroup
+    include RSpec::Puppet::ManifestMatchers
+    include RSpec::Puppet::Support
+
+    def subject
+      @catalogue ||= catalogue(:define)
+    end
+  end
+end

data/lib/rspec-puppet/example/function_example_group.rb

@@ -0,0 +1,46 @@
+module RSpec::Puppet
+  module FunctionExampleGroup
+    include RSpec::Puppet::FunctionMatchers
+    include RSpec::Puppet::ManifestMatchers
+    include RSpec::Puppet::Support
+
+    def subject
+      function_name = self.class.top_level_description.downcase
+
+      vardir = setup_puppet
+
+      node_name = nodename(:function)
+
+      facts_val = facts_hash(node_name)
+
+      # if we specify a pre_condition, we should ensure that we compile that code
+      # into a catalog that is accessible from the scope where the function is called
+      Puppet[:code] = pre_cond
+
+      compiler = build_compiler(node_name, facts_val)
+
+      function_scope = scope(compiler, node_name)
+
+      # Return the method instance for the function.  This can be used with
+      # method.call
+      return nil unless Puppet::Parser::Functions.function(function_name)
+      FileUtils.rm_rf(vardir) if File.directory?(vardir)
+      function_scope.method("function_#{function_name}".intern)
+    end
+
+    # get a compiler with an attached compiled catalog
+    def build_compiler(node_name, fact_values)
+      node_options = {
+        :parameters => fact_values,
+      }
+
+      stub_facts! fact_values
+
+      node = build_node(node_name, node_options)
+
+      compiler = Puppet::Parser::Compiler.new(node)
+      compiler.compile
+      compiler
+    end
+  end
+end

data/lib/rspec-puppet/example/host_example_group.rb

@@ -0,0 +1,10 @@
+module RSpec::Puppet
+  module HostExampleGroup
+    include RSpec::Puppet::ManifestMatchers
+    include RSpec::Puppet::Support
+
+    def subject
+      @catalogue ||= catalogue(:host)
+    end
+  end
+end

data/lib/rspec-puppet/matchers.rb

@@ -0,0 +1,6 @@
+require 'rspec-puppet/matchers/create_generic'
+require 'rspec-puppet/matchers/include_class'
+require 'rspec-puppet/matchers/compile'
+require 'rspec-puppet/matchers/run'
+require 'rspec-puppet/matchers/count_generic'
+require 'rspec-puppet/matchers/dynamic_matchers'

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

@@ -0,0 +1,133 @@
+module RSpec::Puppet
+  module ManifestMatchers
+    class Compile
+      def initialize
+        @failed_resource = ""
+        @check_deps = false
+        @cycles = []
+      end
+
+      def with_all_deps
+        @check_deps = true
+        self
+      end
+
+      def matches?(catalogue)
+        @catalogue = catalogue
+        if cycles_found?
+          false
+        elsif @check_deps == true && missing_dependencies?
+          false
+        else
+          true
+        end
+      end
+
+      def description
+        "compile the catalogue without cycles"
+      end
+
+      def failure_message_for_should
+        unless @cycles.empty?
+          "dependency cycles found: #{@cycles.join('; ')}"
+        else
+          "expected that the catalogue would include #{@failed_resource}"
+        end
+      end
+
+      def failure_message_for_should_not
+        "expected that the catalogue would not compile but it does"
+      end
+
+      private
+      def missing_dependencies?
+        retval = false
+
+        resource_vertices = @catalogue.vertices.select { |v| v.is_a? Puppet::Resource }
+        resource_vertices.each do |vertex|
+          vertex.each do |param,value|
+            if [:require, :subscribe, :notify, :before].include? param
+              value = Array[value] unless value.is_a? Array
+              value.each do |val|
+                if val.is_a? Puppet::Resource
+                  retval = true unless resource_exists?(val, vertex)
+                end
+              end
+            end
+          end
+        end
+
+        retval
+      end
+
+      def resource_hash
+        @resource_hash ||= Proc.new do
+          res_hash = {}
+          @catalogue.vertices.each do |vertex|
+            if vertex.is_a? Puppet::Resource
+              res_hash[vertex.ref] = 1
+              if vertex[:alias]
+                res_hash["#{vertex.type.to_s}[#{vertex[:alias]}]"] = 1
+              end
+            end
+          end
+          res_hash
+        end.call
+      end
+
+      def check_resource(res)
+        if resource_hash[res.ref]
+          true
+        elsif res[:alias] && resource_hash["#{res.type.to_s}[#{res[:alias]}]"]
+          true
+        else
+          false
+        end
+      end
+
+      def resource_exists?(res, vertex)
+        unless check_resource(res)
+          @failed_resource = "#{res.ref} used at #{vertex.file}:#{vertex.line} in #{vertex.ref}"
+          false
+        else
+          true
+        end
+      end
+
+      def cycles_found?
+        retval = false
+        begin
+          cat = @catalogue.to_ral.relationship_graph
+          cat.write_graph(:resources)
+          if cat.respond_to? :find_cycles_in_graph
+            find_cycles(cat)
+          else
+            find_cycles_legacy(cat)
+          end
+          retval = true unless @cycles.empty?
+        rescue Puppet::Error
+          retval = true
+        end
+        retval
+      end
+
+      def find_cycles(catalogue)
+        cycles = catalogue.find_cycles_in_graph
+        if cycles.length > 0
+          cycles.each do |cycle|
+            paths = catalogue.paths_in_cycle(cycle)
+            @cycles << (paths.map{ |path| '(' + path.join(" => ") + ')'}.join("\n") + "\n")
+          end
+        end
+      end
+
+      def find_cycles_legacy(catalogue)
+        begin
+          catalogue.topsort
+        rescue Puppet::Error => e
+          @cycles = [e.message.rpartition(';').first.partition(':').last]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module RSpec::Puppet
+  module ManifestMatchers
+    class CountGeneric
+      def initialize(type, count, *method)
+        if type.nil?
+          @type = method[0].to_s.gsub(/^have_(.+)_resource_count$/, '\1')
+        else
+          @type = type
+        end
+        @referenced_type = referenced_type(@type)
+        @expected_number = count.to_i
+      end
+
+      def matches?(catalogue)
+        if @type == "resource"
+          @actual_number = catalogue.resources.count do |res|
+            !(['Class', 'Node'].include? res.type)
+          end
+
+          # Puppet automatically adds Stage[main]
+          @actual_number = @actual_number - 1
+        else
+          @actual_number = catalogue.resources.count do |res|
+            res.type == @referenced_type
+          end
+
+          # Puppet automatically adds Class[main] and Class[Settings]
+          @actual_number = @actual_number - 2 if @type == "class"
+        end
+
+        @actual_number == @expected_number
+      end
+
+      def description
+        desc = []
+
+        desc << "contain exactly #{@expected_number}"
+        if @type == "class"
+          desc << "#{@expected_number == 1 ? "class" : "classes" }"
+        else
+          unless @type == "resource"
+            desc << "#{@referenced_type}"
+          end
+          desc << "#{@expected_number == 1 ? "resource" : "resources" }"
+        end
+
+        desc.join(" ")
+      end
+
+      def failure_message_for_should
+        "expected that the catalogue would " + description + " but it contains #{@actual_number}"
+      end
+
+      def failure_message_for_should_not
+        "expected that the catalogue would not " + description + " but it does"
+      end
+
+    private
+
+      def referenced_type(type)
+        type.split('__').map { |r| r.capitalize }.join('::')
+      end
+    end
+
+    def have_class_count(count)
+      RSpec::Puppet::ManifestMatchers::CountGeneric.new('class', count)
+    end
+
+    def have_resource_count(count)
+      RSpec::Puppet::ManifestMatchers::CountGeneric.new('resource', count)
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+require 'rspec-puppet/matchers/parameter_matcher'
+module RSpec::Puppet
+  module ManifestMatchers
+    class CreateGeneric
+      include RSpec::Puppet::Errors
+
+      def initialize(*args, &block)
+        @exp_resource_type = args.shift.to_s.gsub(/^(create|contain)_/, '')
+        @args = args
+        @block = block
+        @referenced_type = referenced_type(@exp_resource_type)
+        @title = args[0]
+
+        @errors = []
+        @expected_params = []
+        @expected_undef_params = []
+      end
+
+      def with(*args, &block)
+        params = args.shift
+        @expected_params = @expected_params | params.to_a
+        self
+      end
+
+      def only_with(*args, &block)
+        params = args.shift
+        @expected_params_count = (@expected_params_count || 0) + params.size
+        self.with(params, &block)
+      end
+
+      def without(*args, &block)
+        params = args.shift
+        @expected_undef_params = @expected_undef_params | Array(params)
+        self
+      end
+
+      def method_missing(method, *args, &block)
+        if method.to_s =~ /^with_/
+          param = method.to_s.gsub(/^with_/, '')
+          @expected_params << [param, args[0]]
+          self
+        elsif method.to_s =~ /^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_/
+          param = method.to_s.gsub(/^without_/, '')
+          @expected_undef_params << [param, args[0]]
+          self
+        else
+          super
+        end
+      end
+
+      def matches?(catalogue)
+        ret = true
+        resource = catalogue.resource(@referenced_type, @title)
+
+        if resource.nil?
+          false
+        else
+          rsrc_hsh = resource.to_hash
+          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
+          end
+
+          check_params(rsrc_hsh, @expected_params, :should) if @expected_params.any?
+          check_params(rsrc_hsh, @expected_undef_params, :not) if @expected_undef_params.any?
+
+          @errors.empty?
+        end
+      end
+
+      def failure_message_for_should
+        "expected that the catalogue would contain #{@referenced_type}[#{@title}]#{errors}"
+      end
+
+      def failure_message_for_should_not
+        "expected that the catalogue would not contain #{@referenced_type}[#{@title}]#{errors}"
+      end
+
+      def description
+        values = []
+
+        if @expected_params_count
+          values << "exactly #{@expected_params_count} parameters"
+        end
+
+        if @expected_params.any?
+          values.concat(generate_param_list(@expected_params, :should))
+        end
+
+        if @expected_undef_params.any?
+          values.concat(generate_param_list(@expected_undef_params, :not))
+        end
+
+        unless values.empty?
+          if values.length == 1
+            value_str = " with #{values.first}"
+          else
+            value_str = " with #{values[0..-2].join(", ")} and #{values[-1]}"
+          end
+        end
+
+        "contain #{@referenced_type}[#{@title}]#{value_str}"
+      end
+
+      private
+      def referenced_type(type)
+        type.split('__').map { |r| r.capitalize }.join('::')
+      end
+
+      def errors
+        @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"
+          else
+            a = type == :not ? '!' : '='
+            b = value.is_a?(Regexp) ? '~' : '>'
+            output << "#{param.to_s} #{a}#{b} #{value.inspect}"
+          end
+        end
+        output
+      end
+
+      # @param resource [Hash<Symbol, Object>] The resource in the catalog
+      # @param list [Array<String, Object>] The expected values of the resource
+      # @param type [:should, :not] Whether the given parameters should/not match
+      def check_params(resource, list, type)
+        list.each do |param, value|
+          param = param.to_sym
+
+          if value.nil? then
+            unless resource[param].nil?
+              @errors << "#{param} undefined"
+            end
+          else
+            m = ParameterMatcher.new(param, value, type)
+            unless m.matches?(resource)
+              @errors.concat m.errors
+            end
+          end
+        end
+      end
+    end
+  end
+end