spec/defines/key_compat_spec.rb

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