spec/defines/key_compat_spec.rb

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