Apply automatic pdk validate fixes

15 files changed, 680 insertions, 709 deletions

diff --git a/spec/acceptance/tests/resource/cron/should_allow_changing_parameters.rb b/spec/acceptance/tests/resource/cron/should_allow_changing_parameters.rb
index 4a14371..0e0821d 100644
--- a/spec/acceptance/tests/resource/cron/should_allow_changing_parameters.rb
+++ b/spec/acceptance/tests/resource/cron/should_allow_changing_parameters.rb
@@ -1,7 +1,7 @@
-test_name "Cron: should allow changing parameters after creation"
-confine :except, :platform => 'windows'
-confine :except, :platform => /^eos-/ # See PUP-5500
-confine :except, :platform => /^fedora-28/
+test_name 'Cron: should allow changing parameters after creation'
+confine :except, platform: 'windows'
+confine :except, platform: %r{^eos-} # See PUP-5500
+confine :except, platform: %r{^fedora-28}
 tag 'audit:medium',
     'audit:refactor',  # Use block style `test_name`
     'audit:acceptance' # Could be done at the integration (or unit) layer though
@@ -12,63 +12,61 @@ require 'puppet/acceptance/common_utils'
 extend Puppet::Acceptance::CronUtils
 
 teardown do
-  step "Cron: cleanup"
+  step 'Cron: cleanup'
   agents.each do |agent|
     clean agent
   end
 end
 
-
 agents.each do |agent|
-  step "ensure the user exist via puppet"
+  step 'ensure the user exist via puppet'
   setup agent
 
-  step "Cron: basic - verify that it can be created"
+  step 'Cron: basic - verify that it can be created'
   apply_manifest_on(agent, 'cron { "myjob": command => "/bin/false", user    => "tstuser", hour    => "*", minute  => [1], ensure  => present,}') do
-    assert_match( /ensure: created/, result.stdout, "err: #{agent}")
+    assert_match(%r{ensure: created}, result.stdout, "err: #{agent}")
   end
-  run_cron_on(agent,:list,'tstuser') do
-    assert_match(/.bin.false/, result.stdout, "err: #{agent}")
+  run_cron_on(agent, :list, 'tstuser') do
+    assert_match(%r{.bin.false}, result.stdout, "err: #{agent}")
   end
 
-  step "Cron: allow changing command"
+  step 'Cron: allow changing command'
   apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => "*", minute  => [1], ensure  => present,}') do
-    assert_match(/command changed '.bin.false'.* to '.bin.true'/, result.stdout, "err: #{agent}")
+    assert_match(%r{command changed '.bin.false'.* to '.bin.true'}, result.stdout, "err: #{agent}")
   end
-  run_cron_on(agent,:list,'tstuser') do
-    assert_match(/1 . . . . .bin.true/, result.stdout, "err: #{agent}")
+  run_cron_on(agent, :list, 'tstuser') do
+    assert_match(%r{1 . . . . .bin.true}, result.stdout, "err: #{agent}")
   end
 
-  step "Cron: allow changing time"
+  step 'Cron: allow changing time'
   apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => "1", minute  => [1], ensure  => present,}') do
-    assert_match(/hour: defined 'hour' as \['1'\]/, result.stdout, "err: #{agent}")
+    assert_match(%r{hour: defined 'hour' as \['1'\]}, result.stdout, "err: #{agent}")
   end
-  run_cron_on(agent,:list,'tstuser') do
-    assert_match(/1 1 . . . .bin.true/, result.stdout, "err: #{agent}")
+  run_cron_on(agent, :list, 'tstuser') do
+    assert_match(%r{1 1 . . . .bin.true}, result.stdout, "err: #{agent}")
   end
 
-  step "Cron: allow changing time(array)"
+  step 'Cron: allow changing time(array)'
   apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => ["1","2"], minute  => [1], ensure  => present,}') do
-    assert_match(/hour: hour changed \['1'\].* to \['1', '2'\]/, result.stdout, "err: #{agent}")
+    assert_match(%r{hour: hour changed \['1'\].* to \['1', '2'\]}, result.stdout, "err: #{agent}")
   end
-  run_cron_on(agent,:list,'tstuser') do
-    assert_match(/1 1,2 . . . .bin.true/, result.stdout, "err: #{agent}")
+  run_cron_on(agent, :list, 'tstuser') do
+    assert_match(%r{1 1,2 . . . .bin.true}, result.stdout, "err: #{agent}")
   end
 
-  step "Cron: allow changing time(array modification)"
+  step 'Cron: allow changing time(array modification)'
   apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => ["3","2"], minute  => [1], ensure  => present,}') do
-    assert_match(/hour: hour changed \['1', '2'\].* to \['3', '2'\]/, result.stdout, "err: #{agent}")
+    assert_match(%r{hour: hour changed \['1', '2'\].* to \['3', '2'\]}, result.stdout, "err: #{agent}")
   end
-  run_cron_on(agent,:list,'tstuser') do
-    assert_match(/1 3,2 . . . .bin.true/, result.stdout, "err: #{agent}")
+  run_cron_on(agent, :list, 'tstuser') do
+    assert_match(%r{1 3,2 . . . .bin.true}, result.stdout, "err: #{agent}")
   end
-  step "Cron: allow changing time(array modification to *)"
+  step 'Cron: allow changing time(array modification to *)'
   apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => "*", minute  => "*", ensure  => present,}') do
-    assert_match(/minute: undefined 'minute' from \['1'\]/,result.stdout, "err: #{agent}")
-    assert_match(/hour: undefined 'hour' from \['3', '2'\]/,result.stdout, "err: #{agent}")
+    assert_match(%r{minute: undefined 'minute' from \['1'\]}, result.stdout, "err: #{agent}")
+    assert_match(%r{hour: undefined 'hour' from \['3', '2'\]}, result.stdout, "err: #{agent}")
   end
-  run_cron_on(agent,:list,'tstuser') do
-    assert_match(/\* \* . . . .bin.true/, result.stdout, "err: #{agent}")
+  run_cron_on(agent, :list, 'tstuser') do
+    assert_match(%r{\* \* . . . .bin.true}, result.stdout, "err: #{agent}")
   end
-
 end
diff --git a/spec/acceptance/tests/resource/cron/should_be_idempotent.rb b/spec/acceptance/tests/resource/cron/should_be_idempotent.rb
index 0d302c2..9b286f7 100644
--- a/spec/acceptance/tests/resource/cron/should_be_idempotent.rb
+++ b/spec/acceptance/tests/resource/cron/should_be_idempotent.rb
@@ -1,7 +1,7 @@
-test_name "Cron: check idempotency"
-confine :except, :platform => 'windows'
-confine :except, :platform => /^eos-/ # See PUP-5500
-confine :except, :platform => /^fedora-28/
+test_name 'Cron: check idempotency'
+confine :except, platform: 'windows'
+confine :except, platform: %r{^eos-} # See PUP-5500
+confine :except, platform: %r{^fedora-28}
 tag 'audit:medium',
     'audit:refactor',  # Use block style `test_name`
     'audit:acceptance' # Could be done at the integration (or unit) layer though
@@ -12,27 +12,26 @@ require 'puppet/acceptance/common_utils'
 extend Puppet::Acceptance::CronUtils
 
 teardown do
-  step "Cron: cleanup"
+  step 'Cron: cleanup'
   agents.each do |agent|
     clean agent
   end
 end
 
-
 agents.each do |agent|
-  step "ensure the user exist via puppet"
+  step 'ensure the user exist via puppet'
   setup agent
 
-  step "Cron: basic - verify that it can be created"
+  step 'Cron: basic - verify that it can be created'
   apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => "*", minute  => [1], ensure  => present,}') do
-    assert_match( /ensure: created/, result.stdout, "err: #{agent}")
+    assert_match(%r{ensure: created}, result.stdout, "err: #{agent}")
   end
-  run_cron_on(agent,:list,'tstuser') do
-    assert_match(/. . . . . .bin.true/, result.stdout, "err: #{agent}")
+  run_cron_on(agent, :list, 'tstuser') do
+    assert_match(%r{. . . . . .bin.true}, result.stdout, "err: #{agent}")
   end
 
-  step "Cron: basic - should not create again"
+  step 'Cron: basic - should not create again'
   apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => "*", minute  => [1], ensure  => present,}') do
-    assert_no_match( /ensure: created/, result.stdout, "err: #{agent}")
+    assert_no_match(%r{ensure: created}, result.stdout, "err: #{agent}")
   end
 end
diff --git a/spec/acceptance/tests/resource/cron/should_create_cron.rb b/spec/acceptance/tests/resource/cron/should_create_cron.rb
index 7c3b53f..29dcfc4 100644
--- a/spec/acceptance/tests/resource/cron/should_create_cron.rb
+++ b/spec/acceptance/tests/resource/cron/should_create_cron.rb
@@ -1,7 +1,7 @@
-test_name "should create cron"
-confine :except, :platform => 'windows'
-confine :except, :platform => /^eos-/ # See PUP-5500
-confine :except, :platform => /^fedora-28/
+test_name 'should create cron'
+confine :except, platform: 'windows'
+confine :except, platform: %r{^eos-} # See PUP-5500
+confine :except, platform: %r{^fedora-28}
 tag 'audit:medium',
     'audit:refactor',  # Use block style `test_name`
     'audit:acceptance' # Could be done at the integration (or unit) layer though
@@ -12,25 +12,24 @@ require 'puppet/acceptance/common_utils'
 extend Puppet::Acceptance::CronUtils
 
 teardown do
-  step "Cron: cleanup"
+  step 'Cron: cleanup'
   agents.each do |agent|
     clean agent
   end
 end
 
 agents.each do |host|
-  step "ensure the user exist via puppet"
+  step 'ensure the user exist via puppet'
   setup host
 
-  step "apply the resource on the host using puppet resource"
-  on(host, puppet_resource("cron", "crontest", "user=tstuser",
-                           "command=/bin/true", "ensure=present")) do
-    assert_match(/created/, stdout, "Did not create crontab for tstuser on #{host}")
+  step 'apply the resource on the host using puppet resource'
+  on(host, puppet_resource('cron', 'crontest', 'user=tstuser',
+                           'command=/bin/true', 'ensure=present')) do
+    assert_match(%r{created}, stdout, "Did not create crontab for tstuser on #{host}")
   end
 
-  step "verify that crontab -l contains what you expected"
+  step 'verify that crontab -l contains what you expected'
   run_cron_on(host, :list, 'tstuser') do
     assert_match(/\* \* \* \* \* \/bin\/true/, stdout, "Incorrect crontab for tstuser on #{host}")
   end
-
 end
diff --git a/spec/acceptance/tests/resource/cron/should_match_existing.rb b/spec/acceptance/tests/resource/cron/should_match_existing.rb
index a59d8ed..d309a84 100644
--- a/spec/acceptance/tests/resource/cron/should_match_existing.rb
+++ b/spec/acceptance/tests/resource/cron/should_match_existing.rb
@@ -1,35 +1,35 @@
-test_name "puppet should match existing job"
-confine :except, :platform => 'windows'
-confine :except, :platform => /^eos-/ # See PUP-5500
-confine :except, :platform => /^fedora-28/
+test_name 'puppet should match existing job'
+confine :except, platform: 'windows'
+confine :except, platform: %r{^eos-} # See PUP-5500
+confine :except, platform: %r{^fedora-28}
 tag 'audit:medium',
-    'audit:refactor',  # Use block style `test_name`
+    'audit:refactor', # Use block style `test_name`
     'audit:unit'
 
 require 'puppet/acceptance/common_utils'
 extend Puppet::Acceptance::CronUtils
 
 teardown do
-  step "Cron: cleanup"
+  step 'Cron: cleanup'
   agents.each do |agent|
     clean agent
   end
 end
 
 agents.each do |host|
-  step "ensure the user exist via puppet"
+  step 'ensure the user exist via puppet'
   setup host
 
-  step "Create the existing cron job by hand..."
-  run_cron_on(host,:add,'tstuser',"* * * * * /bin/true")
+  step 'Create the existing cron job by hand...'
+  run_cron_on(host, :add, 'tstuser', '* * * * * /bin/true')
 
-  step "Apply the resource on the host using puppet resource"
-  on(host, puppet_resource("cron", "crontest", "user=tstuser",
-                           "command=/bin/true", "ensure=present")) do
-    assert_match(/present/, stdout, "Failed creating crontab for tstuser on #{host}")
+  step 'Apply the resource on the host using puppet resource'
+  on(host, puppet_resource('cron', 'crontest', 'user=tstuser',
+                           'command=/bin/true', 'ensure=present')) do
+    assert_match(%r{present}, stdout, "Failed creating crontab for tstuser on #{host}")
   end
 
-  step "Verify that crontab -l contains what you expected"
+  step 'Verify that crontab -l contains what you expected'
   run_cron_on(host, :list, 'tstuser') do
     assert_match(/\* \* \* \* \* \/bin\/true/, stdout, "Did not find crontab for tstuser on #{host}")
   end
diff --git a/spec/acceptance/tests/resource/cron/should_remove_cron.rb b/spec/acceptance/tests/resource/cron/should_remove_cron.rb
index 1320272..1759172 100644
--- a/spec/acceptance/tests/resource/cron/should_remove_cron.rb
+++ b/spec/acceptance/tests/resource/cron/should_remove_cron.rb
@@ -1,7 +1,7 @@
-test_name "puppet should remove a crontab entry as expected"
-confine :except, :platform => 'windows'
-confine :except, :platform => /^eos-/ # See PUP-5500
-confine :except, :platform => /^fedora-28/
+test_name 'puppet should remove a crontab entry as expected'
+confine :except, platform: 'windows'
+confine :except, platform: %r{^eos-} # See PUP-5500
+confine :except, platform: %r{^fedora-28}
 tag 'audit:medium',
     'audit:refactor',  # Use block style `test_name`
     'audit:acceptance' # Could be done at the integration (or unit) layer though
@@ -12,28 +12,27 @@ require 'puppet/acceptance/common_utils'
 extend Puppet::Acceptance::CronUtils
 
 teardown do
-  step "Cron: cleanup"
+  step 'Cron: cleanup'
   agents.each do |agent|
     clean agent
   end
 end
 
 agents.each do |host|
-  step "ensure the user exist via puppet"
+  step 'ensure the user exist via puppet'
   setup host
 
-  step "create the existing job by hand..."
-  run_cron_on(host,:add,'tstuser',"* * * * * /bin/true")
+  step 'create the existing job by hand...'
+  run_cron_on(host, :add, 'tstuser', '* * * * * /bin/true')
 
-  step "apply the resource on the host using puppet resource"
-  on(host, puppet_resource("cron", "crontest", "user=tstuser",
-                           "command=/bin/true", "ensure=absent")) do
-    assert_match(/crontest\D+ensure:\s+removed/, stdout, "Didn't remove crobtab entry for tstuser on #{host}")
+  step 'apply the resource on the host using puppet resource'
+  on(host, puppet_resource('cron', 'crontest', 'user=tstuser',
+                           'command=/bin/true', 'ensure=absent')) do
+    assert_match(%r{crontest\D+ensure:\s+removed}, stdout, "Didn't remove crobtab entry for tstuser on #{host}")
   end
 
-  step "verify that crontab -l contains what you expected"
+  step 'verify that crontab -l contains what you expected'
   run_cron_on(host, :list, 'tstuser') do
     assert_no_match(/\/bin\/true/, stderr, "Error: Found entry for tstuser on #{host}")
   end
-
 end
diff --git a/spec/acceptance/tests/resource/cron/should_remove_leading_and_trailing_whitespace.rb b/spec/acceptance/tests/resource/cron/should_remove_leading_and_trailing_whitespace.rb
index 33f7142..b643156 100644
--- a/spec/acceptance/tests/resource/cron/should_remove_leading_and_trailing_whitespace.rb
+++ b/spec/acceptance/tests/resource/cron/should_remove_leading_and_trailing_whitespace.rb
@@ -1,42 +1,42 @@
-test_name "(#656) leading and trailing whitespace in cron entries should should be stripped"
-confine :except, :platform => 'windows'
-confine :except, :platform => /^eos-/ # See PUP-5500
-confine :except, :platform => /^fedora-28/
+test_name '(#656) leading and trailing whitespace in cron entries should should be stripped'
+confine :except, platform: 'windows'
+confine :except, platform: %r{^eos-} # See PUP-5500
+confine :except, platform: %r{^fedora-28}
 tag 'audit:medium',
-    'audit:refactor',  # Use block style `test_name`
+    'audit:refactor', # Use block style `test_name`
     'audit:unit'
 
 require 'puppet/acceptance/common_utils'
 extend Puppet::Acceptance::CronUtils
 
 teardown do
-  step "Cron: cleanup"
+  step 'Cron: cleanup'
   agents.each do |agent|
     clean agent
   end
 end
 
 agents.each do |host|
-  step "create user account for testing cron entries"
+  step 'create user account for testing cron entries'
   setup host
 
-  step "apply the resource on the host using puppet resource"
-  on(host, puppet_resource("cron", "crontest", "user=tstuser", "command='   date > /dev/null    '", "ensure=present")) do
-    assert_match(/created/, stdout, "Did not create crontab for tstuser on #{host}")
+  step 'apply the resource on the host using puppet resource'
+  on(host, puppet_resource('cron', 'crontest', 'user=tstuser', "command='   date > /dev/null    '", 'ensure=present')) do
+    assert_match(%r{created}, stdout, "Did not create crontab for tstuser on #{host}")
   end
 
-  step "verify the added crontab entry has stripped whitespace"
+  step 'verify the added crontab entry has stripped whitespace'
   run_cron_on(host, :list, 'tstuser') do
-    assert_match(/\* \* \* \* \* date > .dev.null/, stdout, "Incorrect crontab for tstuser on #{host}")
+    assert_match(%r{\* \* \* \* \* date > .dev.null}, stdout, "Incorrect crontab for tstuser on #{host}")
   end
 
-  step "apply the resource with trailing whitespace and check nothing happened"
-  on(host, puppet_resource("cron", "crontest", "user=tstuser", "command='date > /dev/null    '", "ensure=present")) do
-    assert_no_match(/ensure: created/, stdout, "Rewrote the line with trailing space in crontab for tstuser on #{host}")
+  step 'apply the resource with trailing whitespace and check nothing happened'
+  on(host, puppet_resource('cron', 'crontest', 'user=tstuser', "command='date > /dev/null    '", 'ensure=present')) do
+    assert_no_match(%r{ensure: created}, stdout, "Rewrote the line with trailing space in crontab for tstuser on #{host}")
   end
 
-  step "apply the resource with leading whitespace and check nothing happened"
-  on(host, puppet_resource("cron", "crontest", "user=tstuser", "command='     date > /dev/null'", "ensure=present")) do
-    assert_no_match(/ensure: created/, stdout, "Rewrote the line with trailing space in crontab for tstuser on #{host}")
+  step 'apply the resource with leading whitespace and check nothing happened'
+  on(host, puppet_resource('cron', 'crontest', 'user=tstuser', "command='     date > /dev/null'", 'ensure=present')) do
+    assert_no_match(%r{ensure: created}, stdout, "Rewrote the line with trailing space in crontab for tstuser on #{host}")
   end
 end
diff --git a/spec/acceptance/tests/resource/cron/should_remove_matching.rb b/spec/acceptance/tests/resource/cron/should_remove_matching.rb
index 2857a4f..cfa3c17 100644
--- a/spec/acceptance/tests/resource/cron/should_remove_matching.rb
+++ b/spec/acceptance/tests/resource/cron/should_remove_matching.rb
@@ -1,7 +1,7 @@
-test_name "puppet should remove a crontab entry based on command matching"
-confine :except, :platform => 'windows'
-confine :except, :platform => /^eos-/ # See PUP-5500
-confine :except, :platform => /^fedora-28/
+test_name 'puppet should remove a crontab entry based on command matching'
+confine :except, platform: 'windows'
+confine :except, platform: %r{^eos-} # See PUP-5500
+confine :except, platform: %r{^fedora-28}
 tag 'audit:medium',
     'audit:refactor',  # Use block style `test_name`
     'audit:acceptance' # Could be done at the integration (or unit) layer though
@@ -12,29 +12,28 @@ require 'puppet/acceptance/common_utils'
 extend Puppet::Acceptance::CronUtils
 
 teardown do
-  step "Cron: cleanup"
+  step 'Cron: cleanup'
   agents.each do |agent|
     clean agent
   end
 end
 
 agents.each do |host|
-  step "ensure the user exist via puppet"
+  step 'ensure the user exist via puppet'
   setup host
 
-  step "create the existing job by hand..."
-  run_cron_on(host,:add,'tstuser',"* * * * * /bin/true")
+  step 'create the existing job by hand...'
+  run_cron_on(host, :add, 'tstuser', '* * * * * /bin/true')
 
-  step "Remove cron resource"
-  on(host, puppet_resource("cron", "bogus", "user=tstuser",
-                           "command=/bin/true", "ensure=absent")) do
-    assert_match(/bogus\D+ensure: removed/, stdout, "Removing cron entry failed for tstuser on #{host}")
+  step 'Remove cron resource'
+  on(host, puppet_resource('cron', 'bogus', 'user=tstuser',
+                           'command=/bin/true', 'ensure=absent')) do
+    assert_match(%r{bogus\D+ensure: removed}, stdout, "Removing cron entry failed for tstuser on #{host}")
   end
 
-  step "verify that crontab -l contains what you expected"
-  run_cron_on(host,:list,'tstuser') do
-    count = stdout.scan("/bin/true").length
+  step 'verify that crontab -l contains what you expected'
+  run_cron_on(host, :list, 'tstuser') do
+    count = stdout.scan('/bin/true').length
     fail_test "found /bin/true the wrong number of times (#{count})" unless count == 0
   end
-
 end
diff --git a/spec/acceptance/tests/resource/cron/should_update_existing.rb b/spec/acceptance/tests/resource/cron/should_update_existing.rb
index a4bf177..eff634b 100644
--- a/spec/acceptance/tests/resource/cron/should_update_existing.rb
+++ b/spec/acceptance/tests/resource/cron/should_update_existing.rb
@@ -1,7 +1,7 @@
-test_name "puppet should update existing crontab entry"
-confine :except, :platform => 'windows'
-confine :except, :platform => /^eos-/ # See PUP-5500
-confine :except, :platform => /^fedora-28/
+test_name 'puppet should update existing crontab entry'
+confine :except, platform: 'windows'
+confine :except, platform: %r{^eos-} # See PUP-5500
+confine :except, platform: %r{^fedora-28}
 tag 'audit:medium',
     'audit:refactor',  # Use block style `test_name`
     'audit:acceptance' # Could be done at the integration (or unit) layer though
@@ -12,31 +12,31 @@ require 'puppet/acceptance/common_utils'
 extend Puppet::Acceptance::CronUtils
 
 teardown do
-  step "Cron: cleanup"
+  step 'Cron: cleanup'
   agents.each do |agent|
     clean agent
   end
 end
 
 agents.each do |host|
-  step "ensure the user exist via puppet"
+  step 'ensure the user exist via puppet'
   setup host
 
-  step "create the existing job by hand..."
-  run_cron_on(host,:add,'tstuser',"* * * * * /bin/true")
+  step 'create the existing job by hand...'
+  run_cron_on(host, :add, 'tstuser', '* * * * * /bin/true')
 
-  step "verify that crontab -l contains what you expected"
-  run_cron_on(host,:list,'tstuser') do
+  step 'verify that crontab -l contains what you expected'
+  run_cron_on(host, :list, 'tstuser') do
     assert_match(/\* \* \* \* \* \/bin\/true/, stdout, "Didn't find correct crobtab entry for tstuser on #{host}")
   end
 
-  step "apply the resource change on the host"
-  on(host, puppet_resource("cron", "crontest", "user=tstuser", "command=/bin/true", "ensure=present", "hour='0-6'")) do
-    assert_match(/hour\s+=>\s+\['0-6'\]/, stdout, "Modifying cron entry failed for tstuser on #{host}")
+  step 'apply the resource change on the host'
+  on(host, puppet_resource('cron', 'crontest', 'user=tstuser', 'command=/bin/true', 'ensure=present', "hour='0-6'")) do
+    assert_match(%r{hour\s+=>\s+\['0-6'\]}, stdout, "Modifying cron entry failed for tstuser on #{host}")
   end
 
-  step "verify that crontab -l contains what you expected"
-  run_cron_on(host,:list,'tstuser') do
+  step 'verify that crontab -l contains what you expected'
+  run_cron_on(host, :list, 'tstuser') do
     assert_match(/\* 0-6 \* \* \* \/bin\/true/, stdout, "Didn't find correctly modified time entry in crobtab entry for tstuser on #{host}")
   end
 end
diff --git a/spec/integration/provider/cron/crontab_spec.rb b/spec/integration/provider/cron/crontab_spec.rb
index 192674f..a4b57a2 100644
--- a/spec/integration/provider/cron/crontab_spec.rb
+++ b/spec/integration/provider/cron/crontab_spec.rb
@@ -4,7 +4,7 @@ require 'spec_helper'
 require 'puppet/file_bucket/dipper'
 require 'puppet_spec/compiler'
 
-describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', unless: Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
   include PuppetSpec::Compiler
 
@@ -40,9 +40,8 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
     expect(File.read(crontab_user1)).to eq(File.read(my_fixture(fixture_name)))
   end
 
-  describe "when managing a cron entry" do
-
-    it "should be able to purge unmanaged entries" do
+  describe 'when managing a cron entry' do
+    it 'is able to purge unmanaged entries' do
       apply_with_error_check(<<-MANIFEST)
       cron {
         'only managed entry':
@@ -55,8 +54,8 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
       expect_output('purged')
     end
 
-    describe "with ensure absent" do
-      it "should do nothing if entry already absent" do
+    describe 'with ensure absent' do
+      it 'does nothing if entry already absent' do
         apply_with_error_check(<<-MANIFEST)
         cron {
           'no_such_entry':
@@ -67,7 +66,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
         expect_output('crontab_user1')
       end
 
-      it "should remove the resource from crontab if present" do
+      it 'removes the resource from crontab if present' do
         apply_with_error_check(<<-MANIFEST)
         cron {
           'My daily failure':
@@ -78,7 +77,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
         expect_output('remove_named_resource')
       end
 
-      it "should remove a matching cronentry if present" do
+      it 'removes a matching cronentry if present' do
         apply_with_error_check(<<-MANIFEST)
         cron {
           'no_such_named_resource_in_crontab':
@@ -94,10 +93,9 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
       end
     end
 
-    describe "with ensure present" do
-
-      context "and no command specified" do
-        it "should work if the resource is already present" do
+    describe 'with ensure present' do
+      context 'and no command specified' do
+        it 'works if the resource is already present' do
           apply_with_error_check(<<-MANIFEST)
           cron {
             'My daily failure':
@@ -107,7 +105,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
           MANIFEST
           expect_output('crontab_user1')
         end
-        it "should fail if the resource needs creating" do
+        it 'fails if the resource needs creating' do
           manifest = <<-MANIFEST
           cron {
             'Entirely new resource':
@@ -117,7 +115,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
           MANIFEST
           apply_compiled_manifest(manifest) do |res|
             if res.ref == 'Cron[Entirely new resource]'
-              res.expects(:err).with(regexp_matches(/no command/))
+              res.expects(:err).with(regexp_matches(%r{no command}))
             else
               res.expects(:err).never
             end
@@ -125,7 +123,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
         end
       end
 
-      it "should do nothing if entry already present" do
+      it 'does nothing if entry already present' do
         apply_with_error_check(<<-MANIFEST)
         cron {
           'My daily failure':
@@ -137,7 +135,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
         expect_output('crontab_user1')
       end
 
-      it "should work correctly when managing 'target' but not 'user'" do
+      it "works correctly when managing 'target' but not 'user'" do
         apply_with_error_check(<<-MANIFEST)
         cron {
           'My daily failure':
@@ -149,7 +147,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
         expect_output('crontab_user1')
       end
 
-      it "should do nothing if a matching entry already present" do
+      it 'does nothing if a matching entry already present' do
         apply_with_error_check(<<-MANIFEST)
         cron {
           'no_such_named_resource_in_crontab':
@@ -163,7 +161,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
         expect_output('crontab_user1')
       end
 
-      it "should add a new normal entry if currently absent" do
+      it 'adds a new normal entry if currently absent' do
         apply_with_error_check(<<-MANIFEST)
         cron {
           'new entry':
@@ -181,7 +179,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
         expect_output('create_normal_entry')
       end
 
-      it "should add a new special entry if currently absent" do
+      it 'adds a new special entry if currently absent' do
         apply_with_error_check(<<-MANIFEST)
         cron {
           'new special entry':
@@ -195,7 +193,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
         expect_output('create_special_entry')
       end
 
-      it "should change existing entry if out of sync" do
+      it 'changes existing entry if out of sync' do
         apply_with_error_check(<<-MANIFEST)
         cron {
           'Monthly job':
@@ -209,7 +207,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
         MANIFEST
         expect_output('modify_entry')
       end
-      it "should change a special schedule to numeric if requested" do
+      it 'changes a special schedule to numeric if requested' do
         apply_with_error_check(<<-MANIFEST)
         cron {
           'My daily failure':
@@ -220,7 +218,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
         MANIFEST
         expect_output('unspecialized')
       end
-      it "should not try to move an entry from one file to another" do
+      it 'does not try to move an entry from one file to another' do
         # force the parsedfile provider to also parse user1's crontab
         apply_with_error_check(<<-MANIFEST)
         cron {
@@ -238,5 +236,4 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
       end
     end
   end
-
 end
diff --git a/spec/lib/puppet_spec/compiler.rb b/spec/lib/puppet_spec/compiler.rb
index 8964a26..c3d33a5 100644
--- a/spec/lib/puppet_spec/compiler.rb
+++ b/spec/lib/puppet_spec/compiler.rb
@@ -34,8 +34,8 @@ module PuppetSpec::Compiler
       catalog.resources.each { |res| yield res }
     end
     transaction = Puppet::Transaction.new(catalog,
-                                         Puppet::Transaction::Report.new,
-                                         prioritizer)
+                                          Puppet::Transaction::Report.new,
+                                          prioritizer)
     transaction.evaluate
     transaction.report.finalize_report
 
@@ -70,7 +70,7 @@ module PuppetSpec::Compiler
     collect_notices(code, node) do |compiler|
       unless topscope_vars.empty?
         scope = compiler.topscope
-        topscope_vars.each {|k,v| scope.setvar(k, v) }
+        topscope_vars.each { |k, v| scope.setvar(k, v) }
       end
       if block_given?
         compiler.compile do |catalog|
@@ -95,7 +95,7 @@ module PuppetSpec::Compiler
     compiler = Puppet::Parser::Compiler.new(node)
     unless variables.empty?
       scope = compiler.topscope
-      variables.each {|k,v| scope.setvar(k, v) }
+      variables.each { |k, v| scope.setvar(k, v) }
     end
 
     if source.nil?
@@ -105,7 +105,7 @@ module PuppetSpec::Compiler
     end
 
     # evaluate given source is the context of the compiled state and return its result
-    compiler.compile do |catalog |
+    compiler.compile do |_catalog|
       Puppet::Pops::Parser::EvaluatingParser.singleton.evaluate_string(compiler.topscope, source, source_location)
     end
   end
diff --git a/spec/lib/puppet_spec/files.rb b/spec/lib/puppet_spec/files.rb
index b34daed..ebbe1a9 100644
--- a/spec/lib/puppet_spec/files.rb
+++ b/spec/lib/puppet_spec/files.rb
@@ -7,10 +7,10 @@ require 'pathname'
 module PuppetSpec::Files
   def self.cleanup
     $global_tempfiles ||= []
-    while path = $global_tempfiles.pop do
+    while path = $global_tempfiles.pop
       begin
         Dir.unstub(:entries)
-        FileUtils.rm_rf path, :secure => true
+        FileUtils.rm_rf path, secure: true
       rescue Errno::ENOENT
         # nothing to do
       end
@@ -48,7 +48,7 @@ module PuppetSpec::Files
       text = contents[:posix]
     end
     File.open(file, 'wb') { |f| f.write(text) }
-    Puppet::FileSystem.chmod(0755, file)
+    Puppet::FileSystem.chmod(0o755, file)
     file
   end
 
@@ -62,12 +62,12 @@ module PuppetSpec::Files
 
   # Copied from ruby 2.4 source
   def make_tmpname((prefix, suffix), n)
-    prefix = (String.try_convert(prefix) or
-              raise ArgumentError, "unexpected prefix: #{prefix.inspect}")
-    suffix &&= (String.try_convert(suffix) or
-                raise ArgumentError, "unexpected suffix: #{suffix.inspect}")
-    t = Time.now.strftime("%Y%m%d")
-    path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}".dup
+    prefix = (String.try_convert(prefix) ||
+              raise(ArgumentError, "unexpected prefix: #{prefix.inspect}"))
+    suffix &&= (String.try_convert(suffix) ||
+                raise(ArgumentError, "unexpected suffix: #{suffix.inspect}"))
+    t = Time.now.strftime('%Y%m%d')
+    path = "#{prefix}#{t}-#{$PROCESS_ID}-#{rand(0x100000000).to_s(36)}".dup
     path << "-#{n}" if n
     path << suffix if suffix
     path
@@ -78,13 +78,13 @@ module PuppetSpec::Files
   end
 
   def dir_contained_in(dir, contents_hash)
-    contents_hash.each do |k,v|
+    contents_hash.each do |k, v|
       if v.is_a?(Hash)
-        Dir.mkdir(tmp = File.join(dir,k))
+        Dir.mkdir(tmp = File.join(dir, k))
         dir_contained_in(tmp, v)
       else
         file = File.join(dir, k)
-        File.open(file, 'wb') {|f| f.write(v) }
+        File.open(file, 'wb') { |f| f.write(v) }
       end
     end
     dir
@@ -97,11 +97,11 @@ module PuppetSpec::Files
   end
 
   def expect_file_mode(file, mode)
-    actual_mode = "%o" % Puppet::FileSystem.stat(file).mode
+    actual_mode = '%o' % Puppet::FileSystem.stat(file).mode
     target_mode = if Puppet.features.microsoft_windows?
-      mode
-    else
-      "10" + "%04i" % mode.to_i
+                    mode
+                  else
+                    '10' + '%04i' % mode.to_i
     end
     expect(actual_mode).to eq(target_mode)
   end
diff --git a/spec/spec_helper_local.rb b/spec/spec_helper_local.rb
index 8757be6..f06b4bb 100644
--- a/spec/spec_helper_local.rb
+++ b/spec/spec_helper_local.rb
@@ -14,4 +14,4 @@ RSpec.configure do |config|
 
     FileUtils.mkdir_p Puppet[:statedir]
   end
-end
\ No newline at end of file
+end
diff --git a/spec/unit/provider/cron/crontab_spec.rb b/spec/unit/provider/cron/crontab_spec.rb
index 98ae589..92924ae 100644
--- a/spec/unit/provider/cron/crontab_spec.rb
+++ b/spec/unit/provider/cron/crontab_spec.rb
@@ -10,17 +10,17 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
 
   def compare_crontab_text(have, want)
     # We should have four header lines, and then the text...
-    expect(have.lines.to_a[0..3]).to be_all {|x| x =~ /^# / }
+    expect(have.lines.to_a[0..3]).to be_all { |x| x =~ %r{^# } }
     expect(have.lines.to_a[4..-1].join('')).to eq(want)
   end
 
-  context "with the simple samples" do
+  context 'with the simple samples' do
     FIELDS = {
-      :crontab => %w{command minute hour month monthday weekday}.collect { |o| o.intern },
-      :environment => [:line],
-      :blank => [:line],
-      :comment => [:line],
-    }
+      crontab: ['command', 'minute', 'hour', 'month', 'monthday', 'weekday'].map { |o| o.to_sym },
+      environment: [:line],
+      blank: [:line],
+      comment: [:line],
+    }.freeze
 
     def compare_crontab_record(have, want)
       want.each do |param, value|
@@ -48,52 +48,51 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
     end
 
     records = []
-    text    = ""
+    text    = ''
 
     # Sorting is from the original, and avoids :empty being the last line,
     # since the provider will ignore that and cause this to fail.
-    samples.sort_by {|x| x.first.to_s }.each do |name, data|
+    samples.sort_by { |x| x.first.to_s }.each do |_name, data|
       records << data[:record]
       text    << data[:text] + "\n"
     end
 
-    it "should parse all sample records at once" do
+    it 'parses all sample records at once' do
       subject.parse(text).zip(records).each do |round|
         compare_crontab_record(*round)
       end
     end
 
-    it "should reconstitute the file from the records" do
+    it 'reconstitutes the file from the records' do
       compare_crontab_text subject.to_file(records), text
     end
 
-    context "multi-line crontabs" do
-      tests = { :simple    => [:spaces_in_command_with_times],
-        :with_name => [:name, :spaces_in_command_with_times],
-        :with_env  => [:environment, :spaces_in_command_with_times],
-        :with_multiple_envs => [:environment, :lowercase_environment, :spaces_in_command_with_times],
-        :with_name_and_env => [:name_with_spaces, :another_env, :spaces_in_command_with_times],
-        :with_name_and_multiple_envs => [:long_name, :another_env, :fourth_env, :spaces_in_command_with_times]
-      }
+    context 'multi-line crontabs' do
+      tests = { simple: [:spaces_in_command_with_times],
+                with_name: [:name, :spaces_in_command_with_times],
+                with_env: [:environment, :spaces_in_command_with_times],
+                with_multiple_envs: [:environment, :lowercase_environment, :spaces_in_command_with_times],
+                with_name_and_env: [:name_with_spaces, :another_env, :spaces_in_command_with_times],
+                with_name_and_multiple_envs: [:long_name, :another_env, :fourth_env, :spaces_in_command_with_times] }
 
       all_records = []
       all_text    = ''
 
       tests.each do |name, content|
-        data    = content.map {|x| samples[x] or raise "missing sample data #{x}" }
-        text    = data.map {|x| x[:text] }.join("\n") + "\n"
-        records = data.map {|x| x[:record] }
+        data    = content.map { |x| samples[x] || raise("missing sample data #{x}") }
+        text    = data.map { |x| x[:text] }.join("\n") + "\n"
+        records = data.map { |x| x[:record] }
 
         # Capture the whole thing for later, too...
         all_records += records
         all_text    += text
 
-        context name.to_s.gsub('_', ' ') do
-          it "should regenerate the text from the record" do
+        context name.to_s.tr('_', ' ') do
+          it 'regenerates the text from the record' do
             compare_crontab_text subject.to_file(records), text
           end
 
-          it "should parse the records from the text" do
+          it 'parses the records from the text' do
             subject.parse(text).zip(records).each do |round|
               compare_crontab_record(*round)
             end
@@ -101,30 +100,30 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
         end
       end
 
-      it "should parse the whole set of records from the text" do
+      it 'parses the whole set of records from the text' do
         subject.parse(all_text).zip(all_records).each do |round|
           compare_crontab_record(*round)
         end
       end
 
-      it "should regenerate the whole text from the set of all records" do
+      it 'regenerates the whole text from the set of all records' do
         compare_crontab_text subject.to_file(all_records), all_text
       end
     end
   end
 
-  context "when receiving a vixie cron header from the cron interface" do
-    it "should not write that header back to disk" do
+  context 'when receiving a vixie cron header from the cron interface' do
+    it 'does not write that header back to disk' do
       vixie_header = File.read(my_fixture('vixie_header.txt'))
       vixie_records = subject.parse(vixie_header)
-      compare_crontab_text subject.to_file(vixie_records), ""
+      compare_crontab_text subject.to_file(vixie_records), ''
     end
   end
 
-  context "when adding a cronjob with the same command as an existing job" do
-    let(:record) { {:name => "existing", :user => "root", :command => "/bin/true", :record_type => :crontab} }
-    let(:resource) { Puppet::Type::Cron.new(:name => "test", :user => "root", :command => "/bin/true") }
-    let(:resources) { { "test" => resource } }
+  context 'when adding a cronjob with the same command as an existing job' do
+    let(:record) { { name: 'existing', user: 'root', command: '/bin/true', record_type: :crontab } }
+    let(:resource) { Puppet::Type::Cron.new(name: 'test', user: 'root', command: '/bin/true') }
+    let(:resources) { { 'test' => resource } }
 
     before :each do
       subject.stubs(:prefetch_all_targets).returns([record])
@@ -142,64 +141,64 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
 #      subject.to_file(subject.records).should match /Puppet name: test/
 #    end
 
-    it "should not base the new resource's provider on the existing record" do
+    it "does not base the new resource's provider on the existing record" do
       subject.expects(:new).with(record).never
       subject.stubs(:new)
       subject.prefetch(resources)
     end
   end
 
-  context "when prefetching an entry now managed for another user" do
+  context 'when prefetching an entry now managed for another user' do
     let(:resource) do
-     s = stub(:resource)
-     s.stubs(:[]).with(:user).returns 'root'
-     s.stubs(:[]).with(:target).returns 'root'
-     s
+      s = stub(:resource)
+      s.stubs(:[]).with(:user).returns 'root'
+      s.stubs(:[]).with(:target).returns 'root'
+      s
     end
 
-    let(:record) { {:name => "test", :user => "nobody", :command => "/bin/true", :record_type => :crontab} }
-    let(:resources) { { "test" => resource } }
+    let(:record) { { name: 'test', user: 'nobody', command: '/bin/true', record_type: :crontab } }
+    let(:resources) { { 'test' => resource } }
 
     before :each do
       subject.stubs(:prefetch_all_targets).returns([record])
     end
 
-    it "should try and use the match method to find a more fitting record" do
+    it 'tries and use the match method to find a more fitting record' do
       subject.expects(:match).with(record, resources)
       subject.prefetch(resources)
     end
 
-    it "should not match a provider to the resource" do
+    it 'does not match a provider to the resource' do
       resource.expects(:provider=).never
       subject.prefetch(resources)
     end
 
-    it "should not find the resource when looking up the on-disk record" do
+    it 'does not find the resource when looking up the on-disk record' do
       subject.prefetch(resources)
       expect(subject.resource_for_record(record, resources)).to be_nil
     end
   end
 
-  context "when matching resources to existing crontab entries" do
-    let(:first_resource) { Puppet::Type::Cron.new(:name => :one, :user => 'root', :command => '/bin/true') }
-    let(:second_resource) { Puppet::Type::Cron.new(:name => :two, :user => 'nobody', :command => '/bin/false') }
+  context 'when matching resources to existing crontab entries' do
+    let(:first_resource) { Puppet::Type::Cron.new(name: :one, user: 'root', command: '/bin/true') }
+    let(:second_resource) { Puppet::Type::Cron.new(name: :two, user: 'nobody', command: '/bin/false') }
 
-    let(:resources) {{:one => first_resource, :two => second_resource}}
+    let(:resources) { { one: first_resource, two: second_resource } }
 
-    describe "with a record with a matching name and mismatching user (#2251)" do
+    describe 'with a record with a matching name and mismatching user (#2251)' do
       # Puppet::Resource objects have #should defined on them, so in these
       # examples we have to use the monkey patched `must` alias for the rspec
       # `should` method.
 
       it "doesn't match the record to the resource" do
-        record = {:name => :one, :user => 'notroot', :record_type => :crontab}
+        record = { name: :one, user: 'notroot', record_type: :crontab }
         expect(subject.resource_for_record(record, resources)).to be_nil
       end
     end
 
-    describe "with a record with a matching name and matching user" do
-      it "matches the record to the resource" do
-        record = {:name => :two, :target => 'nobody', :command => '/bin/false'}
+    describe 'with a record with a matching name and matching user' do
+      it 'matches the record to the resource' do
+        record = { name: :two, target: 'nobody', command: '/bin/false' }
         expect(subject.resource_for_record(record, resources)).to eq(second_resource)
       end
     end
diff --git a/spec/unit/provider/cron/parsed_spec.rb b/spec/unit/provider/cron/parsed_spec.rb
index 6cec867..6d5b752 100644
--- a/spec/unit/provider/cron/parsed_spec.rb
+++ b/spec/unit/provider/cron/parsed_spec.rb
@@ -3,79 +3,78 @@
 require 'spec_helper'
 
 describe Puppet::Type.type(:cron).provider(:crontab) do
-
   let :provider do
-    described_class.new(:command => '/bin/true')
+    described_class.new(command: '/bin/true')
   end
 
   let :resource do
     Puppet::Type.type(:cron).new(
-      :minute      => %w{0 15 30 45},
-      :hour        => %w{8-18 20-22},
-      :monthday    => %w{31},
-      :month       => %w{12},
-      :weekday     => %w{7},
-      :name        => 'basic',
-      :command     => '/bin/true',
-      :target      => 'root',
-      :provider    => provider
+      minute: ['0', '15', '30', '45'],
+      hour: ['8-18', '20-22'],
+      monthday: ['31'],
+      month: ['12'],
+      weekday: ['7'],
+      name: 'basic',
+      command: '/bin/true',
+      target: 'root',
+      provider: provider,
     )
   end
 
   let :resource_special do
     Puppet::Type.type(:cron).new(
-      :special => 'reboot',
-      :name    => 'special',
-      :command => '/bin/true',
-      :target  => 'nobody'
+      special: 'reboot',
+      name: 'special',
+      command: '/bin/true',
+      target: 'nobody',
     )
   end
 
   let :resource_sparse do
     Puppet::Type.type(:cron).new(
-      :minute => %w{42},
-      :target => 'root',
-      :name   => 'sparse'
+      minute: ['42'],
+      target: 'root',
+      name: 'sparse',
     )
   end
 
   let :record_special do
     {
-      :record_type => :crontab,
-      :special     => 'reboot',
-      :command     => '/bin/true',
-      :on_disk     => true,
-      :target      => 'nobody'
+      record_type: :crontab,
+      special: 'reboot',
+      command: '/bin/true',
+      on_disk: true,
+      target: 'nobody',
     }
   end
 
   let :record do
     {
-      :record_type => :crontab,
-      :minute      => %w{0 15 30 45},
-      :hour        => %w{8-18 20-22},
-      :monthday    => %w{31},
-      :month       => %w{12},
-      :weekday     => %w{7},
-      :special     => :absent,
-      :command     => '/bin/true',
-      :on_disk     => true,
-      :target      => 'root'
+      record_type: :crontab,
+      minute: ['0', '15', '30', '45'],
+      hour: ['8-18', '20-22'],
+      monthday: ['31'],
+      month: ['12'],
+      weekday: ['7'],
+      special: :absent,
+      command: '/bin/true',
+      on_disk: true,
+      target: 'root',
     }
   end
 
-  describe "when determining the correct filetype" do
-    it "should use the suntab filetype on Solaris" do
+  describe 'when determining the correct filetype' do
+    it 'uses the suntab filetype on Solaris' do
       Facter.stubs(:value).with(:osfamily).returns 'Solaris'
       expect(described_class.filetype).to eq(Puppet::Util::FileType::FileTypeSuntab)
     end
 
-    it "should use the aixtab filetype on AIX" do
+    it 'uses the aixtab filetype on AIX' do
       Facter.stubs(:value).with(:osfamily).returns 'AIX'
       expect(described_class.filetype).to eq(Puppet::Util::FileType::FileTypeAixtab)
     end
 
-    it "should use the crontab filetype on other platforms" do
+    it 'uses the crontab filetype on other platforms' do
       Facter.stubs(:value).with(:osfamily).returns 'Not a real operating system family'
       expect(described_class.filetype).to eq(Puppet::Util::FileType::FileTypeCrontab)
     end
@@ -83,155 +82,144 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
 
   # I'd use ENV.expects(:[]).with('USER') but this does not work because
   # ENV["USER"] is evaluated at load time.
-  describe "when determining the default target" do
-    it "should use the current user #{ENV['USER']}", :if => ENV['USER'] do
+  describe 'when determining the default target' do
+    it "should use the current user #{ENV['USER']}", if: ENV['USER'] do
       expect(described_class.default_target).to eq(ENV['USER'])
     end
 
-    it "should fallback to root", :unless => ENV['USER'] do
-      expect(described_class.default_target).to eq("root")
+    it 'fallbacks to root', unless: ENV['USER'] do
+      expect(described_class.default_target).to eq('root')
     end
   end
 
-  describe ".targets" do
-    let(:tabs) { [ described_class.default_target ] + %w{foo bar} }
-    before do
+  describe '.targets' do
+    let(:tabs) { [described_class.default_target] + ['foo', 'bar'] }
+
+    before(:each) do
       File.expects(:readable?).returns true
       File.stubs(:file?).returns true
       File.stubs(:writable?).returns true
     end
-    after do
+    after(:each) do
       File.unstub :readable?, :file?, :writable?
       Dir.unstub :foreach
     end
-    it "should add all crontabs as targets" do
+    it 'adds all crontabs as targets' do
       Dir.expects(:foreach).multiple_yields(*tabs)
       expect(described_class.targets).to eq(tabs)
     end
   end
 
-  describe "when parsing a record" do
-    it "should parse a comment" do
-      expect(described_class.parse_line("# This is a test")).to eq({
-        :record_type => :comment,
-        :line        => "# This is a test",
-      })
+  describe 'when parsing a record' do
+    it 'parses a comment' do
+      expect(described_class.parse_line('# This is a test')).to eq(record_type: :comment,
+                                                                   line: '# This is a test')
     end
 
-    it "should get the resource name of a PUPPET NAME comment" do
-      expect(described_class.parse_line('# Puppet Name: My Fancy Cronjob')).to eq({
-        :record_type => :comment,
-        :name        => 'My Fancy Cronjob',
-        :line        => '# Puppet Name: My Fancy Cronjob',
-      })
+    it 'gets the resource name of a PUPPET NAME comment' do
+      expect(described_class.parse_line('# Puppet Name: My Fancy Cronjob')).to eq(record_type: :comment,
+                                                                                  name: 'My Fancy Cronjob',
+                                                                                  line: '# Puppet Name: My Fancy Cronjob')
     end
 
-    it "should ignore blank lines" do
-      expect(described_class.parse_line('')).to eq({:record_type => :blank, :line => ''})
-      expect(described_class.parse_line(' ')).to eq({:record_type => :blank, :line => ' '})
-      expect(described_class.parse_line("\t")).to eq({:record_type => :blank, :line => "\t"})
-      expect(described_class.parse_line("  \t ")).to eq({:record_type => :blank, :line => "  \t "})
+    it 'ignores blank lines' do
+      expect(described_class.parse_line('')).to eq(record_type: :blank, line: '')
+      expect(described_class.parse_line(' ')).to eq(record_type: :blank, line: ' ')
+      expect(described_class.parse_line("\t")).to eq(record_type: :blank, line: "\t")
+      expect(described_class.parse_line("  \t ")).to eq(record_type: :blank, line: "  \t ")
     end
 
-    it "should extract environment assignments" do
+    it 'extracts environment assignments' do
       # man 5 crontab: MAILTO="" with no value can be used to surpress sending
       # mails at all
-      expect(described_class.parse_line('MAILTO=""')).to eq({:record_type => :environment, :line => 'MAILTO=""'})
-      expect(described_class.parse_line('FOO=BAR')).to eq({:record_type => :environment, :line => 'FOO=BAR'})
-      expect(described_class.parse_line('FOO_BAR=BAR')).to eq({:record_type => :environment, :line => 'FOO_BAR=BAR'})
-      expect(described_class.parse_line('SPACE = BAR')).to eq({:record_type => :environment, :line => 'SPACE = BAR'})
+      expect(described_class.parse_line('MAILTO=""')).to eq(record_type: :environment, line: 'MAILTO=""')
+      expect(described_class.parse_line('FOO=BAR')).to eq(record_type: :environment, line: 'FOO=BAR')
+      expect(described_class.parse_line('FOO_BAR=BAR')).to eq(record_type: :environment, line: 'FOO_BAR=BAR')
+      expect(described_class.parse_line('SPACE = BAR')).to eq(record_type: :environment, line: 'SPACE = BAR')
     end
 
-    it "should extract a cron entry" do
-      expect(described_class.parse_line('* * * * * /bin/true')).to eq({
-        :record_type => :crontab,
-        :hour        => :absent,
-        :minute      => :absent,
-        :month       => :absent,
-        :weekday     => :absent,
-        :monthday    => :absent,
-        :special     => :absent,
-        :command     => '/bin/true'
-      })
-      expect(described_class.parse_line('0,15,30,45 8-18,20-22 31 12 7 /bin/true')).to eq({
-        :record_type => :crontab,
-        :minute      => %w{0 15 30 45},
-        :hour        => %w{8-18 20-22},
-        :monthday    => %w{31},
-        :month       => %w{12},
-        :weekday     => %w{7},
-        :special     => :absent,
-        :command     => '/bin/true'
-      })
+    it 'extracts a cron entry' do
+      expect(described_class.parse_line('* * * * * /bin/true')).to eq(record_type: :crontab,
+                                                                      hour: :absent,
+                                                                      minute: :absent,
+                                                                      month: :absent,
+                                                                      weekday: :absent,
+                                                                      monthday: :absent,
+                                                                      special: :absent,
+                                                                      command: '/bin/true')
+      expect(described_class.parse_line('0,15,30,45 8-18,20-22 31 12 7 /bin/true')).to eq(record_type: :crontab,
+                                                                                          minute: ['0', '15', '30', '45'],
+                                                                                          hour: ['8-18', '20-22'],
+                                                                                          monthday: ['31'],
+                                                                                          month: ['12'],
+                                                                                          weekday: ['7'],
+                                                                                          special: :absent,
+                                                                                          command: '/bin/true')
       # A percent sign will cause the rest of the string to be passed as
       # standard input and will also act as a newline character. Not sure
       # if puppet should convert % to a \n as the command property so the
       # test covers the current behaviour: Do not do any conversions
-      expect(described_class.parse_line('0 22 * * 1-5   mail -s "It\'s 10pm" joe%Joe,%%Where are your kids?%')).to eq({
-        :record_type => :crontab,
-        :minute      => %w{0},
-        :hour        => %w{22},
-        :monthday    => :absent,
-        :month       => :absent,
-        :weekday     => %w{1-5},
-        :special     => :absent,
-        :command     => 'mail -s "It\'s 10pm" joe%Joe,%%Where are your kids?%'
-      })
+      expect(described_class.parse_line('0 22 * * 1-5   mail -s "It\'s 10pm" joe%Joe,%%Where are your kids?%')).to eq(record_type: :crontab,
+                                                                                                                      minute: ['0'],
+                                                                                                                      hour: ['22'],
+                                                                                                                      monthday: :absent,
+                                                                                                                      month: :absent,
+                                                                                                                      weekday: ['1-5'],
+                                                                                                                      special: :absent,
+                                                                                                                      command: 'mail -s "It\'s 10pm" joe%Joe,%%Where are your kids?%')
     end
 
-    describe "it should support special strings" do
-      ['reboot','yearly','anually','monthly', 'weekly', 'daily', 'midnight', 'hourly'].each do |special|
+    describe 'it should support special strings' do
+      ['reboot', 'yearly', 'anually', 'monthly', 'weekly', 'daily', 'midnight', 'hourly'].each do |special|
         it "should support @#{special}" do
-          expect(described_class.parse_line("@#{special} /bin/true")).to eq({
-            :record_type => :crontab,
-            :hour        => :absent,
-            :minute      => :absent,
-            :month       => :absent,
-            :weekday     => :absent,
-            :monthday    => :absent,
-            :special     => special,
-            :command     => '/bin/true'
-          })
+          expect(described_class.parse_line("@#{special} /bin/true")).to eq(record_type: :crontab,
+                                                                            hour: :absent,
+                                                                            minute: :absent,
+                                                                            month: :absent,
+                                                                            weekday: :absent,
+                                                                            monthday: :absent,
+                                                                            special: special,
+                                                                            command: '/bin/true')
         end
       end
     end
   end
 
-  describe ".instances" do
+  describe '.instances' do
     before :each do
       described_class.stubs(:default_target).returns 'foobar'
     end
 
-    describe "on linux" do
-      before do
+    describe 'on linux' do
+      before(:each) do
         Facter.stubs(:value).with(:osfamily).returns 'Linux'
         Facter.stubs(:value).with(:operatingsystem)
       end
 
-      it "should contain no resources for a user who has no crontab" do
+      it 'contains no resources for a user who has no crontab' do
         # `crontab...` does only capture stdout here. On vixie-cron-4.1
         # STDERR shows "no crontab for foobar" but stderr is ignored as
         # well as the exitcode.
-        described_class.target_object('foobar').expects(:`).with('crontab -u foobar -l 2>/dev/null').returns ""
-        expect(described_class.instances.select { |resource|
+        described_class.target_object('foobar').expects(:`).with('crontab -u foobar -l 2>/dev/null').returns ''
+        expect(described_class.instances.select do |resource|
           resource.get('target') == 'foobar'
-        }).to be_empty
+        end).to be_empty
       end
 
-      it "should contain no resources for a user who is absent" do
+      it 'contains no resources for a user who is absent' do
         # `crontab...` does only capture stdout. On vixie-cron-4.1
         # STDERR shows "crontab:  user `foobar' unknown" but stderr is
         # ignored as well as the exitcode
-        described_class.target_object('foobar').expects(:`).with('crontab -u foobar -l 2>/dev/null').returns ""
-        expect(described_class.instances.select { |resource|
+        described_class.target_object('foobar').expects(:`).with('crontab -u foobar -l 2>/dev/null').returns ''
+        expect(described_class.instances.select do |resource|
           resource.get('target') == 'foobar'
-        }).to be_empty
+        end).to be_empty
       end
 
-      it "should be able to create records from not-managed records" do
+      it 'is able to create records from not-managed records' do
         described_class.stubs(:target_object).returns File.new(my_fixture('simple'))
         parameters = described_class.instances.map do |p|
-          h = {:name => p.get(:name)}
+          h = { name: p.get(:name) }
           Puppet::Type.type(:cron).validproperties.each do |property|
             h[property] = p.get(property)
           end
@@ -264,95 +252,94 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
         expect(parameters[1][:target]).to eq('foobar')
       end
 
-      it "should be able to parse puppet managed cronjobs" do
+      it 'is able to parse puppet managed cronjobs' do
         described_class.stubs(:target_object).returns File.new(my_fixture('managed'))
         expect(described_class.instances.map do |p|
-          h = {:name => p.get(:name)}
+          h = { name: p.get(:name) }
           Puppet::Type.type(:cron).validproperties.each do |property|
             h[property] = p.get(property)
           end
           h
         end).to eq([
-          {
-            :name        => 'real_job',
-            :minute      => :absent,
-            :hour        => :absent,
-            :weekday     => :absent,
-            :month       => :absent,
-            :monthday    => :absent,
-            :special     => :absent,
-            :command     => '/bin/true',
-            :ensure      => :present,
-            :environment => :absent,
-            :user        => :absent,
-            :target      => 'foobar'
-          },
-          {
-            :name        => 'complex_job',
-            :minute      => :absent,
-            :hour        => :absent,
-            :weekday     => :absent,
-            :month       => :absent,
-            :monthday    => :absent,
-            :special     => 'reboot',
-            :command     => '/bin/true >> /dev/null 2>&1',
-            :ensure      => :present,
-            :environment => [
-              'MAILTO=foo@example.com',
-              'SHELL=/bin/sh'
-            ],
-            :user        => :absent,
-            :target      => 'foobar'
-          }
-        ])
+                     {
+                       name: 'real_job',
+                       minute: :absent,
+                       hour: :absent,
+                       weekday: :absent,
+                       month: :absent,
+                       monthday: :absent,
+                       special: :absent,
+                       command: '/bin/true',
+                       ensure: :present,
+                       environment: :absent,
+                       user: :absent,
+                       target: 'foobar',
+                     },
+                     {
+                       name: 'complex_job',
+                       minute: :absent,
+                       hour: :absent,
+                       weekday: :absent,
+                       month: :absent,
+                       monthday: :absent,
+                       special: 'reboot',
+                       command: '/bin/true >> /dev/null 2>&1',
+                       ensure: :present,
+                       environment: [
+                         'MAILTO=foo@example.com',
+                         'SHELL=/bin/sh',
+                       ],
+                       user: :absent,
+                       target: 'foobar',
+                     },
+                   ])
       end
     end
   end
 
-  describe ".match" do
-    describe "normal records" do
-      it "should match when all fields are the same" do
-        expect(described_class.match(record,{resource[:name] => resource})).to eq(resource)
+  describe '.match' do
+    describe 'normal records' do
+      it 'matches when all fields are the same' do
+        expect(described_class.match(record, resource[:name] => resource)).to eq(resource)
       end
 
       {
-        :minute      => %w{0 15 31 45},
-        :hour        => %w{8-18},
-        :monthday    => %w{30 31},
-        :month       => %w{12 23},
-        :weekday     => %w{4},
-        :command     => '/bin/false',
-        :target      => 'nobody'
+        minute: ['0', '15', '31', '45'],
+        hour: ['8-18'],
+        monthday: ['30', '31'],
+        month: ['12', '23'],
+        weekday: ['4'],
+        command: '/bin/false',
+        target: 'nobody',
       }.each_pair do |field, new_value|
         it "should not match a record when #{field} does not match" do
           record[field] = new_value
-          expect(described_class.match(record,{resource[:name] => resource})).to be_falsey
+          expect(described_class.match(record, resource[:name] => resource)).to be_falsey
         end
       end
     end
 
-    describe "special records" do
-      it "should match when all fields are the same" do
-        expect(described_class.match(record_special,{resource_special[:name] => resource_special})).to eq(resource_special)
+    describe 'special records' do
+      it 'matches when all fields are the same' do
+        expect(described_class.match(record_special, resource_special[:name] => resource_special)).to eq(resource_special)
       end
 
       {
-        :special => 'monthly',
-        :command => '/bin/false',
-        :target  => 'root'
+        special: 'monthly',
+        command: '/bin/false',
+        target: 'root',
       }.each_pair do |field, new_value|
         it "should not match a record when #{field} does not match" do
           record_special[field] = new_value
-          expect(described_class.match(record_special,{resource_special[:name] => resource_special})).to be_falsey
+          expect(described_class.match(record_special, resource_special[:name] => resource_special)).to be_falsey
         end
       end
     end
 
-    describe "with a resource without a command" do
-      it "should not raise an error" do
-        expect { described_class.match(record,{resource_sparse[:name] => resource_sparse}) }.to_not raise_error
+    describe 'with a resource without a command' do
+      it 'does not raise an error' do
+        expect { described_class.match(record, resource_sparse[:name] => resource_sparse) }.not_to raise_error
       end
     end
-
   end
 end
diff --git a/spec/unit/type/cron_spec.rb b/spec/unit/type/cron_spec.rb
index 4241e51..80970d0 100644
--- a/spec/unit/type/cron_spec.rb
+++ b/spec/unit/type/cron_spec.rb
@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:cron), unless: Puppet.features.microsoft_windows? do
   let(:simple_provider) do
     @provider_class = described_class.provide(:simple) { mk_resource_methods }
     @provider_class.stubs(:suitable?).returns true
@@ -17,11 +17,11 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
     described_class.unprovide(:simple)
   end
 
-  it "should have :name be its namevar" do
+  it 'has :name be its namevar' do
     expect(described_class.key_attributes).to eq([:name])
   end
 
-  describe "when validating attributes" do
+  describe 'when validating attributes' do
     [:name, :provider].each do |param|
       it "should have a #{param} parameter" do
         expect(described_class.attrtype(param)).to eq(:param)
@@ -41,487 +41,481 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
     end
   end
 
-
-  describe "when validating values" do
-
-    describe "ensure" do
-      it "should support present as a value for ensure" do
-        expect { described_class.new(:name => 'foo', :ensure => :present) }.to_not raise_error
+  describe 'when validating values' do
+    describe 'ensure' do
+      it 'supports present as a value for ensure' do
+        expect { described_class.new(name: 'foo', ensure: :present) }.not_to raise_error
       end
 
-      it "should support absent as a value for ensure" do
-        expect { described_class.new(:name => 'foo', :ensure => :present) }.to_not raise_error
+      it 'supports absent as a value for ensure' do
+        expect { described_class.new(name: 'foo', ensure: :present) }.not_to raise_error
       end
 
-      it "should not support other values" do
-        expect { described_class.new(:name => 'foo', :ensure => :foo) }.to raise_error(Puppet::Error, /Invalid value/)
+      it 'does not support other values' do
+        expect { described_class.new(name: 'foo', ensure: :foo) }.to raise_error(Puppet::Error, %r{Invalid value})
       end
     end
 
-    describe "command" do
-      it "should discard leading spaces" do
-        expect(described_class.new(:name => 'foo', :command => " /bin/true")[:command]).not_to match Regexp.new(" ")
+    describe 'command' do
+      it 'discards leading spaces' do
+        expect(described_class.new(name: 'foo', command: ' /bin/true')[:command]).not_to match Regexp.new(' ')
       end
-      it "should discard trailing spaces" do
-        expect(described_class.new(:name => 'foo', :command => "/bin/true ")[:command]).not_to match Regexp.new(" ")
+      it 'discards trailing spaces' do
+        expect(described_class.new(name: 'foo', command: '/bin/true ')[:command]).not_to match Regexp.new(' ')
       end
     end
 
-    describe "minute" do
-      it "should support absent" do
-        expect { described_class.new(:name => 'foo', :minute => 'absent') }.to_not raise_error
+    describe 'minute' do
+      it 'supports absent' do
+        expect { described_class.new(name: 'foo', minute: 'absent') }.not_to raise_error
       end
 
-      it "should support *" do
-        expect { described_class.new(:name => 'foo', :minute => '*') }.to_not raise_error
+      it 'supports *' do
+        expect { described_class.new(name: 'foo', minute: '*') }.not_to raise_error
       end
 
-      it "should translate absent to :absent" do
-        expect(described_class.new(:name => 'foo', :minute => 'absent')[:minute]).to eq(:absent)
+      it 'translates absent to :absent' do
+        expect(described_class.new(name: 'foo', minute: 'absent')[:minute]).to eq(:absent)
       end
 
-      it "should translate * to :absent" do
-        expect(described_class.new(:name => 'foo', :minute => '*')[:minute]).to eq(:absent)
+      it 'translates * to :absent' do
+        expect(described_class.new(name: 'foo', minute: '*')[:minute]).to eq(:absent)
       end
 
-      it "should support valid single values" do
-        expect { described_class.new(:name => 'foo', :minute => '0') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :minute => '1') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :minute => '59') }.to_not raise_error
+      it 'supports valid single values' do
+        expect { described_class.new(name: 'foo', minute: '0') }.not_to raise_error
+        expect { described_class.new(name: 'foo', minute: '1') }.not_to raise_error
+        expect { described_class.new(name: 'foo', minute: '59') }.not_to raise_error
       end
 
-      it "should not support non numeric characters" do
-        expect { described_class.new(:name => 'foo', :minute => 'z59') }.to raise_error(Puppet::Error, /z59 is not a valid minute/)
-        expect { described_class.new(:name => 'foo', :minute => '5z9') }.to raise_error(Puppet::Error, /5z9 is not a valid minute/)
-        expect { described_class.new(:name => 'foo', :minute => '59z') }.to raise_error(Puppet::Error, /59z is not a valid minute/)
+      it 'does not support non numeric characters' do
+        expect { described_class.new(name: 'foo', minute: 'z59') }.to raise_error(Puppet::Error, %r{z59 is not a valid minute})
+        expect { described_class.new(name: 'foo', minute: '5z9') }.to raise_error(Puppet::Error, %r{5z9 is not a valid minute})
+        expect { described_class.new(name: 'foo', minute: '59z') }.to raise_error(Puppet::Error, %r{59z is not a valid minute})
       end
 
-      it "should not support single values out of range" do
-
-        expect { described_class.new(:name => 'foo', :minute => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid minute/)
-        expect { described_class.new(:name => 'foo', :minute => '60') }.to raise_error(Puppet::Error, /60 is not a valid minute/)
-        expect { described_class.new(:name => 'foo', :minute => '61') }.to raise_error(Puppet::Error, /61 is not a valid minute/)
-        expect { described_class.new(:name => 'foo', :minute => '120') }.to raise_error(Puppet::Error, /120 is not a valid minute/)
+      it 'does not support single values out of range' do
+        expect { described_class.new(name: 'foo', minute: '-1') }.to raise_error(Puppet::Error, %r{-1 is not a valid minute})
+        expect { described_class.new(name: 'foo', minute: '60') }.to raise_error(Puppet::Error, %r{60 is not a valid minute})
+        expect { described_class.new(name: 'foo', minute: '61') }.to raise_error(Puppet::Error, %r{61 is not a valid minute})
+        expect { described_class.new(name: 'foo', minute: '120') }.to raise_error(Puppet::Error, %r{120 is not a valid minute})
       end
 
-      it "should support valid multiple values" do
-        expect { described_class.new(:name => 'foo', :minute => ['0','1','59'] ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :minute => ['40','30','20'] ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :minute => ['10','30','20'] ) }.to_not raise_error
+      it 'supports valid multiple values' do
+        expect { described_class.new(name: 'foo', minute: ['0', '1', '59']) }.not_to raise_error
+        expect { described_class.new(name: 'foo', minute: ['40', '30', '20']) }.not_to raise_error
+        expect { described_class.new(name: 'foo', minute: ['10', '30', '20']) }.not_to raise_error
       end
 
-      it "should not support multiple values if at least one is invalid" do
+      it 'does not support multiple values if at least one is invalid' do
         # one invalid
-        expect { described_class.new(:name => 'foo', :minute => ['0','1','60'] ) }.to raise_error(Puppet::Error, /60 is not a valid minute/)
-        expect { described_class.new(:name => 'foo', :minute => ['0','120','59'] ) }.to raise_error(Puppet::Error, /120 is not a valid minute/)
-        expect { described_class.new(:name => 'foo', :minute => ['-1','1','59'] ) }.to raise_error(Puppet::Error, /-1 is not a valid minute/)
+        expect { described_class.new(name: 'foo', minute: ['0', '1', '60']) }.to raise_error(Puppet::Error, %r{60 is not a valid minute})
+        expect { described_class.new(name: 'foo', minute: ['0', '120', '59']) }.to raise_error(Puppet::Error, %r{120 is not a valid minute})
+        expect { described_class.new(name: 'foo', minute: ['-1', '1', '59']) }.to raise_error(Puppet::Error, %r{-1 is not a valid minute})
         # two invalid
-        expect { described_class.new(:name => 'foo', :minute => ['0','61','62'] ) }.to raise_error(Puppet::Error, /(61|62) is not a valid minute/)
+        expect { described_class.new(name: 'foo', minute: ['0', '61', '62']) }.to raise_error(Puppet::Error, %r{(61|62) is not a valid minute})
         # all invalid
-        expect { described_class.new(:name => 'foo', :minute => ['-1','61','62'] ) }.to raise_error(Puppet::Error, /(-1|61|62) is not a valid minute/)
+        expect { described_class.new(name: 'foo', minute: ['-1', '61', '62']) }.to raise_error(Puppet::Error, %r{(-1|61|62) is not a valid minute})
       end
 
-      it "should support valid step syntax" do
-        expect { described_class.new(:name => 'foo', :minute => '*/2' ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :minute => '10-16/2' ) }.to_not raise_error
+      it 'supports valid step syntax' do
+        expect { described_class.new(name: 'foo', minute: '*/2') }.not_to raise_error
+        expect { described_class.new(name: 'foo', minute: '10-16/2') }.not_to raise_error
       end
 
-      it "should not support invalid steps" do
-        expect { described_class.new(:name => 'foo', :minute => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid minute/)
-        expect { described_class.new(:name => 'foo', :minute => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid minute/)
+      it 'does not support invalid steps' do
+        expect { described_class.new(name: 'foo', minute: '*/A') }.to raise_error(Puppet::Error, /\*\/A is not a valid minute/)
+        expect { described_class.new(name: 'foo', minute: '*/2A') }.to raise_error(Puppet::Error, /\*\/2A is not a valid minute/)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # expect { described_class.new(:name => 'foo', :minute => '*/120' ) }.to raise_error(Puppet::Error, /is not a valid minute/)
       end
     end
 
-    describe "hour" do
-      it "should support absent" do
-        expect { described_class.new(:name => 'foo', :hour => 'absent') }.to_not raise_error
+    describe 'hour' do
+      it 'supports absent' do
+        expect { described_class.new(name: 'foo', hour: 'absent') }.not_to raise_error
       end
 
-      it "should support *" do
-        expect { described_class.new(:name => 'foo', :hour => '*') }.to_not raise_error
+      it 'supports *' do
+        expect { described_class.new(name: 'foo', hour: '*') }.not_to raise_error
       end
 
-      it "should translate absent to :absent" do
-        expect(described_class.new(:name => 'foo', :hour => 'absent')[:hour]).to eq(:absent)
+      it 'translates absent to :absent' do
+        expect(described_class.new(name: 'foo', hour: 'absent')[:hour]).to eq(:absent)
       end
 
-      it "should translate * to :absent" do
-        expect(described_class.new(:name => 'foo', :hour => '*')[:hour]).to eq(:absent)
+      it 'translates * to :absent' do
+        expect(described_class.new(name: 'foo', hour: '*')[:hour]).to eq(:absent)
       end
 
-      it "should support valid single values" do
-        expect { described_class.new(:name => 'foo', :hour => '0') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :hour => '11') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :hour => '12') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :hour => '13') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :hour => '23') }.to_not raise_error
+      it 'supports valid single values' do
+        expect { described_class.new(name: 'foo', hour: '0') }.not_to raise_error
+        expect { described_class.new(name: 'foo', hour: '11') }.not_to raise_error
+        expect { described_class.new(name: 'foo', hour: '12') }.not_to raise_error
+        expect { described_class.new(name: 'foo', hour: '13') }.not_to raise_error
+        expect { described_class.new(name: 'foo', hour: '23') }.not_to raise_error
       end
 
-      it "should not support non numeric characters" do
-        expect { described_class.new(:name => 'foo', :hour => 'z15') }.to raise_error(Puppet::Error, /z15 is not a valid hour/)
-        expect { described_class.new(:name => 'foo', :hour => '1z5') }.to raise_error(Puppet::Error, /1z5 is not a valid hour/)
-        expect { described_class.new(:name => 'foo', :hour => '15z') }.to raise_error(Puppet::Error, /15z is not a valid hour/)
+      it 'does not support non numeric characters' do
+        expect { described_class.new(name: 'foo', hour: 'z15') }.to raise_error(Puppet::Error, %r{z15 is not a valid hour})
+        expect { described_class.new(name: 'foo', hour: '1z5') }.to raise_error(Puppet::Error, %r{1z5 is not a valid hour})
+        expect { described_class.new(name: 'foo', hour: '15z') }.to raise_error(Puppet::Error, %r{15z is not a valid hour})
       end
 
-      it "should not support single values out of range" do
-        expect { described_class.new(:name => 'foo', :hour => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid hour/)
-        expect { described_class.new(:name => 'foo', :hour => '24') }.to raise_error(Puppet::Error, /24 is not a valid hour/)
-        expect { described_class.new(:name => 'foo', :hour => '120') }.to raise_error(Puppet::Error, /120 is not a valid hour/)
+      it 'does not support single values out of range' do
+        expect { described_class.new(name: 'foo', hour: '-1') }.to raise_error(Puppet::Error, %r{-1 is not a valid hour})
+        expect { described_class.new(name: 'foo', hour: '24') }.to raise_error(Puppet::Error, %r{24 is not a valid hour})
+        expect { described_class.new(name: 'foo', hour: '120') }.to raise_error(Puppet::Error, %r{120 is not a valid hour})
       end
 
-      it "should support valid multiple values" do
-        expect { described_class.new(:name => 'foo', :hour => ['0','1','23'] ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :hour => ['5','16','14'] ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :hour => ['16','13','9'] ) }.to_not raise_error
+      it 'supports valid multiple values' do
+        expect { described_class.new(name: 'foo', hour: ['0', '1', '23']) }.not_to raise_error
+        expect { described_class.new(name: 'foo', hour: ['5', '16', '14']) }.not_to raise_error
+        expect { described_class.new(name: 'foo', hour: ['16', '13', '9']) }.not_to raise_error
       end
 
-      it "should not support multiple values if at least one is invalid" do
+      it 'does not support multiple values if at least one is invalid' do
         # one invalid
-        expect { described_class.new(:name => 'foo', :hour => ['0','1','24'] ) }.to raise_error(Puppet::Error, /24 is not a valid hour/)
-        expect { described_class.new(:name => 'foo', :hour => ['0','-1','5'] ) }.to raise_error(Puppet::Error, /-1 is not a valid hour/)
-        expect { described_class.new(:name => 'foo', :hour => ['-1','1','23'] ) }.to raise_error(Puppet::Error, /-1 is not a valid hour/)
+        expect { described_class.new(name: 'foo', hour: ['0', '1', '24']) }.to raise_error(Puppet::Error, %r{24 is not a valid hour})
+        expect { described_class.new(name: 'foo', hour: ['0', '-1', '5']) }.to raise_error(Puppet::Error, %r{-1 is not a valid hour})
+        expect { described_class.new(name: 'foo', hour: ['-1', '1', '23']) }.to raise_error(Puppet::Error, %r{-1 is not a valid hour})
         # two invalid
-        expect { described_class.new(:name => 'foo', :hour => ['0','25','26'] ) }.to raise_error(Puppet::Error, /(25|26) is not a valid hour/)
+        expect { described_class.new(name: 'foo', hour: ['0', '25', '26']) }.to raise_error(Puppet::Error, %r{(25|26) is not a valid hour})
         # all invalid
-        expect { described_class.new(:name => 'foo', :hour => ['-1','24','120'] ) }.to raise_error(Puppet::Error, /(-1|24|120) is not a valid hour/)
+        expect { described_class.new(name: 'foo', hour: ['-1', '24', '120']) }.to raise_error(Puppet::Error, %r{(-1|24|120) is not a valid hour})
       end
 
-      it "should support valid step syntax" do
-        expect { described_class.new(:name => 'foo', :hour => '*/2' ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :hour => '10-18/4' ) }.to_not raise_error
+      it 'supports valid step syntax' do
+        expect { described_class.new(name: 'foo', hour: '*/2') }.not_to raise_error
+        expect { described_class.new(name: 'foo', hour: '10-18/4') }.not_to raise_error
       end
 
-      it "should not support invalid steps" do
-        expect { described_class.new(:name => 'foo', :hour => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid hour/)
-        expect { described_class.new(:name => 'foo', :hour => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid hour/)
+      it 'does not support invalid steps' do
+        expect { described_class.new(name: 'foo', hour: '*/A') }.to raise_error(Puppet::Error, /\*\/A is not a valid hour/)
+        expect { described_class.new(name: 'foo', hour: '*/2A') }.to raise_error(Puppet::Error, /\*\/2A is not a valid hour/)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # expect { described_class.new(:name => 'foo', :hour => '*/26' ) }.to raise_error(Puppet::Error, /is not a valid hour/)
       end
     end
 
-    describe "weekday" do
-      it "should support absent" do
-        expect { described_class.new(:name => 'foo', :weekday => 'absent') }.to_not raise_error
+    describe 'weekday' do
+      it 'supports absent' do
+        expect { described_class.new(name: 'foo', weekday: 'absent') }.not_to raise_error
       end
 
-      it "should support *" do
-        expect { described_class.new(:name => 'foo', :weekday => '*') }.to_not raise_error
+      it 'supports *' do
+        expect { described_class.new(name: 'foo', weekday: '*') }.not_to raise_error
       end
 
-      it "should translate absent to :absent" do
-        expect(described_class.new(:name => 'foo', :weekday => 'absent')[:weekday]).to eq(:absent)
+      it 'translates absent to :absent' do
+        expect(described_class.new(name: 'foo', weekday: 'absent')[:weekday]).to eq(:absent)
       end
 
-      it "should translate * to :absent" do
-        expect(described_class.new(:name => 'foo', :weekday => '*')[:weekday]).to eq(:absent)
+      it 'translates * to :absent' do
+        expect(described_class.new(name: 'foo', weekday: '*')[:weekday]).to eq(:absent)
       end
 
-      it "should support valid numeric weekdays" do
-        expect { described_class.new(:name => 'foo', :weekday => '0') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => '1') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => '6') }.to_not raise_error
+      it 'supports valid numeric weekdays' do
+        expect { described_class.new(name: 'foo', weekday: '0') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: '1') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: '6') }.not_to raise_error
         # According to http://www.manpagez.com/man/5/crontab 7 is also valid (Sunday)
-        expect { described_class.new(:name => 'foo', :weekday => '7') }.to_not raise_error
+        expect { described_class.new(name: 'foo', weekday: '7') }.not_to raise_error
       end
 
-      it "should support valid weekdays as words (long version)" do
-        expect { described_class.new(:name => 'foo', :weekday => 'Monday') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => 'Tuesday') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => 'Wednesday') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => 'Thursday') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => 'Friday') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => 'Saturday') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => 'Sunday') }.to_not raise_error
+      it 'supports valid weekdays as words (long version)' do
+        expect { described_class.new(name: 'foo', weekday: 'Monday') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: 'Tuesday') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: 'Wednesday') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: 'Thursday') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: 'Friday') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: 'Saturday') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: 'Sunday') }.not_to raise_error
       end
 
-      it "should support valid weekdays as words (3 character version)" do
-        expect { described_class.new(:name => 'foo', :weekday => 'Mon') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => 'Tue') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => 'Wed') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => 'Thu') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => 'Fri') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => 'Sat') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => 'Sun') }.to_not raise_error
+      it 'supports valid weekdays as words (3 character version)' do
+        expect { described_class.new(name: 'foo', weekday: 'Mon') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: 'Tue') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: 'Wed') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: 'Thu') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: 'Fri') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: 'Sat') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: 'Sun') }.not_to raise_error
       end
 
-      it "should not support numeric values out of range" do
-        expect { described_class.new(:name => 'foo', :weekday => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid weekday/)
-        expect { described_class.new(:name => 'foo', :weekday => '8') }.to raise_error(Puppet::Error, /8 is not a valid weekday/)
+      it 'does not support numeric values out of range' do
+        expect { described_class.new(name: 'foo', weekday: '-1') }.to raise_error(Puppet::Error, %r{-1 is not a valid weekday})
+        expect { described_class.new(name: 'foo', weekday: '8') }.to raise_error(Puppet::Error, %r{8 is not a valid weekday})
       end
 
-      it "should not support invalid weekday names" do
-        expect { described_class.new(:name => 'foo', :weekday => 'Sar') }.to raise_error(Puppet::Error, /Sar is not a valid weekday/)
+      it 'does not support invalid weekday names' do
+        expect { described_class.new(name: 'foo', weekday: 'Sar') }.to raise_error(Puppet::Error, %r{Sar is not a valid weekday})
       end
 
-      it "should support valid multiple values" do
-        expect { described_class.new(:name => 'foo', :weekday => ['0','1','6'] ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => ['Mon','Wed','Friday'] ) }.to_not raise_error
+      it 'supports valid multiple values' do
+        expect { described_class.new(name: 'foo', weekday: ['0', '1', '6']) }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: ['Mon', 'Wed', 'Friday']) }.not_to raise_error
       end
 
-      it "should not support multiple values if at least one is invalid" do
+      it 'does not support multiple values if at least one is invalid' do
         # one invalid
-        expect { described_class.new(:name => 'foo', :weekday => ['0','1','8'] ) }.to raise_error(Puppet::Error, /8 is not a valid weekday/)
-        expect { described_class.new(:name => 'foo', :weekday => ['Mon','Fii','Sat'] ) }.to raise_error(Puppet::Error, /Fii is not a valid weekday/)
+        expect { described_class.new(name: 'foo', weekday: ['0', '1', '8']) }.to raise_error(Puppet::Error, %r{8 is not a valid weekday})
+        expect { described_class.new(name: 'foo', weekday: ['Mon', 'Fii', 'Sat']) }.to raise_error(Puppet::Error, %r{Fii is not a valid weekday})
         # two invalid
-        expect { described_class.new(:name => 'foo', :weekday => ['Mos','Fii','Sat'] ) }.to raise_error(Puppet::Error, /(Mos|Fii) is not a valid weekday/)
+        expect { described_class.new(name: 'foo', weekday: ['Mos', 'Fii', 'Sat']) }.to raise_error(Puppet::Error, %r{(Mos|Fii) is not a valid weekday})
         # all invalid
-        expect { described_class.new(:name => 'foo', :weekday => ['Mos','Fii','Saa'] ) }.to raise_error(Puppet::Error, /(Mos|Fii|Saa) is not a valid weekday/)
-        expect { described_class.new(:name => 'foo', :weekday => ['-1','8','11'] ) }.to raise_error(Puppet::Error, /(-1|8|11) is not a valid weekday/)
+        expect { described_class.new(name: 'foo', weekday: ['Mos', 'Fii', 'Saa']) }.to raise_error(Puppet::Error, %r{(Mos|Fii|Saa) is not a valid weekday})
+        expect { described_class.new(name: 'foo', weekday: ['-1', '8', '11']) }.to raise_error(Puppet::Error, %r{(-1|8|11) is not a valid weekday})
       end
 
-      it "should support valid step syntax" do
-        expect { described_class.new(:name => 'foo', :weekday => '*/2' ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :weekday => '0-4/2' ) }.to_not raise_error
+      it 'supports valid step syntax' do
+        expect { described_class.new(name: 'foo', weekday: '*/2') }.not_to raise_error
+        expect { described_class.new(name: 'foo', weekday: '0-4/2') }.not_to raise_error
       end
 
-      it "should not support invalid steps" do
-        expect { described_class.new(:name => 'foo', :weekday => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid weekday/)
-        expect { described_class.new(:name => 'foo', :weekday => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid weekday/)
+      it 'does not support invalid steps' do
+        expect { described_class.new(name: 'foo', weekday: '*/A') }.to raise_error(Puppet::Error, /\*\/A is not a valid weekday/)
+        expect { described_class.new(name: 'foo', weekday: '*/2A') }.to raise_error(Puppet::Error, /\*\/2A is not a valid weekday/)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # expect { described_class.new(:name => 'foo', :weekday => '*/9' ) }.to raise_error(Puppet::Error, /is not a valid weekday/)
       end
     end
 
-    describe "month" do
-      it "should support absent" do
-        expect { described_class.new(:name => 'foo', :month => 'absent') }.to_not raise_error
+    describe 'month' do
+      it 'supports absent' do
+        expect { described_class.new(name: 'foo', month: 'absent') }.not_to raise_error
       end
 
-      it "should support *" do
-        expect { described_class.new(:name => 'foo', :month => '*') }.to_not raise_error
+      it 'supports *' do
+        expect { described_class.new(name: 'foo', month: '*') }.not_to raise_error
       end
 
-      it "should translate absent to :absent" do
-        expect(described_class.new(:name => 'foo', :month => 'absent')[:month]).to eq(:absent)
+      it 'translates absent to :absent' do
+        expect(described_class.new(name: 'foo', month: 'absent')[:month]).to eq(:absent)
       end
 
-      it "should translate * to :absent" do
-        expect(described_class.new(:name => 'foo', :month => '*')[:month]).to eq(:absent)
+      it 'translates * to :absent' do
+        expect(described_class.new(name: 'foo', month: '*')[:month]).to eq(:absent)
       end
 
-      it "should support valid numeric values" do
-        expect { described_class.new(:name => 'foo', :month => '1') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => '12') }.to_not raise_error
+      it 'supports valid numeric values' do
+        expect { described_class.new(name: 'foo', month: '1') }.not_to raise_error
+        expect { described_class.new(name: 'foo', month: '12') }.not_to raise_error
       end
 
-      it "should support valid months as words" do
-        expect( described_class.new(:name => 'foo', :month => 'January')[:month]   ).to eq(['1'])
-        expect( described_class.new(:name => 'foo', :month => 'February')[:month]  ).to eq(['2'])
-        expect( described_class.new(:name => 'foo', :month => 'March')[:month]     ).to eq(['3'])
-        expect( described_class.new(:name => 'foo', :month => 'April')[:month]     ).to eq(['4'])
-        expect( described_class.new(:name => 'foo', :month => 'May')[:month]       ).to eq(['5'])
-        expect( described_class.new(:name => 'foo', :month => 'June')[:month]      ).to eq(['6'])
-        expect( described_class.new(:name => 'foo', :month => 'July')[:month]      ).to eq(['7'])
-        expect( described_class.new(:name => 'foo', :month => 'August')[:month]    ).to eq(['8'])
-        expect( described_class.new(:name => 'foo', :month => 'September')[:month] ).to eq(['9'])
-        expect( described_class.new(:name => 'foo', :month => 'October')[:month]   ).to eq(['10'])
-        expect( described_class.new(:name => 'foo', :month => 'November')[:month]  ).to eq(['11'])
-        expect( described_class.new(:name => 'foo', :month => 'December')[:month]  ).to eq(['12'])
+      it 'supports valid months as words' do
+        expect(described_class.new(name: 'foo', month: 'January')[:month]).to eq(['1'])
+        expect(described_class.new(name: 'foo', month: 'February')[:month]).to eq(['2'])
+        expect(described_class.new(name: 'foo', month: 'March')[:month]).to eq(['3'])
+        expect(described_class.new(name: 'foo', month: 'April')[:month]).to eq(['4'])
+        expect(described_class.new(name: 'foo', month: 'May')[:month]).to eq(['5'])
+        expect(described_class.new(name: 'foo', month: 'June')[:month]).to eq(['6'])
+        expect(described_class.new(name: 'foo', month: 'July')[:month]).to eq(['7'])
+        expect(described_class.new(name: 'foo', month: 'August')[:month]).to eq(['8'])
+        expect(described_class.new(name: 'foo', month: 'September')[:month]).to eq(['9'])
+        expect(described_class.new(name: 'foo', month: 'October')[:month]).to eq(['10'])
+        expect(described_class.new(name: 'foo', month: 'November')[:month]).to eq(['11'])
+        expect(described_class.new(name: 'foo', month: 'December')[:month]).to eq(['12'])
       end
 
-      it "should support valid months as words (3 character short version)" do
-        expect( described_class.new(:name => 'foo', :month => 'Jan')[:month] ).to eq(['1'])
-        expect( described_class.new(:name => 'foo', :month => 'Feb')[:month] ).to eq(['2'])
-        expect( described_class.new(:name => 'foo', :month => 'Mar')[:month] ).to eq(['3'])
-        expect( described_class.new(:name => 'foo', :month => 'Apr')[:month] ).to eq(['4'])
-        expect( described_class.new(:name => 'foo', :month => 'May')[:month] ).to eq(['5'])
-        expect( described_class.new(:name => 'foo', :month => 'Jun')[:month] ).to eq(['6'])
-        expect( described_class.new(:name => 'foo', :month => 'Jul')[:month] ).to eq(['7'])
-        expect( described_class.new(:name => 'foo', :month => 'Aug')[:month] ).to eq(['8'])
-        expect( described_class.new(:name => 'foo', :month => 'Sep')[:month] ).to eq(['9'])
-        expect( described_class.new(:name => 'foo', :month => 'Oct')[:month] ).to eq(['10'])
-        expect( described_class.new(:name => 'foo', :month => 'Nov')[:month] ).to eq(['11'])
-        expect( described_class.new(:name => 'foo', :month => 'Dec')[:month] ).to eq(['12'])
+      it 'supports valid months as words (3 character short version)' do
+        expect(described_class.new(name: 'foo', month: 'Jan')[:month]).to eq(['1'])
+        expect(described_class.new(name: 'foo', month: 'Feb')[:month]).to eq(['2'])
+        expect(described_class.new(name: 'foo', month: 'Mar')[:month]).to eq(['3'])
+        expect(described_class.new(name: 'foo', month: 'Apr')[:month]).to eq(['4'])
+        expect(described_class.new(name: 'foo', month: 'May')[:month]).to eq(['5'])
+        expect(described_class.new(name: 'foo', month: 'Jun')[:month]).to eq(['6'])
+        expect(described_class.new(name: 'foo', month: 'Jul')[:month]).to eq(['7'])
+        expect(described_class.new(name: 'foo', month: 'Aug')[:month]).to eq(['8'])
+        expect(described_class.new(name: 'foo', month: 'Sep')[:month]).to eq(['9'])
+        expect(described_class.new(name: 'foo', month: 'Oct')[:month]).to eq(['10'])
+        expect(described_class.new(name: 'foo', month: 'Nov')[:month]).to eq(['11'])
+        expect(described_class.new(name: 'foo', month: 'Dec')[:month]).to eq(['12'])
       end
 
-      it "should not support numeric values out of range" do
-        expect { described_class.new(:name => 'foo', :month => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid month/)
-        expect { described_class.new(:name => 'foo', :month => '0') }.to raise_error(Puppet::Error, /0 is not a valid month/)
-        expect { described_class.new(:name => 'foo', :month => '13') }.to raise_error(Puppet::Error, /13 is not a valid month/)
+      it 'does not support numeric values out of range' do
+        expect { described_class.new(name: 'foo', month: '-1') }.to raise_error(Puppet::Error, %r{-1 is not a valid month})
+        expect { described_class.new(name: 'foo', month: '0') }.to raise_error(Puppet::Error, %r{0 is not a valid month})
+        expect { described_class.new(name: 'foo', month: '13') }.to raise_error(Puppet::Error, %r{13 is not a valid month})
       end
 
-      it "should not support words that are not valid months" do
-        expect { described_class.new(:name => 'foo', :month => 'Jal') }.to raise_error(Puppet::Error, /Jal is not a valid month/)
+      it 'does not support words that are not valid months' do
+        expect { described_class.new(name: 'foo', month: 'Jal') }.to raise_error(Puppet::Error, %r{Jal is not a valid month})
       end
 
-      it "should not support single values out of range" do
-
-        expect { described_class.new(:name => 'foo', :month => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid month/)
-        expect { described_class.new(:name => 'foo', :month => '60') }.to raise_error(Puppet::Error, /60 is not a valid month/)
-        expect { described_class.new(:name => 'foo', :month => '61') }.to raise_error(Puppet::Error, /61 is not a valid month/)
-        expect { described_class.new(:name => 'foo', :month => '120') }.to raise_error(Puppet::Error, /120 is not a valid month/)
+      it 'does not support single values out of range' do
+        expect { described_class.new(name: 'foo', month: '-1') }.to raise_error(Puppet::Error, %r{-1 is not a valid month})
+        expect { described_class.new(name: 'foo', month: '60') }.to raise_error(Puppet::Error, %r{60 is not a valid month})
+        expect { described_class.new(name: 'foo', month: '61') }.to raise_error(Puppet::Error, %r{61 is not a valid month})
+        expect { described_class.new(name: 'foo', month: '120') }.to raise_error(Puppet::Error, %r{120 is not a valid month})
       end
 
-      it "should support valid multiple values" do
-        expect { described_class.new(:name => 'foo', :month => ['1','9','12'] ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => ['Jan','March','Jul'] ) }.to_not raise_error
+      it 'supports valid multiple values' do
+        expect { described_class.new(name: 'foo', month: ['1', '9', '12']) }.not_to raise_error
+        expect { described_class.new(name: 'foo', month: ['Jan', 'March', 'Jul']) }.not_to raise_error
       end
 
-      it "should not support multiple values if at least one is invalid" do
+      it 'does not support multiple values if at least one is invalid' do
         # one invalid
-        expect { described_class.new(:name => 'foo', :month => ['0','1','12'] ) }.to raise_error(Puppet::Error, /0 is not a valid month/)
-        expect { described_class.new(:name => 'foo', :month => ['1','13','10'] ) }.to raise_error(Puppet::Error, /13 is not a valid month/)
-        expect { described_class.new(:name => 'foo', :month => ['Jan','Feb','Jxx'] ) }.to raise_error(Puppet::Error, /Jxx is not a valid month/)
+        expect { described_class.new(name: 'foo', month: ['0', '1', '12']) }.to raise_error(Puppet::Error, %r{0 is not a valid month})
+        expect { described_class.new(name: 'foo', month: ['1', '13', '10']) }.to raise_error(Puppet::Error, %r{13 is not a valid month})
+        expect { described_class.new(name: 'foo', month: ['Jan', 'Feb', 'Jxx']) }.to raise_error(Puppet::Error, %r{Jxx is not a valid month})
         # two invalid
-        expect { described_class.new(:name => 'foo', :month => ['Jan','Fex','Jux'] ) }.to raise_error(Puppet::Error, /(Fex|Jux) is not a valid month/)
+        expect { described_class.new(name: 'foo', month: ['Jan', 'Fex', 'Jux']) }.to raise_error(Puppet::Error, %r{(Fex|Jux) is not a valid month})
         # all invalid
-        expect { described_class.new(:name => 'foo', :month => ['-1','0','13'] ) }.to raise_error(Puppet::Error, /(-1|0|13) is not a valid month/)
-        expect { described_class.new(:name => 'foo', :month => ['Jax','Fex','Aux'] ) }.to raise_error(Puppet::Error, /(Jax|Fex|Aux) is not a valid month/)
+        expect { described_class.new(name: 'foo', month: ['-1', '0', '13']) }.to raise_error(Puppet::Error, %r{(-1|0|13) is not a valid month})
+        expect { described_class.new(name: 'foo', month: ['Jax', 'Fex', 'Aux']) }.to raise_error(Puppet::Error, %r{(Jax|Fex|Aux) is not a valid month})
       end
 
-      it "should support valid step syntax" do
-        expect { described_class.new(:name => 'foo', :month => '*/2' ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => '1-12/3' ) }.to_not raise_error
+      it 'supports valid step syntax' do
+        expect { described_class.new(name: 'foo', month: '*/2') }.not_to raise_error
+        expect { described_class.new(name: 'foo', month: '1-12/3') }.not_to raise_error
       end
 
-      it "should not support invalid steps" do
-        expect { described_class.new(:name => 'foo', :month => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid month/)
-        expect { described_class.new(:name => 'foo', :month => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid month/)
+      it 'does not support invalid steps' do
+        expect { described_class.new(name: 'foo', month: '*/A') }.to raise_error(Puppet::Error, /\*\/A is not a valid month/)
+        expect { described_class.new(name: 'foo', month: '*/2A') }.to raise_error(Puppet::Error, /\*\/2A is not a valid month/)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # expect { described_class.new(:name => 'foo', :month => '*/13' ) }.to raise_error(Puppet::Error, /is not a valid month/)
       end
     end
 
-    describe "monthday" do
-      it "should support absent" do
-        expect { described_class.new(:name => 'foo', :monthday => 'absent') }.to_not raise_error
+    describe 'monthday' do
+      it 'supports absent' do
+        expect { described_class.new(name: 'foo', monthday: 'absent') }.not_to raise_error
       end
 
-      it "should support *" do
-        expect { described_class.new(:name => 'foo', :monthday => '*') }.to_not raise_error
+      it 'supports *' do
+        expect { described_class.new(name: 'foo', monthday: '*') }.not_to raise_error
       end
 
-      it "should translate absent to :absent" do
-        expect(described_class.new(:name => 'foo', :monthday => 'absent')[:monthday]).to eq(:absent)
+      it 'translates absent to :absent' do
+        expect(described_class.new(name: 'foo', monthday: 'absent')[:monthday]).to eq(:absent)
       end
 
-      it "should translate * to :absent" do
-        expect(described_class.new(:name => 'foo', :monthday => '*')[:monthday]).to eq(:absent)
+      it 'translates * to :absent' do
+        expect(described_class.new(name: 'foo', monthday: '*')[:monthday]).to eq(:absent)
       end
 
-      it "should support valid single values" do
-        expect { described_class.new(:name => 'foo', :monthday => '1') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :monthday => '30') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :monthday => '31') }.to_not raise_error
+      it 'supports valid single values' do
+        expect { described_class.new(name: 'foo', monthday: '1') }.not_to raise_error
+        expect { described_class.new(name: 'foo', monthday: '30') }.not_to raise_error
+        expect { described_class.new(name: 'foo', monthday: '31') }.not_to raise_error
       end
 
-      it "should not support non numeric characters" do
-        expect { described_class.new(:name => 'foo', :monthday => 'z23') }.to raise_error(Puppet::Error, /z23 is not a valid monthday/)
-        expect { described_class.new(:name => 'foo', :monthday => '2z3') }.to raise_error(Puppet::Error, /2z3 is not a valid monthday/)
-        expect { described_class.new(:name => 'foo', :monthday => '23z') }.to raise_error(Puppet::Error, /23z is not a valid monthday/)
+      it 'does not support non numeric characters' do
+        expect { described_class.new(name: 'foo', monthday: 'z23') }.to raise_error(Puppet::Error, %r{z23 is not a valid monthday})
+        expect { described_class.new(name: 'foo', monthday: '2z3') }.to raise_error(Puppet::Error, %r{2z3 is not a valid monthday})
+        expect { described_class.new(name: 'foo', monthday: '23z') }.to raise_error(Puppet::Error, %r{23z is not a valid monthday})
       end
 
-      it "should not support single values out of range" do
-        expect { described_class.new(:name => 'foo', :monthday => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid monthday/)
-        expect { described_class.new(:name => 'foo', :monthday => '0') }.to raise_error(Puppet::Error, /0 is not a valid monthday/)
-        expect { described_class.new(:name => 'foo', :monthday => '32') }.to raise_error(Puppet::Error, /32 is not a valid monthday/)
+      it 'does not support single values out of range' do
+        expect { described_class.new(name: 'foo', monthday: '-1') }.to raise_error(Puppet::Error, %r{-1 is not a valid monthday})
+        expect { described_class.new(name: 'foo', monthday: '0') }.to raise_error(Puppet::Error, %r{0 is not a valid monthday})
+        expect { described_class.new(name: 'foo', monthday: '32') }.to raise_error(Puppet::Error, %r{32 is not a valid monthday})
       end
 
-      it "should support valid multiple values" do
-        expect { described_class.new(:name => 'foo', :monthday => ['1','23','31'] ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :monthday => ['31','23','1'] ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :monthday => ['1','31','23'] ) }.to_not raise_error
+      it 'supports valid multiple values' do
+        expect { described_class.new(name: 'foo', monthday: ['1', '23', '31']) }.not_to raise_error
+        expect { described_class.new(name: 'foo', monthday: ['31', '23', '1']) }.not_to raise_error
+        expect { described_class.new(name: 'foo', monthday: ['1', '31', '23']) }.not_to raise_error
       end
 
-      it "should not support multiple values if at least one is invalid" do
+      it 'does not support multiple values if at least one is invalid' do
         # one invalid
-        expect { described_class.new(:name => 'foo', :monthday => ['1','23','32'] ) }.to raise_error(Puppet::Error, /32 is not a valid monthday/)
-        expect { described_class.new(:name => 'foo', :monthday => ['-1','12','23'] ) }.to raise_error(Puppet::Error, /-1 is not a valid monthday/)
-        expect { described_class.new(:name => 'foo', :monthday => ['13','32','30'] ) }.to raise_error(Puppet::Error, /32 is not a valid monthday/)
+        expect { described_class.new(name: 'foo', monthday: ['1', '23', '32']) }.to raise_error(Puppet::Error, %r{32 is not a valid monthday})
+        expect { described_class.new(name: 'foo', monthday: ['-1', '12', '23']) }.to raise_error(Puppet::Error, %r{-1 is not a valid monthday})
+        expect { described_class.new(name: 'foo', monthday: ['13', '32', '30']) }.to raise_error(Puppet::Error, %r{32 is not a valid monthday})
         # two invalid
-        expect { described_class.new(:name => 'foo', :monthday => ['-1','0','23'] ) }.to raise_error(Puppet::Error, /(-1|0) is not a valid monthday/)
+        expect { described_class.new(name: 'foo', monthday: ['-1', '0', '23']) }.to raise_error(Puppet::Error, %r{(-1|0) is not a valid monthday})
         # all invalid
-        expect { described_class.new(:name => 'foo', :monthday => ['-1','0','32'] ) }.to raise_error(Puppet::Error, /(-1|0|32) is not a valid monthday/)
+        expect { described_class.new(name: 'foo', monthday: ['-1', '0', '32']) }.to raise_error(Puppet::Error, %r{(-1|0|32) is not a valid monthday})
       end
 
-      it "should support valid step syntax" do
-        expect { described_class.new(:name => 'foo', :monthday => '*/2' ) }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :monthday => '10-16/2' ) }.to_not raise_error
+      it 'supports valid step syntax' do
+        expect { described_class.new(name: 'foo', monthday: '*/2') }.not_to raise_error
+        expect { described_class.new(name: 'foo', monthday: '10-16/2') }.not_to raise_error
       end
 
-      it "should not support invalid steps" do
-        expect { described_class.new(:name => 'foo', :monthday => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid monthday/)
-        expect { described_class.new(:name => 'foo', :monthday => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid monthday/)
+      it 'does not support invalid steps' do
+        expect { described_class.new(name: 'foo', monthday: '*/A') }.to raise_error(Puppet::Error, /\*\/A is not a valid monthday/)
+        expect { described_class.new(name: 'foo', monthday: '*/2A') }.to raise_error(Puppet::Error, /\*\/2A is not a valid monthday/)
         # As it turns out cron does not complaining about steps that exceed the valid range
         # expect { described_class.new(:name => 'foo', :monthday => '*/32' ) }.to raise_error(Puppet::Error, /is not a valid monthday/)
       end
     end
 
-    describe "special" do
-      %w(reboot yearly annually monthly weekly daily midnight hourly).each do |value|
+    describe 'special' do
+      ['reboot', 'yearly', 'annually', 'monthly', 'weekly', 'daily', 'midnight', 'hourly'].each do |value|
         it "should support the value '#{value}'" do
-          expect { described_class.new(:name => 'foo', :special => value ) }.to_not raise_error
+          expect { described_class.new(name: 'foo', special: value) }.not_to raise_error
         end
       end
 
-      context "when combined with numeric schedule fields" do
+      context 'when combined with numeric schedule fields' do
         context "which are 'absent'" do
-          [ %w(reboot yearly annually monthly weekly daily midnight hourly), :absent ].flatten.each { |value|
+          [['reboot', 'yearly', 'annually', 'monthly', 'weekly', 'daily', 'midnight', 'hourly'], :absent].flatten.each do |value|
             it "should accept the value '#{value}' for special" do
               expect {
-                described_class.new(:name => 'foo', :minute => :absent, :special => value )
-              }.to_not raise_error
+                described_class.new(name: 'foo', minute: :absent, special: value)
+              }.not_to raise_error
             end
-          }
+          end
         end
-        context "which are not absent" do
-          %w(reboot yearly annually monthly weekly daily midnight hourly).each { |value|
+        context 'which are not absent' do
+          ['reboot', 'yearly', 'annually', 'monthly', 'weekly', 'daily', 'midnight', 'hourly'].each do |value|
             it "should not accept the value '#{value}' for special" do
               expect {
-                described_class.new(:name => 'foo', :minute => "1", :special => value )
-              }.to raise_error(Puppet::Error, /cannot specify both a special schedule and a value/)
+                described_class.new(name: 'foo', minute: '1', special: value)
+              }.to raise_error(Puppet::Error, %r{cannot specify both a special schedule and a value})
             end
-          }
-          it "should accept the 'absent' value for special" do
+          end
+          it "accepts the 'absent' value for special" do
             expect {
-              described_class.new(:name => 'foo', :minute => "1", :special => :absent )
-            }.to_not raise_error
+              described_class.new(name: 'foo', minute: '1', special: :absent)
+            }.not_to raise_error
           end
         end
       end
     end
 
-    describe "environment" do
-      it "it should accept an :environment that looks like a path" do
-        expect do
-          described_class.new(:name => 'foo',:environment => 'PATH=/bin:/usr/bin:/usr/sbin')
-        end.to_not raise_error
+    describe 'environment' do
+      it 'accepts an :environment that looks like a path' do
+        expect {
+          described_class.new(name: 'foo', environment: 'PATH=/bin:/usr/bin:/usr/sbin')
+        }.not_to raise_error
       end
 
-      it "should not accept environment variables that do not contain '='" do
-        expect do
-          described_class.new(:name => 'foo',:environment => 'INVALID')
-        end.to raise_error(Puppet::Error, /Invalid environment setting "INVALID"/)
+      it "does not accept environment variables that do not contain '='" do
+        expect {
+          described_class.new(name: 'foo', environment: 'INVALID')
+        }.to raise_error(Puppet::Error, %r{Invalid environment setting "INVALID"})
       end
 
-      it "should accept empty environment variables that do not contain '='" do
-        expect do
-          described_class.new(:name => 'foo',:environment => 'MAILTO=')
-        end.to_not raise_error
+      it "accepts empty environment variables that do not contain '='" do
+        expect {
+          described_class.new(name: 'foo', environment: 'MAILTO=')
+        }.not_to raise_error
       end
 
-      it "should accept 'absent'" do
-        expect do
-          described_class.new(:name => 'foo',:environment => 'absent')
-        end.to_not raise_error
+      it "accepts 'absent'" do
+        expect {
+          described_class.new(name: 'foo', environment: 'absent')
+        }.not_to raise_error
       end
-
     end
   end
 
-  describe "when autorequiring resources" do
-
+  describe 'when autorequiring resources' do
     before :each do
-      @user_bob = Puppet::Type.type(:user).new(:name => 'bob', :ensure => :present)
-      @user_alice = Puppet::Type.type(:user).new(:name => 'alice', :ensure => :present)
+      @user_bob = Puppet::Type.type(:user).new(name: 'bob', ensure: :present)
+      @user_alice = Puppet::Type.type(:user).new(name: 'alice', ensure: :present)
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @user_bob, @user_alice
     end
 
-    it "should autorequire the user" do
-      @resource = described_class.new(:name => 'dummy', :command => '/usr/bin/uptime', :user => 'alice')
+    it 'autorequires the user' do
+      @resource = described_class.new(name: 'dummy', command: '/usr/bin/uptime', user: 'alice')
       @catalog.add_resource @resource
       req = @resource.autorequire
       expect(req.size).to eq(1)
@@ -530,14 +524,14 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
     end
   end
 
-  it "should not require a command when removing an entry" do
-    entry = described_class.new(:name => "test_entry", :ensure => :absent)
+  it 'does not require a command when removing an entry' do
+    entry = described_class.new(name: 'test_entry', ensure: :absent)
     expect(entry.value(:command)).to eq(nil)
   end
 
-  it "should default to user => root if Etc.getpwuid(Process.uid) returns nil (#12357)" do
+  it 'defaults to user => root if Etc.getpwuid(Process.uid) returns nil (#12357)' do
     Etc.expects(:getpwuid).returns(nil)
-    entry = described_class.new(:name => "test_entry", :ensure => :present)
-    expect(entry.value(:user)).to eql "root"
+    entry = described_class.new(name: 'test_entry', ensure: :present)
+    expect(entry.value(:user)).to eql 'root'
   end
 end