spec/defines/key_compat_spec.rb

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