X-Git-Url: https://review.fuel-infra.org/gitweb?a=blobdiff_plain;f=spec%2Fdefines%2Fkey_spec.rb;h=59695006c21f1790f6c9eed3ff1c94d0f763cbd9;hb=refs%2Fheads%2Frelease-prep;hp=4ba7b87eae6c777896d5de3c7a67948403060d66;hpb=9eaa3a43aa2568838106d1f139929c8e39d9943f;p=puppet-modules%2Fpuppetlabs-apt.git

diff --git a/spec/defines/key_spec.rb b/spec/defines/key_spec.rb
index 4ba7b87..5969500 100644
--- a/spec/defines/key_spec.rb
+++ b/spec/defines/key_spec.rb
@@ -1,124 +1,432 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
-describe 'apt::key', :type => :define do
-  let(:facts) { { :lsbdistid => 'Debian' } }
-  let :title do
-    '8347A27F'
+
+GPG_KEY_ID = '6F6B15509CF8E59E6E469F327F438280EF8D349F'
+
+title_key_example = { id: GPG_KEY_ID,
+                      ensure: 'present',
+                      source: nil,
+                      server: 'keyserver.ubuntu.com',
+                      content: nil,
+                      options: nil }
+
+def default_apt_key_example(title)
+  { id: title,
+    ensure: 'present',
+    source: nil,
+    server: 'keyserver.ubuntu.com',
+    content: nil,
+    options: nil,
+    refresh: false }
+end
+
+def bunch_things_apt_key_example(title, params)
+  { id: title,
+    ensure: 'present',
+    source: 'http://apt.puppetlabs.com/pubkey.gpg',
+    server: 'pgp.mit.edu',
+    content: params[:content],
+    options: 'debug' }
+end
+
+def absent_apt_key(title)
+  { id: title,
+    ensure: 'absent',
+    source: nil,
+    server: 'keyserver.ubuntu.com',
+    content: nil,
+    keyserver: nil }
+end
+
+describe 'apt::key' do
+  let :pre_condition do
+    'class { "apt": }'
   end
 
-  let :default_params do
+  let(:facts) do
     {
-      :key         => title,
-      :ensure      => 'present',
-      :key_server  => "keyserver.ubuntu.com",
-      :key_source  => false,
-      :key_content => false
+      os: {
+        family: 'Debian',
+        name: 'Debian',
+        release: {
+          major: '9',
+          full: '9.0'
+        },
+        distro: {
+          codename: 'stretch',
+          id: 'Debian'
+        }
+      }
     }
   end
 
-  [{},
-    {
-      :ensure  => 'absent'
-    },
-    {
-      :ensure  => 'random'
-    },
-    {
-      :key_source => 'ftp://ftp.example.org/key',
-    },
-    {
-      :key_content => 'deadbeef',
-    }
-  ].each do |param_set|
+  let :title do
+    GPG_KEY_ID
+  end
+
+  describe 'normal operation' do
+    describe 'default options' do
+      it 'contains the apt_key' do
+        expect(subject).to contain_apt_key(title).with(default_apt_key_example(title))
+      end
 
-    let :param_hash do
-      param_hash = default_params.merge(param_set)
-      param_hash[:key].upcase! if param_hash[:key]
-      param_hash
+      it 'contains the apt_key present anchor' do
+        expect(subject).to contain_anchor("apt_key #{title} present")
+      end
     end
 
-    let :params do
-      param_set
+    describe 'title and key =>' do
+      let :title do
+        'puppetlabs'
+      end
+
+      let :params do
+        {
+          id: GPG_KEY_ID
+        }
+      end
+
+      it 'contains the apt_key' do
+        expect(subject).to contain_apt_key(title).with(title_key_example)
+      end
+
+      it 'contains the apt_key present anchor' do
+        expect(subject).to contain_anchor("apt_key #{GPG_KEY_ID} present")
+      end
     end
 
-    let :digest do
-      str = String.new
-      str << param_hash[:key].to_s         << '/'
-      str << param_hash[:key_content].to_s << '/'
-      str << param_hash[:key_source].to_s  << '/'
-      str << param_hash[:key_server].to_s  << '/'
-      Digest::SHA1.hexdigest(str)
+    describe 'ensure => absent' do
+      let :params do
+        {
+          ensure: 'absent'
+        }
+      end
+
+      it 'contains the apt_key' do
+        expect(subject).to contain_apt_key(title).with(absent_apt_key(title))
+      end
+
+      it 'contains the apt_key absent anchor' do
+        expect(subject).to contain_anchor("apt_key #{title} absent")
+      end
     end
 
-    describe "when #{param_set == {} ? "using default" : "specifying"} define parameters" do
+    describe 'ensure => refreshed' do
+      let :params do
+        {
+          ensure: 'refreshed'
+        }
+      end
 
-      it {
-        if [:present, 'present', :absent, 'absent'].include? param_hash[:ensure]
-          should contain_apt__params
-        end
-      }
+      it 'contains the apt_key with refresh => true' do
+        expect(subject).to contain_apt_key(title).with(
+          ensure: 'present',
+          refresh: true,
+        )
+      end
+    end
 
-      it {
-        if [:present, 'present'].include? param_hash[:ensure]
-          should_not contain_exec("apt::key #{param_hash[:key]} absent")
-          should contain_anchor("apt::key #{param_hash[:key]} present")
-          should contain_exec(digest).with({
-            "path"    => "/bin:/usr/bin",
-            "unless"  => "/usr/bin/apt-key list | /bin/grep '#{param_hash[:key]}'"
-          })
-        elsif [:absent, 'absent'].include? param_hash[:ensure]
-          should_not contain_anchor("apt::key #{param_hash[:key]} present")
-          should contain_exec("apt::key #{param_hash[:key]} absent").with({
-            "path"    => "/bin:/usr/bin",
-            "onlyif"  => "apt-key list | grep '#{param_hash[:key]}'",
-            "command" => "apt-key del '#{param_hash[:key]}'"
-          })
-        else
-          expect { should raise_error(Puppet::Error) }
-        end
-      }
+    describe 'set a bunch of things!' do
+      let :params do
+        {
+          content: 'GPG key content',
+          source: 'http://apt.puppetlabs.com/pubkey.gpg',
+          server: 'pgp.mit.edu',
+          options: 'debug'
+        }
+      end
 
-      it {
-        if [:present, 'present'].include? param_hash[:ensure]
-          if param_hash[:key_content]
-            should contain_exec(digest).with({
-              "command" => "echo '#{param_hash[:key_content]}' | /usr/bin/apt-key add -"
-            })
-          elsif param_hash[:key_source]
-            should contain_exec(digest).with({
-              "command" => "wget -q '#{param_hash[:key_source]}' -O- | apt-key add -"
-            })
-          elsif param_hash[:key_server]
-            should contain_exec(digest).with({
-              "command" => "apt-key adv --keyserver '#{param_hash[:key_server]}' --recv-keys '#{param_hash[:key]}'"
-            })
-          end
-        end
-      }
+      it 'contains the apt_key' do
+        expect(subject).to contain_apt_key(title).with(bunch_things_apt_key_example(title, params))
+      end
+
+      it 'contains the apt_key present anchor' do
+        expect(subject).to contain_anchor("apt_key #{title} present")
+      end
+    end
+
+    context 'when domain with dash' do
+      let(:params) do
+        {
+          server: 'p-gp.m-it.edu'
+        }
+      end
+
+      it 'contains the apt_key' do
+        expect(subject).to contain_apt_key(title).with(id: title,
+                                                       server: 'p-gp.m-it.edu')
+      end
+    end
+
+    context 'with url' do
+      let :params do
+        {
+          server: 'hkp://pgp.mit.edu'
+        }
+      end
+
+      it 'contains the apt_key' do
+        expect(subject).to contain_apt_key(title).with(id: title,
+                                                       server: 'hkp://pgp.mit.edu')
+      end
+    end
 
+    context 'when url with port number' do
+      let :params do
+        {
+          server: 'hkp://pgp.mit.edu:80'
+        }
+      end
+
+      it 'contains the apt_key' do
+        expect(subject).to contain_apt_key(title).with(id: title,
+                                                       server: 'hkp://pgp.mit.edu:80')
+      end
     end
   end
 
-  [{ :ensure => 'present' }, { :ensure => 'absent' }].each do |param_set|
-    describe "should correctly handle duplicate definitions" do
+  describe 'validation' do
+    context 'when domain begin with dash' do
+      let(:params) do
+        {
+          server: '-pgp.mit.edu'
+        }
+      end
 
-      let :pre_condition do
-        "apt::key { 'duplicate': key => '#{title}'; }"
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a match})
+      end
+    end
+
+    context 'when domain begin with dot' do
+      let(:params) do
+        {
+          server: '.pgp.mit.edu'
+        }
+      end
+
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a match})
+      end
+    end
+
+    context 'when domain end with dot' do
+      let(:params) do
+        {
+          server: 'pgp.mit.edu.'
+        }
+      end
+
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a match})
+      end
+    end
+
+    context 'when character url exceeded' do
+      let :params do
+        {
+          server: 'hkp://pgpiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii.mit.edu'
+        }
+      end
+
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a match})
+      end
+    end
+
+    context 'with incorrect port number url' do
+      let :params do
+        {
+          server: 'hkp://pgp.mit.edu:8008080'
+        }
       end
 
-      let(:params) { param_set }
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a match})
+      end
+    end
+
+    context 'with incorrect protocol for url' do
+      let :params do
+        {
+          server: 'abc://pgp.mit.edu:80'
+        }
+      end
 
-      it {
-        if param_set[:ensure] == 'present'
-          should contain_anchor("apt::key #{title} present")
-          should contain_apt__key(title)
-          should contain_apt__key("duplicate")
-        elsif param_set[:ensure] == 'absent'
-          expect { should raise_error(Puppet::Error) }
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a match})
+      end
+    end
+
+    context 'with missing port number url' do
+      let :params do
+        {
+          server: 'hkp://pgp.mit.edu:'
+        }
+      end
+
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a match})
+      end
+    end
+
+    context 'with url ending with a dot' do
+      let :params do
+        {
+          server: 'hkp://pgp.mit.edu.'
+        }
+      end
+
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a match})
+      end
+    end
+
+    context 'when url begins with a dash' do
+      let(:params) do
+        {
+          server: 'hkp://-pgp.mit.edu'
+        }
+      end
+
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a match})
+      end
+    end
+
+    context 'with invalid key' do
+      let :title do
+        'Out of rum. Why? Why are we out of rum?'
+      end
+
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a match})
+      end
+    end
+
+    context 'with invalid source' do
+      let :params do
+        {
+          source: 'afp://puppetlabs.com/key.gpg'
+        }
+      end
+
+      it 'fails' do
+        expect(subject).to raise_error(%r{evaluating a Resource})
+      end
+    end
+
+    context 'with invalid content' do
+      let :params do
+        {
+          content: []
+        }
+      end
+
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a})
+      end
+    end
+
+    context 'with invalid server' do
+      let :params do
+        {
+          server: 'two bottles of rum'
+        }
+      end
+
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a match})
+      end
+    end
+
+    context 'with invalid options' do
+      let :params do
+        {
+          options: {}
+        }
+      end
+
+      it 'fails' do
+        expect(subject).to raise_error(%r{expects a})
+      end
+    end
+
+    context 'with invalid ensure' do
+      ['foo', 'aabsent', 'absenta', 'apresent', 'presenta', 'refresh', 'arefreshed', 'refresheda'].each do |param|
+        let :params do
+          {
+            ensure: param
+          }
         end
-      }
 
+        it 'fails' do
+          expect(subject).to raise_error(%r{for Enum\['absent', 'present', 'refreshed'\], got})
+        end
+      end
+    end
+
+    describe 'duplication - two apt::key resources for same key, different titles' do
+      let :pre_condition do
+        "class { 'apt': }
+        apt::key { 'duplicate': id => '#{title}', }"
+      end
+
+      it 'contains two apt::key resource - duplicate' do
+        expect(subject).to contain_apt__key('duplicate').with(id: title,
+                                                              ensure: 'present')
+      end
+
+      it 'contains two apt::key resource - title' do
+        expect(subject).to contain_apt__key(title).with(id: title,
+                                                        ensure: 'present')
+      end
+
+      it 'contains only a single apt_key - duplicate' do
+        expect(subject).to contain_apt_key('duplicate').with(default_apt_key_example(title))
+      end
+
+      it 'contains only a single apt_key - no title' do
+        expect(subject).not_to contain_apt_key(title)
+      end
+    end
+
+    describe 'duplication - two apt::key resources, different ensure' do
+      let :pre_condition do
+        "class { 'apt': }
+        apt::key { 'duplicate': id => '#{title}', ensure => 'absent', }"
+      end
+
+      it 'informs the user of the impossibility' do
+        expect(subject).to raise_error(%r{already ensured as absent})
+      end
     end
   end
 
-end
+  describe 'defaults' do
+    context 'when setting keyserver on the apt class' do
+      let :pre_condition do
+        'class { "apt":
+          keyserver => "keyserver.example.com",
+        }'
+      end
 
+      it 'uses default keyserver' do
+        expect(subject).to contain_apt_key(title).with_server('keyserver.example.com')
+      end
+    end
+
+    context 'when setting key_options on the apt class' do
+      let :pre_condition do
+        'class { "apt":
+          key_options => "http-proxy=http://proxy.example.com:8080",
+        }'
+      end
+
+      it 'uses default keyserver' do
+        expect(subject).to contain_apt_key(title).with_options('http-proxy=http://proxy.example.com:8080')
+      end
+    end
+  end
+end