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