spec/defines/key_compat_spec.rb

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