puppet 2.7.25 → 2.7.26

data/ext/packaging/lib/packaging/util/serialization.rb

@@ -0,0 +1,19 @@
+# Utility methods for dealing with serialization of Config params
+
+module Pkg::Util::Serialization
+  class << self
+
+    # Given the path to a yaml file, load the yaml file into an object and return the object.
+    def load_yaml(file)
+      require 'yaml'
+      file = File.expand_path(file)
+      begin
+        input_data = YAML.load_file(file) || {}
+      rescue
+        fail "There was an error loading data from #{file}."
+      end
+      input_data
+    end
+  end
+end
+

data/ext/packaging/lib/packaging/util/tool.rb

@@ -0,0 +1,30 @@
+# Utility methods for handling system binaries
+
+module Pkg::Util::Tool
+
+  #   Set up utility methods for handling system binaries
+  #
+  class << self
+    def check_tool(tool)
+      find_tool(tool, :required => true)
+    end
+
+    def find_tool(tool, args={:required => false})
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |root|
+        location = File.join(root, tool)
+        return location if FileTest.executable? location
+      end
+      fail "#{tool} tool not found...exiting" if args[:required]
+      return nil
+    end
+
+    alias :has_tool :find_tool
+
+  end
+
+  #   Set up paths to system tools we use in the packaging repo
+  #   no matter what distribution we're packaging for.
+
+  GIT = Pkg::Util::Tool.find_tool('git', :required => :true)
+
+end

data/ext/packaging/lib/packaging/util/version.rb

@@ -0,0 +1,300 @@
+# Utility methods used for versioning projects for various kinds of packaging
+
+module Pkg::Util::Version
+  class << self
+
+    GIT = Pkg::Util::Tool::GIT
+
+    def git_co(ref)
+      Pkg::Util.in_project_root do
+        %x{#{GIT} reset --hard ; #{GIT} checkout #{ref}}
+        $?.success? or fail "Could not checkout #{ref} git branch to build package from...exiting"
+      end
+    end
+
+    def git_tagged?
+      Pkg::Util.in_project_root do
+        %x{#{GIT} describe >/dev/null 2>&1}
+        $?.success?
+      end
+    end
+
+    def git_describe
+      Pkg::Util.in_project_root do
+        %x{#{GIT} describe}.strip
+      end
+    end
+
+    # return the sha of HEAD on the current branch
+    def git_sha
+      Pkg::Util.in_project_root do
+        %x{#{GIT} rev-parse HEAD}.strip
+      end
+    end
+
+    # Return the ref type of HEAD on the current branch
+    def git_ref_type
+      Pkg::Util.in_project_root do
+        %x{#{GIT} cat-file -t #{git_describe}}.strip
+      end
+    end
+
+    # If HEAD is a tag, return the tag. Otherwise return the sha of HEAD.
+    def git_sha_or_tag
+      if git_ref_type == "tag"
+        git_describe
+      else
+        git_sha
+      end
+    end
+
+    # Return true if we're in a git repo, otherwise false
+    def is_git_repo?
+      Pkg::Util.in_project_root do
+        %x{#{GIT} rev-parse --git-dir > /dev/null 2>&1}
+        $?.success?
+      end
+    end
+
+    alias :is_git_repo :is_git_repo?
+
+    # Return the basename of the project repo
+    def git_project_name
+      Pkg::Util.in_project_root do
+        %x{#{GIT} config --get remote.origin.url}.split('/')[-1].chomp(".git").chomp
+      end
+    end
+
+    # Return information about the current tree, using `git describe`, ready for
+    # further processing.
+    #
+    # Returns an array of one to four elements, being:
+    # * version (three dot-joined numbers, leading `v` stripped)
+    # * the string 'rcX' (if the last tag was an rc release, where X is the rc number)
+    # * commits (string containing integer, number of commits since that version was tagged)
+    # * dirty (string 'dirty' if local changes exist in the repo)
+    def git_describe_version
+      return nil unless is_git_repo and raw = run_git_describe_internal
+      # reprocess that into a nice set of output data
+      # The elements we select potentially change if this is an rc
+      # For an rc with added commits our string will be something like '0.7.0-rc1-63-g51ccc51'
+      # and our return will be [0.7.0, rc1, 63, <dirty>]
+      # For a final with added commits, it will look like '0.7.0-63-g51ccc51'
+      # and our return will be [0.7.0, 64, <dirty>]
+      info = raw.chomp.sub(/^v/, '').split('-')
+      if git_ref_type == "tag"
+        version_string = info.compact
+      elsif info[1].to_s.match('^[\d]+')
+        version_string = info.values_at(0,1,3).compact
+      else
+        version_string = info.values_at(0,1,2,4).compact
+      end
+      version_string
+    end
+
+    # This is a stub to ease testing...
+    def run_git_describe_internal
+      Pkg::Util.in_project_root do
+        raw = %x{#{GIT} describe --tags --dirty 2>/dev/null}
+        $?.success? ? raw : nil
+      end
+    end
+
+    def get_dash_version
+      if info = git_describe_version
+        info.join('-')
+      else
+        get_pwd_version
+      end
+    end
+
+    def uname_r
+      uname = Pkg::Util::Tool.find_tool('uname', :required => true)
+      %x{#{uname} -r}.chomp
+    end
+
+    def get_ips_version
+      if info = git_describe_version
+        version, commits, dirty = info
+        if commits.to_s.match('^rc[\d]+')
+          commits = info[2]
+          dirty   = info[3]
+        end
+        osrelease = uname_r
+        "#{version},#{osrelease}-#{commits.to_i}#{dirty ? '-dirty' : ''}"
+      else
+        get_pwd_version
+      end
+    end
+
+    def get_dot_version
+      get_dash_version.gsub('-', '.')
+    end
+
+    def get_pwd_version
+      Dir.pwd.split('.')[-1]
+    end
+
+    def get_base_pkg_version
+      dash = get_dash_version
+      if dash.include?("rc")
+        # Grab the rc number
+        rc_num = dash.match(/rc(\d+)/)[1]
+        ver = dash.sub(/-?rc[0-9]+/, "-0.#{Pkg::Config.release}rc#{rc_num}").gsub(/(rc[0-9]+)-(\d+)?-?/, '\1.\2')
+      else
+        ver = dash.gsub('-','.') + "-#{Pkg::Config.release}"
+      end
+
+      ver.split('-')
+    end
+
+    def get_debversion
+      get_base_pkg_version.join('-') << "#{Pkg::Config.packager}1"
+    end
+
+    def get_origversion
+      Pkg::Config.debversion.split('-')[0]
+    end
+
+    def get_rpmversion
+      get_base_pkg_version[0]
+    end
+
+    def get_rpmrelease
+      get_base_pkg_version[1]
+    end
+
+    def source_dirty?
+      git_describe_version.include?('dirty')
+    end
+
+    def fail_on_dirty_source
+      if source_dirty?
+        fail "
+    The source tree is dirty, e.g. there are uncommited changes. Please
+    commit/discard changes and try again."
+      end
+    end
+
+    # Determines if this package is a final package via the
+    # selected version_strategy.
+    # There are currently two supported version strategies.
+    #
+    # This method calls down to the version strategy indicated, defaulting to the
+    # rc_final strategy. The methods themselves will return false if it is a final
+    # release, so their return values are collected and then inverted before being
+    # returned.
+    def is_final?
+      ret = nil
+      case Pkg::Config.version_strategy
+        when "rc_final"
+          ret = is_rc?
+        when "odd_even"
+          ret = is_odd?
+        when "zero_based"
+          ret = is_less_than_one?
+        when nil
+          ret = is_rc?
+      end
+      return (! ret)
+    end
+
+    # the rc_final strategy (default)
+    # Assumes version strings in the formats:
+    # final:
+    # '0.7.0'
+    # '0.7.0-63'
+    # '0.7.0-63-dirty'
+    # development:
+    # '0.7.0rc1 (we don't actually use this format anymore, but once did)
+    # '0.7.0-rc1'
+    # '0.7.0-rc1-63'
+    # '0.7.0-rc1-63-dirty'
+    def is_rc?
+      return TRUE if get_dash_version =~ /^\d+\.\d+\.\d+-*rc\d+/
+      return FALSE
+    end
+
+    # the odd_even strategy (mcollective)
+    # final:
+    # '0.8.0'
+    # '1.8.0-63'
+    # '0.8.1-63-dirty'
+    # development:
+    # '0.7.0'
+    # '1.7.0-63'
+    # '0.7.1-63-dirty'
+    def is_odd?
+      return TRUE if get_dash_version.match(/^\d+\.(\d+)\.\d+/)[1].to_i.odd?
+      return FALSE
+    end
+
+    # the pre-1.0 strategy (node classifier)
+    # final:
+    # '1.8.0'
+    # '1.8.0-63'
+    # '1.8.1-63-dirty'
+    # development:
+    # '0.7.0'
+    # '0.7.0-63'
+    # '0.7.1-63-dirty'
+    def is_less_than_one?
+      return TRUE if get_dash_version.match(/^(\d+)\.\d+\.\d+/)[1].to_i.zero?
+      return FALSE
+    end
+
+    # Utility method to return the dist method if this is a redhat box. We use this
+    # in rpm packaging to define a dist macro, and we use it in the pl:fetch task
+    # to disable ssl checking for redhat 5 because it has a certs bundle so old by
+    # default that it's useless for our purposes.
+    def el_version
+      if File.exists?('/etc/fedora-release')
+        nil
+      elsif File.exists?('/etc/redhat-release')
+        rpm = Pkg::Util::Tool.find_tool('rpm', :required => true)
+        return %x{#{rpm} -q --qf \"%{VERSION}\" $(#{rpm} -q --whatprovides /etc/redhat-release )}
+      end
+    end
+
+    # This is to support packages that only burn-in the version number in the
+    # release artifact, rather than storing it two (or more) times in the
+    # version control system.  Razor is a good example of that; see
+    # https://github.com/puppetlabs/Razor/blob/master/lib/project_razor/version.rb
+    # for an example of that this looks like.
+    #
+    # If you invoke this the version will only be modified in the temporary copy,
+    # with the intent that it never change the official source tree.
+    def versionbump(workdir=nil)
+      version = ENV['VERSION'] || Pkg::Config.version.to_s.strip
+      new_version = '"' + version + '"'
+
+      version_file = "#{workdir ? workdir + '/' : ''}#{Pkg::Config.version_file}"
+
+      # Read the previous version file in...
+      contents = IO.read(version_file)
+
+      # Match version files containing 'VERSION = "x.x.x"' and just x.x.x
+      if version_string = contents.match(/VERSION =.*/)
+        old_version = version_string.to_s.split()[-1]
+      else
+        old_version = contents
+      end
+
+      puts "Updating #{old_version} to #{new_version} in #{version_file}"
+      if contents.match("@DEVELOPMENT_VERSION@")
+        contents.gsub!("@DEVELOPMENT_VERSION@", version)
+      elsif contents.match('version\s*=\s*[\'"]DEVELOPMENT[\'"]')
+        contents.gsub!(/version\s*=\s*['"]DEVELOPMENT['"]/, "version = '#{version}'")
+      elsif contents.match("VERSION = #{old_version}")
+        contents.gsub!("VERSION = #{old_version}", "VERSION = #{new_version}")
+      elsif contents.match("#{Pkg::Config.project.upcase}VERSION = #{old_version}")
+        contents.gsub!("#{Pkg::Config.project.upcase}VERSION = #{old_version}", "#{Pkg::Config.project.upcase}VERSION = #{new_version}")
+      else
+        contents.gsub!(old_version, Pkg::Config.version)
+      end
+
+      # ...and write it back on out.
+      File.open(version_file, 'w') {|f| f.write contents }
+    end
+  end
+end

data/ext/packaging/packaging.rake

@@ -1,14 +1,17 @@
+# Load the packaging repo libraries
+
+require File.join(File.dirname(__FILE__), 'lib', 'packaging.rb')
+
 # Load packaging repo tasks
 
 # These are ordered
 
-PACKAGING_PATH = File.join(File.dirname(__FILE__), 'tasks')
+PACKAGING_ROOT = File.expand_path(File.dirname(__FILE__))
+PACKAGING_TASK_DIR = File.join(PACKAGING_ROOT, 'tasks')
 
 @using_loader = true
 
 [ '00_utils.rake',
-  '10_setupvars.rake',
-  '20_setupextravars.rake',
   '30_metrics.rake',
   'apple.rake',
   'build.rake',
@@ -21,6 +24,7 @@ PACKAGING_PATH = File.join(File.dirname(__FILE__), 'tasks')
   'ips.rake',
   'jenkins.rake',
   'jenkins_dynamic.rake',
+  'load_extras.rake',
   'mock.rake',
   'pe_deb.rake',
   'pe_remote.rake',
@@ -37,9 +41,10 @@ PACKAGING_PATH = File.join(File.dirname(__FILE__), 'tasks')
   'sign.rake',
   'tag.rake',
   'tar.rake',
-  'template.rake',
+  'tickets.rake',
   'update.rake',
   'vendor_gems.rake',
   'version.rake',
-  'z_data_dump.rake'].each { |t| load File.join(PACKAGING_PATH, t)}
+  'z_data_dump.rake'].each { |t| load File.join(PACKAGING_TASK_DIR, t)}
 
+Pkg::Util::RakeUtils.evaluate_pre_tasks

data/ext/packaging/spec/fixtures/config/ext/build_defaults.yaml

@@ -0,0 +1,2 @@
+---
+:apt_host: foo

data/ext/packaging/spec/fixtures/config/ext/project_data.yaml

@@ -0,0 +1,2 @@
+---
+:apt_host: foo

data/ext/packaging/spec/fixtures/config/params.yaml

@@ -0,0 +1,2 @@
+---
+:apt_host: foo

data/ext/packaging/spec/fixtures/util/pre_tasks.yaml

@@ -0,0 +1,4 @@
+---
+pre_tasks:
+  foo: 'bar'
+

data/ext/packaging/spec/lib/packaging/config_spec.rb

@@ -0,0 +1,330 @@
+# -*- ruby -*-
+require 'spec_helper'
+require 'yaml'
+
+describe "Pkg::Config" do
+
+  Build_Params = [:apt_host,
+                  :apt_repo_path,
+                  :apt_repo_url,
+                  :author,
+                  :benchmark,
+                  :build_date,
+                  :build_defaults,
+                  :build_dmg,
+                  :build_doc,
+                  :build_gem,
+                  :build_ips,
+                  :build_pe,
+                  :builder_data_file,
+                  :bundle_platforms,
+                  :certificate_pem,
+                  :cows,
+                  :db_table,
+                  :deb_build_host,
+                  :deb_build_mirrors,
+                  :debversion,
+                  :debug,
+                  :default_cow,
+                  :default_mock,
+                  :description,
+                  :dmg_path,
+                  :email,
+                  :files,
+                  :final_mocks,
+                  :freight_conf,
+                  :gem_default_executables,
+                  :gem_dependencies,
+                  :gem_description,
+                  :gem_devel_dependencies,
+                  :gem_development_dependencies,
+                  :gem_excludes,
+                  :gem_executables,
+                  :gem_files,
+                  :gem_forge_project,
+                  :gem_name,
+                  :gem_platform_dependencies,
+                  :gem_rdoc_options,
+                  :gem_require_path,
+                  :gem_runtime_dependencies,
+                  :gem_summary,
+                  :gem_test_files,
+                  :gemversion,
+                  :gpg_key,
+                  :gpg_name,
+                  :homepage,
+                  :ips_build_host,
+                  :ips_host,
+                  :ips_inter_cert,
+                  :ips_package_host,
+                  :ips_path,
+                  :ips_repo,
+                  :ips_store,
+                  :ipsversion,
+                  :jenkins_build_host,
+                  :jenkins_packaging_job,
+                  :jenkins_repo_path,
+                  :metrics,
+                  :metrics_url,
+                  :name,
+                  :notify,
+                  :project,
+                  :origversion,
+                  :osx_build_host,
+                  :packager,
+                  :packaging_repo,
+                  :packaging_root,
+                  :packaging_url,
+                  :pbuild_conf,
+                  :pe_name,
+                  :pe_version,
+                  :pg_major_version,
+                  :pre_tar_task,
+                  :pre_tasks,
+                  :privatekey_pem,
+                  :random_mockroot,
+                  :rc_mocks,
+                  :release,
+                  :rpm_build_host,
+                  :rpmrelease,
+                  :rpmversion,
+                  :ref,
+                  :sign_tar,
+                  :summary,
+                  :tar_excludes,
+                  :tar_host,
+                  :tarball_path,
+                  :team,
+                  :templates,
+                  :update_version_file,
+                  :version,
+                  :version_file,
+                  :version_strategy,
+                  :yum_host,
+                  :yum_repo_path]
+
+  describe "#new" do
+    Build_Params.each do |param|
+      it "should have r/w accessors for #{param}" do
+        Pkg::Config.should respond_to(param)
+        Pkg::Config.should respond_to("#{param.to_s}=")
+      end
+    end
+  end
+
+  describe "#config_from_hash" do
+    good_params = { :yum_host => 'foo', :pe_name => 'bar' }
+    context "given a valid params hash #{good_params}" do
+      it "should set instance variable values for each param" do
+        good_params.each do |param, value|
+          Pkg::Config.should_receive(:instance_variable_set).with("@#{param}", value)
+        end
+        Pkg::Config.config_from_hash(good_params)
+      end
+    end
+
+    bad_params = { :foo => 'bar' }
+    context "given an invalid params hash #{bad_params}" do
+      bad_params.each do |param, value|
+        it "should print a warning that param '#{param}' is not valid" do
+          Pkg::Config.should_receive(:warn).with(/No build data parameter found for '#{param}'/)
+          Pkg::Config.config_from_hash(bad_params)
+        end
+
+        it "should not try to set instance variable @:#{param}" do
+          Pkg::Config.should_not_receive(:instance_variable_set).with("@#{param}", value)
+          Pkg::Config.config_from_hash(bad_params)
+        end
+      end
+    end
+
+    mixed_params = { :sign_tar => TRUE, :baz => 'qux' }
+    context "given a hash with both valid and invalid params" do
+      it "should set the valid param" do
+        Pkg::Config.should_receive(:instance_variable_set).with("@sign_tar", TRUE)
+        Pkg::Config.config_from_hash(mixed_params)
+      end
+
+      it "should issue a warning that the invalid param is not valid" do
+        Pkg::Config.should_receive(:warn).with(/No build data parameter found for 'baz'/)
+        Pkg::Config.config_from_hash(mixed_params)
+      end
+
+      it "should not try to set instance variable @:baz" do
+        Pkg::Config.should_not_receive(:instance_variable_set).with("@baz", "qux")
+        Pkg::Config.config_from_hash(mixed_params)
+      end
+    end
+  end
+
+  describe "#params" do
+    it "should return a hash containing keys for all build parameters" do
+      params = Pkg::Config.config
+      Build_Params.each { |param| params.has_key?(param).should == TRUE }
+    end
+  end
+
+  describe "#config_to_yaml" do
+    it "should write a valid yaml file" do
+      file = double('file')
+      File.should_receive(:open).with(anything(), 'w').and_yield(file)
+      file.should_receive(:puts).with(instance_of(String))
+      YAML.should_receive(:load_file).with(file)
+      expect { YAML.load_file(file) }.to_not raise_error
+      Pkg::Config.config_to_yaml
+    end
+  end
+
+  describe "#get_binding" do
+    it "should return the binding of the Pkg::Config object" do
+      # test by eval'ing using the binding before and after setting a param
+      orig = Pkg::Config.apt_host
+      Pkg::Config.apt_host = "foo"
+      expect(eval("@apt_host", Pkg::Config.get_binding)).to eq("foo")
+      Pkg::Config.apt_host = "bar"
+      expect(eval("@apt_host", Pkg::Config.get_binding)).to eq("bar")
+      Pkg::Config.apt_host = orig
+    end
+  end
+
+  describe "#config_from_yaml" do
+    context "given a yaml file" do
+      it "should, use it to set params" do
+        # apt_host: is set to "foo" in the fixture
+        orig = Pkg::Config.apt_host
+        Pkg::Config.apt_host = "bar"
+        Pkg::Config.config_from_yaml(File.join(FIXTURES, 'config', 'params.yaml'))
+        expect(Pkg::Config.apt_host).to eq("foo")
+        Pkg::Config.apt_host = orig
+      end
+    end
+  end
+
+  describe "#cow_list" do
+    it "should return a list of the cows for a project" do
+      Pkg::Config.cows = "base-lucid-i386.cow base-lucid-amd64.cow base-precise-i386.cow base-precise-amd64.cow base-quantal-i386.cow base-quantal-amd64.cow base-saucy-i386.cow base-saucy-amd64.cow base-sid-i386.cow base-sid-amd64.cow base-squeeze-i386.cow base-squeeze-amd64.cow base-stable-i386.cow base-stable-amd64.cow base-testing-i386.cow base-testing-amd64.cow base-trusty-i386.cow base-trusty-amd64.cow base-unstable-i386.cow base-unstable-amd64.cow base-wheezy-i386.cow base-wheezy-amd64.cow"
+      Pkg::Config.cow_list.should eq "lucid precise quantal saucy sid squeeze stable testing trusty unstable wheezy"
+    end
+  end
+
+  describe "#config" do
+    context "given :format => :hash" do
+      it "should call Pkg::Config.config_to_hash" do
+        expect(Pkg::Config).to receive(:config_to_hash)
+        Pkg::Config.config(:target => nil, :format => :hash)
+      end
+    end
+
+    context "given :format => :yaml" do
+      it "should call Pkg::Config.config_to_yaml if given :format => :yaml" do
+        expect(Pkg::Config).to receive(:config_to_yaml)
+        Pkg::Config.config(:target => nil, :format => :yaml)
+      end
+    end
+  end
+
+  describe "#issue_reassignments" do
+    before :all do
+      prev_tar_host = Pkg::Config.tar_host
+      Pkg::Config.tar_host = nil
+    end
+
+    it "should set tar_host to yum_host" do
+      Pkg::Config.config_from_hash({ :yum_host => 'foo' })
+      Pkg::Config.issue_reassignments
+      Pkg::Config.tar_host.should eq("foo")
+    end
+
+    after :all do
+      Pkg::Config.tar_host = prev_tar_host
+    end
+  end
+
+  describe "#config_to_hash" do
+    it "should return a hash object" do
+      hash = Pkg::Config.config_to_hash
+      hash.should be_a(Hash)
+    end
+
+    it "should return a hash with the current parameters" do
+      Pkg::Config.apt_host = "foo"
+      Pkg::Config.config_to_hash[:apt_host].should eq("foo")
+      Pkg::Config.apt_host = "bar"
+      Pkg::Config.config_to_hash[:apt_host].should eq("bar")
+    end
+  end
+
+  describe "#load_default_configs" do
+    context "given ext/build_defaults.yaml and ext/project_data.yaml are readable" do
+      it "should try to load build_defaults.yaml and project_data.yaml" do
+        orig = Pkg::Config.project_root
+        Pkg::Config.project_root = File.join(FIXTURES, 'config')
+        test_project_data = File.join(FIXTURES, 'config', 'ext', 'project_data.yaml')
+        test_build_defaults = File.join(FIXTURES, 'config', 'ext', 'build_defaults.yaml')
+        expect(Pkg::Config).to receive(:config_from_yaml).with(test_project_data)
+        expect(Pkg::Config).to receive(:config_from_yaml).with(test_build_defaults)
+        Pkg::Config.load_default_configs
+        Pkg::Config.project_root = orig
+      end
+    end
+
+    context "given ext/build_defaults.yaml and ext/project_data.yaml are not readable" do
+      it "should not try to load build_defaults.yaml and project_data.yaml" do
+        orig = Pkg::Config.project_root
+        Pkg::Config.project_root = 'foo'
+        expect(Pkg::Config).to_not receive(:config_from_yaml)
+        Pkg::Config.load_default_configs
+        Pkg::Config.project_root = orig
+      end
+
+      it "should set the project root to nil" do
+        orig = Pkg::Config.project_root
+        Pkg::Config.project_root = 'foo'
+        Pkg::Config.load_default_configs
+        expect(Pkg::Config.project_root).to be(nil)
+        Pkg::Config.project_root = orig
+      end
+    end
+  end
+
+  describe "#load_versioning" do
+      # We let the actual version determination testing happen in the version
+      # tests. Here we just test that we try when we should.
+    context "When project root is nil" do
+      it "should not try to load versioning" do
+        Pkg::Config.stub(:project_root) {nil}
+        expect(Pkg::Config).to_not receive(:git_sha_or_tag)
+      end
+    end
+  end
+
+  describe "#load_envvars" do
+    # We're going to pollute the environment with this test, so afterwards we
+    # explicitly set everything to nil to prevent any hazardous effects on
+    # the rest of the tests.
+    after(:all) do
+      reset_env(Pkg::Params::ENV_VARS.map {|hash| hash[:envvar].to_s})
+    end
+
+    Pkg::Params::ENV_VARS.each do |v|
+      if v[:type] == :bool
+        it "should set boolean value on #{v[:var]} for :type == :bool" do
+          ENV[v[:envvar].to_s] = "FOO"
+          Pkg::Util.stub(:boolean_value) {"FOO"}
+          allow(Pkg::Config).to receive(:instance_variable_set)
+          expect(Pkg::Util).to receive(:boolean_value).with("FOO")
+          expect(Pkg::Config).to receive(:instance_variable_set).with("@#{v[:var]}", "FOO")
+          Pkg::Config.load_envvars
+        end
+      else
+        it "should set Pkg::Config##{v[:var]} to ENV[#{v[:envvar].to_s}]" do
+          ENV[v[:envvar].to_s] = "FOO"
+          Pkg::Util.stub(:boolean_value) {"FOO"}
+          allow(Pkg::Config).to receive(:instance_variable_set)
+          expect(Pkg::Config).to receive(:instance_variable_set).with("@#{v[:var]}", "FOO")
+          Pkg::Config.load_envvars
+        end
+      end
+    end
+  end
+end