`). It highlights the use of a custom selector for the parent element to control layout, such as creating columns and rows. The example also shows how to exclude specific images from the gallery.
```html
```
--------------------------------
### Manually Applying matchHeight
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/assets/plugins/jquery-match-height/README.md
Illustrates how to directly use the apply function to match heights for specific elements, bypassing the automatic update functionality.
```javascript
$.fn.matchHeight._apply(elements, byRow)
```
--------------------------------
### Fixes and Enhancements for `run` Matcher (rspec-puppet)
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
Several fixes and enhancements have been made to the `run` matcher in rspec-puppet. These improvements ensure more reliable and accurate testing of Puppet runs. The example implies that the `run` matcher is now more robust.
```ruby
describe 'run_matcher_enhancements' do
it 'should work correctly with the updated run matcher'
# expect(run).to ... # Use the enhanced run matcher
end
end
```
--------------------------------
### Puppet Resource Matching Syntax
Source: https://github.com/rodjek/rspec-puppet/blob/master/README.md
Demonstrates the correct and incorrect syntax for matching Puppet resources in rspec-puppet tests. It highlights limitations such as the lack of support for quoted titles, inline arrays, and fully qualified class names with leading '::'.
```puppet
Notify[foo]
Class[profile::apache]
```
--------------------------------
### Fixing Newline Issue in pre_condition (rspec-puppet)
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
This fix addresses a bug in rspec-puppet where a newline might not be added after a user-specified `pre_condition`. This could cause catalogue compilation to fail. The example shows how the `pre_condition` is now correctly handled.
```ruby
describe 'pre_condition_newline' do
let(:pre_condition) { 'ensure_packages(apache2)' } # Pre-condition string
it 'should ensure newline after pre_condition'
# Test that the catalogue compiles correctly with the pre_condition
end
end
```
--------------------------------
### Testing Custom Types in rspec-puppet
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
This snippet demonstrates how to test custom Puppet types using rspec-puppet. It includes an example group and matcher specifically designed for this purpose. No external dependencies are required beyond rspec-puppet itself.
```ruby
describe 'custom_type' do
let(:title) { 'my_resource' }
let(:params) { { 'param1' => 'value1' } }
it { is_expected.to contain_custom_type(title).with(params) }
end
```
--------------------------------
### Display Gallery of YouTube Videos
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/assets/plugins/lightbox/examples/index.html
Illustrates how to create a gallery specifically for YouTube videos. It shows different ways to link to YouTube videos, including standard URLs, youtu.be short links, and embed URLs, all within a gallery format.
```html
```
--------------------------------
### Puppet Recursive Dependencies: Vertical
Source: https://github.com/rodjek/rspec-puppet/blob/master/README.md
Illustrates vertical recursion in rspec-puppet's relationship matchers, where dependencies with parent resources are checked. This example shows a class dependency where 'Package['foo']' must come before 'File['/foo']'.
```puppet
class { 'foo::install': } ->
class { 'foo::config': }
class foo::install {
package { 'foo': }
}
class foo::config {
file { '/foo': }
}
```
--------------------------------
### Fixing `compile.and_raise_error` in rspec-puppet
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
The `compile.and_raise_error` matcher has been fixed to correctly consider successful compilation as an error when this matcher is used. This ensures accurate testing of scenarios where compilation is expected to fail. The example implies correct behavior for this matcher.
```ruby
describe 'compilation_error_matcher' do
let(:manifest) { '...' } # Malformed Puppet code
it 'should raise an error when using and_raise_error'
expect(compile(manifest)).to raise_error(Puppet::Error)
end
end
```
--------------------------------
### Configure Hiera in rspec-puppet
Source: https://github.com/rodjek/rspec-puppet/blob/master/README.md
Demonstrates how to set up Hiera configuration within rspec-puppet tests. This involves defining the Hiera configuration file path and initializing Hiera. It's crucial for tests that rely on Hiera data.
```ruby
let(:hiera_config) { 'spec/fixtures/hiera/hiera.yaml' }
hiera = Hiera.new(:config => 'spec/fixtures/hiera/hiera.yaml')
```
--------------------------------
### Configure Test Environment with Facts and Node Parameters in rspec-puppet
Source: https://context7.com/rodjek/rspec-puppet/llms.txt
Shows how to configure the test environment in rspec-puppet using facts, node parameters, trusted facts, and pre/post conditions. This allows for more realistic testing scenarios by simulating different node states and configurations.
```ruby
require 'spec_helper'
describe 'mymodule' do
# Basic facts
let(:facts) do
{
'os' => {
'family' => 'RedHat',
'release' => { 'major' => '7', 'full' => '7.9' }
},
'networking' => { 'fqdn' => 'server.example.com' },
'kernel' => 'Linux'
}
end
# Node name
let(:node) { 'server.example.com' }
# Node parameters (top-scope variables like from ENC)
let(:node_params) do
{
'role' => 'webserver',
'environment' => 'production',
'datacenter' => 'us-east-1'
}
end
# Trusted facts (certificate extensions)
let(:trusted_facts) do
{
'pp_role' => 'webserver',
'pp_datacenter' => 'us-east-1'
}
end
# Trusted external data (Puppet 6.14+)
let(:trusted_external_data) do
{
'vault' => { 'secret_key' => 'abc123' }
}
end
# Pre-condition: code evaluated before the tested class
let(:pre_condition) do
<<-PUPPET
class { 'stdlib': }
$global_var = 'test_value'
PUPPET
end
# Post-condition: code evaluated after the tested class
let(:post_condition) { 'include mymodule::cleanup' }
# Environment name
let(:environment) { 'production' }
it { is_expected.to compile }
it { is_expected.to contain_class('mymodule').with_role('webserver') }
end
```
--------------------------------
### Coverage for Non-Class Resources in rspec-puppet
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
Coverage reports in rspec-puppet now correctly include non-class resources. This ensures a more accurate and comprehensive understanding of your code coverage, as all resource types are accounted for. The example implies that coverage is now calculated for all resource types.
```ruby
# In your RSpec configuration (e.g., spec/spec_helper.rb)
require 'rspec/puppet/coverage'
# Coverage reports will now include non-class resources.
```
--------------------------------
### Basic rspec-puppet Test Structure
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/documentation/applications/index.md
Defines the fundamental structure for an rspec-puppet test case for an application. It includes setting up the node, title, and parameters, which are essential for defining the application's context and configuration within the test. The `ref` method is crucial for creating valid node and resource references.
```ruby
describe '
' do
let(:node) { '' }
let(:title) { '' }
let(:params) do
{
'nodes' => {
ref('Node', node) => ref('', title)
}
# any additional app parameters
}
end
# tests go here
end
```
--------------------------------
### Basic Host Test Structure (Ruby)
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/documentation/hosts/index.md
Defines the basic structure for testing a host using RSpec-Puppet. It requires the spec_helper and uses a describe block for the host name. This sets up the environment to compile the catalogue for the specified host and run tests against it.
```ruby
require 'spec_helper'
describe '' do
# your tests go here
end
```
--------------------------------
### Test Puppet Catalog Compilation with RSpec-Puppet
Source: https://context7.com/rodjek/rspec-puppet/llms.txt
Demonstrates using the `compile` matcher in RSpec-Puppet to test catalog compilation. Covers basic compilation, compilation with all dependencies, testing for expected compilation errors, and detecting circular dependencies.
```ruby
require 'spec_helper'
describe 'mymodule' do
# Basic compilation
it { is_expected.to compile }
# Compile with all dependencies resolved
it { is_expected.to compile.with_all_deps }
# Test compilation failure with error matching
context 'with invalid parameters' do
let(:params) { { 'port' => 'invalid' } }
it { is_expected.to compile.and_raise_error(/expects an Integer/) }
it { is_expected.to compile.and_raise_error(Puppet::PreformattedError) }
end
# Test for dependency cycles
context 'with circular dependencies' do
let(:pre_condition) do
<<-PUPPET
file { '/a': require => File['/b'] }
file { '/b': require => File['/a'] }
PUPPET
end
it { is_expected.not_to compile }
end
end
```
--------------------------------
### Better Function Failure Messages
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
Function failure messages in rspec-puppet have been improved, providing more clarity and detail when functions encounter errors during testing. This aids in quicker debugging and resolution of function-related issues. The example implies more informative error output.
```ruby
describe 'function_failure_messages' do
it 'should provide clear failure messages for functions'
# expect { my_function_that_fails }.to raise_error(...)
# The error message will be more descriptive.
end
end
```
--------------------------------
### Configuring Resize Update Throttling for matchHeight
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/assets/plugins/jquery-match-height/README.md
Explains how to adjust the `_throttle` property to control the rate at which matchHeight updates its layout during window resize events. Lower values offer smoother updates at the cost of performance, while higher values improve performance at the cost of responsiveness.
```javascript
$.fn.matchHeight._throttle = 80;
```
--------------------------------
### Documenting the `scope` Property in rspec-puppet
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
The `scope` property within rspec-puppet has been documented. This clarifies its purpose and how it can be used, particularly in function testing, allowing developers to better understand and leverage this aspect of the framework. The example implies that documentation for `scope` is now available.
```ruby
# Refer to the rspec-puppet documentation for details on the 'scope' property.
```
--------------------------------
### Verify Resource Parameters with with_ and only_with_
Source: https://github.com/rodjek/rspec-puppet/blob/master/README.md
Allows testing of specific parameters passed to a resource. `with_` checks individual parameters, while `only_with_` ensures those are the only parameters set. The `with` and `only_with` methods can verify multiple parameters simultaneously.
```ruby
it { is_expected.to contain_package('mysql-server').with_ensure('present') }
it { is_expected.to contain_package('httpd').only_with_ensure('latest') }
it do
is_expected.to contain_service('keystone').with(
'ensure' => 'running',
'enable' => 'true',
'hasstatus' => 'true',
'hasrestart' => 'true'
)
end
it do
is_expected.to contain_user('luke').only_with(
'ensure' => 'present',
'uid' => '501'
)
end
```
--------------------------------
### Puppet's module_path Configuration in rspec-puppet
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
rspec-puppet now correctly respects and configures Puppet's `module_path`. It can handle multiple entries in `module_path`, ensuring that Puppet loads code from all specified directories. The example shows how multiple paths are handled.
```ruby
describe 'module_path_support' do
let(:module_path) { ['/etc/puppet/modules', '/usr/share/puppet/modules'] } # Multiple paths
it 'should load modules from all specified paths'
# Assert that modules from both paths are available for compilation
end
end
```
--------------------------------
### Delegate Event for Lightbox Initialization (jQuery)
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/assets/plugins/lightbox/examples/index.html
This JavaScript code sets up a delegated event listener for any element with the 'data-toggle="lightbox"' attribute. When clicked, it prevents the default action and initializes the Ekko Lightbox, making it efficient for dynamically added content.
```javascript
$(document).delegate('*[data-toggle="lightbox"]', 'click', function(event) {
event.preventDefault();
$(this).ekkoLightbox();
});
```
--------------------------------
### Specify Trusted Facts for Manifests in rspec-puppet
Source: https://github.com/rodjek/rspec-puppet/blob/master/README.md
Allows you to define custom trusted facts, particularly for Puppet versions 4.3 and later. This includes simulating certificate extensions that are typically found in the `$trusted['extensions']` hash. These can be set per example or as defaults.
```ruby
let(:trusted_facts) { {'pp_uuid' => 'ED803750-E3C7-44F5-BB08-41A04433FE2E', '1.3.6.1.4.1.34380.1.2.1' => 'ssl-termination'} }
```
```ruby
RSpec.configure do |c|
c.default_trusted_facts = {
'pp_uuid' => 'ED803750-E3C7-44F5-BB08-41A04433FE2E',
'1.3.6.1.4.1.34380.1.2.1' => 'ssl-termination'
}
end
```
--------------------------------
### Asserting File Resource Parameters in Puppet Defined Type with RSpec
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/tutorial/index.md
This RSpec snippet demonstrates how to assert specific parameters and their values for a file resource created by a Puppet defined type. It uses the `with` method to chain parameter checks.
```ruby
it do
is_expected.to contain_file('/etc/logrotate.d/nginx').with({
'ensure' => 'present',
'owner' => 'root',
'group' => 'root',
'mode' => '0444',
})
end
```
--------------------------------
### Munging Parameter Values in rspec-puppet
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
This fix ensures that when comparing parameter values, rspec-puppet will munge the actual value into an array if the expected value is an array with a single item. This provides more consistent and predictable parameter comparisons. The example illustrates this behavior.
```ruby
describe 'parameter_munging' do
let(:params) { { 'users' => ['alice'] } } # Actual value is an array
it 'should handle single-item array expectations'
expect(params['users']).to eq('alice') # Expected value is a string
# rspec-puppet will now correctly compare ['alice'] with 'alice'
end
end
```
--------------------------------
### RSpec Describe Blocks for Puppet Resource Types
Source: https://github.com/rodjek/rspec-puppet/blob/master/README.md
Demonstrates how to use RSpec's 'describe' blocks with type metadata to group tests for various Puppet resource types. This is useful when not adhering to the recommended directory structure for automatic grouping.
```ruby
describe 'myclass', :type => :class do
...
end
describe 'mydefine', :type => :define do
...
end
describe 'myapplication', :type => :application do
...
end
describe 'myfunction', :type => :puppet_function do
...
end
describe 'mytype', :type => :type do
...
end
describe 'My::TypeAlias', :type => :type_alias do
...
end
describe 'myhost.example.com', :type => :host do
...
end
```
--------------------------------
### Accessing Catalogue in Function Tests (rspec-puppet)
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
Function tests in rspec-puppet now have access to the compiled catalogue. This allows you to inspect the catalogue generated by your functions and perform more in-depth assertions. The example demonstrates how to access and use the catalogue within a function test.
```ruby
describe 'my_function' do
let(:scope) { ... }
let(:catalogue) { compile_catalogue(scope) } # Access the catalogue
it 'should produce the correct resources'
expect(catalogue.resource('Notify[hello]')).to be_present
end
end
```
--------------------------------
### Testing File Resource Creation in Puppet Defined Type with RSpec
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/tutorial/index.md
Shows how to test if a Puppet defined type creates a specific file resource. This snippet asserts the existence of a file in `/etc/logrotate.d/`.
```ruby
it { is_expected.to contain_file('/etc/logrotate.d/nginx') }
```
--------------------------------
### Testing with Future Parser in rspec-puppet
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
rspec-puppet allows you to test your Puppet code against the future parser. This is essential for ensuring compatibility with upcoming Puppet versions and for adopting new syntax features. The example shows how to enable the future parser for your tests.
```ruby
describe 'future_parser_tests' do
let(:parser) { 'future' } # Enable future parser
it 'should work with the future parser'
# Test your code using future parser syntax
end
end
```
--------------------------------
### Coverage Reports in rspec-puppet
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
This feature provides coverage reports for your Puppet code, helping you identify untested parts of your manifests and modules. It integrates with RSpec's coverage reporting mechanisms. The example shows how to enable and view coverage reports.
```ruby
# In your RSpec configuration (e.g., spec/spec_helper.rb)
require 'rspec/puppet/coverage'
RSpec.configure do |c|
c.before :each do
# Optionally clear coverage before each test
Puppet::RSpec::Coverage.instance.reset
end
end
# Run with: rspec --format progress --format RspecPuppet::CoverageFormatter
```
--------------------------------
### Specify Post-Conditions for Manifest Loading in rspec-puppet
Source: https://github.com/rodjek/rspec-puppet/blob/master/README.md
Enables you to define Puppet code that will be evaluated after the manifest under test. This is useful for ensuring that certain code runs after the tested class, for example, when testing modular components. The post-condition can be a single string or an array of strings.
```ruby
let(:post_condition) { 'include other_class' }
```
--------------------------------
### Test Puppet Function Execution with RSpec-Puppet
Source: https://context7.com/rodjek/rspec-puppet/llms.txt
Demonstrates testing Puppet functions using RSpec-Puppet's `run` matcher. Covers successful execution, regex matching, error handling, and lambda/block usage. It also shows how to test functions that modify the catalogue and interact with scope lookups.
```ruby
require 'spec_helper'
describe 'my_split' do
# Test successful execution with return value
it { is_expected.to run.with_params('hello-world', '-').and_return(['hello', 'world']) }
# Test with regex pattern matching on return
it { is_expected.to run.with_params('test123', /\d+/).and_return(/test/) }
# Test error handling
it { is_expected.to run.with_params().and_raise_error(ArgumentError) }
it { is_expected.to run.with_params('single').and_raise_error(ArgumentError, /expects 2 arguments/) }
# Test that function runs without error (no return value check)
it { is_expected.to run.with_params('foo', 'o') }
# Test with lambda/block
it { is_expected.to run.with_params([1, 2, 3]).with_lambda { |x| x * 2 }.and_return([2, 4, 6]) }
# Test function that modifies catalogue
context 'ensure_resource function' do
it 'adds resources to the catalogue' do
is_expected.to run.with_params('user', 'testuser', { 'ensure' => 'present' })
expect(catalogue).to contain_user('testuser').with_ensure('present')
end
end
# Access parser scope for stubbing
context 'with scope lookups' do
let(:pre_condition) { 'include ::mymodule' }
before do
allow(scope).to receive(:lookupvar).with('mymodule::config_dir').and_return('/etc/myapp')
end
it { is_expected.to run.with_params('config').and_return('/etc/myapp/config') }
end
end
```
--------------------------------
### Testing Puppet Catalog Compilation with rspec-puppet
Source: https://github.com/rodjek/rspec-puppet/blob/master/README.md
Shows how to use the 'compile' matcher in rspec-puppet to verify that a Puppet catalog compiles without errors. It also demonstrates how to assert specific error messages during compilation.
```ruby
it { is_expected.to compile }
```
```ruby
it { is_expected.to compile.and_raise_error(/error message match/) }
```
--------------------------------
### Adding Settings for Ordering, Strict Variables, etc. (rspec-puppet)
Source: https://github.com/rodjek/rspec-puppet/blob/master/docs/changelog/index.md
New settings have been added to rspec-puppet, including `ordering`, `strict_variables`, `stringify_facts`, and `trusted_node_data`. These allow for more granular control over Puppet's behavior during testing. The example shows how to set one of these options.
```ruby
describe 'puppet_settings' do
let(:strict_variables) { true } # Enable strict variables
it 'should compile with strict variables enabled'
# Test your code to ensure it adheres to strict variable rules
end
end
```
