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