spec/defines/key_spec.rb

   1 # frozen_string_literal: true
   2
   3 require 'spec_helper'
   4
   5 GPG_KEY_ID = '6F6B15509CF8E59E6E469F327F438280EF8D349F'
   6
   7 title_key_example = { id: GPG_KEY_ID,
   8                       ensure: 'present',
   9                       source: nil,
  10                       server: 'keyserver.ubuntu.com',
  11                       content: nil,
  12                       options: nil }
  13
  14 def default_apt_key_example(title)
  15   { id: title,
  16     ensure: 'present',
  17     source: nil,
  18     server: 'keyserver.ubuntu.com',
  19     content: nil,
  20     options: nil,
  21     refresh: false }
  22 end
  23
  24 def bunch_things_apt_key_example(title, params)
  25   { id: title,
  26     ensure: 'present',
  27     source: 'http://apt.puppetlabs.com/pubkey.gpg',
  28     server: 'pgp.mit.edu',
  29     content: params[:content],
  30     options: 'debug' }
  31 end
  32
  33 def absent_apt_key(title)
  34   { id: title,
  35     ensure: 'absent',
  36     source: nil,
  37     server: 'keyserver.ubuntu.com',
  38     content: nil,
  39     keyserver: nil }
  40 end
  41
  42 describe 'apt::key' do
  43   let :pre_condition do
  44     'class { "apt": }'
  45   end
  46
  47   let(:facts) do
  48     {
  49       os: {
  50         family: 'Debian',
  51         name: 'Debian',
  52         release: {
  53           major: '9',
  54           full: '9.0'
  55         },
  56         distro: {
  57           codename: 'stretch',
  58           id: 'Debian'
  59         }
  60       }
  61     }
  62   end
  63
  64   let :title do
  65     GPG_KEY_ID
  66   end
  67
  68   describe 'normal operation' do
  69     describe 'default options' do
  70       it 'contains the apt_key' do
  71         expect(subject).to contain_apt_key(title).with(default_apt_key_example(title))
  72       end
  73
  74       it 'contains the apt_key present anchor' do
  75         expect(subject).to contain_anchor("apt_key #{title} present")
  76       end
  77     end
  78
  79     describe 'title and key =>' do
  80       let :title do
  81         'puppetlabs'
  82       end
  83
  84       let :params do
  85         {
  86           id: GPG_KEY_ID
  87         }
  88       end
  89
  90       it 'contains the apt_key' do
  91         expect(subject).to contain_apt_key(title).with(title_key_example)
  92       end
  93
  94       it 'contains the apt_key present anchor' do
  95         expect(subject).to contain_anchor("apt_key #{GPG_KEY_ID} present")
  96       end
  97     end
  98
  99     describe 'ensure => absent' do
 100       let :params do
 101         {
 102           ensure: 'absent'
 103         }
 104       end
 105
 106       it 'contains the apt_key' do
 107         expect(subject).to contain_apt_key(title).with(absent_apt_key(title))
 108       end
 109
 110       it 'contains the apt_key absent anchor' do
 111         expect(subject).to contain_anchor("apt_key #{title} absent")
 112       end
 113     end
 114
 115     describe 'ensure => refreshed' do
 116       let :params do
 117         {
 118           ensure: 'refreshed'
 119         }
 120       end
 121
 122       it 'contains the apt_key with refresh => true' do
 123         expect(subject).to contain_apt_key(title).with(
 124           ensure: 'present',
 125           refresh: true,
 126         )
 127       end
 128     end
 129
 130     describe 'set a bunch of things!' do
 131       let :params do
 132         {
 133           content: 'GPG key content',
 134           source: 'http://apt.puppetlabs.com/pubkey.gpg',
 135           server: 'pgp.mit.edu',
 136           options: 'debug'
 137         }
 138       end
 139
 140       it 'contains the apt_key' do
 141         expect(subject).to contain_apt_key(title).with(bunch_things_apt_key_example(title, params))
 142       end
 143
 144       it 'contains the apt_key present anchor' do
 145         expect(subject).to contain_anchor("apt_key #{title} present")
 146       end
 147     end
 148
 149     context 'when domain with dash' do
 150       let(:params) do
 151         {
 152           server: 'p-gp.m-it.edu'
 153         }
 154       end
 155
 156       it 'contains the apt_key' do
 157         expect(subject).to contain_apt_key(title).with(id: title,
 158                                                        server: 'p-gp.m-it.edu')
 159       end
 160     end
 161
 162     context 'with url' do
 163       let :params do
 164         {
 165           server: 'hkp://pgp.mit.edu'
 166         }
 167       end
 168
 169       it 'contains the apt_key' do
 170         expect(subject).to contain_apt_key(title).with(id: title,
 171                                                        server: 'hkp://pgp.mit.edu')
 172       end
 173     end
 174
 175     context 'when url with port number' do
 176       let :params do
 177         {
 178           server: 'hkp://pgp.mit.edu:80'
 179         }
 180       end
 181
 182       it 'contains the apt_key' do
 183         expect(subject).to contain_apt_key(title).with(id: title,
 184                                                        server: 'hkp://pgp.mit.edu:80')
 185       end
 186     end
 187   end
 188
 189   describe 'validation' do
 190     context 'when domain begin with dash' do
 191       let(:params) do
 192         {
 193           server: '-pgp.mit.edu'
 194         }
 195       end
 196
 197       it 'fails' do
 198         expect(subject).to raise_error(%r{expects a match})
 199       end
 200     end
 201
 202     context 'when domain begin with dot' do
 203       let(:params) do
 204         {
 205           server: '.pgp.mit.edu'
 206         }
 207       end
 208
 209       it 'fails' do
 210         expect(subject).to raise_error(%r{expects a match})
 211       end
 212     end
 213
 214     context 'when domain end with dot' do
 215       let(:params) do
 216         {
 217           server: 'pgp.mit.edu.'
 218         }
 219       end
 220
 221       it 'fails' do
 222         expect(subject).to raise_error(%r{expects a match})
 223       end
 224     end
 225
 226     context 'when character url exceeded' do
 227       let :params do
 228         {
 229           server: 'hkp://pgpiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii.mit.edu'
 230         }
 231       end
 232
 233       it 'fails' do
 234         expect(subject).to raise_error(%r{expects a match})
 235       end
 236     end
 237
 238     context 'with incorrect port number url' do
 239       let :params do
 240         {
 241           server: 'hkp://pgp.mit.edu:8008080'
 242         }
 243       end
 244
 245       it 'fails' do
 246         expect(subject).to raise_error(%r{expects a match})
 247       end
 248     end
 249
 250     context 'with incorrect protocol for url' do
 251       let :params do
 252         {
 253           server: 'abc://pgp.mit.edu:80'
 254         }
 255       end
 256
 257       it 'fails' do
 258         expect(subject).to raise_error(%r{expects a match})
 259       end
 260     end
 261
 262     context 'with missing port number url' do
 263       let :params do
 264         {
 265           server: 'hkp://pgp.mit.edu:'
 266         }
 267       end
 268
 269       it 'fails' do
 270         expect(subject).to raise_error(%r{expects a match})
 271       end
 272     end
 273
 274     context 'with url ending with a dot' do
 275       let :params do
 276         {
 277           server: 'hkp://pgp.mit.edu.'
 278         }
 279       end
 280
 281       it 'fails' do
 282         expect(subject).to raise_error(%r{expects a match})
 283       end
 284     end
 285
 286     context 'when url begins with a dash' do
 287       let(:params) do
 288         {
 289           server: 'hkp://-pgp.mit.edu'
 290         }
 291       end
 292
 293       it 'fails' do
 294         expect(subject).to raise_error(%r{expects a match})
 295       end
 296     end
 297
 298     context 'with invalid key' do
 299       let :title do
 300         'Out of rum. Why? Why are we out of rum?'
 301       end
 302
 303       it 'fails' do
 304         expect(subject).to raise_error(%r{expects a match})
 305       end
 306     end
 307
 308     context 'with invalid source' do
 309       let :params do
 310         {
 311           source: 'afp://puppetlabs.com/key.gpg'
 312         }
 313       end
 314
 315       it 'fails' do
 316         expect(subject).to raise_error(%r{evaluating a Resource})
 317       end
 318     end
 319
 320     context 'with invalid content' do
 321       let :params do
 322         {
 323           content: []
 324         }
 325       end
 326
 327       it 'fails' do
 328         expect(subject).to raise_error(%r{expects a})
 329       end
 330     end
 331
 332     context 'with invalid server' do
 333       let :params do
 334         {
 335           server: 'two bottles of rum'
 336         }
 337       end
 338
 339       it 'fails' do
 340         expect(subject).to raise_error(%r{expects a match})
 341       end
 342     end
 343
 344     context 'with invalid options' do
 345       let :params do
 346         {
 347           options: {}
 348         }
 349       end
 350
 351       it 'fails' do
 352         expect(subject).to raise_error(%r{expects a})
 353       end
 354     end
 355
 356     context 'with invalid ensure' do
 357       ['foo', 'aabsent', 'absenta', 'apresent', 'presenta', 'refresh', 'arefreshed', 'refresheda'].each do |param|
 358         let :params do
 359           {
 360             ensure: param
 361           }
 362         end
 363
 364         it 'fails' do
 365           expect(subject).to raise_error(%r{for Enum\['absent', 'present', 'refreshed'\], got})
 366         end
 367       end
 368     end
 369
 370     describe 'duplication - two apt::key resources for same key, different titles' do
 371       let :pre_condition do
 372         "class { 'apt': }
 373         apt::key { 'duplicate': id => '#{title}', }"
 374       end
 375
 376       it 'contains two apt::key resource - duplicate' do
 377         expect(subject).to contain_apt__key('duplicate').with(id: title,
 378                                                               ensure: 'present')
 379       end
 380
 381       it 'contains two apt::key resource - title' do
 382         expect(subject).to contain_apt__key(title).with(id: title,
 383                                                         ensure: 'present')
 384       end
 385
 386       it 'contains only a single apt_key - duplicate' do
 387         expect(subject).to contain_apt_key('duplicate').with(default_apt_key_example(title))
 388       end
 389
 390       it 'contains only a single apt_key - no title' do
 391         expect(subject).not_to contain_apt_key(title)
 392       end
 393     end
 394
 395     describe 'duplication - two apt::key resources, different ensure' do
 396       let :pre_condition do
 397         "class { 'apt': }
 398         apt::key { 'duplicate': id => '#{title}', ensure => 'absent', }"
 399       end
 400
 401       it 'informs the user of the impossibility' do
 402         expect(subject).to raise_error(%r{already ensured as absent})
 403       end
 404     end
 405   end
 406
 407   describe 'defaults' do
 408     context 'when setting keyserver on the apt class' do
 409       let :pre_condition do
 410         'class { "apt":
 411           keyserver => "keyserver.example.com",
 412         }'
 413       end
 414
 415       it 'uses default keyserver' do
 416         expect(subject).to contain_apt_key(title).with_server('keyserver.example.com')
 417       end
 418     end
 419
 420     context 'when setting key_options on the apt class' do
 421       let :pre_condition do
 422         'class { "apt":
 423           key_options => "http-proxy=http://proxy.example.com:8080",
 424         }'
 425       end
 426
 427       it 'uses default keyserver' do
 428         expect(subject).to contain_apt_key(title).with_options('http-proxy=http://proxy.example.com:8080')
 429       end
 430     end
 431   end
 432 end