diff --git a/manifests/init.pp b/manifests/init.pp
index ebd8ca1..09b119b 100644
--- a/manifests/init.pp
+++ b/manifests/init.pp
@@ -1,353 +1,353 @@
 # This class installs redis
 #
 # @example Default install
 #   include redis
 #
 # @example Slave Node
 #   class { '::redis':
 #     bind    => '10.0.1.2',
 #     slaveof => '10.0.1.1 6379',
 #   }
 #
 # @example Binding on multiple interfaces
 #   class { 'redis':
 #     bind => ['127.0.0.1', '10.0.0.1', '10.1.0.1'],
 #   }
 #
 # @example Binding on all interfaces
 #   class { 'redis':
 #     bind => [],
 #   }
 #
 # @param activerehashing
 #   Enable/disable active rehashing.
 # @param aof_load_truncated
 #   Enable/disable loading truncated AOF file
 # @param aof_rewrite_incremental_fsync
 #   Enable/disable fsync for AOF file
 # @param appendfilename
 #   The name of the append only file
 # @param appendfsync
 #   Adjust fsync mode
 # @param appendonly
 #   Enable/disable appendonly mode.
 # @param auto_aof_rewrite_min_size
 #   Adjust minimum size for auto-aof-rewrite.
 # @param auto_aof_rewrite_percentage
 #   Adjust percentatge for auto-aof-rewrite.
 # @param bind
 #   Configure which IP address(es) to listen on. To bind on all interfaces, use an empty array.
 # @param config_dir
 #   Directory containing the configuration files.
 # @param config_dir_mode
 #   Adjust mode for directory containing configuration files.
 # @param config_file_orig
 #   The location and name of a config file that provides the source
 # @param config_file
 #   Adjust main configuration file.
 # @param config_file_mode
 #   Adjust permissions for configuration files.
 # @param config_group
 #   Adjust filesystem group for config files.
 # @param config_owner
 #   Adjust filesystem owner for config files.
 # @param conf_template
 #   Define which template to use.
 # @param daemonize
 #   Have Redis run as a daemon.
 # @param default_install
 #   Configure a default install of redis.
 # @param databases
 #   Set the number of databases.
 # @param dbfilename
 #   The filename where to dump the DB
 # @param extra_config_file
 #   Optional extra config file to include
 # @param hash_max_ziplist_entries
 #   Set max ziplist entries for hashes.
 # @param hash_max_ziplist_value
 #   Set max ziplist values for hashes.
 # @param hll_sparse_max_bytes
 #   HyperLogLog sparse representation bytes limit
 # @param hz
 #   Set redis background tasks frequency
 # @param latency_monitor_threshold
 #   Latency monitoring threshold in milliseconds
 # @param list_max_ziplist_entries
 #   Set max ziplist entries for lists.
 # @param list_max_ziplist_value
 #   Set max ziplist values for lists.
 # @param log_dir
 #   Specify directory where to write log entries.
 # @param log_dir_mode
 #   Adjust mode for directory containing log files.
 # @param log_file
 #   Specify file where to write log entries. Relative paths will be prepended
 #   with log_dir but absolute paths are also accepted.
 # @param log_level
 #   Specify the server verbosity level.
 # @param manage_repo
 #   Enable/disable upstream repository configuration.
 # @param manage_package
 #   Enable/disable management of package
 # @param managed_by_cluster_manager
 #   Choose if redis will be managed by a cluster manager such as pacemaker or rgmanager
 # @param masterauth
 #   If the master is password protected (using the "requirepass" configuration
 # @param maxclients
 #   Set the max number of connected clients at the same time.
 # @param maxmemory
 #   Don't use more memory than the specified amount of bytes.
 # @param maxmemory_policy
 #   How Redis will select what to remove when maxmemory is reached.
 # @param maxmemory_samples
 #   Select as well the sample size to check.
 # @param min_slaves_max_lag
 #   The lag in seconds
 # @param min_slaves_to_write
 #   Minimum number of slaves to be in "online" state
 # @param no_appendfsync_on_rewrite
 #   If you have latency problems turn this to 'true'. Otherwise leave it as
 # @param notify_keyspace_events
 #   Which events to notify Pub/Sub clients about events happening
 # @param notify_service
 #   You may disable service reloads when config files change if you
 # @param package_ensure
 #   Default action for package.
 # @param package_name
 #   Upstream package name.
 # @param pid_file
 #   Where to store the pid.
 # @param port
 #   Configure which port to listen on.
 # @param protected_mode
 #   Whether protected mode is enabled or not.  Only applicable when no bind is set.
 # @param ppa_repo
 #   Specify upstream (Ubuntu) PPA entry.
 # @param rdbcompression
 #   Enable/disable compression of string objects using LZF when dumping.
 # @param rename_commands
 #   A list of Redis commands to rename or disable for security reasons
 # @param repl_backlog_size
 #   The replication backlog size
 # @param repl_backlog_ttl
 #   The number of seconds to elapse before freeing backlog buffer
 # @param repl_disable_tcp_nodelay
 #   Enable/disable TCP_NODELAY on the slave socket after SYNC
 # @param repl_ping_slave_period
 #   Slaves send PINGs to server in a predefined interval. It's possible
 # @param repl_timeout
 #   Set the replication timeout for:
 # @param requirepass
 #   Require clients to issue AUTH <PASSWORD> before processing any other commands.
 # @param save_db_to_disk
 #   Set if save db to disk.
 # @param save_db_to_disk_interval
 #   save the dataset every N seconds if there are at least M changes in the dataset
 # @param service_manage
 #   Specify if the service should be part of the catalog.
 # @param service_enable
 #   Enable/disable daemon at boot.
 # @param service_ensure
 #   Specify if the server should be running.
 # @param service_group
 #   Specify which group to run as.
 # @param service_name
 #   Specify the service name for Init or Systemd.
 # @param service_user
 #   Specify which user to run as.
 # @param set_max_intset_entries
 #   The following configuration setting sets the limit in the size of the set
 #   in order to use this special memory saving encoding.
 # @param slave_priority
 #   The priority number for slave promotion by Sentinel
 # @param slave_read_only
 #   You can configure a slave instance to accept writes or not.
 # @param slave_serve_stale_data
 #   When a slave loses its connection with the master, or when the replication
 #   is still in progress, the slave can act in two different ways:
 #   1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
 #      still reply to client requests, possibly with out of date data, or the
 #      data set may just be empty if this is the first synchronization.
 #   2) if slave-serve-stale-data is set to 'no' the slave will reply with
 #      an error "SYNC with master in progress" to all the kind of commands
 #      but to INFO and SLAVEOF.
 # @param slaveof
 #   Use slaveof to make a Redis instance a copy of another Redis server.
 # @param slowlog_log_slower_than
 #   Tells Redis what is the execution time, in microseconds, to exceed in order
 #   for the command to get logged.
 # @param slowlog_max_len
 #   Tells Redis what is the length to exceed in order for the command to get
 #   logged.
 # @param stop_writes_on_bgsave_error
 #   If false then Redis will continue to work as usual even if there are
 #   problems with disk, permissions, and so forth.
 # @param syslog_enabled
 #   Enable/disable logging to the system logger.
 # @param syslog_facility
 #   Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
 # @param tcp_backlog
 #   Sets the TCP backlog
 # @param tcp_keepalive
 #   TCP keepalive.
 # @param timeout
 #   Close the connection after a client is idle for N seconds (0 to disable).
 # @param ulimit
 #   Limit the use of system-wide resources.
 # @param ulimit_managed
 #   Defines wheter the max number of open files for the
 #   systemd service unit is explicitly managed.
 # @param unixsocket
 #   Define unix socket path
 # @param unixsocketperm
 #   Define unix socket file permissions
 # @param workdir
 #   The DB will be written inside this directory, with the filename specified
 #   above using the 'dbfilename' configuration directive.
 # @param workdir_mode
 #   Adjust mode for data directory.
 # @param zset_max_ziplist_entries
 #   Set max entries for sorted sets.
 # @param zset_max_ziplist_value
 #   Set max values for sorted sets.
 # @param cluster_enabled
 #   Enables redis 3.0 cluster functionality
 # @param cluster_config_file
 #   Config file for saving cluster nodes configuration. This file is never
 #   touched by humans. Only set if cluster_enabled is true
 # @param cluster_node_timeout
 #   Node timeout. Only set if cluster_enabled is true
 # @param cluster_slave_validity_factor
 #   Control variable to disable promoting slave in case of disconnection from master
 #   Only set if cluster_enabled is true
 # @param cluster_require_full_coverage
 #   If false Redis Cluster will server queries even if requests about a subset of keys can be processed
 #   Only set if cluster_enabled is true
 # @param cluster_migration_barrier
 #   Minimum number of slaves master will remain connected with, for another
 #   slave to migrate to a master which is no longer covered by any slave.
 #   Only set if cluster_enabled is true
 # @param instances
 #   Iterate through multiple instance configurations
 class redis (
   Boolean $activerehashing                                       = true,
   Boolean $aof_load_truncated                                    = true,
   Boolean $aof_rewrite_incremental_fsync                         = true,
   String[1] $appendfilename                                      = 'appendonly.aof',
   Enum['no', 'always', 'everysec'] $appendfsync                  = 'everysec',
   Boolean $appendonly                                            = false,
   String[1] $auto_aof_rewrite_min_size                           = '64mb',
   Integer[0] $auto_aof_rewrite_percentage                        = 100,
   Variant[Stdlib::IP::Address, Array[Stdlib::IP::Address]] $bind = ['127.0.0.1'],
   String[1] $output_buffer_limit_slave                           = '256mb 64mb 60',
   String[1] $output_buffer_limit_pubsub                          = '32mb 8mb 60',
   String[1] $conf_template                                       = 'redis/redis.conf.epp',
   Stdlib::Absolutepath $config_dir                               = $redis::params::config_dir,
   Stdlib::Filemode $config_dir_mode                              = $redis::params::config_dir_mode,
   Stdlib::Absolutepath $config_file                              = $redis::params::config_file,
   Stdlib::Filemode $config_file_mode                             = '0644',
   Stdlib::Absolutepath $config_file_orig                         = $redis::params::config_file_orig,
   String[1] $config_group                                        = $redis::params::config_group,
   String[1] $config_owner                                        = $redis::params::config_owner,
   Boolean $daemonize                                             = $redis::params::daemonize,
   Integer[1] $databases                                          = 16,
   Boolean $default_install                                       = true,
   Variant[String[1], Boolean] $dbfilename                        = 'dump.rdb',
   Optional[String] $extra_config_file                            = undef,
   Integer[0] $hash_max_ziplist_entries                           = 512,
   Integer[0] $hash_max_ziplist_value                             = 64,
   Integer[0] $hll_sparse_max_bytes                               = 3000,
   Integer[1, 500] $hz                                            = 10,
   Integer[0] $latency_monitor_threshold                          = 0,
   Integer[0] $list_max_ziplist_entries                           = 512,
   Integer[0] $list_max_ziplist_value                             = 64,
   Stdlib::Absolutepath $log_dir                                  = $redis::params::log_dir,
   Stdlib::Filemode $log_dir_mode                                 = $redis::params::log_dir_mode,
   String $log_file                                               = 'redis.log',
   Redis::LogLevel $log_level                                     = 'notice',
   Boolean $manage_service_file                                   = false,
   Boolean $manage_package                                        = true,
   Boolean $manage_repo                                           = false,
   Optional[Variant[String[1], Sensitive[String[1]]]] $masterauth = undef,
   Integer[1] $maxclients                                         = 10000,
   $maxmemory                                                     = undef,
   $maxmemory_policy                                              = undef,
   $maxmemory_samples                                             = undef,
   Integer[0] $min_slaves_max_lag                                 = 10,
   Integer[0] $min_slaves_to_write                                = 0,
   Boolean $no_appendfsync_on_rewrite                             = false,
   Optional[String[1]] $notify_keyspace_events                    = undef,
   Boolean $notify_service                                        = true,
   Boolean $managed_by_cluster_manager                            = false,
-  String[1] $package_ensure                                      = 'present',
+  String[1] $package_ensure                                      = 'installed',
   String[1] $package_name                                        = $redis::params::package_name,
   Stdlib::Absolutepath $pid_file                                 = $redis::params::pid_file,
   Stdlib::Port $port                                             = 6379,
   Boolean $protected_mode                                        = true,
   Optional[String] $ppa_repo                                     = $redis::params::ppa_repo,
   Boolean $rdbcompression                                        = true,
   Hash[String,String] $rename_commands                           = {},
   String[1] $repl_backlog_size                                   = '1mb',
   Integer[0] $repl_backlog_ttl                                   = 3600,
   Boolean $repl_disable_tcp_nodelay                              = false,
   Integer[1] $repl_ping_slave_period                             = 10,
   Integer[1] $repl_timeout                                       = 60,
   Optional[String] $requirepass                                  = undef,
   Boolean $save_db_to_disk                                       = true,
   Hash $save_db_to_disk_interval                                 = { '900' => '1', '300' => '10', '60' => '10000' },
   Boolean $service_enable                                        = true,
   Stdlib::Ensure::Service $service_ensure                        = 'running',
   String[1] $service_group                                       = 'redis',
   Boolean $service_manage                                        = true,
   String[1] $service_name                                        = $redis::params::service_name,
   String[1] $service_user                                        = 'redis',
   Integer[0] $set_max_intset_entries                             = 512,
   Integer[0] $slave_priority                                     = 100,
   Boolean $slave_read_only                                       = true,
   Boolean $slave_serve_stale_data                                = true,
   Optional[String[1]] $slaveof                                   = undef,
   Integer[0] $slowlog_log_slower_than                            = 10000,
   Integer[0] $slowlog_max_len                                    = 1024,
   Boolean $stop_writes_on_bgsave_error                           = true,
   Boolean $syslog_enabled                                        = false,
   Optional[String[1]] $syslog_facility                           = undef,
   Integer[0] $tcp_backlog                                        = 511,
   Integer[0] $tcp_keepalive                                      = 0,
   Integer[0] $timeout                                            = 0,
   Variant[Stdlib::Absolutepath, Enum['']] $unixsocket            = '/var/run/redis/redis.sock',
   Variant[Stdlib::Filemode, Enum['']] $unixsocketperm            = '0755',
   Integer[0] $ulimit                                             = 65536,
   Boolean $ulimit_managed                                        = true,
   Stdlib::Absolutepath $workdir                                  = $redis::params::workdir,
   Stdlib::Filemode $workdir_mode                                 = '0750',
   Integer[0] $zset_max_ziplist_entries                           = 128,
   Integer[0] $zset_max_ziplist_value                             = 64,
   Boolean $cluster_enabled                                       = false,
   String[1] $cluster_config_file                                 = 'nodes.conf',
   Integer[1] $cluster_node_timeout                               = 5000,
   Integer[0] $cluster_slave_validity_factor                      = 0,
   Boolean $cluster_require_full_coverage                         = true,
   Integer[0] $cluster_migration_barrier                          = 1,
   Hash[String[1], Hash] $instances                               = {},
 ) inherits redis::params {
   contain redis::preinstall
   contain redis::install
   contain redis::config
   contain redis::service
 
   $instances.each | String $key, Hash $values | {
     redis::instance { $key:
       * => $values,
     }
   }
 
   Class['redis::preinstall']
   -> Class['redis::install']
   -> Class['redis::config']
 
   if $redis::notify_service {
     Class['redis::config']
     ~> Class['redis::service']
   }
 }
diff --git a/spec/classes/redis_sentinel_spec.rb b/spec/classes/redis_sentinel_spec.rb
index 4a27edf..a853389 100644
--- a/spec/classes/redis_sentinel_spec.rb
+++ b/spec/classes/redis_sentinel_spec.rb
@@ -1,160 +1,160 @@
 require 'spec_helper'
 
 describe 'redis::sentinel' do
   on_supported_os.each do |os, facts|
     context "on #{os}" do
       let(:facts) { facts }
       let(:config_file_orig) do
         case facts[:osfamily]
         when 'Archlinux'
           '/etc/redis/redis-sentinel.conf.puppet'
         when 'Debian'
           '/etc/redis/redis-sentinel.conf.puppet'
         when 'Suse'
           '/etc/redis/redis-sentinel.conf.puppet'
         when 'FreeBSD'
           '/usr/local/etc/redis-sentinel.conf.puppet'
         when 'RedHat'
           '/etc/redis-sentinel.conf.puppet'
         end
       end
 
       let(:pidfile) do
         if facts[:operatingsystem] == 'Ubuntu'
           '/var/run/sentinel/redis-sentinel.pid'
         elsif facts[:operatingsystem] == 'Debian'
           facts[:operatingsystemmajrelease] == '9' ? '/var/run/redis/redis-sentinel.pid' : '/run/sentinel/redis-sentinel.pid'
         else
           '/var/run/redis/redis-sentinel.pid'
         end
       end
 
       describe 'without parameters' do
         let(:expected_content) do
           <<CONFIG
 port 26379
 dir #{facts[:osfamily] == 'Debian' ? '/var/lib/redis' : '/tmp'}
 daemonize #{facts[:osfamily] == 'RedHat' ? 'no' : 'yes'}
 pidfile #{pidfile}
 protected-mode yes
 
 sentinel monitor mymaster 127.0.0.1 6379 2
 sentinel down-after-milliseconds mymaster 30000
 sentinel parallel-syncs mymaster 1
 sentinel failover-timeout mymaster 180000
 
 loglevel notice
 logfile #{facts[:osfamily] == 'Debian' ? '/var/log/redis/redis-sentinel.log' : '/var/log/redis/sentinel.log'}
 CONFIG
         end
 
         it { is_expected.to create_class('redis::sentinel') }
 
         it {
           is_expected.to contain_file(config_file_orig).
             with_ensure('file').
             with_mode('0644').
             with_owner('redis').
             with_content(expected_content)
         }
 
         it {
           is_expected.to contain_service('redis-sentinel').
             with_ensure('running').
             with_enable('true')
         }
 
         if facts[:os]['family'] == 'Debian'
-          it { is_expected.to contain_package('redis-sentinel').with_ensure('present') }
+          it { is_expected.to contain_package('redis-sentinel').with_ensure('installed') }
         else
           it { is_expected.not_to contain_package('redis-sentinel') }
         end
       end
 
       describe 'with custom parameters' do
         let(:params) do
           {
             auth_pass: 'password',
             sentinel_bind: '192.0.2.10',
             protected_mode: false,
             master_name: 'cow',
             down_after: 6000,
             working_dir: '/tmp/redis',
             log_file: '/tmp/barn-sentinel.log',
             failover_timeout: 28_000,
             notification_script: '/path/to/bar.sh',
             client_reconfig_script: '/path/to/foo.sh'
           }
         end
 
         let(:expected_content) do
           <<CONFIG
 bind 192.0.2.10
 port 26379
 dir /tmp/redis
 daemonize #{facts[:osfamily] == 'RedHat' ? 'no' : 'yes'}
 pidfile #{pidfile}
 protected-mode no
 
 sentinel monitor cow 127.0.0.1 6379 2
 sentinel down-after-milliseconds cow 6000
 sentinel parallel-syncs cow 1
 sentinel failover-timeout cow 28000
 sentinel auth-pass cow password
 sentinel notification-script cow /path/to/bar.sh
 sentinel client-reconfig-script cow /path/to/foo.sh
 
 loglevel notice
 logfile /tmp/barn-sentinel.log
 CONFIG
         end
 
         it { is_expected.to compile.with_all_deps }
         it { is_expected.to create_class('redis::sentinel') }
         it { is_expected.to contain_file(config_file_orig).with_content(expected_content) }
       end
 
       describe 'with array sentinel bind' do
         let(:params) do
           {
             auth_pass: 'password',
             sentinel_bind: ['192.0.2.10', '192.168.1.1'],
             master_name: 'cow',
             down_after: 6000,
             working_dir: '/tmp/redis',
             log_file: '/tmp/barn-sentinel.log',
             failover_timeout: 28_000,
             notification_script: '/path/to/bar.sh',
             client_reconfig_script: '/path/to/foo.sh'
           }
         end
 
         let(:expected_content) do
           <<CONFIG
 bind 192.0.2.10 192.168.1.1
 port 26379
 dir /tmp/redis
 daemonize #{facts[:osfamily] == 'RedHat' ? 'no' : 'yes'}
 pidfile #{pidfile}
 protected-mode yes
 
 sentinel monitor cow 127.0.0.1 6379 2
 sentinel down-after-milliseconds cow 6000
 sentinel parallel-syncs cow 1
 sentinel failover-timeout cow 28000
 sentinel auth-pass cow password
 sentinel notification-script cow /path/to/bar.sh
 sentinel client-reconfig-script cow /path/to/foo.sh
 
 loglevel notice
 logfile /tmp/barn-sentinel.log
 CONFIG
         end
 
         it { is_expected.to compile.with_all_deps }
         it { is_expected.to create_class('redis::sentinel') }
         it { is_expected.to contain_file(config_file_orig).with_content(expected_content) }
       end
     end
   end
 end
diff --git a/spec/classes/redis_spec.rb b/spec/classes/redis_spec.rb
index 8913010..ce89afe 100644
--- a/spec/classes/redis_spec.rb
+++ b/spec/classes/redis_spec.rb
@@ -1,1391 +1,1391 @@
 require 'spec_helper'
 
 describe 'redis' do
   let(:package_name) { facts[:osfamily] == 'Debian' ? 'redis-server' : 'redis' }
   let(:service_name) { package_name }
   let(:config_file) do
     case facts[:osfamily]
     when 'Archlinux', 'Debian'
       '/etc/redis/redis.conf'
     when 'FreeBSD',
       '/usr/local/etc/redis.conf'
     when 'RedHat'
       '/etc/redis.conf'
     end
   end
   let(:config_file_orig) { "#{config_file}.puppet" }
 
   on_supported_os.each do |os, facts|
     context "on #{os}" do
       let(:facts) { facts }
 
       describe 'without parameters' do
         it { is_expected.to compile.with_all_deps }
         it { is_expected.to create_class('redis') }
         it { is_expected.to contain_class('redis::preinstall') }
         it { is_expected.to contain_class('redis::install') }
         it { is_expected.to contain_class('redis::config') }
         it { is_expected.to contain_class('redis::service') }
 
-        it { is_expected.to contain_package(package_name).with_ensure('present') }
+        it { is_expected.to contain_package(package_name).with_ensure('installed') }
 
         it do
           is_expected.to contain_file(config_file_orig).
             with_ensure('file').
             with_content(%r{logfile /var/log/redis/redis\.log}).
             without_content(%r{undef})
 
           if facts[:osfamily] == 'FreeBSD'
             is_expected.to contain_file(config_file_orig).
               with_content(%r{dir /var/db/redis}).
               with_content(%r{pidfile /var/run/redis/redis\.pid})
           end
         end
 
         it do
           is_expected.to contain_service(service_name).with(
             'ensure'     => 'running',
             'enable'     => 'true',
           )
         end
 
         context 'with SCL', if: facts[:osfamily] == 'RedHat' && facts[:operatingsystemmajrelease] < '8' do
           let(:pre_condition) do
             <<-PUPPET
             class { 'redis::globals':
               scl => 'rh-redis5',
             }
             PUPPET
           end
 
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to create_class('redis').
               with_package_name('rh-redis5-redis').
               with_config_file('/etc/opt/rh/rh-redis5/redis.conf').
               with_service_name('rh-redis5-redis')
           end
 
           context 'manage_repo => true', if: facts[:operatingsystem] == 'CentOS' do
             let(:params) { { manage_repo: true } }
 
             it { is_expected.to compile.with_all_deps }
             it { is_expected.to contain_package('centos-release-scl-rh') }
           end
         end
       end
 
       context 'with managed_by_cluster_manager true' do
         let(:params) { { managed_by_cluster_manager: true } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file('/etc/security/limits.d/redis.conf').with(
             'ensure'  => 'file',
             'owner'   => 'root',
             'group'   => 'root',
             'mode'    => '0644',
             'content' => "redis soft nofile 65536\nredis hard nofile 65536\n"
           )
         end
 
         context 'when not managing service' do
           let(:params) { super().merge(service_manage: false, notify_service: false) }
 
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to contain_file('/etc/security/limits.d/redis.conf').with(
               'ensure'  => 'file',
               'owner'   => 'root',
               'group'   => 'root',
               'mode'    => '0644',
               'content' => "redis soft nofile 65536\nredis hard nofile 65536\n"
             )
           end
         end
       end
 
       describe 'with parameter ulimit_managed' do
         context 'true' do
           let(:params) { { ulimit: 7777, ulimit_managed: true } }
 
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to contain_file("/etc/systemd/system/#{service_name}.service.d/limit.conf")
               .with_ensure('absent')
 
             is_expected.to contain_systemd__service_limits("#{service_name}.service").
               with_limits({ "LimitNOFILE" => 7777 }).
               with_restart_service(false).
               with_ensure('present')
           end
         end
 
         context 'false' do
           let(:params) { { ulimit_managed: false } }
 
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.not_to contain_systemd__service_limits("#{service_name}.service")
           end
         end
       end
 
       describe 'with parameter activerehashing' do
         let(:params) do
           {
             activerehashing: true
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{activerehashing.*yes}) }
       end
 
       describe 'with parameter aof_load_truncated' do
         let(:params) do
           {
             aof_load_truncated: true
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{aof-load-truncated.*yes}) }
       end
 
       describe 'with parameter aof_rewrite_incremental_fsync' do
         let(:params) do
           {
             aof_rewrite_incremental_fsync: true
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{aof-rewrite-incremental-fsync.*yes}) }
       end
 
       describe 'with parameter appendfilename' do
         let(:params) do
           {
             appendfilename: '_VALUE_'
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{appendfilename.*_VALUE_}) }
       end
 
       describe 'with parameter appendfsync' do
         let(:params) do
           {
             appendfsync: 'no'
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{^appendfsync no$}) }
       end
 
       describe 'with parameter appendonly' do
         let(:params) do
           {
             appendonly: true
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{appendonly.*yes}) }
       end
 
       describe 'with parameter auto_aof_rewrite_min_size' do
         let(:params) do
           {
             auto_aof_rewrite_min_size: '_VALUE_'
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{auto-aof-rewrite-min-size.*_VALUE_}) }
       end
 
       describe 'with parameter auto_aof_rewrite_percentage' do
         let(:params) do
           {
             auto_aof_rewrite_percentage: 75
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{auto-aof-rewrite-percentage 75}) }
       end
 
       describe 'parameter bind' do
         context 'by default' do
           it 'binds to localhost' do
             is_expected.to contain_file(config_file_orig).with_content(%r{bind 127\.0\.0\.1$})
           end
         end
         context 'with a single IP address' do
           let(:params) { { bind: '10.0.0.1' } }
 
           it { is_expected.to contain_file(config_file_orig).with_content(%r{bind 10\.0\.0\.1$}) }
         end
         context 'with array of IP addresses' do
           let(:params) do
             {
               bind: ['127.0.0.1', '::1']
             }
           end
 
           it { is_expected.to contain_file(config_file_orig).with_content(%r{bind 127\.0\.0\.1 ::1}) }
         end
         context 'with empty array' do
           let(:params) { { bind: [] } }
 
           it { is_expected.not_to contain_file(config_file_orig).with_content(%r{^bind}) }
         end
       end
 
       describe 'with parameter output_buffer_limit_slave' do
         let(:params) do
           {
             output_buffer_limit_slave: '_VALUE_'
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{client-output-buffer-limit slave.*_VALUE_}) }
       end
 
       describe 'with parameter output_buffer_limit_pubsub' do
         let(:params) do
           {
             output_buffer_limit_pubsub: '_VALUE_'
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{client-output-buffer-limit pubsub.*_VALUE_}) }
       end
 
       describe 'with parameter: config_dir' do
         let(:params) { { config_dir: '/etc/config_dir' } }
 
         it { is_expected.to contain_file('/etc/config_dir').with_ensure('directory') }
       end
 
       describe 'with parameter: config_dir_mode' do
         let(:params) { { config_dir_mode: '0700' } }
 
         it { is_expected.to contain_file('/etc/redis').with_mode('0700') }
       end
 
       describe 'with parameter: log_dir_mode' do
         let(:params) { { log_dir_mode: '0660' } }
 
         it { is_expected.to contain_file('/var/log/redis').with_mode('0660') }
       end
 
       describe 'with parameter: config_file_orig' do
         let(:params) { { config_file_orig: '/path/to/orig' } }
 
         it { is_expected.to contain_file('/path/to/orig') }
       end
 
       describe 'with parameter: config_file_mode' do
         let(:params) { { config_file_mode: '0600' } }
 
         it { is_expected.to contain_file(config_file_orig).with_mode('0600') }
       end
 
       describe 'with parameter: config_group' do
         let(:params) { { config_group: '_VALUE_' } }
 
         it { is_expected.to contain_file('/etc/redis').with_group('_VALUE_') }
       end
 
       describe 'with parameter: config_owner' do
         let(:params) { { config_owner: '_VALUE_' } }
 
         it { is_expected.to contain_file('/etc/redis').with_owner('_VALUE_') }
       end
 
       describe 'with parameter daemonize' do
         let(:params) do
           {
             daemonize: true
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{daemonize.*yes}
           )
         }
       end
 
       describe 'with parameter databases' do
         let(:params) do
           {
             databases: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{databases 42}
           )
         }
       end
 
       describe 'with parameter dbfilename' do
         let(:params) do
           {
             dbfilename: '_VALUE_'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{dbfilename.*_VALUE_}
           )
         }
       end
 
       describe 'without parameter dbfilename' do
         let(:params) do
           {
             dbfilename: false
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).without_content(%r{^dbfilename}) }
       end
 
       describe 'with parameter hash_max_ziplist_entries' do
         let(:params) do
           {
             hash_max_ziplist_entries: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{hash-max-ziplist-entries 42}
           )
         }
       end
 
       describe 'with parameter hash_max_ziplist_value' do
         let(:params) do
           {
             hash_max_ziplist_value: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{hash-max-ziplist-value 42}
           )
         }
       end
 
       # TODO: Only present in 3.0
       describe 'with parameter list_max_ziplist_entries' do
         let(:params) do
           {
             list_max_ziplist_entries: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{list-max-ziplist-entries 42}
           )
         }
       end
 
       describe 'with parameter list_max_ziplist_value' do
         let(:params) do
           {
             list_max_ziplist_value: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{list-max-ziplist-value 42}
           )
         }
       end
 
       describe 'with parameter log_dir' do
         let(:params) do
           {
             log_dir: '/var/log/redis'
           }
         end
 
         it {
           is_expected.to contain_file('/var/log/redis').with(
             'ensure' => 'directory'
           )
         }
       end
 
       describe 'with parameter log_file' do
         describe 'as absolute path' do
           let(:params) do
             {
               log_file: '/var/log/my-redis/my-redis.log'
             }
           end
 
           it {
             is_expected.to contain_file(config_file_orig).with(
               'content' => %r{^logfile /var/log/my-redis/my-redis\.log$}
             )
           }
         end
 
         describe 'as relative path' do
           let(:params) do
             {
               log_dir: '/var/log/my-redis',
               log_file: 'my-redis.log'
             }
           end
 
           it {
             is_expected.to contain_file(config_file_orig).with(
               'content' => %r{^logfile /var/log/my-redis/my-redis\.log$}
             )
           }
         end
       end
 
       describe 'with parameter log_level' do
         let(:params) do
           {
             log_level: 'debug'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^loglevel debug$}
           )
         }
       end
 
       describe 'with parameter: manage_repo' do
         let(:params) { { manage_repo: true } }
 
         case facts[:operatingsystem]
         when 'Ubuntu'
           it { is_expected.to contain_apt__ppa('ppa:chris-lea/redis-server') }
         when 'RedHat', 'CentOS', 'Scientific', 'OEL', 'Amazon'
           it { is_expected.to contain_class('epel') }
         end
       end
 
       describe 'with parameter unixsocket' do
         describe '/tmp/redis.sock' do
           let(:params) { { unixsocket: '/tmp/redis.sock' } }
 
           it { is_expected.to contain_file(config_file_orig).with_content(%r{^unixsocket /tmp/redis\.sock$}) }
         end
 
         describe 'empty string' do
           let(:params) { { unixsocket: '' } }
 
           it { is_expected.to contain_file(config_file_orig).without_content(%r{^unixsocket }) }
         end
       end
 
       describe 'with parameter unixsocketperm' do
         describe '777' do
           let(:params) { { unixsocketperm: '777' } }
 
           it { is_expected.to contain_file(config_file_orig).with_content(%r{^unixsocketperm 777$}) }
         end
 
         describe 'empty string' do
           let(:params) { { unixsocketperm: '' } }
 
           it { is_expected.to contain_file(config_file_orig).without_content(%r{^unixsocketperm }) }
         end
       end
 
       describe 'with parameter masterauth' do
         let(:params) do
           {
             masterauth: '_VALUE_'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{masterauth.*_VALUE_}
           )
         }
       end
 
       describe 'with parameter maxclients' do
         let(:params) do
           {
             maxclients: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^maxclients 42$}
           )
         }
       end
 
       describe 'with parameter maxmemory' do
         let(:params) do
           {
             maxmemory: '_VALUE_'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{maxmemory.*_VALUE_}
           )
         }
       end
 
       describe 'with parameter maxmemory_policy' do
         let(:params) do
           {
             maxmemory_policy: '_VALUE_'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{maxmemory-policy.*_VALUE_}
           )
         }
       end
 
       describe 'with parameter maxmemory_samples' do
         let(:params) do
           {
             maxmemory_samples: '_VALUE_'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{maxmemory-samples.*_VALUE_}
           )
         }
       end
 
       describe 'with parameter min_slaves_max_lag' do
         let(:params) do
           {
             min_slaves_max_lag: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^min-slaves-max-lag 42$}
           )
         }
       end
 
       describe 'with parameter min_slaves_to_write' do
         let(:params) do
           {
             min_slaves_to_write: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^min-slaves-to-write 42$}
           )
         }
       end
 
       describe 'with parameter notify_keyspace_events' do
         let(:params) do
           {
             notify_keyspace_events: '_VALUE_'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{notify-keyspace-events.*_VALUE_}
           )
         }
       end
 
       describe 'with parameter notify_service' do
         let(:params) do
           {
             notify_service: true
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).that_notifies("Service[#{service_name}]") }
       end
 
       describe 'with parameter no_appendfsync_on_rewrite' do
         let(:params) do
           {
             no_appendfsync_on_rewrite: true
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{no-appendfsync-on-rewrite.*yes}
           )
         }
       end
 
       describe 'with parameter: package_ensure' do
         let(:params) { { package_ensure: '_VALUE_' } }
 
         it {
           is_expected.to contain_package(package_name).with(
             'ensure' => '_VALUE_'
           )
         }
       end
 
       describe 'with parameter: package_name' do
         let(:params) { { package_name: '_VALUE_' } }
 
         it { is_expected.to contain_package('_VALUE_') }
       end
 
       describe 'with parameter pid_file' do
         let(:params) do
           {
             pid_file: '/path/to/redis.pid'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^pidfile /path/to/redis.pid$}
           )
         }
       end
 
       describe 'with parameter port' do
         let(:params) do
           {
             port: 6666
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^port 6666$}
           )
         }
       end
 
       describe 'with parameter protected-mode' do
         let(:params) do
           {
             protected_mode: false
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{^protected-mode no$}) }
       end
 
       describe 'with parameter hll_sparse_max_bytes' do
         let(:params) do
           {
             hll_sparse_max_bytes: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^hll-sparse-max-bytes 42$}
           )
         }
       end
 
       describe 'with parameter hz' do
         let(:params) do
           {
             hz: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^hz 42$}
           )
         }
       end
 
       describe 'with parameter latency_monitor_threshold' do
         let(:params) do
           {
             latency_monitor_threshold: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^latency-monitor-threshold 42$}
           )
         }
       end
 
       describe 'with parameter rdbcompression' do
         let(:params) do
           {
             rdbcompression: true
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{rdbcompression.*yes}
           )
         }
       end
 
       describe 'with parameter rename_commands' do
         context 'with a single rename' do
           let(:params) do
             {
               rename_commands: { CONFIG: "\"\"" }
             }
           end
           it {
             is_expected.to contain_file(config_file_orig).with(
               'content' => %r{^rename-command CONFIG ""$}
             )
           }
         end
         context 'with multiple renames' do
           let(:params) do
             {
               rename_commands: { CONFIG: "\"\"", RENAME: "\"\"" }
             }
           end
           it {
             is_expected.to contain_file(config_file_orig).with(
               'content' => %r{^rename-command CONFIG ""$}
             )
             is_expected.to contain_file(config_file_orig).with(
               'content' => %r{^rename-command RENAME ""$}
             )
           }
         end
         context 'with empty hash' do
           let(:params) do
             {
               "rename_commands" => {}
             }
           end
           it { is_expected.not_to contain_file(config_file_orig).with_content(%r{^rename-command}) }
         end
       end
 
       describe 'with parameter repl_backlog_size' do
         let(:params) do
           {
             repl_backlog_size: '_VALUE_'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{repl-backlog-size.*_VALUE_}
           )
         }
       end
 
       describe 'with parameter repl_backlog_ttl' do
         let(:params) do
           {
             repl_backlog_ttl: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^repl-backlog-ttl 42$}
           )
         }
       end
 
       describe 'with parameter repl_disable_tcp_nodelay' do
         let(:params) do
           {
             repl_disable_tcp_nodelay: true
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{repl-disable-tcp-nodelay.*yes}
           )
         }
       end
 
       describe 'with parameter repl_ping_slave_period' do
         let(:params) do
           {
             repl_ping_slave_period: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^repl-ping-slave-period 42}
           )
         }
       end
 
       describe 'with parameter repl_timeout' do
         let(:params) do
           {
             repl_timeout: 1
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{repl-timeout.*1}
           )
         }
       end
 
       describe 'with parameter requirepass' do
         let(:params) do
           {
             requirepass: '_VALUE_'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{requirepass.*_VALUE_}
           )
         }
       end
 
       describe 'with parameter save_db_to_disk' do
         context 'true' do
           let(:params) do
             {
               save_db_to_disk: true
             }
           end
 
           it {
             is_expected.to contain_file(config_file_orig).with(
               'content' => %r{^save}
             )
           }
         end
 
         context 'false' do
           let(:params) do
             {
               save_db_to_disk: false
             }
           end
 
           it {
             is_expected.to contain_file(config_file_orig).with(
               'content' => %r{^(?!save)}
             )
           }
         end
       end
 
       describe 'with parameter save_db_to_disk_interval' do
         context 'with save_db_to_disk true' do
           context 'default' do
             let(:params) do
               {
                 save_db_to_disk: true
               }
             end
 
             it { is_expected.to contain_file(config_file_orig).with('content' => %r{save 900 1}) }
             it { is_expected.to contain_file(config_file_orig).with('content' => %r{save 300 10}) }
             it {
               is_expected.to contain_file(config_file_orig).with('content' => %r{save 60 10000})
             }
           end
 
           context 'default' do
             let(:params) do
               {
                 save_db_to_disk: true,
                 save_db_to_disk_interval: { '900' => '2', '300' => '11', '60' => '10011' }
               }
             end
 
             it { is_expected.to contain_file(config_file_orig).with('content' => %r{save 900 2}) }
             it { is_expected.to contain_file(config_file_orig).with('content' => %r{save 300 11}) }
             it {
               is_expected.to contain_file(config_file_orig).with('content' => %r{save 60 10011})
             }
           end
         end
 
         context 'with save_db_to_disk false' do
           context 'default' do
             let(:params) do
               {
                 save_db_to_disk: false
               }
             end
 
             it { is_expected.to contain_file(config_file_orig).without('content' => %r{save 900 1}) }
             it { is_expected.to contain_file(config_file_orig).without('content' => %r{save 300 10}) }
             it { is_expected.to contain_file(config_file_orig).without('content' => %r{save 60 10000}) }
           end
         end
       end
 
       describe 'with parameter: service_manage (set to false)' do
         let(:params) { { service_manage: false } }
 
         it { is_expected.not_to contain_service(package_name) }
       end
 
       describe 'with parameter: service_enable' do
         let(:params) { { service_enable: true } }
 
         it { is_expected.to contain_service(package_name).with_enable(true) }
       end
 
       describe 'with parameter: service_ensure' do
         let(:params) { { service_ensure: 'stopped' } }
 
         it { is_expected.to contain_service(package_name).with_ensure('stopped') }
       end
 
       describe 'with parameter: service_group' do
         let(:params) { { service_group: '_VALUE_' } }
 
         it { is_expected.to contain_file('/var/log/redis').with_group('_VALUE_') }
       end
 
       describe 'with parameter: service_name' do
         let(:params) { { service_name: '_VALUE_' } }
 
         it { is_expected.to contain_service('_VALUE_').with_name('_VALUE_') }
       end
 
       describe 'with parameter: service_user' do
         let(:params) { { service_user: '_VALUE_' } }
 
         it { is_expected.to contain_file('/var/log/redis').with_owner('_VALUE_') }
       end
 
       describe 'with parameter set_max_intset_entries' do
         let(:params) do
           {
             set_max_intset_entries: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^set-max-intset-entries 42$}
           )
         }
       end
 
       describe 'with parameter slave_priority' do
         let(:params) do
           {
             slave_priority: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^slave-priority 42$}
           )
         }
       end
 
       describe 'with parameter slave_read_only' do
         let(:params) do
           {
             slave_read_only: true
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{slave-read-only.*yes}
           )
         }
       end
 
       describe 'with parameter slave_serve_stale_data' do
         let(:params) do
           {
             slave_serve_stale_data: true
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{slave-serve-stale-data.*yes}
           )
         }
       end
 
       describe 'with parameter: slaveof' do
         context 'binding to localhost' do
           let(:params) do
             {
               bind: '127.0.0.1',
               slaveof: '_VALUE_'
             }
           end
 
           it {
             is_expected.to contain_file(config_file_orig).with(
               'content' => %r{^slaveof _VALUE_}
             )
           }
         end
 
         context 'binding to external ip' do
           let(:params) do
             {
               bind: '10.0.0.1',
               slaveof: '_VALUE_'
             }
           end
 
           it {
             is_expected.to contain_file(config_file_orig).with(
               'content' => %r{^slaveof _VALUE_}
             )
           }
         end
       end
 
       describe 'with parameter slowlog_log_slower_than' do
         let(:params) do
           {
             slowlog_log_slower_than: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^slowlog-log-slower-than 42$}
           )
         }
       end
 
       describe 'with parameter slowlog_max_len' do
         let(:params) do
           {
             slowlog_max_len: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^slowlog-max-len 42$}
           )
         }
       end
 
       describe 'with parameter stop_writes_on_bgsave_error' do
         let(:params) do
           {
             stop_writes_on_bgsave_error: true
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{stop-writes-on-bgsave-error.*yes}
           )
         }
       end
 
       describe 'with parameter syslog_enabled' do
         let(:params) do
           {
             syslog_enabled: true
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{syslog-enabled yes}
           )
         }
       end
 
       describe 'with parameter syslog_facility' do
         let(:params) do
           {
             syslog_enabled: true,
             syslog_facility: '_VALUE_'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{syslog-facility.*_VALUE_}
           )
         }
       end
 
       describe 'with parameter tcp_backlog' do
         let(:params) do
           {
             tcp_backlog: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^tcp-backlog 42$}
           )
         }
       end
 
       describe 'with parameter tcp_keepalive' do
         let(:params) do
           {
             tcp_keepalive: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^tcp-keepalive 42$}
           )
         }
       end
 
       describe 'with parameter timeout' do
         let(:params) do
           {
             timeout: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^timeout 42$}
           )
         }
       end
 
       describe 'with parameter workdir' do
         let(:params) do
           {
             workdir: '/var/workdir'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{^dir /var/workdir$}
           )
         }
       end
 
       describe 'with parameter zset_max_ziplist_entries' do
         let(:params) do
           {
             zset_max_ziplist_entries: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{zset-max-ziplist-entries 42}
           )
         }
       end
 
       describe 'with parameter zset_max_ziplist_value' do
         let(:params) do
           {
             zset_max_ziplist_value: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{zset-max-ziplist-value 42}
           )
         }
       end
 
       describe 'with parameter cluster_enabled-false' do
         let(:params) do
           {
             cluster_enabled: false
           }
         end
 
         it {
           is_expected.not_to contain_file(config_file_orig).with(
             'content' => %r{cluster-enabled}
           )
         }
       end
 
       describe 'with parameter cluster_enabled-true' do
         let(:params) do
           {
             cluster_enabled: true
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{cluster-enabled.*yes}
           )
         }
       end
 
       describe 'with parameter cluster_config_file' do
         let(:params) do
           {
             cluster_enabled: true,
             cluster_config_file: '_VALUE_'
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{cluster-config-file.*_VALUE_}
           )
         }
       end
 
       describe 'with parameter cluster_config_file' do
         let(:params) do
           {
             cluster_enabled: true,
             cluster_node_timeout: 42
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{cluster-node-timeout 42}
           )
         }
       end
 
       describe 'with parameter cluster_config_file' do
         let(:params) do
           {
             cluster_enabled: true,
             cluster_slave_validity_factor: 1
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{cluster-slave-validity-factor.*1}
           )
         }
       end
 
       describe 'with parameter cluster_config_file' do
         let(:params) do
           {
             cluster_enabled: true,
             cluster_require_full_coverage: true
           }
         end
 
         it {
           is_expected.to contain_file(config_file_orig).with(
             'content' => %r{cluster-require-full-coverage.*yes}
           )
         }
       end
 
       describe 'with parameter cluster_config_file' do
         let(:params) do
           {
             cluster_enabled: true,
             cluster_require_full_coverage: false
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{cluster-require-full-coverage.*no}) }
       end
 
       describe 'with parameter cluster_config_file' do
         let(:params) do
           {
             cluster_enabled: true,
             cluster_migration_barrier: 1
           }
         end
 
         it { is_expected.to contain_file(config_file_orig).with_content(%r{cluster-migration-barrier.*1}) }
       end
 
       describe 'with parameter manage_service_file' do
         let(:params) do
           {
             manage_service_file: true
           }
         end
 
         it { is_expected.to contain_systemd__unit_file("#{service_name}.service") }
 
         it do
           content = <<-END.gsub(%r{^\s+\|}, '')
             |[Unit]
             |Description=Redis Advanced key-value store for instance default
             |After=network.target
             |After=network-online.target
             |Wants=network-online.target
             |
             |[Service]
             |RuntimeDirectory=redis
             |RuntimeDirectoryMode=2755
             |Type=notify
             |ExecStart=/usr/bin/redis-server #{config_file} --supervised systemd
             |ExecStop=/usr/bin/redis-cli -p 6379 shutdown
             |Restart=always
             |User=redis
             |Group=redis
             |LimitNOFILE=65536
             |
             |[Install]
             |WantedBy=multi-user.target
           END
 
           is_expected.to contain_systemd__unit_file("#{service_name}.service").with_content(content)
         end
       end
 
       describe 'with parameter manage_service_file set to false' do
         let(:params) do
           {
             manage_service_file: false
           }
         end
 
         it { is_expected.not_to contain_systemd__unit_file("#{service_name}.service") }
       end
     end
   end
 end