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