spec/defines/key_spec.rb

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