diff --git a/spec/classes/init_spec.rb b/spec/classes/init_spec.rb
index 4055d7c..04c2ef8 100644
--- a/spec/classes/init_spec.rb
+++ b/spec/classes/init_spec.rb
@@ -1,280 +1,280 @@
 require 'spec_helper'
 
 shared_examples 'zookeeper' do |os_facts|
   let(:user) { 'zookeeper' }
   let(:group) { 'zookeeper' }
 
   os_info = get_os_info(os_facts)
 
   service_name = os_info[:service_name]
   environment_file = os_info[:environment_file]
   init_provider = os_info[:init_provider]
   should_install_zookeeperd = os_info[:should_install_zookeeperd]
 
   it { is_expected.to contain_class('zookeeper::config') }
   it { is_expected.to contain_class('zookeeper::install') }
   it { is_expected.to contain_class('zookeeper::service') }
   it { is_expected.to compile.with_all_deps }
   it { is_expected.to contain_service(service_name) }
   it { is_expected.to contain_service(service_name).that_subscribes_to('File[/etc/zookeeper/conf/myid]') }
   it { is_expected.to contain_service(service_name).that_subscribes_to('File[/etc/zookeeper/conf/zoo.cfg]') }
   it { is_expected.to contain_service(service_name).that_subscribes_to("File[#{environment_file}]") }
   it { is_expected.to contain_service(service_name).that_subscribes_to('File[/etc/zookeeper/conf/log4j.properties]') }
 
   context 'skip service restart' do
     let(:params) do
       {
         restart_on_change: false,
       }
     end
 
     it { is_expected.to contain_service(service_name) }
     it { is_expected.not_to contain_service(service_name).that_subscribes_to('File[/etc/zookeeper/conf/myid]') }
     it { is_expected.not_to contain_service(service_name).that_subscribes_to('File[/etc/zookeeper/conf/zoo.cfg]') }
     it { is_expected.not_to contain_service(service_name).that_subscribes_to("File[#{environment_file}]") }
     it { is_expected.not_to contain_service(service_name).that_subscribes_to('File[/etc/zookeeper/conf/log4j.properties]') }
   end
 
   context 'allow installing multiple packages' do
     let(:params) do
       {
         packages: ['zookeeper', 'zookeeper-bin'],
       }
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_package('zookeeper').with(ensure: 'present') }
     it { is_expected.to contain_package('zookeeper-bin').with(ensure: 'present') }
     it { is_expected.to contain_service(service_name).with(ensure: 'running') }
     # datastore exec is not included by default
     it { is_expected.not_to contain_exec('initialize_datastore') }
 
     it { is_expected.to contain_user('zookeeper').with(ensure: 'present') }
     it { is_expected.to contain_group('zookeeper').with(ensure: 'present') }
   end
 
   context 'Cloudera packaging' do
     let(:params) do
       {
         packages: ['zookeeper', 'zookeeper-server'],
         service_name: 'zookeeper-server',
         initialize_datastore: true,
       }
     end
 
     it { is_expected.to contain_package('zookeeper').with(ensure: 'present') }
     it { is_expected.to contain_package('zookeeper-server').with(ensure: 'present') }
     it { is_expected.to contain_service('zookeeper-server').with(ensure: 'running') }
     it { is_expected.to contain_exec('initialize_datastore') }
   end
 
   context 'setting minSessionTimeout' do
     let(:params) do
       {
         min_session_timeout: 3000,
       }
     end
 
     it do
       is_expected.to contain_file(
         '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{minSessionTimeout=3000})
     end
   end
 
   context 'setting maxSessionTimeout' do
     let(:params) do
       {
         max_session_timeout: 60_000,
       }
     end
 
     it do
       is_expected.to contain_file(
         '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{maxSessionTimeout=60000})
     end
   end
 
   context 'disable service management' do
     let(:params) do
       {
         manage_service: false,
       }
     end
 
     it { is_expected.to contain_package('zookeeper').with(ensure: 'present') }
     it { is_expected.not_to contain_service(service_name).with(ensure: 'running') }
     it { is_expected.not_to contain_class('zookeeper::service') }
   end
 
-  if os_facts[:os]['family'] =~ %r{RedHat|Suse}
+  if %r{RedHat|Suse}.match?(os_facts[:os]['family'])
     context 'Do not use cloudera by default' do
       it { is_expected.to compile.with_all_deps }
       it { is_expected.to contain_class('zookeeper::install::repo') }
       it { is_expected.not_to contain_yumrepo('cloudera-cdh5') }
     end
 
     context 'use Cloudera RPM repo' do
       let(:params) do
         {
           repo: 'cloudera',
           cdhver: '5',
         }
       end
 
       it { is_expected.to compile.with_all_deps }
       it { is_expected.to contain_class('zookeeper::install::repo') }
       it { is_expected.to contain_yumrepo('cloudera-cdh5') }
 
       context 'custom RPM repo' do
         let(:params) do
           {
             repo: {
               'name'  => 'myrepo',
               'url'   => 'http://repo.url',
               'descr' => 'custom repo',
             },
             cdhver: '5',
           }
         end
 
         it { is_expected.to contain_yumrepo('myrepo').with(baseurl: 'http://repo.url') }
       end
     end
   end
 
   context 'service provider' do
     context 'autodetect provider' do
       it { is_expected.to contain_package('zookeeper').with(ensure: 'present') }
 
-      if os_facts[:os]['family'] =~ %r{RedHat|Suse}
+      if %r{RedHat|Suse}.match?(os_facts[:os]['family'])
         it { is_expected.to contain_package('zookeeper-server').with(ensure: 'present') }
       else
         it { is_expected.not_to contain_package('zookeeper-server').with(ensure: 'present') }
       end
 
       it do
         is_expected.to contain_service(service_name).with(ensure: 'running',
                                                           provider: init_provider)
       end
     end
 
     it { is_expected.to contain_class('zookeeper::service') }
   end
 
   context 'allow passing specific version' do
     let(:version) { '3.4.5+dfsg-1' }
 
     let(:params) do
       {
         ensure: version,
       }
     end
 
     it { is_expected.to contain_package('zookeeper').with(ensure: version) }
 
     if should_install_zookeeperd
       it { is_expected.to contain_package('zookeeperd').with(ensure: version) }
     else
       it { is_expected.not_to contain_package('zookeeperd').with(ensure: version) }
     end
 
     it { is_expected.to contain_user('zookeeper').with(ensure: 'present') }
   end
 
   context 'set pid file for init provider' do
     let(:params) do
       {
         zoo_dir: '/usr/lib/zookeeper',
         log_dir: '/var/log/zookeeper',
         manage_service: true,
         manage_service_file: true,
         service_provider: 'init',
       }
     end
 
     it do
       is_expected.to contain_file(
         '/etc/zookeeper/conf/log4j.properties',
       ).with_content(%r{zookeeper.log.dir=/var/log/zookeeper})
     end
 
     context 'set service provider' do
       it { is_expected.to contain_package('zookeeper').with(ensure: 'present') }
       it do
         is_expected.to contain_service(service_name).with(ensure: 'running',
                                                           provider: 'init')
       end
     end
 
-    if os_facts[:os]['family'] =~ %r{RedHat|Suse}
+    if %r{RedHat|Suse}.match?(os_facts[:os]['family'])
       it do
         is_expected.to contain_file(
           "/etc/init.d/#{service_name}",
         ).with_content(%r{pidfile=/var/run/zookeeper.pid})
       end
     else
       it do
         is_expected.to contain_file(
           environment_file,
         ).with_content(%r{PIDFILE=/var/run/zookeeper.pid})
       end
     end
   end
 
   context 'create env file' do
     it do
       is_expected.to contain_file(
         environment_file,
       )
     end
   end
 
   context 'managed by exhibitor' do
     let(:params) do
       {
         service_provider: 'exhibitor',
         service_name: 'zookeeper',
         cfg_dir: '/opt/zookeeper/conf',
       }
     end
 
     it { is_expected.not_to contain_class('zookeeper::service') }
     it { is_expected.not_to contain_service(service_name) }
     it { is_expected.not_to contain_file('/opt/zookeeper/conf/zoo.cfg') }
     it { is_expected.not_to contain_file('/opt/zookeeper/conf/myid') }
   end
 
   context 'install from archive' do
     let(:params) do
       {
         install_method: 'archive',
         archive_version: '3.4.9',
       }
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_class('Zookeeper::Install::Archive') }
 
     it { is_expected.not_to contain_package('zookeeper').with(ensure: 'present') }
     it { is_expected.to contain_service(service_name).with(ensure: 'running') }
 
     it { is_expected.to contain_user('zookeeper').with(ensure: 'present') }
     it { is_expected.to contain_group('zookeeper').with(ensure: 'present') }
   end
 end
 
 describe 'zookeeper', type: :class do
   on_supported_os.each do |os, os_facts|
     os_facts[:os]['hardware'] = 'x86_64'
 
     context "on #{os}" do
       let(:facts) do
         os_facts.merge(ipaddress: '192.168.1.1')
       end
 
       include_examples 'zookeeper', os_facts
     end
   end
 end
diff --git a/spec/classes/repo_spec.rb b/spec/classes/repo_spec.rb
index d06e205..9e569f5 100644
--- a/spec/classes/repo_spec.rb
+++ b/spec/classes/repo_spec.rb
@@ -1,158 +1,158 @@
 require 'spec_helper'
 
 shared_examples 'zookeeper repo release support' do |os_facts|
   os_name = if os_facts[:os]['family'] == 'RedHat'
               os_facts[:os]['family'].downcase
             else
               os_facts[:os]['name'].downcase
             end
   os_release = os_facts[:os]['release']['major']
 
   context 'fail when release not supported' do
     let :pre_condition do
       'class {"zookeeper":
         repo   => "cloudera",
         cdhver => "5",
        }'
     end
 
     it do
       expect {
         is_expected.to compile
       }.to raise_error(%r{is not supported for #{os_name} version #{os_release}})
     end
   end
 end
 
 shared_examples 'zookeeper repo arch support' do |os_facts|
   os_hardware = os_facts[:os]['hardware']
 
   context 'fail when architecture not supported' do
     let :pre_condition do
       'class {"zookeeper":
         repo   => "cloudera",
         cdhver => "5",
        }'
     end
 
     it do
       expect {
         is_expected.to compile
       }.to raise_error(%r{is not supported for architecture #{os_hardware}})
     end
   end
 end
 
 shared_examples 'zookeeper repo' do |os_facts|
   let(:user) { 'zookeeper' }
   let(:group) { 'zookeeper' }
 
   os_name = if os_facts[:os]['family'] == 'RedHat'
               os_facts[:os]['family'].downcase
             else
               os_facts[:os]['name'].downcase
             end
   os_release = os_facts[:os]['release']['major']
   os_hardware = os_facts[:os]['hardware']
 
-  if os_facts[:os]['family'] =~ %r{RedHat|Suse}
+  if %r{RedHat|Suse}.match?(os_facts[:os]['family'])
     context 'Cloudera repo' do
       let :pre_condition do
         'class {"zookeeper":
           repo   => "cloudera",
           cdhver => "5",
         }'
       end
 
       it {
         is_expected.to contain_yumrepo('cloudera-cdh5').with(baseurl: "http://archive.cloudera.com/cdh5/#{os_name}/#{os_release}/#{os_hardware}/cdh/5/")
       }
     end
   end
 
   context 'fail when CDH version not supported' do
     let :pre_condition do
       'class {"zookeeper":
         repo   => "cloudera",
         cdhver => "6",
        }'
     end
 
     it do
       expect {
         is_expected.to compile
       }.to raise_error(%r{is not a supported cloudera repo.})
     end
   end
 
   context 'fail when repository source not supported' do
     let :pre_condition do
       'class {"zookeeper":
         repo => "another-repo",
        }'
     end
 
     it do
       expect {
         is_expected.to compile
       }.to raise_error(%r{provides no repository information for yum repository})
     end
   end
 end
 
 describe 'zookeeper::install::repo' do
   on_supported_os.each do |os, os_facts|
     os_facts[:os]['hardware'] = 'x86_64'
 
     context "on #{os}" do
       let(:facts) do
         os_facts.merge(ipaddress: '192.168.1.1')
       end
 
       include_examples 'zookeeper repo', os_facts
     end
   end
 
   context 'test unsupported repo arch' do
     test_on = {
       hardwaremodels: ['arc'],
       supported_os: [
         {
           'operatingsystem'        => 'RedHat',
           'operatingsystemrelease' => ['7'],
         },
       ],
     }
     on_supported_os(test_on).each do |os, os_facts|
       context "on #{os}" do
         let(:facts) do
           os_facts.merge(ipaddress: '192.168.1.1')
         end
 
         include_examples 'zookeeper repo arch support', os_facts
       end
     end
   end
 
   context 'test unsupported repo release' do
     test_on = {
       supported_os: [
         {
           'operatingsystem'        => 'RedHat',
           'operatingsystemrelease' => ['8'],
         },
       ],
     }
     on_supported_os(test_on).each do |os, os_facts|
       os_facts[:os]['hardware'] = 'x86_64'
 
       context "on #{os}" do
         let(:facts) do
           os_facts.merge(ipaddress: '192.168.1.1')
         end
 
         include_examples 'zookeeper repo release support', os_facts
       end
     end
   end
 end
diff --git a/spec/spec_helper_acceptance.rb b/spec/spec_helper_acceptance.rb
index 434b957..964066f 100644
--- a/spec/spec_helper_acceptance.rb
+++ b/spec/spec_helper_acceptance.rb
@@ -1,36 +1,36 @@
 require 'beaker-rspec'
 require 'beaker-puppet'
 require 'beaker/puppet_install_helper'
 require 'beaker/module_install_helper'
 
 run_puppet_install_helper unless ENV['BEAKER_provision'] == 'no'
-install_ca_certs unless ENV['PUPPET_INSTALL_TYPE'] =~ %r{pe}i
+install_ca_certs unless %r{pe}i.match?(ENV['PUPPET_INSTALL_TYPE'])
 install_module_on(hosts)
 install_module_dependencies_on(hosts)
 
 RSpec.configure do |c|
   # Readable test descriptions
   c.formatter = :documentation
   hosts.each do |host|
     if fact_on(host, 'osfamily') == 'Debian'
       on host, puppet('resource', 'package', 'net-tools', 'ensure=installed')
       on host, puppet('resource', 'package', 'netcat', 'ensure=installed')
     end
     if fact_on(host, 'osfamily') == 'RedHat'
       case fact('os.release.major')
       when '6'
         on host, puppet('resource', 'package', 'nc', 'ensure=installed')
       when '7'
         on host, puppet('resource', 'package', 'net-tools', 'ensure=installed')
         on host, puppet('resource', 'package', 'nmap-ncat', 'ensure=installed')
       end
     end
     if fact_on(host, 'osfamily') == 'Suse'
       on host, puppet('resource', 'package', 'net-tools', 'ensure=installed')
       on host, puppet('resource', 'package', 'netcat-openbsd', 'ensure=installed')
     end
-    if host[:platform] =~ %r{el-7-x86_64} && host[:hypervisor] =~ %r{docker}
+    if host[:platform].include?('el-7-x86_64') && host[:hypervisor].include?('docker')
       on(host, "sed -i '/nodocs/d' /etc/yum.conf")
     end
   end
 end