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