rspec-puppet 0.1.6 → 1.0.0

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

@@ -0,0 +1,17 @@
+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$/
+      return RSpec::Puppet::ManifestMatchers::Compile.new if method == :compile
+      super
+    end
+  end
+
+  module FunctionMatchers
+    def method_missing(method, *args, &block)
+      return RSpec::Puppet::FunctionMatchers::Run.new if method == :run
+      super
+    end
+  end
+end

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

@@ -4,7 +4,8 @@ module RSpec::Puppet
 
     matcher :include_class do |expected_class|
       match do |catalogue|
-        catalogue.classes.include? expected_class
+        RSpec.deprecate(:include_class, :contain_class)
+        catalogue.classes.include?(expected_class)
       end
 
       description do

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

@@ -0,0 +1,110 @@
+module RSpec::Puppet
+  module ManifestMatchers
+    class ParameterMatcher
+      include RSpec::Puppet::Errors
+
+      # @param parameter [Symbol] The specific parameter to check
+      # @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
+
+        @should_match = (type == :should)
+
+        @errors = []
+      end
+
+      # Ensure that the actual parameter matches the expected parameter.
+      #
+      # @param resource [Hash<Symbol, Object>] A hash representing a Puppet
+      #   resource in the catalog
+      #
+      # @return [true, false]
+      def matches?(resource)
+
+        @resource = resource
+
+        actual   = @resource[@parameter]
+        expected = @value
+
+        retval = check(expected, actual)
+
+        unless retval
+          @errors << MatchError.new(@parameter, expected, actual, !@should_match)
+        end
+
+        retval
+      end
+
+      # @!attribute [r] errors
+      #   @return [Array<Object < StandardError>] All expectation errors
+      #     generated on this parameter.
+      attr_reader :errors
+
+      private
+
+      # Recursively check that the `expected` and `actual` data structures match
+      #
+      # @param expected [Object] The expected value of the given resource param
+      # @param actual [Object] The value of the resource as found in the catalogue
+      #
+      # @return [true, false] If the resource matched
+      def check(expected, actual)
+        case expected
+        when Proc
+          check_proc(expected, actual)
+        when Regexp
+          check_regexp(expected, actual)
+        when Hash
+          check_hash(expected, actual)
+        when Array
+          check_array(expected, actual)
+        else
+          check_string(expected, actual)
+        end
+      end
+
+      def check_proc(expected, actual)
+        expected_return = @should_match
+        actual_return   = expected.call(actual)
+
+        actual_return == expected_return
+      end
+
+      def check_regexp(expected, actual)
+        !!(actual.to_s.match expected) == @should_match
+      end
+
+      # Ensure that two hashes have the same number of keys, and that for each
+      # 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 ? :"==" : :"!="
+
+        unless expected.keys.size.send(op, actual.keys.size)
+          return false
+        end
+
+        expected.keys.all? do |key|
+          check(expected[key], actual[key.to_s])
+        end
+      end
+
+      def check_array(expected, actual)
+        op = @should_match ? :"==" : :"!="
+
+        unless expected.size.send(op, actual.size)
+          return false
+        end
+
+        (0...expected.size).all? do |index|
+          check(expected[index], actual[index])
+        end
+      end
+
+      def check_string(expected, actual)
+        (expected.to_s == actual.to_s) == @should_match
+      end
+    end
+  end
+end

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

@@ -1,27 +1,35 @@
 module RSpec::Puppet
   module FunctionMatchers
-    extend RSpec::Matchers::DSL
-
-    matcher :run do
-      match do |func_obj|
+    class Run
+      def matches?(func_obj)
         if @params
           @func = lambda { func_obj.call(@params) }
         else
           @func = lambda { func_obj.call }
         end
 
-        if @expected_error
+        unless @expected_error.nil?
+          result = false
           begin
             @func.call
-          rescue @expected_error
-            #XXX check error string here
-            true
-          rescue
-            false
+          rescue Exception => e
+            @actual_error = e.class
+            if e.is_a?(@expected_error)
+              case @expected_error_message
+              when nil
+                result = true
+              when Regexp
+                result = @expected_error_message =~ e.message
+              else
+                result = @expected_error_message == e.message
+              end
+            end
           end
+          result
         else
-          if @expected_return
-            @func.call == @expected_return
+          unless @expected_return.nil?
+            @actual_return = @func.call
+            @actual_return == @expected_return
           else
             begin
               @func.call
@@ -33,43 +41,53 @@ module RSpec::Puppet
         end
       end
 
-      chain :with_params do |*params|
+      def with_params(*params)
         @params = params
+        self
       end
 
-      chain :and_return do |value|
+      def and_return(value)
         @expected_return = value
+        self
       end
 
-      # XXX support error string and regexp
-      chain :and_raise_error do |value|
-        @expected_error = value
+      def and_raise_error(error_or_message, message=nil)
+        case error_or_message
+        when String, Regexp
+          @expected_error, @expected_error_message = Exception, error_or_message
+        else
+          @expected_error, @expected_error_message = error_or_message, message
+        end
+        self
       end
 
-      failure_message_for_should do |func_obj|
-        func_name = func_obj.name.to_s.gsub(/^function_/, '')
-        func_params = @params.inspect[1..-2]
+      def failure_message_for_should(func_obj)
+        failure_message_generic(:should, func_obj)
+      end
 
-        if @expected_return
-          "expected #{func_name}(#{func_params}) to have returned #{@expected_return.inspect} instead of #{@func.call.inspect}"
-        elsif @expected_error
-          "expected #{func_name}(#{func_params}) to have raised #{@expected_error.inspect}"
-        else
-          "expected #{func_name}(#{func_params}) to have run successfully"
-        end
+      def failure_message_for_should_not(func_obj)
+        failure_message_generic(:should_not, func_obj)
       end
 
-      failure_message_for_should_not do |func_obj|
+      private
+      def failure_message_generic(type, func_obj)
         func_name = func_obj.name.gsub(/^function_/, '')
         func_params = @params.inspect[1..-2]
 
+        message = "expected #{func_name}(#{func_params}) to "
+        message << "not " if type == :should_not
+
         if @expected_return
-          "expected #{func_name}(#{func_params}) to not have returned #{@expected_return.inspect}"
+          message << "have returned #{@expected_return.inspect}"
+          if type == :should
+            message << " instead of #{@actual_return.inspect}"
+          end
         elsif @expected_error
-          "expected #{func_name}(#{func_params}) to not have raised #{@expected_error.inspect}"
+          message << "have raised #{@expected_error.inspect}"
         else
-          "expected #{func_name}(#{func_params}) to not have run successfully"
+          message << "have run successfully"
         end
+        message
       end
     end
   end

data/lib/rspec-puppet/setup.rb

@@ -43,17 +43,25 @@ module RSpec::Puppet
 
   protected
     def self.get_module_name
-      p = Puppet::Parser::Lexer.new
       module_name = nil
       Dir["manifests/*.pp"].entries.each do |manifest|
-        p.string = File.read(manifest)
-        tokens = p.fullscan
-        i = tokens.index { |token| [:CLASS, :DEFINE].include? token.first }
-        unless i.nil?
-          module_name = tokens[i + 1].last[:value].split('::').first
-          break
-        end
+        module_name = get_module_name_from_file(manifest)
+        break unless module_name.nil?
+      end
+      module_name
+    end
+
+    def self.get_module_name_from_file(file)
+      p = Puppet::Parser::Lexer.new
+      module_name = nil
+      p.string = File.read(file)
+      tokens = p.fullscan
+
+      i = tokens.index { |token| [:CLASS, :DEFINE].include? token.first }
+      unless i.nil?
+        module_name = tokens[i + 1].last[:value].split('::').first
       end
+
       module_name
     end
 
@@ -83,6 +91,20 @@ module RSpec::Puppet
       end
     end
 
+    def self.safe_create_file(filename, content)
+      if File.exists? filename
+        old_content = File.read(filename)
+        if old_content != content
+          $stderr.puts "!! #{filename} already exists and differs from template"
+        end
+      else
+        File.open(filename, 'w') do |f|
+          f.puts content
+        end
+        puts " + #{filename}"
+      end
+    end
+
     def self.safe_create_spec_helper
       content = <<-EOF
 require 'rspec-puppet'
@@ -94,17 +116,7 @@ RSpec.configure do |c|
   c.manifest_dir = File.join(fixture_path, 'manifests')
 end
 EOF
-      if File.exists? 'spec/spec_helper.rb'
-        old_content = File.read('spec/spec_helper.rb')
-        if old_content != content
-          $stderr.puts "!! spec/spec_helper.rb already exists and differs from template"
-        end
-      else
-        File.open('spec/spec_helper.rb', 'w') do |f|
-          f.puts content
-        end
-        puts ' + spec/spec_helper.rb'
-      end
+    safe_create_file('spec/spec_helper.rb', content)
     end
 
     def self.safe_make_symlink(source, target)
@@ -119,26 +131,37 @@ EOF
     end
 
     def self.safe_create_rakefile
-      content = <<-EOF
+      content = <<-'EOF'
 require 'rake'
-
 require 'rspec/core/rake_task'
 
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.pattern = 'spec/*/*_spec.rb'
+desc "Run all RSpec code examples"
+RSpec::Core::RakeTask.new(:rspec) do |t|
+  t.rspec_opts = File.read("spec/spec.opts").chomp || ""
+end
+
+SPEC_SUITES = (Dir.entries('spec') - ['.', '..','fixtures']).select {|e| File.directory? "spec/#{e}" }
+namespace :rspec do
+  SPEC_SUITES.each do |suite|
+    desc "Run #{suite} RSpec code examples"
+    RSpec::Core::RakeTask.new(suite) do |t|
+      t.pattern = "spec/#{suite}/**/*_spec.rb"
+      t.rspec_opts = File.read("spec/spec.opts").chomp || ""
+    end
+  end
+end
+task :default => :rspec
+
+begin
+  if Gem::Specification::find_by_name('puppet-lint')
+    require 'puppet-lint/tasks/puppet-lint'
+    PuppetLint.configuration.ignore_paths = ["spec/**/*.pp", "vendor/**/*.pp"]
+    task :default => [:rspec, :lint]
+  end
+rescue Gem::LoadError
 end
 EOF
-      if File.exists? 'Rakefile'
-        old_content = File.read('Rakefile')
-        if old_content != content
-          $stderr.puts "!! Rakefile already exists and differs from template"
-        end
-      else
-        File.open('Rakefile', 'w') do |f|
-          f.puts content
-        end
-        puts ' + Rakefile'
-      end
+    safe_create_file('Rakefile', content)
     end
   end
 end

data/lib/rspec-puppet/support.rb

@@ -3,15 +3,132 @@ module RSpec::Puppet
 
     @@cache = {}
 
-    protected
-    def build_catalog_without_cache(nodename, facts_val, code)
-      if Integer(Puppet.version.split('.').first) >= 3
-        Puppet.initialize_settings
+    def catalogue(type)
+      vardir = setup_puppet
+
+      code = import_str + pre_cond + test_manifest(type)
+      node_name = nodename(type)
+
+      catalogue = build_catalog(node_name, facts_hash(node_name), code)
+      FileUtils.rm_rf(vardir) if File.directory?(vardir)
+      catalogue
+    end
+
+    def import_str
+      klass_name = self.class.top_level_description.downcase
+
+      if File.exists?(File.join(Puppet[:modulepath], 'manifests', 'init.pp'))
+        path_to_manifest = File.join([
+          Puppet[:modulepath],
+          'manifests',
+          klass_name.split('::')[1..-1]
+        ].flatten)
+        import_str = [
+          "import '#{Puppet[:modulepath]}/manifests/init.pp'",
+          "import '#{path_to_manifest}.pp'",
+          '',
+        ].join("\n")
+      elsif File.exists?(Puppet[:modulepath])
+        import_str = "import '#{Puppet[:manifest]}'\n"
+      else
+        import_str = ""
+      end
+
+      import_str
+    end
+
+    def test_manifest(type)
+      klass_name = self.class.top_level_description.downcase
+
+      if type == :class
+        if !self.respond_to?(:params) || params == {}
+          "include #{klass_name}"
+        else
+          "class { '#{klass_name}': #{param_str} }"
+        end
+      elsif type == :define
+        if self.respond_to? :params
+          "#{klass_name} { '#{title}': #{param_str} }"
+        else
+          "#{klass_name} { '#{title}': }"
+        end
+      elsif type == :host
+        ""
+      end
+    end
+
+    def nodename(type)
+      if [:class, :define, :function].include? type
+        self.respond_to?(:node) ? node : Puppet[:certname]
+      else
+        self.class.top_level_description.downcase
+      end
+    end
+
+
+    def pre_cond
+      if self.respond_to?(:pre_condition) && !pre_condition.nil?
+        if pre_condition.is_a? Array
+          pre_condition.join("\n")
+        else
+          pre_condition
+        end
+      else
+        ''
+      end
+    end
+
+    def facts_hash(node)
+      facts_val = {
+        'hostname' => node.split('.').first,
+        'fqdn'     => node,
+        'domain'   => node.split('.', 2).last,
+      }
+
+      if RSpec.configuration.default_facts.any?
+        facts_val.merge!(munge_facts(RSpec.configuration.default_facts))
+      end
+
+      facts_val.merge!(munge_facts(facts)) if self.respond_to?(:facts)
+      facts_val
+    end
+
+    def param_str
+      params.keys.map do |r|
+        param_val = escape_special_chars(params[r].inspect)
+        "#{r.to_s} => #{param_val}"
+      end.join(', ')
+    end
+
+    def setup_puppet
+      vardir = Dir.mktmpdir
+      Puppet[:vardir] = vardir
+
+      [
+        [:modulepath, :module_path],
+        [:manifestdir, :manifest_dir],
+        [:manifest, :manifest],
+        [:templatedir, :template_dir],
+        [:config, :config],
+        [:confdir, :confdir],
+        [:hiera_config, :hiera_config],
+      ].each do |a, b|
+        value = self.respond_to?(b) ? self.send(b) : RSpec.configuration.send(b)
+        begin
+          Puppet[a] = value
+        rescue ArgumentError
+          Puppet.settings.setdefaults(:main, {a => {:default => value, :desc => a.to_s}})
+        end
       end
 
+      Puppet[:libdir] = Dir["#{Puppet[:modulepath]}/*/lib"].entries.join(File::PATH_SEPARATOR)
+      vardir
+    end
+
+    def build_catalog_without_cache(nodename, facts_val, code)
       Puppet[:code] = code
 
-      facts_val.each { |k, v| Facter.add(k) { setcode { v } } }
+      stub_facts! facts_val
 
       node_obj = Puppet::Node.new(nodename)
 
@@ -25,8 +142,11 @@ module RSpec::Puppet
       end
     end
 
-    public
-    def build_catalog *args
+    def stub_facts!(facts)
+      facts.each { |k, v| Facter.add(k) { setcode { v } } }
+    end
+
+    def build_catalog(*args)
       @@cache[args] ||= self.build_catalog_without_cache(*args)
     end
 
@@ -35,5 +155,32 @@ module RSpec::Puppet
       facts.keys.each { |key| output[key.to_s] = facts[key] }
       output
     end
+
+    def escape_special_chars(string)
+      string.gsub!(/\$/, "\\$")
+      string
+    end
+
+    def scope(compiler, node_name)
+      if Puppet.version =~ /^2\.[67]/
+        # loadall should only be necessary prior to 3.x
+        # Please note, loadall needs to happen first when creating a scope, otherwise
+        # you might receive undefined method `function_*' errors
+        Puppet::Parser::Functions.autoloader.loadall
+        scope = Puppet::Parser::Scope.new(:compiler => compiler)
+      else
+        scope = Puppet::Parser::Scope.new(compiler)
+      end
+
+      scope.source = Puppet::Resource::Type.new(:node, node_name)
+      scope.parent = compiler.topscope
+      scope
+    end
+
+    def build_node(name, opts = {})
+      node_environment = Puppet::Node::Environment.new('test')
+      opts.merge!({:environment => node_environment})
+      Puppet::Node.new(name, opts)
+    end
   end
 end