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