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

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

@@ -0,0 +1,19 @@
+module RSpec::Puppet
+  module ManifestMatchers
+    extend RSpec::Matchers::DSL
+
+    matcher :include_class do |expected_class|
+      match do |catalogue|
+        catalogue.classes.include? expected_class
+      end
+
+      description do
+        "include Class[#{expected_class}]"
+      end
+
+      failure_message_for_should do |actual|
+        "expected that the catalogue would include Class[#{expected_class}]"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module RSpec::Puppet
+  module FunctionMatchers
+    class Run
+      def matches?(func_obj)
+        if @params
+          @func = lambda { func_obj.call(@params) }
+        else
+          @func = lambda { func_obj.call }
+        end
+
+        unless @expected_error.nil?
+          result = false
+          begin
+            @func.call
+          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
+          unless @expected_return.nil?
+            @actual_return = @func.call
+            @actual_return == @expected_return
+          else
+            begin
+              @func.call
+            rescue
+              false
+            end
+            true
+          end
+        end
+      end
+
+      def with_params(*params)
+        @params = params
+        self
+      end
+
+      def and_return(value)
+        @expected_return = value
+        self
+      end
+
+      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
+
+      def failure_message_for_should(func_obj)
+        failure_message_generic(:should, func_obj)
+      end
+
+      def failure_message_for_should_not(func_obj)
+        failure_message_generic(:should_not, func_obj)
+      end
+
+      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
+          message << "have returned #{@expected_return.inspect}"
+          if type == :should
+            message << " instead of #{@actual_return.inspect}"
+          end
+        elsif @expected_error
+          message << "have raised #{@expected_error.inspect}"
+        else
+          message << "have run successfully"
+        end
+        message
+      end
+    end
+  end
+end

data/lib/rspec-puppet/setup.rb

@@ -0,0 +1,167 @@
+require 'puppet'
+require 'fileutils'
+
+module RSpec::Puppet
+  class Setup
+    def self.run(module_name=nil)
+      unless is_module_dir?
+        $stderr.puts "Does not appear to be a Puppet module.  Aborting"
+        return false
+      end
+
+      if module_name.nil?
+        module_name = get_module_name
+        if module_name.nil?
+          $stderr.puts "Unable to determine module name.  Aborting"
+          return false
+        end
+      end
+
+      [
+        'spec',
+        'spec/classes',
+        'spec/defines',
+        'spec/functions',
+        'spec/hosts',
+        'spec/fixtures',
+        'spec/fixtures/manifests',
+        'spec/fixtures/modules',
+        "spec/fixtures/modules/#{module_name}",
+      ].each { |dir| safe_mkdir(dir) }
+
+      safe_touch('spec/fixtures/manifests/site.pp')
+
+      ['manifests','lib','files','templates'].each do |dir|
+        if File.exist? dir
+          safe_make_symlink("../../../../#{dir}", "spec/fixtures/modules/#{module_name}/#{dir}")
+        end
+      end
+
+      safe_create_spec_helper
+      safe_create_rakefile
+    end
+
+  protected
+    def self.get_module_name
+      module_name = nil
+      Dir["manifests/*.pp"].entries.each do |manifest|
+        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
+
+    def self.is_module_dir?
+      Dir["*"].entries.include? "manifests"
+    end
+
+    def self.safe_mkdir(dir)
+      if File.exists? dir
+        unless File.directory? dir
+          $stderr.puts "!! #{dir} already exists and is not a directory"
+        end
+      else
+        FileUtils.mkdir dir
+        puts " + #{dir}/"
+      end
+    end
+
+    def self.safe_touch(file)
+      if File.exists? file
+        unless File.file? file
+          $stderr.puts "!! #{file} already exists and is not a regular file"
+        end
+      else
+        FileUtils.touch file
+        puts " + #{file}"
+      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'
+
+fixture_path = File.expand_path(File.join(__FILE__, '..', 'fixtures'))
+
+RSpec.configure do |c|
+  c.module_path = File.join(fixture_path, 'modules')
+  c.manifest_dir = File.join(fixture_path, 'manifests')
+end
+EOF
+    safe_create_file('spec/spec_helper.rb', content)
+    end
+
+    def self.safe_make_symlink(source, target)
+      if File.exists? target
+        unless File.symlink? target
+          $stderr.puts "!! #{file} already exists and is not a symlink"
+        end
+      else
+        FileUtils.ln_s(source, target)
+        puts " + #{target}"
+      end
+    end
+
+    def self.safe_create_rakefile
+      content = <<-'EOF'
+require 'rake'
+require 'rspec/core/rake_task'
+
+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
+    safe_create_file('Rakefile', content)
+    end
+  end
+end

data/lib/rspec-puppet/support.rb

@@ -0,0 +1,165 @@
+module RSpec::Puppet
+  module Support
+
+    @@cache = {}
+
+    def catalogue(type)
+      vardir = setup_puppet
+
+      code = 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 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('.').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],
+      ].each do |a, b|
+        if self.respond_to? b
+          Puppet[a] = self.send(b)
+        else
+          Puppet[a] = RSpec.configuration.send(b)
+        end
+      end
+
+      if Puppet[:hiera_config] == File.expand_path('/dev/null')
+        Puppet[:hiera_config] = File.join(vardir, 'hiera.yaml')
+      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
+
+      stub_facts! facts_val
+
+      node_obj = Puppet::Node.new(nodename)
+
+      node_obj.merge(facts_val)
+
+      # trying to be compatible with 2.7 as well as 2.6
+      if Puppet::Resource::Catalog.respond_to? :find
+        Puppet::Resource::Catalog.find(node_obj.name, :use_node => node_obj)
+      else
+        Puppet::Resource::Catalog.indirection.find(node_obj.name, :use_node => node_obj)
+      end
+    end
+
+    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
+
+    def munge_facts(facts)
+      output = {}
+      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