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