Modernize the acceptance tests

spec/acceptance/redis_cli_task_spec.rb

@@ -7,22 +7,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)
+  include_examples 'an idempotent resource' do
+    let(:manifest) { 'include redis' }
   end
 
   unless fact('os.family') == 'RedHat' && fact('os.release.major').to_i >= 9
     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
 
@@ -31,17 +27,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

@@ -1,28 +1,30 @@
 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_debian_run_dir_spec.rb

@@ -3,53 +3,44 @@
 # since this test polutes others, we'll only run it if specifically asked
 if ENV['RUN_BACKPORT_TEST'] == 'yes'
   describe 'redis', if: (fact('operatingsystem') == 'Debian') do
-    it 'runs with newer Debian package' do
-      pp = <<-EOS
-
-      include ::apt
-
-      class {'::apt::backports':}
-      ->
-      file { '/usr/sbin/policy-rc.d':
-        ensure  => present,
-        content => "/usr/bin/env sh\nexit 101",
-        mode    => '0755',
-      }
-      ->
-      package { 'redis-server':
-        ensure => 'latest',
-        install_options => {
-          '-t' => "${::lsbdistcodename}-backports",
-        },
-      }
-      ->
-      class { 'redis':
-        manage_package => false,
-      }
-      EOS
-
-      apply_manifest(pp, catch_failures: true)
-      apply_manifest(pp, catch_change: true)
-    end
-
-    describe package('redis-server') do
-      it { is_expected.to be_installed }
+    include_examples 'an idempotent resource' do
+      let(:manifest) do
+        <<-PUPPET
+        include ::apt
+
+        class {'::apt::backports':}
+        ->
+        file { '/usr/sbin/policy-rc.d':
+          ensure  => present,
+          content => "/usr/bin/env sh\nexit 101",
+          mode    => '0755',
+        }
+        ->
+        package { 'redis-server':
+          ensure => 'latest',
+          install_options => {
+            '-t' => "${::lsbdistcodename}-backports",
+          },
+        }
+        ->
+        class { 'redis':
+          manage_package => false,
+        }
+        PUPPET
+      end
     end
 
-    describe service('redis-server') do
-      it { is_expected.to be_running }
-    end
+    specify { expect(package('redis-server')).to be_installed }
+    specify { expect(service('redis-server')).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
 
-    context 'redis log should be clean' do
-      describe command('journalctl --no-pager') do
-        its(:stdout) { is_expected.not_to match %r{Failed at step RUNTIME_DIRECTORY} }
-      end
+    specify 'redis log should be clean' do
+      expect(command('journalctl --no-pager'))
+        .not_to have_attributes(stdout: %r{Failed at step RUNTIME_DIRECTORY})
     end
   end
 end

spec/acceptance/suites/default/redis_multi_instances_one_host_spec.rb

@@ -23,67 +23,64 @@
                  'redis'
                end
 
-  it 'runs successfully' do
-    pp = <<-EOS
-    $listening_ports = #{instances}
+  include_examples 'an idempotent resource' do
+    let(:manifest) do
+      <<-PUPPET
+      $listening_ports = #{instances}
 
-    class { '::redis':
-      default_install => false,
-      service_enable  => false,
-      service_ensure  => 'stopped',
-    }
-
-    $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'],
+      class { '::redis':
+        default_install => false,
+        service_enable  => false,
+        service_ensure  => 'stopped',
       }
-    }
-
-    EOS
 
-    # Apply twice to ensure no errors the second time.
-    apply_manifest(pp, catch_failures: true)
-    apply_manifest(pp, catch_changes: true)
+      $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))
+      .to be_enabled
+      .and 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} }
-    end
-
-    describe service("redis-server-#{instance}") do
-      it { is_expected.to be_enabled }
+    specify do
+      expect(file("/etc/systemd/system/redis-server-#{instance}.service"))
+        .to be_file
+        .and have_attributes(content: %r{redis-server-#{instance}.conf})
     end
 
-    describe service("redis-server-#{instance}") do
-      it { is_expected.to be_running }
+    specify do
+      expect(service("redis-server-#{instance}"))
+        .to be_enabled
+        .and be_running
     end
 
-    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: %r{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

@@ -1,54 +1,37 @@
 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 }
-  end
-
-  describe service(redis_name) do
-    it { is_expected.to be_running }
+  redis_name = fact('osfamily') == '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-sentinel') do
-    it { is_expected.to be_running }
-  end
+  specify { expect(package(redis_name)).to be_installed }
+  specify { expect(service(redis_name)).to be_running }
 
-  case fact('osfamily')
-  when 'Debian'
-    describe package('redis-sentinel') do
-      it { is_expected.to be_installed }
-    end
+  specify 'redis should respond to ping command' do
+    expect(command('redis-cli ping'))
+      .to have_attributes(stdout: %r{PONG})
   end
 
-  context 'redis should respond to ping command' do
-    describe command('redis-cli ping') do
-      its(:stdout) { is_expected.to match %r{PONG} }
-    end
+  specify { expect(service('redis-sentinel')).to be_running }
+  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