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