3rdparty/modules/concat/spec/unit/defines/concat_spec.rb

   1 require 'spec_helper'
   2
   3 describe 'concat', :type => :define do
   4
   5   shared_examples 'concat' do |title, params, id|
   6     params = {} if params.nil?
   7     id = 'root' if id.nil?
   8
   9     # default param values
  10     p = {
  11       :ensure         => 'present',
  12       :path           => title,
  13       :owner          => nil,
  14       :group          => nil,
  15       :mode           => '0644',
  16       :warn           => false,
  17       :backup         => 'puppet',
  18       :replace        => true,
  19     }.merge(params)
  20
  21     file_defaults = {
  22       :backup  => p[:backup],
  23     }
  24
  25     let(:title) { title }
  26     let(:params) { params }
  27     let(:facts) do
  28       {
  29         :id             => id,
  30         :osfamily       => 'Debian',
  31         :path           => '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
  32         :kernel         => 'Linux',
  33         :is_pe          => false,
  34       }
  35     end
  36
  37     if p[:ensure] == 'present'
  38       it do
  39         should contain_concat(title).with(file_defaults.merge({
  40           :ensure                  => 'present',
  41           :owner                   => p[:owner],
  42           :group                   => p[:group],
  43           :mode                    => p[:mode],
  44           :path                    => p[:path],
  45           :backup                  => p[:backup],
  46           :replace                 => p[:replace],
  47           :selinux_ignore_defaults => p[:selinux_ignore_defaults],
  48           :selrange                => p[:selrange],
  49           :selrole                 => p[:selrole],
  50           :seltype                 => p[:seltype],
  51           :seluser                 => p[:seluser],
  52         }))
  53       end
  54     else
  55       it do
  56         should contain_concat(title).with(file_defaults.merge({
  57           :ensure => 'absent',
  58           :backup => p[:backup],
  59         }))
  60       end
  61     end
  62   end
  63
  64   context 'title' do
  65     context 'without path param' do
  66       # title/name is the default value for the path param. therefore, the
  67       # title must be an absolute path unless path is specified
  68       ['/foo', '/foo/bar', '/foo/bar/baz'].each do |title|
  69         context title do
  70           it_behaves_like 'concat', '/etc/foo.bar'
  71         end
  72       end
  73
  74       ['./foo', 'foo', 'foo/bar'].each do |title|
  75         context title do
  76           let(:title) { title }
  77           it 'should fail' do
  78             expect { catalogue }.to raise_error(Puppet::Error, /Stdlib::Unixpath/)
  79           end
  80         end
  81       end
  82     end
  83
  84     context 'with path param' do
  85       ['/foo', 'foo', 'foo/bar'].each do |title|
  86         context title do
  87           it_behaves_like 'concat', title, { :path => '/etc/foo.bar' }
  88         end
  89       end
  90     end
  91
  92     context 'with special characters in title' do
  93       ['foo:bar', 'foo*bar', 'foo(bar)', 'foo@bar'].each do |title|
  94         context title do
  95           it_behaves_like 'concat', title, { :path => '/etc/foo.bar' }
  96         end
  97       end
  98     end
  99   end # title =>
 100
 101   context 'as non-root user' do
 102     it_behaves_like 'concat', '/etc/foo.bar', {}, 'bob'
 103   end
 104
 105   context 'ensure =>' do
 106     ['present', 'absent'].each do |ens|
 107       context ens do
 108         it_behaves_like 'concat', '/etc/foo.bar', { :ensure => ens }
 109       end
 110     end
 111
 112     context 'invalid' do
 113       let(:title) { '/etc/foo.bar' }
 114       let(:params) {{ :ensure => 'invalid' }}
 115       it 'should fail' do
 116         expect { catalogue }.to raise_error(Puppet::Error, /expects a match for Enum\['absent', 'present'\]/)
 117       end
 118     end
 119   end # ensure =>
 120
 121   context 'path =>' do
 122     context '/foo' do
 123       it_behaves_like 'concat', '/etc/foo.bar', { :path => '/foo' }
 124     end
 125
 126     context 'false' do
 127       let(:title) { '/etc/foo.bar' }
 128       let(:params) {{ :path => false }}
 129       it 'should fail' do
 130         expect { catalogue }.to raise_error(Puppet::Error, /Stdlib::Unixpath/)
 131       end
 132     end
 133
 134     ['./foo', 'foo', 'foo/bar'].each do |path|
 135       context path do
 136         let(:title) { '/etc/foo.bar' }
 137         let(:params) {{ :path => path }}
 138         it 'should fail' do
 139           expect { catalogue }.to raise_error(Puppet::Error, /Stdlib::Unixpath/)
 140         end
 141       end
 142     end
 143   end # path =>
 144
 145   context 'owner =>' do
 146     ['apenney',1000,'1001'].each do |owner|
 147       context owner do
 148         it_behaves_like 'concat', '/etc/foo.bar', { :owner => owner }
 149       end
 150     end
 151
 152     context 'false' do
 153       let(:title) { '/etc/foo.bar' }
 154       let(:params) {{ :owner => false }}
 155       it 'should fail' do
 156         expect { catalogue }.to raise_error(Puppet::Error, /Evaluation Error.*expects.*String.*Boolean.*/)
 157       end
 158     end
 159   end # owner =>
 160
 161   context 'group =>' do
 162     ['apenney',1000,'1001'].each do |group|
 163       context group do
 164         it_behaves_like 'concat', '/etc/foo.bar', { :group => group }
 165       end
 166     end
 167
 168     context 'false' do
 169       let(:title) { '/etc/foo.bar' }
 170       let(:params) {{ :group => false }}
 171       it 'should fail' do
 172         expect { catalogue }.to raise_error(Puppet::Error, /Evaluation Error.*expects.*String.*Boolean.*/)
 173       end
 174     end
 175   end # group =>
 176
 177   context 'mode =>' do
 178     context '1755' do
 179       it_behaves_like 'concat', '/etc/foo.bar', { :mode => '1755' }
 180     end
 181
 182     context 'false' do
 183       let(:title) { '/etc/foo.bar' }
 184       let(:params) {{ :mode => false }}
 185       it 'should fail' do
 186         expect { catalogue }.to raise_error(Puppet::Error, /parameter 'mode' expects .*String.*/)
 187       end
 188     end
 189   end # mode =>
 190
 191   context 'warn =>' do
 192     [true, false, '# foo'].each do |warn|
 193       context warn do
 194         it_behaves_like 'concat', '/etc/foo.bar', { :warn => warn }
 195       end
 196     end
 197
 198     context '(stringified boolean)' do
 199       ['true', 'yes', 'on', 'false', 'no', 'off'].each do |warn|
 200         context warn do
 201           it_behaves_like 'concat', '/etc/foo.bar', { :warn => warn }
 202
 203           it 'should create a warning' do
 204             skip('rspec-puppet support for testing warning()')
 205           end
 206         end
 207       end
 208     end
 209
 210     context '123' do
 211       let(:title) { '/etc/foo.bar' }
 212       let(:params) {{ :warn => 123 }}
 213       it 'should fail' do
 214         expect { catalogue }.to raise_error(Puppet::Error, /parameter 'warn' expects .*Boolean.*String.*/)
 215       end
 216     end
 217   end # warn =>
 218
 219   context 'show_diff =>' do
 220     [true, false].each do |show_diff|
 221       context show_diff do
 222         it_behaves_like 'concat', '/etc/foo.bar', { :show_diff => show_diff }
 223       end
 224     end
 225
 226     context '123' do
 227       let(:title) { '/etc/foo.bar' }
 228       let(:params) {{ :show_diff => 123 }}
 229       it 'should fail' do
 230         expect { catalogue }.to raise_error(Puppet::Error, /parameter 'show_diff' expects .*Boolean.*/)
 231       end
 232     end
 233   end # show_diff =>
 234
 235   context 'backup =>' do
 236     ['reverse',false,true].each do |backup|
 237       context "#{backup}" do
 238         it_behaves_like 'concat', '/etc/foo.bar', { :backup => backup }
 239       end
 240     end
 241
 242     context 'true' do
 243       let(:title) { '/etc/foo.bar' }
 244       let(:params) {{ :backup => [] }}
 245       it 'should fail' do
 246         expect { catalogue }.to raise_error(Puppet::Error, /parameter 'backup' expects .*Boolean.*String.*/)
 247       end
 248     end
 249   end # backup =>
 250
 251   context 'replace =>' do
 252     [true, false].each do |replace|
 253       context replace do
 254         it_behaves_like 'concat', '/etc/foo.bar', { :replace => replace }
 255       end
 256     end
 257
 258     context '123' do
 259       let(:title) { '/etc/foo.bar' }
 260       let(:params) {{ :replace => 123 }}
 261       it 'should fail' do
 262         expect { catalogue }.to raise_error(Puppet::Error, /parameter 'replace' expects .*Boolean.*/)
 263       end
 264     end
 265   end # replace =>
 266
 267   context 'order =>' do
 268     ['alpha', 'numeric'].each do |order|
 269       context order do
 270         it_behaves_like 'concat', '/etc/foo.bar', { :order => order }
 271       end
 272     end
 273
 274     context 'invalid' do
 275       let(:title) { '/etc/foo.bar' }
 276       let(:params) {{ :order => 'invalid' }}
 277       it 'should fail' do
 278         expect { catalogue }.to raise_error(Puppet::Error, /expects a match for Enum\['alpha', 'numeric'\]/)
 279       end
 280     end
 281   end # order =>
 282
 283   context 'ensure_newline =>' do
 284     [true, false].each do |ensure_newline|
 285       context 'true' do
 286         it_behaves_like 'concat', '/etc/foo.bar', { :ensure_newline => ensure_newline}
 287       end
 288     end
 289
 290     context '123' do
 291       let(:title) { '/etc/foo.bar' }
 292       let(:params) {{ :ensure_newline => 123 }}
 293       it 'should fail' do
 294         expect { catalogue }.to raise_error(Puppet::Error, /parameter 'ensure_newline' expects a Boolean value/)
 295       end
 296     end
 297   end # ensure_newline =>
 298
 299   context 'validate_cmd =>' do
 300     context '/usr/bin/test -e %' do
 301       it_behaves_like 'concat', '/etc/foo.bar', { :validate_cmd => '/usr/bin/test -e %' }
 302     end
 303
 304     [ 1234, true ].each do |cmd|
 305       context cmd do
 306         let(:title) { '/etc/foo.bar' }
 307         let(:params) {{ :validate_cmd => cmd }}
 308         it 'should fail' do
 309           expect { catalogue }.to raise_error(Puppet::Error, /parameter 'validate_cmd' expects.*String.*/)
 310         end
 311       end
 312     end
 313   end # validate_cmd =>
 314
 315   context 'selinux_ignore_defaults =>' do
 316     let(:title) { '/etc/foo.bar' }
 317
 318     [true, false].each do |v|
 319       context v do
 320         it_behaves_like 'concat', '/etc/foo.bar', { :selinux_ignore_defaults => v }
 321       end
 322     end
 323
 324     context '123' do
 325       let(:title) { '/etc/foo.bar' }
 326       let(:params) {{ :selinux_ignore_defaults => 123 }}
 327       it 'should fail' do
 328         expect { catalogue }.to raise_error(Puppet::Error, /Evaluation Error.*expects.*Boolean.*/)
 329       end
 330     end
 331   end # selinux_ignore_defaults =>
 332
 333   [
 334     :selrange,
 335     :selrole,
 336     :seltype,
 337     :seluser,
 338   ].each do |p|
 339     context " #{p} =>" do
 340       let(:title) { '/etc/foo.bar' }
 341
 342       context 'foo' do
 343         it_behaves_like 'concat', '/etc/foo.bar', { p => 'foo' }
 344       end
 345
 346       context 'false' do
 347         let(:title) { '/etc/foo.bar' }
 348         let(:params) {{ p => false }}
 349         it 'should fail' do
 350           expect { catalogue }.to raise_error(Puppet::Error, /parameter '#{p}' expects.*String.*/)
 351         end
 352       end
 353     end # #{p} =>
 354   end
 355 end