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