rspec-puppet 0.1.6 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fc2b092d4a84ad47ceff22b0123d01b8171ff612
+  data.tar.gz: eb32c18c64ad5ae96e69f53fc8d2999665784f24
+SHA512:
+  metadata.gz: 4f6909ee0c338d72e1251590bccc3d6a5b34fcc8279158ce1a39a26f3905396e3e6a06284cb92392c7b7aecf8f4c3b7e1a5960189ab3f5d7796afe3c131f49e1
+  data.tar.gz: ffd7a6073b9afc2d660d061c42450381ff631c77df9f953289c62875e8f12aa5d05889f7a23eafd01a9741e931b6007da82fc17a5cb76538090adcb42ce7b541

data/README.md

@@ -96,6 +96,13 @@ the generic `with_<parameter>` chains.
 it { should contain_package('mysql-server').with_ensure('present') }
 ```
 
+If you want to specify that the given parameters should be the only ones passed
+to the resource, use the `only_with_<parameter>` chains.
+
+```ruby
+it { should contain_package('httpd').only_with_ensure('latest') }
+```
+
 You can use the `with` method to verify the value of multiple parameters.
 
 ```ruby
@@ -107,6 +114,16 @@ it do should contain_service('keystone').with(
 ) end
 ```
 
+The same holds for the `only_with` method, which in addition verifies the exact
+set of parameters and values for the resource in the catalogue.
+
+```ruby
+it do should contain_user('luke').only_with(
+  'ensure'    => 'present',
+  'uid'    => '501'
+) end
+```
+
 You can also test that specific parameters have been left undefined with the
 generic `without_<parameter>` chains.
 
@@ -123,6 +140,41 @@ it { should contain_service('keystone').without(
 )}
 ```
 
+#### Checking the number of resources
+
+You can test the number of resources in the catalogue with the
+`have_resource_count` matcher.
+
+```ruby
+it { should have_resource_count(2) }
+```
+
+The number of classes in the catalogue can be checked with the
+`have_class_count` matcher.
+
+```ruby
+it { should have_class_count(2) }
+```
+
+You can also test the number of a specific resource type, by using the generic
+`have_<resource type>_resource_count` matcher.
+
+```ruby
+it { should have_exec_resource_count(1) }
+```
+
+This last matcher also works for defined types. If the resource type contains
+::, you can replace it with __ (two underscores).
+
+```ruby
+it { should have_logrotate__rule_resource_count(3) }
+```
+
+*NOTE*: when testing a class, the catalogue generated will always contain at
+least one class, the class under test. The same holds for defined types, the
+catalogue generated when testing a defined type will have at least one resource
+(the defined type itself).
+
 ### Writing tests
 
 #### Basic test structure
@@ -180,6 +232,19 @@ You can set them with a hash
 let(:facts) { {:operatingsystem => 'Debian', :kernel => 'Linux', ...} }
 ```
 
+You can also create a set of default facts provided to all specs in your spec_helper:
+
+``` ruby
+RSpec.configure do |c|
+  c.default_facts = {
+    :operatingsystem => 'Ubuntu'
+  }
+end
+```
+
+Any facts you provide with `let(:facts)` in a spec will automatically be merged on top
+of the default facts.
+
 #### Specifying the path to find your modules
 
 I recommend setting a default module path by adding the following code to your
@@ -206,7 +271,7 @@ Puppet functions.
 
 ```ruby
 it 'should be able to do something' do
-  subject.call('foo') == 'bar'
+  subject.call(['foo']) == 'bar'
 end
 ```
 
@@ -250,7 +315,7 @@ Or by using the `call` method on the subject directly
 
 ```ruby
 it 'something' do
-  subject.call('foo', 'bar', ['baz'])
+  subject.call(['foo', 'bar', ['baz']])
 end
 ```
 
@@ -267,8 +332,8 @@ Or by using any of the existing RSpec matchers on the subject directly
 
 ```ruby
 it 'something' do
-  subject.call('foo') == 'bar'
-  subject.call('baz').should be_an Array
+  subject.call(['foo']) == 'bar'
+  subject.call(['baz']).should be_an Array
 end
 ```
 
@@ -286,7 +351,7 @@ Or by using the existing `raises_error` RSpec matcher
 
 ```ruby
 it 'something' do
-  expect { subject.call('a', 'b') }.should raise_error(Puppet::ParseError)
-  expect { subject.call('a') }.should_not raise_error(Puppet::ParseError)
+  expect { subject.call(['a', 'b']) }.should raise_error(Puppet::ParseError)
+  expect { subject.call(['a']) }.should_not raise_error(Puppet::ParseError)
 end
 ```

data/lib/rspec-puppet.rb

@@ -2,14 +2,59 @@ require 'puppet'
 require 'rspec'
 require 'fileutils'
 require 'tmpdir'
+require 'rspec-puppet/errors'
 require 'rspec-puppet/matchers'
 require 'rspec-puppet/example'
 require 'rspec-puppet/setup'
 
+begin
+  require 'puppet/test/test_helper'
+rescue LoadError
+end
+
 RSpec.configure do |c|
   c.add_setting :module_path, :default => '/etc/puppet/modules'
   c.add_setting :manifest_dir, :default => nil
   c.add_setting :manifest, :default => nil
   c.add_setting :template_dir, :default => nil
   c.add_setting :config, :default => nil
+  c.add_setting :confdir, :default => '/etc/puppet'
+  c.add_setting :default_facts, :default => {}
+  c.add_setting :hiera_config, :default => '/dev/null'
+
+  if defined?(Puppet::Test::TestHelper)
+    begin
+      Puppet::Test::TestHelper.initialize
+    rescue NoMethodError
+      Puppet::Test::TestHelper.before_each_test
+    end
+
+    c.before :all do
+      begin
+        Puppet::Test::TestHelper.before_all_tests
+      rescue
+      end
+    end
+
+    c.after :all do
+      begin
+        Puppet::Test::TestHelper.after_all_tests
+      rescue
+      end
+    end
+
+    c.before :each do
+      begin
+        Puppet::Test::TestHelper.before_each_test
+      rescue
+      end
+    end
+
+    c.after :each do
+      begin
+        Puppet::Test::TestHelper.after_each_test
+      rescue
+      end
+    end
+  end
 end

data/lib/rspec-puppet/errors.rb

@@ -0,0 +1,83 @@
+module RSpec::Puppet
+  module Errors
+    class MatchError < StandardError
+      attr_reader :param, :expected, :actual, :negative
+
+      def initialize(param, expected, actual, negative)
+        @param = param
+        @expected = expected.inspect
+        @actual = actual.inspect
+        @negative = negative
+      end
+
+      def message
+        if negative == true
+          "#{param} not set to #{expected} but it is set to #{actual}"
+        else
+          "#{param} set to #{expected} but it is set to #{actual}"
+        end
+      end
+
+      def to_s
+        message
+      end
+    end
+
+    class RegexpMatchError < MatchError
+      def message
+        if negative == true
+          "#{param} not matching #{expected} but its value of #{actual} does"
+        else
+          "#{param} matching #{expected} but its value of #{actual} does not"
+        end
+      end
+    end
+
+    class ProcMatchError < MatchError
+      def message
+        if negative == true
+          "#{param} passed to the block would not return `#{expected}` but it did"
+        else
+          "#{param} passed to the block would return `#{expected}` but it is `#{actual}`"
+        end
+      end
+    end
+
+    class RelationshipError < StandardError
+      attr_reader :from, :to
+
+      def initialize(from, to)
+        @from = from
+        @to = to
+      end
+
+      def to_s
+        message
+      end
+    end
+
+    class BeforeRelationshipError < RelationshipError
+      def message
+        "#{from} to come before #{to} in the graph"
+      end
+    end
+
+    class RequireRelationshipError < RelationshipError
+      def message
+        "#{from} to require #{to} in the graph"
+      end
+    end
+
+    class NotifyRelationshipError < RelationshipError
+      def message
+        "#{from} to notify #{to}"
+      end
+    end
+
+    class SubscribeRelationshipError < RelationshipError
+      def message
+        "#{from} to be subscribed to #{to}"
+      end
+    end
+  end
+end

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

@@ -4,61 +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
-
-      klass_name = self.class.top_level_description.downcase
-
-      # If we're testing a standalone module (i.e. one that's outside of a
-      # puppet tree), the autoloader won't work, so we need to fudge it a bit.
-      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'\nimport '#{path_to_manifest}.pp'\n"
-      elsif File.exists?(Puppet[:modulepath])
-        import_str = "import '#{Puppet[:manifest]}'\n"
-      else
-        import_str = ""
-      end
-
-      if self.respond_to? :pre_condition
-        if pre_condition.kind_of?(Array)
-          pre_cond = pre_condition.join("\n")
-        else
-          pre_cond = pre_condition
-        end
-      else
-        pre_cond = ''
-      end
-
-      if !self.respond_to?(:params) || params == {}
-        code = import_str + "include #{klass_name}"
-      else
-        code = import_str + 'class' + " { \"" + klass_name + "\": " + params.keys.map { |r| "#{r.to_s} => #{params[r].inspect}"
-      }.join(',' ) + " }"
-      end
-      code = pre_cond + "\n" + code
-
-      nodename = self.respond_to?(:node) ? node : Puppet[:certname]
-      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(:class)
     end
   end
 end

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

@@ -4,63 +4,7 @@ module RSpec::Puppet
     include RSpec::Puppet::Support
 
     def subject
-      @catalogue ||= catalogue
-    end
-
-    def catalogue
-      define_name = self.class.top_level_description.downcase
-
-      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
-
-      # If we're testing a standalone module (i.e. one that's outside of a
-      # puppet tree), the autoloader won't work, so we need to fudge it a bit.
-      if File.exists?(File.join(Puppet[:modulepath], 'manifests', 'init.pp'))
-        path_to_manifest = File.join([Puppet[:modulepath], 'manifests', define_name.split('::')[1..-1]].flatten)
-        import_str = "import '#{Puppet[:modulepath]}/manifests/init.pp'\nimport '#{path_to_manifest}.pp'\n"
-      elsif File.exists?(Puppet[:modulepath])
-        import_str = "import '#{Puppet[:manifest]}'\n"
-      else
-        import_str = ""
-      end
-
-      if self.respond_to? :params
-        param_str = params.keys.map { |r|
-          "#{r.to_s} => #{params[r].inspect}"
-        }.join(', ')
-      else
-        param_str = ""
-      end
-
-      if self.respond_to? :pre_condition
-        if pre_condition.kind_of?(Array)
-          pre_cond = pre_condition.join("\n")
-        else
-          pre_cond = pre_condition
-        end
-      else
-        pre_cond = ""
-      end
-
-      code = pre_cond + "\n" + import_str + define_name + " { \"" + title + "\": " + param_str + " }"
-
-      nodename = self.respond_to?(:node) ? node : Puppet[:certname]
-      facts_val = {
-        'hostname' => nodename.split('.').first,
-        'fqdn' => nodename,
-        'domain' => nodename.split('.', 2).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(:define)
     end
   end
 end

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

@@ -1,58 +1,44 @@
-require 'puppetlabs_spec_helper/puppetlabs_spec/puppet_internals'
-
 module RSpec::Puppet
   module FunctionExampleGroup
     include RSpec::Puppet::FunctionMatchers
-    PuppetInternals = PuppetlabsSpec::PuppetInternals
+    include RSpec::Puppet::ManifestMatchers
+    include RSpec::Puppet::Support
 
     def subject
       function_name = self.class.top_level_description.downcase
 
-      Puppet[:modulepath] = self.respond_to?(:module_path) ? module_path : RSpec.configuration.module_path
-      Puppet[:libdir] = Dir["#{Puppet[:modulepath]}/*/lib"].entries.join(File::PATH_SEPARATOR)
+      vardir = setup_puppet
 
-      nodename = self.respond_to?(:node) ? node : Puppet[:certname]
-      facts_val = {
-        'hostname' => nodename.split('.').first,
-        'fqdn' => nodename,
-        'domain' => nodename.split('.').last,
-      }
-      facts_val.merge!(munge_facts(facts)) if self.respond_to?(:facts)
-      facts_val.each { |k, v| Facter.add(k) { setcode { v } } }
+      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
-      if self.respond_to? :pre_condition
-        if pre_condition.kind_of?(Array)
-          Puppet[:code] = pre_condition.join("\n")
-        else
-          Puppet[:code] = pre_condition
-        end
-        # we need to get a compiler, b/c we can attach that to a scope
-        @compiler = build_compiler(nodename, facts_val)
-      else
-        @compiler = PuppetInternals.compiler
-      end
-
-      scope = PuppetInternals.scope(:compiler => @compiler)
+      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
-      method = PuppetInternals.function_method(function_name, :scope => scope)
-    end
-
-    def compiler
-      @compiler
+      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 = {
-        :name    => node_name,
-        :options => { :parameters => fact_values },
+        :parameters => fact_values,
       }
-      node = PuppetInternals.node(node_options)
-      compiler = PuppetInternals.compiler(:node => node)
+
+      stub_facts! fact_values
+
+      node = build_node(node_name, node_options)
+
+      compiler = Puppet::Parser::Compiler.new(node)
       compiler.compile
       compiler
     end