diff --git a/spec/classes/munin_master_spec.rb b/spec/classes/munin_master_spec.rb
index b4e99e5..8ba97e7 100644
--- a/spec/classes/munin_master_spec.rb
+++ b/spec/classes/munin_master_spec.rb
@@ -1,196 +1,196 @@
 require 'spec_helper'
 
 _conf_dir = {}
 _conf_dir.default = '/etc/munin'
 _conf_dir['Solaris'] = '/opt/local/etc/munin'
 _conf_dir['FreeBSD'] = '/usr/local/etc/munin'
 
 _package = {}
 _package.default = 'munin'
 _package['FreeBSD'] = 'munin-master'
 
 describe 'munin::master' do
   on_supported_os.each do |os, facts|
     # Avoid testing on distributions similar to RedHat and Debian
     next if os =~ %r{^(ubuntu|centos|scientific|oraclelinux)-}
 
     # No need to test all os versions as long as os version is not
     # used in the params class
     next if os =~ %r{^(debian-[67]|redhat-[56]|freebsd-9)-}
 
     context "on #{os}" do
       let(:facts) do
         facts
       end
 
       conf_dir = _conf_dir[facts[:osfamily]]
       package = _package[facts[:osfamily]]
 
       it { is_expected.to compile.with_all_deps }
 
       it { is_expected.to contain_package(package) }
 
       context 'with default params' do
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
             .with_content(%r{graph_strategy\s+cgi})
             .with_content(%r{html_strategy\s+cgi})
         end
 
         it do
           is_expected.to contain_file("#{conf_dir}/munin-conf.d")
             .with_ensure('directory')
         end
       end
 
       context 'with html_strategy => cron' do
         let(:params) { { html_strategy: 'cron' } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
             .with_content(%r{html_strategy\s+cron})
         end
       end
 
       context 'with graph_strategy => cron' do
         let(:params) { { graph_strategy: 'cron' } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
             .with_content(%r{graph_strategy\s+cron})
         end
       end
 
       context 'with dbdir => /var/lib/munin' do
         let(:params) { { dbdir: '/var/lib/munin' } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
-            .with_content(/dbdir\s+\/var\/lib\/munin/)
+            .with_content(%r{dbdir\s+/var/lib/munin})
         end
       end
 
       context 'with htmldir => /var/www/munin' do
         let(:params) { { htmldir: '/var/www/munin' } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
-            .with_content(/htmldir\s+\/var\/www\/munin/)
+            .with_content(%r{htmldir\s+/var/www/munin})
         end
       end
 
       context 'with logdir => /var/log/munin' do
         let(:params) { { dbdir: '/var/log/munin' } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
-            .with_content(/dbdir\s+\/var\/log\/munin/)
+            .with_content(%r{dbdir\s+/var/log/munin})
         end
       end
 
       context 'with rundir => /var/run/munin' do
         let(:params) { { dbdir: '/var/run/munin' } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
-            .with_content(/dbdir\s+\/var\/run\/munin/)
+            .with_content(%r{dbdir\s+/var/run/munin})
         end
       end
 
       context 'with tls => enabled' do
         let(:params) do
           {
             tls: 'enabled',
             tls_certificate: '/path/to/certificate.pem',
             tls_private_key: '/path/to/key.pem',
             tls_verify_certificate: 'yes',
           }
         end
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
             .with_content(%r{tls = enabled})
-            .with_content(/tls_certificate = \/path\/to\/certificate\.pem/)
-            .with_content(/tls_private_key = \/path\/to\/key\.pem/)
+            .with_content(%r{tls_certificate = /path/to/certificate\.pem})
+            .with_content(%r{tls_private_key = /path/to/key\.pem})
             .with_content(%r{tls_verify_certificate = yes})
         end
       end
 
       context 'with node_definitions' do
         let(:params) do
           {
             node_definitions: {
               'node-a' => {
                 'address' => 'munin://node-a.example.com',
               },
               'node-b' => {
                 'address' => 'munin://node-b.example.com',
               },
             },
           }
         end
 
         it { is_expected.to compile.with_all_deps }
         it { is_expected.to contain_munin__master__node_definition('node-a') }
         it { is_expected.to contain_munin__master__node_definition('node-b') }
       end
 
       context 'with extra_config' do
         token = '1b7febce-bb2d-4c18-b889-84c73538a900'
         let(:params) do
           { extra_config: [token] }
         end
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
             .with_content(%r{#{token}})
         end
       end
 
       context 'with extra_config set to a string' do
         token = '1b7febce-bb2d-4c18-b889-84c73538a900'
         let(:params) do
           { extra_config: token }
         end
 
         it { is_expected.to raise_error(Puppet::Error, %r{is not an Array}) }
       end
 
       ['test.example.com', 'invalid/hostname.example.com'].each do |param|
         context "with host_name => #{param}" do
           let(:params) do
             { host_name: param }
           end
 
           if param =~ %r{invalid}
             it { is_expected.to raise_error(Puppet::Error, %r{valid domain name}) }
           else
             it { is_expected.to compile.with_all_deps }
           end
         end
       end
 
       %w[enabled disabled mine unclaimed invalid].each do |param|
         context "with collect_nodes => #{param}" do
           let(:params) do
             { collect_nodes: param }
           end
 
           if param == 'invalid'
             it { is_expected.to raise_error(Puppet::Error, %r{validate_re}) }
           else
             it { is_expected.to compile.with_all_deps }
           end
         end
       end
     end
   end
 end
diff --git a/spec/classes/munin_node_spec.rb b/spec/classes/munin_node_spec.rb
index 1604b87..f23c898 100644
--- a/spec/classes/munin_node_spec.rb
+++ b/spec/classes/munin_node_spec.rb
@@ -1,186 +1,186 @@
 require 'spec_helper'
 
 _conf_dir = {}
 _conf_dir.default = '/etc/munin'
 _conf_dir['DragonFly'] = '/usr/local/etc/munin'
 _conf_dir['FreeBSD'] = '/usr/local/etc/munin'
 _conf_dir['Solaris'] = '/opt/local/etc/munin'
 
 describe 'munin::node' do
   on_supported_os.each do |os, facts|
     # Avoid testing on distributions similar to RedHat and Debian
     next if os =~ %r{^(ubuntu|centos|scientific|oraclelinux)-}
 
     # No need to test all os versions as long as os version is not
     # used in the params class
     next if os =~ %r{^(debian-[67]|redhat-[56]|freebsd-9)-}
 
     context "on #{os}" do
       let(:facts) { facts }
 
       it { is_expected.to compile.with_all_deps }
 
       it { is_expected.to contain_package('munin-node') }
 
       munin_confdir = _conf_dir[facts[:osfamily]]
 
       munin_node_conf = "#{munin_confdir}/munin-node.conf"
       munin_plugin_dir = "#{munin_confdir}/plugins"
       munin_plugin_conf_dir = "#{munin_confdir}/plugin-conf.d"
 
       munin_node_service =
         case facts[:osfamily]
         when 'Solaris' then 'smf:/munin-node'
         else 'munin-node'
         end
 
       log_dir =
         case facts[:osfamily]
         when 'Solaris' then '/var/opt/log/munin'
         when 'RedHat' then '/var/log/munin-node'
         else '/var/log/munin'
         end
 
       it { is_expected.to contain_service(munin_node_service) }
       it { is_expected.to contain_file(munin_node_conf) }
 
       context 'with no parameters' do
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_service(munin_node_service)
             .without_ensure
         end
         it do
           is_expected.to contain_file(munin_node_conf)
             .with_content(%r{host_name\s+foo.example.com})
-            .with_content(/log_file\s+#{log_dir}\/munin-node.log/)
+            .with_content(%r{log_file\s+#{log_dir}/munin-node.log})
         end
       end
 
       context 'with parameter allow' do
         let(:params) do
           { allow: ['2001:db8:1::',
                     '2001:db8:2::/64',
                     '192.0.2.129',
                     '192.0.2.0/25',
                     '192\.0\.2'] }
         end
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file(munin_node_conf)
-            .with_content(/^cidr_allow 192.0.2.0\/25$/)
-            .with_content(/^cidr_allow 2001:db8:2::\/64$/)
-            .with_content(%r{^allow \^192\\.0\\.2\\.129\$$})
+            .with_content(%r{^cidr_allow 192\.0\.2\.0/25$})
+            .with_content(%r{^cidr_allow 2001:db8:2::/64$})
+            .with_content(%r{^allow \^192\\\.0\\\.2\\\.129\$$})
             .with_content(%r{^allow 192\\.0\\.2$})
             .with_content(%r{^allow \^2001:db8:1::\$$})
         end
       end
 
       context 'with parameter host_name' do
         let(:params) do
           { host_name: 'something.example.com' }
         end
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file(munin_node_conf)
             .with_content(%r{host_name\s+something.example.com})
         end
       end
 
       context 'with parameter service_ensure' do
         let(:params) do
           { service_ensure: 'running' }
         end
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_service('munin-node')
             .with_ensure('running')
         end
       end
 
       context 'logging to syslog' do
         context 'defaults' do
           let(:params) do
             { log_destination: 'syslog' }
           end
 
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to contain_file(munin_node_conf)
               .with_content(%r{log_file\s+Sys::Syslog})
           end
         end
 
         context 'with syslog options' do
           let(:params) do
             { log_destination: 'syslog',
               syslog_facility: 'local1' }
           end
 
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to contain_file(munin_node_conf)
               .with_content(%r{log_file\s+Sys::Syslog})
               .with_content(%r{syslog_facility\s+local1})
           end
         end
 
         context 'with syslog_facility set to wrong value ' do
           let(:params) do
             { log_destination: 'syslog',
               syslog_facility: 'wrong' }
           end
 
           it { expect { is_expected.to compile.with_all_deps }.to raise_error(%r{validate_re}) }
         end
       end
 
       context 'purge_configs' do
         context 'set' do
           let(:params) { { purge_configs: true } }
 
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to contain_file(munin_plugin_dir)
               .with_ensure('directory')
               .with_recurse(true)
               .with_purge(true)
           end
           it do
             is_expected.to contain_file(munin_plugin_conf_dir)
               .with_ensure('directory')
               .with_recurse(true)
               .with_purge(true)
           end
         end
         context 'unset' do
           it { is_expected.to compile.with_all_deps }
           it { is_expected.not_to contain_file(munin_plugin_dir) }
           it { is_expected.not_to contain_file(munin_plugin_conf_dir) }
         end
       end
 
       context 'timeout' do
         context 'set' do
           let(:params) { { timeout: 123 } }
 
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to contain_file(munin_node_conf)
               .with_content(%r{^timeout 123})
           end
         end
         context 'unset' do
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to contain_file(munin_node_conf)
               .without_content(%r{^timeout})
           end
         end
       end
     end
   end
 end