diff --git a/manifests/params.pp b/manifests/params.pp
index 62e2deb..de1845c 100644
--- a/manifests/params.pp
+++ b/manifests/params.pp
@@ -1,164 +1,164 @@
 # OS specific configuration should be defined here
 #
 # PRIVATE CLASS - do not use directly (use main `zookeeper` class).
 class zookeeper::params {
   $_defaults = {
     'packages' => ['zookeeper'],
   }
 
   $os_family = $facts['os']['family']
   $os_name = $facts['os']['name']
   $os_release = $facts['os']['release']['major']
 
   case $os_family {
     'Debian': {
       case $os_name {
         'Debian', 'Ubuntu': {
           $initstyle = 'systemd'
         }
         default: { $initstyle = undef }
       }
 
       $_os_overrides = {
         'packages'         => ['zookeeper', 'zookeeperd'],
         'service_name'     => 'zookeeper',
         'service_provider' => $initstyle,
         'shell'            => '/bin/false',
       }
       # 'environment' file probably read just by Debian
       # see #16, #81
       $environment_file = 'environment'
     }
     'RedHat': {
       case $os_name {
         'RedHat', 'CentOS': {
           if versioncmp($os_release, '7') < 0 {
             $initstyle = 'redhat'
           } else {
             $initstyle = 'systemd'
           }
         }
         default: {
           $initstyle = undef
         }
       }
 
       $_os_overrides = {
         'packages'         => ['zookeeper', 'zookeeper-server'],
         'service_name'     => 'zookeeper-server',
         'service_provider' => $initstyle,
         'shell'            => '/sbin/nologin',
       }
       $environment_file = 'java.env'
     }
 
     default: {
       fail("Module '${module_name}' is not supported on OS: '${os_name}', family: '${os_family}'")
     }
   }
   $_params = merge($_defaults, $_os_overrides)
 
   # meta options
   $ensure = present
   $ensure_account = present
   $ensure_cron = true
   $group = 'zookeeper'
   $system_group = false
   $packages = $_params['packages']
   $shell = $_params['shell']
   $user = 'zookeeper'
   $system_user = false
 
   # installation options
   $archive_checksum = {}
   $archive_dl_site = undef
   $archive_dl_timeout = 600
   $archive_dl_url = undef
   $archive_install_dir = '/opt'
   $archive_symlink = true
   $archive_symlink_name = "${archive_install_dir}/zookeeper"
   $archive_version = '3.4.8'
   $cdhver = '5'
   $install_java = false
   $install_method = 'package'
   $java_bin = '/usr/bin/java'
   $java_opts = ''
   $java_package = undef
-  $repo = 'cloudera'
+  $repo = undef
   $proxy_server = undef
   $proxy_type = undef
 
   # service options
   $manage_service = true
   $manage_service_file = false
   $pid_dir = '/var/run'
   $pid_file = undef
   $restart_on_change = true
   $service_ensure = 'running'
   $service_name = $_params['service_name']
   $service_provider = $_params['service_provider']
   # systemd_unit_want and _after can be overridden to
   # donate the matching directives in the [Unit] section
   $systemd_unit_want = undef
   $systemd_unit_after = 'network.target'
   $systemd_path = '/etc/systemd/system'
 
   $zk_dir = '/etc/zookeeper'
   # zookeeper config
   $cfg_dir = '/etc/zookeeper/conf'
   $cleanup_sh = '/usr/share/zookeeper/bin/zkCleanup.sh'
   $client_ip = undef # use e.g. $::ipaddress if you want to bind to single interface
   $client_port = 2181
   $datastore = '/var/lib/zookeeper'
   # datalogstore used to put transaction logs in separate location than snapshots
   $datalogstore = undef
   $election_port = 2888
   $export_tag = 'zookeeper'
   $id = '1'
   $init_limit = 10
   $initialize_datastore = false
   $leader = true
   $leader_port = 3888
   $log_dir = '/var/log/zookeeper'
   $manual_clean = false
   $max_allowed_connections = undef
   $max_session_timeout = undef
   $min_session_timeout = undef
   $observers = []
   # interval in hours, purging enabled when >= 1
   $purge_interval = 0
   $servers = []
   $snap_count = 10000
   # since zookeeper 3.4, for earlier version cron task might be used
   $snap_retain_count = 3
   $sync_limit = 5
   $tick_time = 2000
   $global_outstanding_limit = 1000
   $use_sasl_auth = false
   $zoo_dir = '/usr/lib/zookeeper'
   $zoo_main = 'org.apache.zookeeper.server.quorum.QuorumPeerMain'
 
   # log4j properties
   $log4j_prop = 'INFO,ROLLINGFILE'
   $peer_type = 'UNSET'
   $rollingfile_threshold = 'INFO'
   $console_threshold = 'INFO'
   $tracefile_threshold = 'TRACE'
   $maxfilesize = '256MB'
   $maxbackupindex = 20
   $extra_appenders = {}
 
   # sasl options
   $sasl_krb5 = true
   $sasl_users = {}
   $keytab_path = '/etc/zookeeper/conf/zookeeper.keytab'
   $principal = "zookeeper/${facts['networking']['fqdn']}"
   $realm = pick($trusted['domain'], $trusted['certname'])
   $store_key = true
   $use_keytab = true
   $use_ticket_cache = false
   $remove_host_principal = false
   $remove_realm_principal = false
   # whitelist of Four Letter Words commands, see https://zookeeper.apache.org/doc/r3.4.12/zookeeperAdmin.html#sc_zkCommands
   $whitelist_4lw = []
 }
diff --git a/spec/classes/init_spec.rb b/spec/classes/init_spec.rb
index fcfc7f6..abb4d33 100644
--- a/spec/classes/init_spec.rb
+++ b/spec/classes/init_spec.rb
@@ -1,274 +1,280 @@
 require 'spec_helper'
 
 shared_examples 'zookeeper' do |os_facts|
   let(:user) { 'zookeeper' }
   let(:group) { 'zookeeper' }
 
   os_info = get_os_info(os_facts)
 
   service_name = os_info[:service_name]
   environment_file = os_info[:environment_file]
   init_provider = os_info[:init_provider]
   should_install_zookeeperd = os_info[:should_install_zookeeperd]
 
   it { is_expected.to contain_class('zookeeper::config') }
   it { is_expected.to contain_class('zookeeper::install') }
   it { is_expected.to contain_class('zookeeper::service') }
   it { is_expected.to compile.with_all_deps }
   it { is_expected.to contain_service(service_name) }
   it { is_expected.to contain_service(service_name).that_subscribes_to('File[/etc/zookeeper/conf/myid]') }
   it { is_expected.to contain_service(service_name).that_subscribes_to('File[/etc/zookeeper/conf/zoo.cfg]') }
   it { is_expected.to contain_service(service_name).that_subscribes_to("File[#{environment_file}]") }
   it { is_expected.to contain_service(service_name).that_subscribes_to('File[/etc/zookeeper/conf/log4j.properties]') }
 
   context 'skip service restart' do
     let(:params) do
       {
         restart_on_change: false
       }
     end
 
     it { is_expected.to contain_service(service_name) }
     it { is_expected.not_to contain_service(service_name).that_subscribes_to('File[/etc/zookeeper/conf/myid]') }
     it { is_expected.not_to contain_service(service_name).that_subscribes_to('File[/etc/zookeeper/conf/zoo.cfg]') }
     it { is_expected.not_to contain_service(service_name).that_subscribes_to("File[#{environment_file}]") }
     it { is_expected.not_to contain_service(service_name).that_subscribes_to('File[/etc/zookeeper/conf/log4j.properties]') }
   end
 
   context 'allow installing multiple packages' do
     let(:params) do
       {
         packages: ['zookeeper', 'zookeeper-bin']
       }
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_package('zookeeper').with(ensure: 'present') }
     it { is_expected.to contain_package('zookeeper-bin').with(ensure: 'present') }
     it { is_expected.to contain_service(service_name).with(ensure: 'running') }
     # datastore exec is not included by default
     it { is_expected.not_to contain_exec('initialize_datastore') }
 
     it { is_expected.to contain_user('zookeeper').with(ensure: 'present') }
     it { is_expected.to contain_group('zookeeper').with(ensure: 'present') }
   end
 
   context 'Cloudera packaging' do
     let(:params) do
       {
         packages: ['zookeeper', 'zookeeper-server'],
         service_name: 'zookeeper-server',
         initialize_datastore: true
       }
     end
 
     it { is_expected.to contain_package('zookeeper').with(ensure: 'present') }
     it { is_expected.to contain_package('zookeeper-server').with(ensure: 'present') }
     it { is_expected.to contain_service('zookeeper-server').with(ensure: 'running') }
     it { is_expected.to contain_exec('initialize_datastore') }
   end
 
   context 'setting minSessionTimeout' do
     let(:params) do
       {
         min_session_timeout: 3000
       }
     end
 
     it do
       is_expected.to contain_file(
         '/etc/zookeeper/conf/zoo.cfg'
       ).with_content(%r{minSessionTimeout=3000})
     end
   end
 
   context 'setting maxSessionTimeout' do
     let(:params) do
       {
         max_session_timeout: 60_000
       }
     end
 
     it do
       is_expected.to contain_file(
         '/etc/zookeeper/conf/zoo.cfg'
       ).with_content(%r{maxSessionTimeout=60000})
     end
   end
 
   context 'disable service management' do
     let(:params) do
       {
         manage_service: false
       }
     end
 
     it { is_expected.to contain_package('zookeeper').with(ensure: 'present') }
     it { is_expected.not_to contain_service(service_name).with(ensure: 'running') }
     it { is_expected.not_to contain_class('zookeeper::service') }
   end
 
   if os_facts[:osfamily] == 'RedHat'
+    context 'Do not use cloudera by default' do
+      it { is_expected.to compile.with_all_deps }
+      it { is_expected.to contain_class('zookeeper::install::repo') }
+      it { is_expected.not_to contain_yumrepo('cloudera-cdh5') }
+    end
+
     context 'use Cloudera RPM repo' do
       let(:params) do
         {
           repo: 'cloudera',
           cdhver: '5'
         }
       end
 
       it { is_expected.to compile.with_all_deps }
       it { is_expected.to contain_class('zookeeper::install::repo') }
       it { is_expected.to contain_yumrepo('cloudera-cdh5') }
 
       context 'custom RPM repo' do
         let(:params) do
           {
             repo: {
               'name'  => 'myrepo',
               'url'   => 'http://repo.url',
               'descr' => 'custom repo'
             },
             cdhver: '5'
           }
         end
 
         it { is_expected.to contain_yumrepo('myrepo').with(baseurl: 'http://repo.url') }
       end
     end
   end
 
   context 'service provider' do
     context 'autodetect provider' do
       it { is_expected.to contain_package('zookeeper').with(ensure: 'present') }
 
       if os_facts[:osfamily] == 'RedHat'
         it { is_expected.to contain_package('zookeeper-server').with(ensure: 'present') }
       else
         it { is_expected.not_to contain_package('zookeeper-server').with(ensure: 'present') }
       end
 
       it do
         is_expected.to contain_service(service_name).with(ensure: 'running',
                                                           provider: init_provider)
       end
     end
 
     it { is_expected.to contain_class('zookeeper::service') }
   end
 
   context 'allow passing specific version' do
     let(:version) { '3.4.5+dfsg-1' }
 
     let(:params) do
       {
         ensure: version
       }
     end
 
     it { is_expected.to contain_package('zookeeper').with(ensure: version) }
 
     if should_install_zookeeperd
       it { is_expected.to contain_package('zookeeperd').with(ensure: version) }
     else
       it { is_expected.not_to contain_package('zookeeperd').with(ensure: version) }
     end
 
     it { is_expected.to contain_user('zookeeper').with(ensure: 'present') }
   end
 
   context 'set pid file for init provider' do
     let(:params) do
       {
         zoo_dir: '/usr/lib/zookeeper',
         log_dir: '/var/log/zookeeper',
         manage_service: true,
         manage_service_file: true,
         service_provider: 'init'
       }
     end
 
     it do
       is_expected.to contain_file(
         '/etc/zookeeper/conf/log4j.properties'
       ).with_content(%r{zookeeper.log.dir=/var/log/zookeeper})
     end
 
     context 'set service provider' do
       it { is_expected.to contain_package('zookeeper').with(ensure: 'present') }
       it do
         is_expected.to contain_service(service_name).with(ensure: 'running',
                                                           provider: 'init')
       end
     end
 
     if os_facts[:osfamily] == 'RedHat'
       it do
         is_expected.to contain_file(
           "/etc/init.d/#{service_name}"
         ).with_content(%r{pidfile=/var/run/zookeeper.pid})
       end
     else
       it do
         is_expected.to contain_file(
           environment_file
         ).with_content(%r{PIDFILE=/var/run/zookeeper.pid})
       end
     end
   end
 
   context 'create env file' do
     it do
       is_expected.to contain_file(
         environment_file
       )
     end
   end
 
   context 'managed by exhibitor' do
     let(:params) do
       {
         service_provider: 'exhibitor',
         service_name: 'zookeeper',
         cfg_dir: '/opt/zookeeper/conf'
       }
     end
 
     it { is_expected.not_to contain_class('zookeeper::service') }
     it { is_expected.not_to contain_service(service_name) }
     it { is_expected.not_to contain_file('/opt/zookeeper/conf/zoo.cfg') }
     it { is_expected.not_to contain_file('/opt/zookeeper/conf/myid') }
   end
 
   context 'install from archive' do
     let(:params) do
       {
         install_method: 'archive',
         archive_version: '3.4.9'
       }
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_class('Zookeeper::Install::Archive') }
 
     it { is_expected.not_to contain_package('zookeeper').with(ensure: 'present') }
     it { is_expected.to contain_service(service_name).with(ensure: 'running') }
 
     it { is_expected.to contain_user('zookeeper').with(ensure: 'present') }
     it { is_expected.to contain_group('zookeeper').with(ensure: 'present') }
   end
 end
 
 describe 'zookeeper', type: :class do
   on_supported_os.each do |os, os_facts|
     os_facts[:os]['hardware'] = 'x86_64'
 
     context "on #{os}" do
       let(:facts) do
         os_facts.merge(ipaddress: '192.168.1.1')
       end
 
       include_examples 'zookeeper', os_facts
     end
   end
 end