spec/defines/key_spec.rb

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