spec/defines/key_compat_spec.rb

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