puppet 2.7.26 → 3.0.0.rc4

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

@@ -1,19 +0,0 @@
-# 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

@@ -1,30 +0,0 @@
-# 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

@@ -1,300 +0,0 @@
-# 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,50 +0,0 @@
-# Load the packaging repo libraries
-
-require File.join(File.dirname(__FILE__), 'lib', 'packaging.rb')
-
-# Load packaging repo tasks
-
-# These are ordered
-
-PACKAGING_ROOT = File.expand_path(File.dirname(__FILE__))
-PACKAGING_TASK_DIR = File.join(PACKAGING_ROOT, 'tasks')
-
-@using_loader = true
-
-[ '00_utils.rake',
-  '30_metrics.rake',
-  'apple.rake',
-  'build.rake',
-  'clean.rake',
-  'deb.rake',
-  'deb_repos.rake',
-  'doc.rake',
-  'fetch.rake',
-  'gem.rake',
-  'ips.rake',
-  'jenkins.rake',
-  'jenkins_dynamic.rake',
-  'load_extras.rake',
-  'mock.rake',
-  'pe_deb.rake',
-  'pe_remote.rake',
-  'pe_rpm.rake',
-  'pe_ship.rake',
-  'pe_sign.rake',
-  'pe_tar.rake',
-  'release.rake',
-  'remote_build.rake',
-  'retrieve.rake',
-  'rpm.rake',
-  'rpm_repos.rake',
-  'ship.rake',
-  'sign.rake',
-  'tag.rake',
-  'tar.rake',
-  'tickets.rake',
-  'update.rake',
-  'vendor_gems.rake',
-  'version.rake',
-  '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

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

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

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

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

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

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

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

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

@@ -1,330 +0,0 @@
-# -*- 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