rspec-puppet 0.1.6 → 1.0.0

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

@@ -4,32 +4,7 @@ module RSpec::Puppet
     include RSpec::Puppet::Support
 
     def subject
-      @catalogue ||= catalogue
-    end
-
-    def catalogue
-      vardir = Dir.mktmpdir
-      Puppet[:vardir] = vardir
-      Puppet[:hiera_config] = File.join(vardir, "hiera.yaml") if Puppet[:hiera_config] == File.expand_path("/dev/null")
-      Puppet[:modulepath] = self.respond_to?(:module_path) ? module_path : RSpec.configuration.module_path
-      Puppet[:manifestdir] = self.respond_to?(:manifest_dir) ? manifest_dir : RSpec.configuration.manifest_dir
-      Puppet[:manifest] = self.respond_to?(:manifest) ? manifest : RSpec.configuration.manifest
-      Puppet[:templatedir] = self.respond_to?(:template_dir) ? template_dir : RSpec.configuration.template_dir
-      Puppet[:config] = self.respond_to?(:config) ? config : RSpec.configuration.config
-      code = ""
-
-      nodename = self.class.top_level_description.downcase
-
-      facts_val = {
-        'hostname' => nodename.split('.').first,
-        'fqdn' => nodename,
-        'domain' => nodename.split('.').last,
-      }
-      facts_val.merge!(munge_facts(facts)) if self.respond_to?(:facts)
-
-      catalogue = build_catalog(nodename, facts_val, code)
-      FileUtils.rm_rf(vardir) if File.directory?(vardir)
-      catalogue
+      @catalogue ||= catalogue(:host)
     end
   end
 end

data/lib/rspec-puppet/matchers.rb

@@ -1,4 +1,6 @@
 require 'rspec-puppet/matchers/create_generic'
-require 'rspec-puppet/matchers/create_resource'
 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

@@ -1,34 +1,76 @@
+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 = []
+        @notifies = []
+        @subscribes = []
+        @requires = []
+        @befores = []
       end
 
       def with(*args, &block)
         params = args.shift
-        @expected_params = (@expected_params || []) | params.to_a
+        @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)
+        @expected_undef_params = @expected_undef_params | Array(params)
+        self
+      end
+
+      def that_notifies(resource)
+        @notifies << resource
+        self
+      end
+
+      def that_subscribes_to(resource)
+        @subscribes << resource
+        self
+      end
+
+      def that_requires(resource)
+        @requires << resource
+        self
+      end
+
+      def that_comes_before(resource)
+        @befores << resource
         self
       end
 
       def method_missing(method, *args, &block)
         if method.to_s =~ /^with_/
           param = method.to_s.gsub(/^with_/, '')
-          (@expected_params ||= []) << [param, args[0]]
+          @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
+          @expected_undef_params << [param, args[0]]
           self
         else
           super
@@ -40,41 +82,25 @@ module RSpec::Puppet
         resource = catalogue.resource(@referenced_type, @title)
 
         if resource.nil?
-          ret = false
+          false
         else
           rsrc_hsh = resource.to_hash
-          if @expected_params
-            @expected_params.each do |name, value|
-              if value.kind_of?(Regexp) then
-                unless rsrc_hsh[name.to_sym].to_s =~ value
-                  ret = false
-                  (@errors ||= []) << "#{name.to_s} matching `#{value.inspect}` but its value of `#{rsrc_hsh[name.to_sym].inspect}` does not"
-                end
-              elsif value.kind_of?(Array) then
-                unless Array(rsrc_hsh[name.to_sym]).flatten.join == value.flatten.join
-                  ret = false
-                  (@errors ||= []) << "#{name.to_s} set to `#{value.inspect}` but it is set to `#{rsrc_hsh[name.to_sym].inspect}` in the catalogue"
-                end
-              else
-                unless rsrc_hsh[name.to_sym].to_s == value.to_s
-                  ret = false
-                  (@errors ||= []) << "#{name.to_s} set to `#{value.inspect}` but it is set to `#{rsrc_hsh[name.to_sym].inspect}` in the catalogue"
-                end
-              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
           end
 
-          if @expected_undef_params
-            @expected_undef_params.each do |name|
-              unless resource.send(:parameters)[name.to_sym].nil?
-                ret = false
-                (@errors ||= []) << "#{name.to_s} undefined"
-              end
-            end
-          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?
+          check_befores(catalogue, resource) if @befores.any?
+          check_requires(catalogue, resource) if @requires.any?
+          check_notifies(catalogue, resource) if @notifies.any?
+          check_subscribes(catalogue, resource) if @subscribes.any?
 
-        ret
+          @errors.empty?
+        end
       end
 
       def failure_message_for_should
@@ -87,20 +113,17 @@ module RSpec::Puppet
 
       def description
         values = []
-        if @expected_params
-          @expected_params.each do |name, value|
-            if value.kind_of?(Regexp)
-              values << "#{name.to_s} matching #{value.inspect}"
-            else
-              values << "#{name.to_s} => #{value.inspect}"
-            end
-          end
+
+        if @expected_params_count
+          values << "exactly #{@expected_params_count} parameters"
         end
 
-        if @expected_undef_params
-          @expected_undef_params.each do |name, value|
-            values << "#{name.to_s} undefined"
-          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?
@@ -114,20 +137,100 @@ module RSpec::Puppet
         "contain #{@referenced_type}[#{@title}]#{value_str}"
       end
 
-    private
-
+      private
       def referenced_type(type)
         type.split('__').map { |r| r.capitalize }.join('::')
       end
 
       def errors
-        @errors.nil? ? "" : " with #{@errors.join(', and parameter ')}"
+        @errors.empty? ? "" : " with #{@errors.join(', and parameter ')}"
       end
-    end
 
-    def method_missing(method, *args, &block)
-      return RSpec::Puppet::ManifestMatchers::CreateGeneric.new(method, *args, &block) if method.to_s =~ /^(create|contain)_/
-      super
+      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
+
+      def check_befores(catalogue, resource)
+        @befores.each do |ref|
+          unless precedes?(resource, catalogue.resource(ref))
+            @errors << BeforeRelationshipError.new(resource.to_ref, ref)
+          end
+        end
+      end
+
+      def check_requires(catalogue, resource)
+        @requires.each do |ref|
+          unless precedes?(catalogue.resource(ref), resource)
+            @errors << RequireRelationshipError.new(resource.to_ref, ref)
+          end
+        end
+      end
+
+      def check_notifies(catalogue, resource)
+        @notifies.each do |ref|
+          unless notifies?(resource, catalogue.resource(ref))
+            @errors << NotifyRelationshipError.new(resource.to_ref, ref)
+          end
+        end
+      end
+
+      def check_subscribes(catalogue, resource)
+        @subscribes.each do |ref|
+          unless notifies?(catalogue.resource(ref), resource)
+            @errors << SubscribeRelationshipError.new(resource.to_ref, ref)
+          end
+        end
+      end
+
+      def relationship_refs(array)
+        Array[array].flatten.map do |resource|
+          resource.respond_to?(:to_ref) ? resource.to_ref : resource
+        end
+      end
+
+      def precedes?(first, second)
+        before_refs = relationship_refs(first[:before])
+        require_refs = relationship_refs(second[:require])
+
+        before_refs.include?(second.to_ref) || require_refs.include?(first.to_ref)
+      end
+
+      def notifies?(first, second)
+        notify_refs = relationship_refs(first[:notify])
+        subscribe_refs = relationship_refs(second[:subscribe])
+
+        notify_refs.include?(second.to_ref) || subscribe_refs.include?(first.to_ref)
+      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