Modernize the acceptance tests

spec/acceptance/redis_cli_task_spec.rb

@@ -9,22 +9,18 @@
 
   let(:task_name) { 'redis::redis_cli' }
 
-  it 'install redis-cli with the class' do
-    pp = <<-EOS
-    include redis
-    EOS
-
-    apply_manifest(pp, catch_failures: true)
-    apply_manifest(pp, catch_changes: true)
-  end
-
   unless fact('os.family') == 'RedHat' && fact('os.release.major').to_i >= 9
+    include_examples 'an idempotent resource' do
+      let(:manifest) { 'include redis' }
+    end
+
     describe 'ping' do
       let(:params) { 'command="ping"' }
 
       it 'execute ping' do
-        is_expected.to match(%r{{\s*"status":\s*"PONG"\s*}})
-        is_expected.to match(%r{Ran on 1 target in .+ sec})
+        is_expected.
+          to match(%r{{\s*"status":\s*"PONG"\s*}}).
+          and match(%r{Ran on 1 target in .+ sec})
       end
     end
 
@@ -33,17 +29,19 @@
         let(:params) { 'command="ping; cat /etc/passwd"' }
 
         it 'stops script injections and escapes' do
-          is_expected.to match(%r!{\s*"status":\s*"ERR unknown command ('|`)ping; cat /etc/passwd('|`)!)
-          is_expected.to match(%r{Ran on 1 target in .+ sec})
+          is_expected.
+            to match(%r!{\s*"status":\s*"ERR unknown command ('|`)ping; cat /etc/passwd('|`)!).
+            and match(%r{Ran on 1 target in .+ sec})
         end
       end
 
       describe 'command with double ampersand' do
         let(:params) { 'command="ping && cat /etc/passwd"' }
 
         it 'stops script injections and escapes' do
-          is_expected.to match(%r!{\s*"status":\s*"ERR unknown command ('|`)ping && cat /etc/passwd('|`)!)
-          is_expected.to match(%r{Ran on 1 target in .+ sec})
+          is_expected.
+            to match(%r!{\s*"status":\s*"ERR unknown command ('|`)ping && cat /etc/passwd('|`)!).
+            and match(%r{Ran on 1 target in .+ sec})
         end
       end
     end

spec/acceptance/suites/default/redis_adminstration_spec.rb

@@ -2,29 +2,31 @@
 
 require 'spec_helper_acceptance'
 
+RSpec::Matchers.define_negated_matcher :execute_without_warning, :execute_with_warning
+
 # systcl settings are untestable in docker
 describe 'redis::administration', unless: default['hypervisor'] =~ %r{docker} do
-  it 'runs successfully' do
-    pp = <<-EOS
-    include redis
-    include redis::administration
-    EOS
+  def execute_with_warning
+    have_attributes(stderr: %r{WARNING})
+  end
 
-    # Apply twice to ensure no errors the second time.
-    apply_manifest(pp, catch_failures: true)
-    apply_manifest(pp, catch_changes: true)
+  include_examples 'an idempotent resource' do
+    let(:manifest) { 'include redis, redis::administration' }
   end
 
-  describe file('/proc/sys/vm/overcommit_memory') do
-    its(:content) { is_expected.to eq("1\n") }
+  specify do
+    expect(file('/proc/sys/vm/overcommit_memory')).
+      to have_attributes(content: "1\n")
   end
 
-  describe file('/proc/sys/net/core/somaxconn') do
-    its(:content) { is_expected.to eq("65535\n") }
+  specify do
+    expect(file('/proc/sys/net/core/somaxconn')).
+      to have_attributes(content: "65535\n")
   end
 
-  describe command('timeout 1s redis-server --port 7777 --loglevel verbose') do
-    its(:stderr) { is_expected.not_to match(%r{WARNING}) }
-    its(:exit_status) { is_expected.to eq(124) }
+  specify do
+    expect(command('timeout 1s redis-server --port 7777 --loglevel verbose')).
+      to execute_without_warning.
+      and have_attributes(exit_status: 124)
   end
 end

spec/acceptance/suites/default/redis_multi_instances_one_host_spec.rb

@@ -29,66 +29,61 @@
                  'redis'
                end
 
-  it 'runs successfully' do
-    pp = <<-EOS
-    $listening_ports = #{instances}
-
-    class { 'redis':
-      default_install => false,
-      service_enable  => false,
-      service_ensure  => 'stopped',
-      protected_mode  => false,
-      bind            => [],
-    }
-
-    $listening_ports.each |$port| {
-      $port_string = sprintf('%d',$port)
-      redis::instance { $port_string:
-        service_enable => true,
-        service_ensure => 'running',
-        port           => $port,
-        bind           => $facts['networking']['ip'],
-        dbfilename     => "${port}-dump.rdb",
-        appendfilename => "${port}-appendonly.aof",
-        appendfsync    => 'always',
-        require        => Class['Redis'],
-      }
-    }
-
-    EOS
-
-    # Apply twice to ensure no errors the second time.
-    apply_manifest(pp, catch_failures: true)
-    apply_manifest(pp, catch_changes: true)
+  include_examples 'an idempotent resource' do
+    let(:manifest) do
+      <<~PUPPET
+        $listening_ports = #{instances}
+
+        class { 'redis':
+          default_install => false,
+          service_enable  => false,
+          service_ensure  => 'stopped',
+          protected_mode  => false,
+          bind            => [],
+        }
+
+        $listening_ports.each |$port| {
+          $port_string = sprintf('%d',$port)
+          redis::instance { $port_string:
+            service_enable => true,
+            service_ensure => 'running',
+            port           => $port,
+            bind           => $facts['networking']['ip'],
+            dbfilename     => "${port}-dump.rdb",
+            appendfilename => "${port}-appendonly.aof",
+            appendfsync    => 'always',
+            require        => Class['Redis'],
+          }
+        }
+      PUPPET
+    end
   end
 
-  describe package(redis_name) do
-    it { is_expected.to be_installed }
-  end
+  specify { expect(package(redis_name)).to be_installed }
 
-  describe service(redis_name) do
-    it { is_expected.not_to be_enabled }
-    it { is_expected.not_to be_running }
+  specify do
+    expect(service(redis_name)).not_to be_enabled
+    expect(service(redis_name)).not_to be_running
   end
 
   instances.each do |instance|
-    describe file("/etc/systemd/system/redis-server-#{instance}.service") do
-      its(:content) { is_expected.to match %r{redis-server-#{instance}.conf} }
+    specify do
+      expect(file("/etc/systemd/system/redis-server-#{instance}.service")).
+        to be_file.
+        and have_attributes(content: include("redis-server-#{instance}.conf"))
     end
 
-    describe service("redis-server-#{instance}") do
-      it { is_expected.to be_enabled }
-      it { is_expected.to be_running }
-    end
+    specify { expect(service("redis-server-#{instance}")).to be_enabled.and be_running }
 
-    describe file("#{config_path}/redis-server-#{instance}.conf") do
-      its(:content) { is_expected.to match %r{port #{instance}} }
+    specify do
+      expect(file("#{config_path}/redis-server-#{instance}.conf")).
+        to be_file.
+        and have_attributes(content: include("port #{instance}"))
     end
 
-    context "redis instance #{instance} should respond to ping command" do
-      describe command("redis-cli -h #{fact('networking.ip')} -p #{instance} ping") do
-        its(:stdout) { is_expected.to match %r{PONG} }
-      end
+    specify "redis instance #{instance} should respond to ping command" do
+      expect(command("redis-cli -h #{fact('networking.ip')} -p #{instance} ping")).
+        to have_attributes(stdout: %r{PONG})
     end
   end
 end

spec/acceptance/suites/default/redis_sentinel_one_node_spec.rb

@@ -3,54 +3,38 @@
 require 'spec_helper_acceptance'
 
 describe 'redis::sentinel' do
-  redis_name = case fact('osfamily')
-               when 'Debian'
-                 'redis-server'
-               else
-                 'redis'
-               end
-
-  it 'runs successfully' do
-    pp = <<-EOS
-    class { 'redis::sentinel':
-      master_name      => 'mymaster',
-      redis_host       => '127.0.0.1',
-      failover_timeout => 10000,
-    }
-    EOS
-
-    apply_manifest(pp, catch_failures: true)
-    apply_manifest(pp, catch_changes: true)
-  end
-
-  describe package(redis_name) do
-    it { is_expected.to be_installed }
+  redis_name = fact('os.family') == 'Debian' ? 'redis-server' : 'redis'
+
+  include_examples 'an idempotent resource' do
+    let(:manifest) do
+      <<-PUPPET
+      class { 'redis::sentinel':
+        master_name      => 'mymaster',
+        redis_host       => '127.0.0.1',
+        failover_timeout => 10000,
+      }
+      PUPPET
+    end
   end
 
-  describe service(redis_name) do
-    it { is_expected.to be_running }
-  end
+  specify { expect(package(redis_name)).to be_installed }
+  specify { expect(service(redis_name)).to be_running }
 
-  describe service('redis-sentinel'), :sentinel do
-    it { is_expected.to be_running }
+  specify 'redis should respond to ping command' do
+    expect(command('redis-cli ping')).
+      to have_attributes(stdout: %r{PONG})
   end
 
-  case fact('osfamily')
-  when 'Debian'
-    describe package('redis-sentinel') do
-      it { is_expected.to be_installed }
-    end
-  end
+  specify { expect(service('redis-sentinel')).to be_running }
 
-  context 'redis should respond to ping command' do
-    describe command('redis-cli ping') do
-      its(:stdout) { is_expected.to match %r{PONG} }
-    end
+  if redis_name == 'redis-server'
+    specify { expect(package('redis-sentinel')).to be_installed }
+  else
+    specify { expect(package('redis-sentinel')).not_to be_installed }
   end
 
-  context 'redis-sentinel should return correct sentinel master' do
-    describe command('redis-cli -p 26379 SENTINEL masters') do
-      its(:stdout) { is_expected.to match %r{^mymaster} }
-    end
+  specify 'redis-sentinel should return correct sentinel master' do
+    expect(command('redis-cli -p 26379 SENTINEL masters')).
+      to have_attributes(stdout: %r{^mymaster})
   end
 end

spec/acceptance/suites/default/redis_spec.rb

@@ -3,21 +3,10 @@
 require 'spec_helper_acceptance'
 
 describe 'redis' do
-  redis_name = case fact('osfamily')
-               when 'Debian'
-                 'redis-server'
-               else
-                 'redis'
-               end
-
-  it 'runs successfully' do
-    pp = <<-EOS
-    include redis
-    EOS
+  redis_name = fact('os.family') == 'Debian' ? 'redis-server' : 'redis'
 
-    # Apply twice to ensure no errors the second time.
-    apply_manifest(pp, catch_failures: true)
-    apply_manifest(pp, catch_changes: true)
+  include_examples 'an idempotent resource' do
+    let(:manifest) { 'include redis' }
   end
 
   it 'returns a fact' do
@@ -31,18 +20,12 @@
     end
   end
 
-  describe package(redis_name) do
-    it { is_expected.to be_installed }
-  end
-
-  describe service(redis_name) do
-    it { is_expected.to be_running }
-  end
+  specify { expect(package(redis_name)).to be_installed }
+  specify { expect(service(redis_name)).to be_running }
 
-  context 'redis should respond to ping command' do
-    describe command('redis-cli ping') do
-      its(:stdout) { is_expected.to match %r{PONG} }
-    end
+  specify 'redis should respond to ping command' do
+    expect(command('redis-cli ping')).
+      to have_attributes(stdout: %r{PONG})
   end
 
   it 'runs successfully when using Redis apt repository', if: (fact('os.family') == 'Debian') do