rspec-puppet-maestrodev 0.1.5.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Tim Sharpe
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,292 @@
+# RSpec tests for your Puppet manifests & modules
+
+## Installation
+
+    gem install rspec-puppet
+
+## Naming conventions
+
+For clarity and consistency, I recommend that you use the following directory
+structure and naming convention.
+
+    module
+      |
+      +-- manifests
+      |
+      +-- lib
+      |
+      +-- spec
+           |
+           +-- spec_helper.rb
+           |
+           +-- classes
+           |     |
+           |     +-- <class_name>_spec.rb
+           |
+           +-- defines
+           |     |
+           |     +-- <define_name>_spec.rb
+           |
+           +-- functions
+           |     |
+           |     +-- <function_name>_spec.rb
+           |
+           +-- hosts
+                 |
+                 +-- <host_name>_spec.rb
+
+## Example groups
+
+If you use the above directory structure, your examples will automatically be
+placed in the correct groups and have access to the custom matchers.  *If you
+choose not to*, you can force the examples into the required groups as follows.
+
+```ruby
+describe 'myclass', :type => :class do
+  ...
+end
+
+describe 'mydefine', :type => :define do
+  ...
+end
+
+describe 'myfunction', :type => :puppet_function do
+  ...
+end
+
+describe 'myhost.example.com', :type => :host do
+  ...
+end
+```
+
+## Defined Types & Classes
+
+### Matchers
+
+#### Checking if a class has been included
+
+You can test if a class has been included in the catalogue with the
+`include_class` matcher.  It takes the class name as a string as its only
+argument
+
+```ruby
+it { should include_class('foo') }
+```
+
+#### Checking if a resource exists
+
+You can test if a resource exists in the catalogue with the generic
+`contain_<resource type>` matcher.
+
+```ruby
+it { should contain_augeas('bleh') }
+```
+
+If your resource type includes :: (e.g.
+`foo::bar` simply replace the :: with __ (two underscores).
+
+```ruby
+it { should contain_foo__bar('baz') }
+```
+
+You can further test the parameters that have been passed to the resources with
+the generic `with_<parameter>` chains.
+
+```ruby
+it { should contain_package('mysql-server').with_ensure('present') }
+```
+
+You can use the `with` method to verify the value of multiple parameters.
+
+```ruby
+it do should contain_service('keystone').with(
+  'ensure'     => 'running',
+  'enable'     => 'true',
+  'hasstatus'  => 'true',
+  'hasrestart' => 'true'
+) end
+```
+
+You can also test that specific parameters have been left undefined with the
+generic `without_<parameter>` chains.
+
+```ruby
+it { should contain_file('/foo/bar').without_mode }
+```
+
+You can use the without method to verify that a list of parameters have not been
+defined
+
+```ruby
+it { should contain_service('keystone').without(
+  ['restart', 'status']
+)}
+```
+
+### Writing tests
+
+#### Basic test structure
+
+To test that
+
+    sysctl { 'baz'
+      value => 'foo',
+    }
+
+Will cause the following resource to be in included in catalogue for a host
+
+    exec { 'sysctl/reload':
+      command => '/sbin/sysctl -p /etc/sysctl.conf',
+    }
+
+We can write the following testcase (in `spec/defines/sysctl_spec.rb`)
+
+```ruby
+describe 'sysctl' do
+  let(:title) { 'baz' }
+  let(:params) { { :value => 'foo' } }
+
+  it { should contain_exec('sysctl/reload').with_command("/sbin/sysctl -p /etc/sysctl.conf") }
+end
+```
+
+#### Specifying the title of a resource
+
+```ruby
+let(:title) { 'foo' }
+```
+
+#### Specifying the parameters to pass to a resources or parametised class
+
+```ruby
+let(:params) { {:ensure => 'present', ...} }
+```
+
+#### Specifying the FQDN of the test node
+
+If the manifest you're testing expects to run on host with a particular name,
+you can specify this as follows
+
+```ruby
+let(:node) { 'testhost.example.com' }
+```
+
+#### Specifying the facts that should be available to your manifest
+
+By default, the test environment contains no facts for your manifest to use.
+You can set them with a hash
+
+```ruby
+let(:facts) { {:operatingsystem => 'Debian', :kernel => 'Linux', ...} }
+```
+
+#### Specifying the path to find your modules
+
+I recommend setting a default module path by adding the following code to your
+`spec_helper.rb`
+
+```ruby
+RSpec.configure do |c|
+  c.module_path = '/path/to/your/module/dir'
+end
+```
+
+However, if you want to specify it in each example, you can do so
+
+```ruby
+let(:module_path) { '/path/to/your/module/dir' }
+```
+
+## Functions
+
+### Matchers
+
+All of the standard RSpec matchers are available for you to use when testing
+Puppet functions.
+
+```ruby
+it 'should be able to do something' do
+  subject.call('foo') == 'bar'
+end
+```
+
+For your convenience though, a `run` matcher exists to provide easier to
+understand test cases.
+
+```ruby
+it { should run.with_params('foo').and_return('bar') }
+```
+
+### Writing tests
+
+#### Basic test structure
+
+```ruby
+require 'spec_helper'
+
+describe '<function name>' do
+  ...
+end
+```
+
+#### Specifying the name of the function to test
+
+The name of the function must be provided in the top level description, e.g.
+
+```ruby
+describe 'split' do
+```
+
+#### Specifying the arguments to pass to the function
+
+You can specify the arguments to pass to your function during the test(s) using
+either the `with_params` chain method in the `run` matcher
+
+```ruby
+it { should run.with_params('foo', 'bar', ['baz']) }
+```
+
+Or by using the `call` method on the subject directly
+
+```ruby
+it 'something' do
+  subject.call('foo', 'bar', ['baz'])
+end
+```
+
+#### Testing the results of the function
+
+You can test the result of a function (if it produces one) using either the
+`and_returns` chain method in the `run` matcher
+
+```ruby
+it { should run.with_params('foo').and_return('bar') }
+```
+
+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
+end
+```
+
+#### Testing the errors thrown by the function
+
+You can test whether the function throws an exception using either the
+`and_raises_error` chain method in the `run` matcher
+
+```ruby
+it { should run.with_params('a', 'b').and_raise_error(Puppet::ParseError) }
+it { should_not run.with_params('a').and_raise_error(Puppet::ParseError) }
+```
+
+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)
+end
+```

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake'
+require 'rspec/core/rake_task'
+
+task :default => :test
+task :spec => :test
+
+RSpec::Core::RakeTask.new(:test)

data/bin/rspec-puppet-init

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'rspec-puppet'
+require 'optparse'
+
+options = {
+  :module_name => nil,
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: rspec-puppet-init [options]"
+
+  opts.on('-n', '--name NAME', 'The name of the module (override autodetection)') do |v|
+    options[:module_name] = v
+  end
+end.parse!
+
+RSpec::Puppet::Setup.run(options[:module_name])

data/lib/rspec-puppet.rb

@@ -0,0 +1,15 @@
+require 'puppet'
+require 'rspec'
+require 'fileutils'
+require 'tmpdir'
+require 'rspec-puppet/matchers'
+require 'rspec-puppet/example'
+require 'rspec-puppet/setup'
+
+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
+end

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,60 @@
+module RSpec::Puppet
+  module ClassExampleGroup
+    include RSpec::Puppet::ManifestMatchers
+    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
+        pre_cond = pre_condition
+      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
+    end
+  end
+end