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