diff --git a/spec/classes/config_spec.rb b/spec/classes/config_spec.rb
index 9a2b9f5..e5cc96a 100644
--- a/spec/classes/config_spec.rb
+++ b/spec/classes/config_spec.rb
@@ -1,594 +1,596 @@
 require 'spec_helper'
 
 shared_examples 'zookeeper parameters' do |_os_facts, precond|
   # load class, handle custom params
   let :pre_condition do
     precond
   end
 
   it do
     is_expected.to contain_file(cfg_dir).with('ensure'  => 'directory',
                                               'owner'   => user,
                                               'group'   => group)
   end
 
   it do
     is_expected.to contain_file(log_dir).with('ensure'  => 'directory',
                                               'owner'   => user,
                                               'group'   => group)
   end
 
   it do
     is_expected.to contain_file(id_file).with('ensure'  => 'file',
                                               'owner'   => user,
                                               'group'   => group).with_content(myid)
   end
 end
 
 shared_examples 'zookeeper common' do |os_facts|
   os_info = get_os_info(os_facts)
 
   environment_file = os_info[:environment_file]
 
   context 'extra parameters' do
     # set custom params
     let :pre_condition do
       'class {"zookeeper":
          log4j_prop => "ERROR",
          snap_count => 15000,
        }'
     end
 
     it do
       is_expected.to contain_file(environment_file).with_content(%r{ERROR})
-      is_expected.to contain_file(environment_file).with_content(%r{CLASSPATH})
+      is_expected.to contain_file(environment_file).with_content(%r{ZOOCFG})
+      # CLASSPATH won't be overriden for all install methods
+      # is_expected.to contain_file(environment_file).with_content(%r{CLASSPATH})
     end
 
     it do
       is_expected.to contain_file('/etc/zookeeper/conf/zoo.cfg').with_content(%r{snapCount=15000})
     end
 
     # leave the default value to be determined by ZooKeeper
     it 'does not set maxClientCnxns by default' do
       # due to problem with should_not not matching, we're using more complicated way
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{^#maxClientCnxns=})
     end
 
     # by default do not set client IP address
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{^#clientPortAddress=})
     end
   end
 
   context 'install from archive' do
     let :pre_condition do
       'class {"zookeeper":
          install_method  => "archive",
          archive_version => "3.4.9",
       }'
     end
 
     it do
       is_expected.to contain_file(environment_file).without_content(%r{CLASSPATH})
     end
   end
 
   context 'extra environment_file parameter' do
     # set custom params
     let :pre_condition do
       'class {"zookeeper":
          log4j_prop => "ERROR",
          environment_file => "java.env",
        }'
     end
 
     it do
       is_expected.to contain_file('/etc/zookeeper/conf/java.env').with_content(%r{ERROR})
       is_expected.not_to contain_file('/etc/zookeeper/environment')
     end
   end
 
   context 'max allowed connections' do
     let :pre_condition do
       'class {"zookeeper":
          max_allowed_connections => 15,
        }'
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{maxClientCnxns=15})
     end
   end
 
   context 'set client ip address' do
     let :pre_condition do
       'class {"zookeeper":
          client_ip => "192.168.1.1",
        }'
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{clientPortAddress=192.168.1.1})
     end
   end
 
   context 'setting tick time' do
     let :pre_condition do
       'class {"zookeeper":
          tick_time => 3000,
        }'
     end
 
     it do
       is_expected.to contain_file('/etc/zookeeper/conf/zoo.cfg').with_content(%r{tickTime=3000})
     end
   end
 
   context 'setting init and sync limit' do
     let :pre_condition do
       'class {"zookeeper":
          init_limit => 15,
          sync_limit => 10,
        }'
     end
 
     it do
       is_expected.to contain_file('/etc/zookeeper/conf/zoo.cfg').with_content(%r{initLimit=15})
     end
 
     it do
       is_expected.to contain_file('/etc/zookeeper/conf/zoo.cfg').with_content(%r{syncLimit=10})
     end
   end
 
   context 'setting leader' do
     let :pre_condition do
       'class {"zookeeper":
          leader => false,
        }'
     end
 
     it do
       is_expected.to contain_file('/etc/zookeeper/conf/zoo.cfg').with_content(%r{leaderServes=no})
     end
   end
 
   context 'myid link' do
     let :pre_condition do
       'class {"zookeeper":}'
     end
 
     it do
       is_expected.to contain_file(
-        '/var/lib/zookeeper/myid'
+        '/var/lib/zookeeper/myid',
       ).with('ensure' => 'link',
              'target' => '/etc/zookeeper/conf/myid')
     end
   end
 
   context 'without datalogstore parameter' do
     let :pre_condition do
       'class {"zookeeper":}'
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{# dataLogDir=/disk2/zookeeper})
     end
   end
 
   context 'with datalogstore parameter' do
     let :pre_condition do
       'class {"zookeeper":
          datalogstore => "/zookeeper/transaction/device",
        }'
     end
 
     let(:datalogstore) { '/zookeeper/transaction/device' }
 
     it do
       is_expected.to contain_file(datalogstore).with('ensure' => 'directory')
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{dataLogDir=/zookeeper/transaction/device})
     end
   end
 
   context 'setting quorum of servers with custom ports' do
     let :pre_condition do
       'class {"zookeeper":
          election_port => 3000,
          leader_port   => 4000,
          servers       => ["192.168.1.1", "192.168.1.2"],
        }'
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.1=192.168.1.1:3000:4000})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.2=192.168.1.2:3000:4000})
     end
   end
 
   context 'setting quorum of servers with custom ports with servers as hash' do
     let :pre_condition do
       'class {"zookeeper":
          election_port => 3000,
          leader_port   => 4000,
          servers       => {"12" => "192.168.1.1", "23" => "192.168.1.2"},
        }'
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.12=192.168.1.1:3000:4000})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.23=192.168.1.2:3000:4000})
     end
   end
 
   context 'setting quorum of servers with default ports' do
     let :pre_condition do
       'class {"zookeeper":
          servers => ["192.168.1.1", "192.168.1.2"]
        }'
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.1=192.168.1.1:2888:3888})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.2=192.168.1.2:2888:3888})
     end
   end
 
   context 'setting quorum of servers with default ports with servers as hash' do
     let :pre_condition do
       'class {"zookeeper":
          servers => {"12" => "192.168.1.1", "23" => "192.168.1.2"},
        }'
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.12=192.168.1.1:2888:3888})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.23=192.168.1.2:2888:3888})
     end
   end
 
   context 'setting quorum of servers with default ports with observer' do
     let :pre_condition do
       'class {"zookeeper":
          servers   => ["192.168.1.1", "192.168.1.2", "192.168.1.3", "192.168.1.4", "192.168.1.5"],
          observers => ["192.168.1.4", "192.168.1.5"]
        }'
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.1=192.168.1.1:2888:3888})
     end
 
     it do
       is_expected.not_to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.1=192.168.1.1:2888:3888:observer})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.2=192.168.1.2:2888:3888})
     end
 
     it do
       is_expected.not_to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.2=192.168.1.2:2888:3888:observer})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.3=192.168.1.3:2888:3888})
     end
 
     it do
       is_expected.not_to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.3=192.168.1.3:2888:3888:observer})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.4=192.168.1.4:2888:3888:observer})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.5=192.168.1.5:2888:3888:observer})
     end
   end
 
   context 'setting quorum of servers with default ports with observer with servers as hash' do
     let :pre_condition do
       'class {"zookeeper":
          servers   => {"12" => "192.168.1.1",
                        "23" => "192.168.1.2",
                        "34" => "192.168.1.3",
                        "45" => "192.168.1.4",
                        "56" => "192.168.1.5"},
          observers => ["192.168.1.4", "192.168.1.5"]
        }'
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.12=192.168.1.1:2888:3888})
     end
 
     it do
       is_expected.not_to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.12=192.168.1.1:2888:3888:observer})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.23=192.168.1.2:2888:3888})
     end
 
     it do
       is_expected.not_to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.23=192.168.1.2:2888:3888:observer})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.34=192.168.1.3:2888:3888})
     end
 
     it do
       is_expected.not_to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.34=192.168.1.3:2888:3888:observer})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.45=192.168.1.4:2888:3888:observer})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.56=192.168.1.5:2888:3888:observer})
     end
   end
 
   context 'setting minSessionTimeout' do
     let :pre_condition do
       'class {"zookeeper":
          min_session_timeout => 5000
        }'
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{minSessionTimeout=5000})
     end
   end
 
   context 'setting maxSessionTimeout' do
     let :pre_condition do
       'class {"zookeeper":
          max_session_timeout => 50000
        }'
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{maxSessionTimeout=50000})
     end
   end
 
   context 'make sure port is not included in server IP/hostname' do
     let :pre_condition do
       'class {"zookeeper":
          servers => ["192.168.1.1:2888", "192.168.1.2:2333"]
        }'
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.1=192.168.1.1:2888:3888})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{server.2=192.168.1.2:2888:3888})
     end
   end
 
   context 'configure logging' do
     context 'by default set to INFO' do
       let :pre_condition do
         'class {"zookeeper": }'
       end
 
       it do
         is_expected.to contain_file(
-          '/etc/zookeeper/conf/log4j.properties'
+          '/etc/zookeeper/conf/log4j.properties',
         ).with_content(%r{zookeeper.log.threshold=INFO})
       end
 
       it do
         is_expected.to contain_file(
-          '/etc/zookeeper/conf/log4j.properties'
+          '/etc/zookeeper/conf/log4j.properties',
         ).with_content(%r{zookeeper.console.threshold=INFO})
       end
     end
 
     context 'allow changing rollingfile loglevel' do
       let :pre_condition do
         'class {"zookeeper":
            rollingfile_threshold => "TRACE",
          }'
       end
 
       it do
         is_expected.to contain_file(
-          '/etc/zookeeper/conf/log4j.properties'
+          '/etc/zookeeper/conf/log4j.properties',
         ).with_content(%r{zookeeper.log.threshold=TRACE})
       end
     end
 
     context 'allow changing console loglevel' do
       let :pre_condition do
         'class {"zookeeper":
            console_threshold => "TRACE",
          }'
       end
 
       it do
         is_expected.to contain_file(
-          '/etc/zookeeper/conf/log4j.properties'
+          '/etc/zookeeper/conf/log4j.properties',
         ).with_content(%r{zookeeper.console.threshold=TRACE})
       end
     end
 
     context 'allow changing tracefile loglevel' do
       let :pre_condition do
         'class {"zookeeper":
            tracefile_threshold => "DEBUG",
          }'
       end
 
       it do
         is_expected.to contain_file(
-          '/etc/zookeeper/conf/log4j.properties'
+          '/etc/zookeeper/conf/log4j.properties',
         ).with_content(%r{log4j.appender.TRACEFILE.Threshold=DEBUG})
       end
     end
 
     context 'setting 4lw whitelist' do
       let :pre_condition do
         'class {"zookeeper":
            whitelist_4lw => ["ruok","stat"]
          }'
       end
 
       it do
         is_expected.to contain_file(
-          '/etc/zookeeper/conf/zoo.cfg'
+          '/etc/zookeeper/conf/zoo.cfg',
         ).with_content(%r{4lw.commands.whitelist=ruok,stat})
       end
     end
 
     context 'set global outstanding limit' do
       let :pre_condition do
         'class {"zookeeper":
            global_outstanding_limit => 2000
          }'
       end
 
       it do
         is_expected.to contain_file(
-          '/etc/zookeeper/conf/zoo.cfg'
+          '/etc/zookeeper/conf/zoo.cfg',
         ).with_content(%r{globalOutstandingLimit=2000})
       end
     end
   end
 end
 
 describe 'zookeeper::config' 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
 
       context 'with default parameters' do
         let(:user)    { 'zookeeper' }
         let(:group)   { 'zookeeper' }
         let(:cfg_dir) { '/etc/zookeeper/conf' }
         let(:log_dir) { '/var/lib/zookeeper' }
         let(:id_file) { '/etc/zookeeper/conf/myid' }
         let(:myid)    { %r{^1} }
 
         precond = 'class {"zookeeper": }'
         include_examples 'zookeeper parameters', os_facts, precond
       end
 
       context 'with custom parameters' do
         let(:user)    { 'zoo' }
         let(:group)   { 'zoo' }
         let(:cfg_dir) { '/var/lib/zookeeper/conf' }
         let(:log_dir) { '/var/lib/zookeeper/log' }
         let(:id_file) { '/var/lib/zookeeper/conf/myid' }
         let(:myid)    { %r{^2} }
 
         # set custom params
         precond = 'class {"zookeeper":
           id      => "2",
           user    => "zoo",
           group   => "zoo",
           cfg_dir => "/var/lib/zookeeper/conf",
           log_dir => "/var/lib/zookeeper/log",
         }'
 
         include_examples 'zookeeper parameters', os_facts, precond
       end
 
       include_examples 'zookeeper common', os_facts
     end
   end
 end
diff --git a/spec/classes/init_spec.rb b/spec/classes/init_spec.rb
index 51659b6..4055d7c 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
+        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']
+        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
+        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
+        min_session_timeout: 3000,
       }
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{minSessionTimeout=3000})
     end
   end
 
   context 'setting maxSessionTimeout' do
     let(:params) do
       {
-        max_session_timeout: 60_000
+        max_session_timeout: 60_000,
       }
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{maxSessionTimeout=60000})
     end
   end
 
   context 'disable service management' do
     let(:params) do
       {
-        manage_service: false
+        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}
     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'
+          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'
+              'descr' => 'custom repo',
             },
-            cdhver: '5'
+            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}
         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
+        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'
+        service_provider: 'init',
       }
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/log4j.properties'
+        '/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}
       it do
         is_expected.to contain_file(
-          "/etc/init.d/#{service_name}"
+          "/etc/init.d/#{service_name}",
         ).with_content(%r{pidfile=/var/run/zookeeper.pid})
       end
     else
       it do
         is_expected.to contain_file(
-          environment_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
+        environment_file,
       )
     end
   end
 
   context 'managed by exhibitor' do
     let(:params) do
       {
         service_provider: 'exhibitor',
         service_name: 'zookeeper',
-        cfg_dir: '/opt/zookeeper/conf'
+        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'
+        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/install_spec.rb b/spec/classes/install_spec.rb
index 49cf1da..7d00984 100644
--- a/spec/classes/install_spec.rb
+++ b/spec/classes/install_spec.rb
@@ -1,346 +1,347 @@
 require 'spec_helper'
 
 shared_examples 'zookeeper install' do |os_facts|
   # load class, handle custom params
   let :pre_condition do
     'class {"zookeeper":
        snap_retain_count => 1,
     }'
   end
 
   it { is_expected.to contain_package('zookeeper') }
 
   os_info = get_os_info(os_facts)
 
   should_install_cron = os_info[:should_install_cron]
   should_install_zookeeperd = os_info[:should_install_zookeeperd]
   zookeeper_shell = os_info[:zookeeper_shell]
 
   it { is_expected.to contain_class('zookeeper::post_install') }
   it { is_expected.to compile.with_all_deps }
 
   if should_install_zookeeperd
     it { is_expected.to contain_package('zookeeperd') }
   else
     it { is_expected.not_to contain_package('zookeeperd') }
   end
 
   if should_install_cron
     it { is_expected.to contain_package('cron') }
   else
     it { is_expected.not_to contain_package('cron') }
   end
 
   it 'installs cron script' do
     cron_exists = contain_cron__job('zookeeper-cleanup').with('ensure' => 'present',
                                                               'command'   => '/usr/share/zookeeper/bin/zkCleanup.sh /var/lib/zookeeper 1',
                                                               'user'      => 'zookeeper',
                                                               'hour'      => '2',
                                                               'minute' => '42')
 
     if should_install_cron
       is_expected.to cron_exists
     else
       is_expected.not_to cron_exists
     end
   end
 
   it 'installs cron script' do
     cron_exists = contain_cron__job('zookeeper-cleanup').with('ensure' => 'present',
                                                               'command'   => '/usr/share/zookeeper/bin/zkCleanup.sh /var/lib/zookeeper 1',
                                                               'user'      => 'zookeeper',
                                                               'hour'      => '2',
                                                               'minute' => '42')
 
     if should_install_cron
       is_expected.to cron_exists
     else
       is_expected.not_to cron_exists
     end
   end
 
   context 'without cron' do
     let :pre_condition do
       'class {"zookeeper":
          snap_retain_count => 0,
        }'
     end
 
     it { is_expected.to contain_package('zookeeper') }
     it { is_expected.not_to contain_package('cron') }
 
     if should_install_zookeeperd
       it { is_expected.to contain_package('zookeeperd') }
     else
       it { is_expected.not_to contain_package('zookeeperd') }
     end
   end
 
   context 'with cron' do
     let :pre_condition do
       'class {"zookeeper":
          snap_retain_count => 5,
          manual_clean      => true,
        }'
     end
 
     it { is_expected.to contain_package('zookeeper') }
     it { is_expected.to contain_package('cron') }
 
     it 'installs cron script' do
       is_expected.to contain_cron__job('zookeeper-cleanup').with('ensure' => 'present',
                                                                  'command'   => '/usr/share/zookeeper/bin/zkCleanup.sh /var/lib/zookeeper 5',
                                                                  'user'      => 'zookeeper',
                                                                  'hour'      => '2',
                                                                  'minute' => '42')
     end
   end
 
   context 'allow changing package names' do
     let :pre_condition do
       'class {"zookeeper":
          packages => [ "zookeeper", "zookeeper-server" ],
        }'
     end
 
     it { is_expected.to contain_package('zookeeper') }
     it { is_expected.to contain_package('zookeeper-server') }
     it { is_expected.not_to contain_package('zookeeperd') }
   end
 
   context 'allow installing multiple packages' do
     let :pre_condition do
       'class {"zookeeper":
          packages => [ "zookeeper", "zookeeper-devel" ],
        }'
     end
 
     it { is_expected.to contain_package('zookeeper') }
     it { is_expected.to contain_package('zookeeper-devel') }
   end
 
   context 'with java installation' do
     let(:user) { 'zookeeper' }
     let(:group) { 'zookeeper' }
 
     let :pre_condition do
       'class {"zookeeper":
          install_java => true,
          java_package => "java-1.7.0-openjdk",
        }'
     end
 
     it do
       is_expected.to contain_package('java-1.7.0-openjdk').with('ensure' => 'present')
     end
     it do
       is_expected.to contain_package('zookeeper').with('ensure' => 'present')
     end
   end
 
   context 'with java installation fail when no packge provided' do
     let :pre_condition do
       'class {"zookeeper":
          install_java => true,
        }'
     end
 
     it do
-      expect do
+      expect {
         is_expected.to compile
-      end.to raise_error(%r{Java installation is required}) end
+      }.to raise_error(%r{Java installation is required})
+    end
   end
 
   context 'removing package' do
     let :pre_condition do
       'class {"zookeeper":
          ensure => absent,
        }'
     end
 
     it do
       is_expected.to contain_package('zookeeper').with('ensure' => 'absent')
     end
     if should_install_zookeeperd
       it do
         is_expected.to contain_package('zookeeperd').with('ensure' => 'absent')
       end
     else
       it do
         is_expected.not_to contain_package('zookeeperd').with('ensure' => 'present')
       end
     end
     it { is_expected.not_to contain_package('cron') }
   end
 
   # create user with proper shell #50 (https://github.com/deric/puppet-zookeeper/issues/50)
   context 'ensure user resource exists' do
     it do
       is_expected.to contain_user('zookeeper').with('ensure' => 'present',
                                                     'shell' => zookeeper_shell)
     end
   end
 
   context 'user account' do
     let :pre_condition do
       'class {"zookeeper":
          ensure_account => "present",
        }'
     end
 
     it do
       is_expected.to contain_user('zookeeper').with(ensure: 'present')
     end
 
     context 'remove user accounts' do
       let :pre_condition do
         'class {"zookeeper":
           ensure_account => "absent",
         }'
       end
 
       it do
         is_expected.to contain_user('zookeeper').with(ensure: 'absent')
       end
     end
 
     context 'do not manage user accounts' do
       let :pre_condition do
         'class {"zookeeper":
           ensure_account => false,
         }'
       end
 
       it { is_expected.not_to contain_user('zookeeper') }
     end
   end
 
   context 'installing 3.4.8 from tar archive' do
     let(:install_dir) { '/opt' }
     let(:zoo_dir) { '/opt/zookeeper' }
     let(:vers) { '3.4.8' }
     let(:mirror_url) { 'http://archive.apache.org/dist' }
     let(:basefilename) { "zookeeper-#{vers}.tar.gz" }
     let(:package_url) { "#{mirror_url}/zookeeper/zookeeper-#{vers}/zookeeper-#{vers}.tar.gz" }
     let(:extract_path) { "#{zoo_dir}-#{vers}" }
 
     let :pre_condition do
       'class {"zookeeper":
          install_method => "archive",
          archive_version => "3.4.8",
          archive_install_dir => "/opt",
          zoo_dir => "/opt/zookeeper",
        }'
     end
 
     it do
       is_expected.to contain_file(zoo_dir).with(ensure: 'link',
                                                 target: extract_path)
     end
     it do
       is_expected.to contain_archive("#{install_dir}/#{basefilename}").with(extract_path: install_dir,
                                                                             source: package_url,
                                                                             creates: extract_path,
                                                                             user: 'root',
                                                                             group: 'root')
     end
 
     it do
       is_expected.to contain_file('/etc/zookeeper').with(ensure: 'directory',
                                                          owner: 'zookeeper',
                                                          group: 'zookeeper')
     end
   end
 
   context 'installing 3.5.5 from tar archive' do
     let(:install_dir) { '/opt' }
     let(:zoo_dir) { '/opt/zookeeper' }
     let(:vers) { '3.5.5' }
     let(:mirror_url) { 'http://apache.org/dist/zookeeper' }
     let(:basefilename) { "apache-zookeeper-#{vers}-bin.tar.gz" }
     let(:package_url) { "#{mirror_url}/zookeeper-#{vers}/apache-zookeeper-#{vers}-bin.tar.gz" }
     let(:extract_path) { "/opt/apache-zookeeper-#{vers}-bin" }
 
     let :pre_condition do
       'class {"zookeeper":
          install_method => "archive",
          archive_version => "3.5.5",
          archive_install_dir => "/opt",
          zoo_dir => "/opt/zookeeper",
        }'
     end
 
     it do
       is_expected.to contain_file(zoo_dir).with(ensure: 'link',
                                                 target: extract_path)
     end
 
     it do
       is_expected.to contain_archive("#{install_dir}/#{basefilename}").with(extract_path: install_dir,
                                                                             source: package_url,
                                                                             creates: extract_path,
                                                                             user: 'root',
                                                                             group: 'root')
     end
 
     it do
       is_expected.to contain_file('/etc/zookeeper').with(ensure: 'directory',
                                                          owner: 'zookeeper',
                                                          group: 'zookeeper')
     end
   end
 
   context 'installing 3.4.8 from tar archive over proxy server' do
     let(:install_dir) { '/opt' }
     let(:zoo_dir) { '/opt/zookeeper' }
     let(:vers) { '3.4.8' }
     let(:mirror_url) { 'http://archive.apache.org/dist' }
     let(:basefilename) { "zookeeper-#{vers}.tar.gz" }
     let(:package_url) { "#{mirror_url}/zookeeper/zookeeper-#{vers}/zookeeper-#{vers}.tar.gz" }
     let(:extract_path) { "#{zoo_dir}-#{vers}" }
 
     let :pre_condition do
       'class {"zookeeper":
          install_method => "archive",
          proxy_server => "http://10.0.0.1:8080",
          archive_version => "3.4.8",
          archive_install_dir => "/opt",
          zoo_dir => "/opt/zookeeper",
        }'
     end
 
     it do
       is_expected.to contain_file(zoo_dir).with(ensure: 'link',
                                                 target: extract_path)
     end
     it do
       is_expected.to contain_archive("#{install_dir}/#{basefilename}").with(extract_path:  install_dir,
                                                                             source:        package_url,
                                                                             creates:       extract_path,
                                                                             proxy_server:  'http://10.0.0.1:8080',
                                                                             user:          'root',
                                                                             group:         'root')
     end
 
     it do
       is_expected.to contain_file('/etc/zookeeper').with(ensure: 'directory',
                                                          owner: 'zookeeper',
                                                          group: 'zookeeper')
     end
   end
 end
 
 describe 'zookeeper::install' do
   let(:user) { 'zookeeper' }
   let(:group) { 'zookeeper' }
 
   on_supported_os.each do |os, os_facts|
     context "on #{os}" do
       let(:facts) do
         os_facts
       end
 
       include_examples 'zookeeper install', os_facts
     end
   end
 end
diff --git a/spec/classes/repo_spec.rb b/spec/classes/repo_spec.rb
index 5d77012..d06e205 100644
--- a/spec/classes/repo_spec.rb
+++ b/spec/classes/repo_spec.rb
@@ -1,154 +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 do
+      expect {
         is_expected.to compile
-      end.to raise_error(%r{is not supported for #{os_name} version #{os_release}}) end
+      }.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 do
+      expect {
         is_expected.to compile
-      end.to raise_error(%r{is not supported for architecture #{os_hardware}}) end
+      }.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}
     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 do
+      expect {
         is_expected.to compile
-      end.to raise_error(%r{is not a supported cloudera repo.}) end
+      }.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 do
+      expect {
         is_expected.to compile
-      end.to raise_error(%r{provides no repository information for yum repository}) end
+      }.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']
-        }
-      ]
+          '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']
-        }
-      ]
+          '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/classes/sasl_spec.rb b/spec/classes/sasl_spec.rb
index ec17433..3581d1f 100644
--- a/spec/classes/sasl_spec.rb
+++ b/spec/classes/sasl_spec.rb
@@ -1,69 +1,69 @@
 require 'spec_helper'
 
 shared_examples 'zookeeper::sasl' do |os_facts|
   os_info = get_os_info(os_facts)
 
   environment_file = os_info[:environment_file]
 
   context 'sasl config' do
     let :pre_condition do
       'class {"zookeeper":
          use_sasl_auth => true,
        }'
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_class('zookeeper::sasl') }
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/jaas.conf'
+        '/etc/zookeeper/conf/jaas.conf',
       ).with_content(%r{storeKey=true})
     end
 
     it do
       is_expected.to contain_file(
-        environment_file
+        environment_file,
       ).with_content(%r{JAVA_OPTS=".* -Djava.security.auth.login.config=/etc/zookeeper/conf/jaas.conf"})
     end
   end
 
   context 'remove host and realm from principal' do
     let :pre_condition do
       'class {"zookeeper":
          use_sasl_auth => true,
          remove_host_principal => true,
          remove_realm_principal => true,
        }'
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_class('zookeeper::sasl') }
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{kerberos.removeHostFromPrincipal=true})
     end
 
     it do
       is_expected.to contain_file(
-        '/etc/zookeeper/conf/zoo.cfg'
+        '/etc/zookeeper/conf/zoo.cfg',
       ).with_content(%r{kerberos.removeRealmFromPrincipal=true})
     end
   end
 end
 
 describe 'zookeeper::sasl' 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::sasl', os_facts
     end
   end
 end
diff --git a/spec/classes/service_spec.rb b/spec/classes/service_spec.rb
index d061a18..45263a1 100644
--- a/spec/classes/service_spec.rb
+++ b/spec/classes/service_spec.rb
@@ -1,187 +1,187 @@
 require 'spec_helper'
 
 shared_examples 'zookeeper::service' do |os_facts|
   let(:user) { 'zookeeper' }
   let(:group) { 'zookeeper' }
 
   os_info = get_os_info(os_facts)
 
   should_install_zookeeperd = os_info[:should_install_zookeeperd]
   service_name = os_info[:service_name]
   init_dir = os_info[:init_dir]
   init_provider = os_info[:init_provider]
   service_file = os_info[:service_file]
 
   case init_provider
   when 'systemd'
     context 'systemd' do
       let :pre_condition do
         'class {"zookeeper":
            manage_service_file => true,
            service_provider    => "systemd",
            systemd_path        => "/usr/lib/systemd/system",
            zoo_dir             => "/usr/lib/zookeeper",
            log_dir             => "/var/log/zookeeper",
          }'
       end
 
       it { is_expected.to contain_package('zookeeper') }
 
       if should_install_zookeeperd
         it { is_expected.to contain_package('zookeeperd') }
       else
         it { is_expected.not_to contain_package('zookeeperd') }
       end
 
       it do
         is_expected.to contain_file(
-          "/usr/lib/systemd/system/#{service_name}.service"
+          "/usr/lib/systemd/system/#{service_name}.service",
         ).with('ensure' => 'present')
       end
 
       it do
         is_expected.to contain_file(
-          "/usr/lib/systemd/system/#{service_name}.service"
+          "/usr/lib/systemd/system/#{service_name}.service",
         ).with_content(%r{CLASSPATH="/usr/lib/zookeeper/zookeeper.jar})
       end
 
       it do
         is_expected.to contain_service(service_name).with(
           ensure: 'running',
-          enable: true
+          enable: true,
         )
       end
 
       context 'install from archive' do
         let :pre_condition do
           'class {"zookeeper":
              manage_service_file => true,
              install_method      => "archive",
              archive_version     => "3.4.9"
            }'
         end
 
         it do
           is_expected.to contain_file(service_file).with_content(
-            %r{zookeeper-3\.4\.9\.jar}
+            %r{zookeeper-3\.4\.9\.jar},
           )
         end
       end
 
       context 'do not manage systemd' do
         let :pre_condition do
           'class {"zookeeper":
              manage_service_file => false,
              zoo_dir             => "/usr/lib/zookeeper",
              log_dir             => "/var/log/zookeeper",
            }'
         end
 
         it do
           is_expected.not_to contain_file(
-            '/usr/lib/systemd/system/zookeeper.service'
+            '/usr/lib/systemd/system/zookeeper.service',
           ).with('ensure' => 'present')
         end
 
         it do
           is_expected.not_to contain_file(service_file).with('ensure' => 'present')
         end
       end
 
       context 'systemd dependencies' do
         let :pre_condition do
           'class {"zookeeper":
              service_provider    => "systemd",
              manage_service_file => true,
              manage_service      => true,
              systemd_unit_after  => "network-online.target openvpn-client@.service",
              systemd_unit_want   => "network-online.target openvpn-client@.service",
            }'
         end
 
         it do
           is_expected.to contain_file(service_file).with('ensure' => 'present')
         end
 
         it do
           is_expected.to contain_file(service_file).with_content(
-            %r{Wants=network-online.target openvpn-client@.service}
+            %r{Wants=network-online.target openvpn-client@.service},
           )
         end
 
         it do
           is_expected.to contain_service(service_name).with(
             ensure: 'running',
-            enable: true
+            enable: true,
           )
         end
       end
     end
 
   when 'init'
     context 'init' do
       let :pre_condition do
         'class {"zookeeper":
            zoo_dir             => "/usr/lib/zookeeper",
            log_dir             => "/var/log/zookeeper",
            manage_service_file => true,
            service_provider    => "init",
          }'
       end
 
       it do
         is_expected.to contain_file(
-          '/etc/init.d/zookeeper'
+          '/etc/init.d/zookeeper',
         ).with('ensure' => 'present')
       end
 
       it do
         is_expected.to contain_service('zookeeper').with(
           ensure: 'running',
           enable: true,
-          provider: 'init'
+          provider: 'init',
         )
       end
     end
 
     context 'custom service name' do
       let :pre_condition do
         'class {"zookeeper":
            manage_service_file => true,
            service_name        => "my-zookeeper",
          }'
       end
 
       custom_service_file = if init_provider == 'systemd'
                               "#{init_dir}/my-zookeeper.service"
                             else
                               "#{init_dir}/my-zookeeper"
                             end
 
       it do
         is_expected.to contain_file(custom_service_file).with('ensure' => 'present')
       end
 
       it do
         is_expected.to contain_service('my-zookeeper').with(
           ensure: 'running',
-          enable: true
+          enable: true,
         )
       end
     end
   end
 end
 
 describe 'zookeeper::service' 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::service', os_facts
     end
   end
 end
diff --git a/spec/spec_helper_local.rb b/spec/spec_helper_local.rb
index 564f67b..504942b 100644
--- a/spec/spec_helper_local.rb
+++ b/spec/spec_helper_local.rb
@@ -1,54 +1,54 @@
 def get_os_info(facts)
   info = {
     service_name: nil,
     environment_file: nil,
     should_install_zookeeperd: nil,
     init_provider: nil,
     init_dir: nil,
     service_file: nil,
     should_install_cron: false,
-    zookeeper_shell: nil
+    zookeeper_shell: nil,
   }
 
   case facts[:osfamily]
   when 'Debian'
     info[:service_name] = 'zookeeper'
     info[:environment_file] = '/etc/zookeeper/conf/environment'
     info[:should_install_zookeeperd] = true
     info[:zookeeper_shell] = '/bin/false'
     info[:init_provider] = 'systemd'
   when 'RedHat'
     info[:service_name] = 'zookeeper-server'
     info[:environment_file] = '/etc/zookeeper/conf/java.env'
     info[:should_install_zookeeperd] = false
     info[:zookeeper_shell] = '/sbin/nologin'
     info[:init_provider] = if Puppet::Util::Package.versioncmp(facts[:os]['release']['major'], '7') < 0
                              'redhat'
                            else
                              'systemd'
                            end
   when 'Suse'
     info[:service_name] = 'zookeeper-server'
     info[:environment_file] = '/etc/zookeeper/conf/java.env'
     info[:should_install_zookeeperd] = false
     info[:zookeeper_shell] = '/bin/false'
     info[:init_provider] = 'systemd'
   end
 
   case info[:init_provider]
   when 'init'
     info[:init_dir] = '/etc/init.d'
   when 'systemd'
     info[:init_dir] = '/etc/systemd/system'
   when 'redhat'
     info[:init_dir] = '/etc/init.d'
   end
 
   info[:service_file] = if info[:init_provider] == 'systemd'
                           "#{info[:init_dir]}/#{info[:service_name]}.service"
                         else
                           "#{info[:init_dir]}/#{info[:service_name]}"
                         end
 
   info
 end