license-acceptance 0.2.10 → 2.1.13

data/lib/license_acceptance/file_acceptance.rb

@@ -1,97 +0,0 @@
-require 'date'
-require 'yaml'
-require 'fileutils'
-require 'etc'
-require "license_acceptance/logger"
-
-module LicenseAcceptance
-  class FileAcceptance
-    include Logger
-
-    attr_reader :config
-
-    def initialize(config)
-      @config = config
-    end
-
-    INVOCATION_TIME = DateTime.now.freeze
-
-    # For all the given products in the product set, search all possible locations for the
-    # license acceptance files.
-    def accepted?(product_relationship)
-      searching = [product_relationship.parent] + product_relationship.children
-      missing_licenses = searching.clone
-      logger.debug("Searching for the following licenses: #{missing_licenses.map(&:name)}")
-
-      searching.each do |product|
-        found = false
-        config.license_locations.each do |loc|
-          f = File.join(loc, product.filename)
-          if File.exist?(f)
-            found = true
-            logger.debug("Found license #{product.filename} at #{f}")
-            missing_licenses.delete(product)
-            break
-          end
-        end
-        break if missing_licenses.empty?
-      end
-      logger.debug("Missing licenses remaining: #{missing_licenses.map(&:name)}")
-      missing_licenses
-    end
-
-    def persist(product_relationship, missing_licenses)
-      parent = product_relationship.parent
-      parent_version = product_relationship.parent_version
-      root_dir = config.persist_location
-
-      if !Dir.exist?(root_dir)
-        begin
-          FileUtils.mkdir_p(root_dir)
-        rescue StandardError => e
-          msg = "Could not create license directory #{root_dir}"
-          logger.info "#{msg}\n\t#{e.message}\n\t#{e.backtrace.join("\n\t")}"
-          return [e]
-        end
-      end
-
-      errs = []
-      if missing_licenses.include?(parent)
-        err = persist_license(root_dir, parent, parent, parent_version)
-        errs << err unless err.nil?
-      end
-      product_relationship.children.each do |child|
-        if missing_licenses.include?(child)
-          err = persist_license(root_dir, child, parent, parent_version)
-          errs << err unless err.nil?
-        end
-      end
-      return errs
-    end
-
-    private
-
-    def persist_license(folder_path, product, parent, parent_version)
-      path = File.join(folder_path, product.filename)
-      logger.info("Persisting a license for #{product.name} at path #{path}")
-      File.open(path, File::WRONLY | File::CREAT | File::EXCL) do |license_file|
-        contents = {
-          name: product.name,
-          date_accepted: INVOCATION_TIME.iso8601,
-          accepting_product: parent.name,
-          accepting_product_version: parent_version,
-          user: Etc.getlogin,
-          file_format: 1,
-        }
-        contents = Hash[contents.map { |k, v| [k.to_s, v] }]
-        license_file << YAML.dump(contents)
-      end
-      return nil
-    rescue StandardError => e
-      msg = "Could not persist license to #{path}"
-      logger.info "#{msg}\n\t#{e.message}\n\t#{e.backtrace.join("\n\t")}"
-      return e
-    end
-
-  end
-end

data/lib/license_acceptance/prompt_acceptance.rb

@@ -1,106 +0,0 @@
-require 'tty-prompt'
-require 'pastel'
-require "license_acceptance/logger"
-require "timeout"
-
-module LicenseAcceptance
-  class PromptAcceptance
-    include Logger
-
-    attr_reader :output
-
-    def initialize(config)
-      @output = config.output
-    end
-
-    WIDTH = 50.freeze
-    PASTEL = Pastel.new
-    BORDER = "+---------------------------------------------+".freeze
-    YES = PASTEL.green.bold("yes")
-    CHECK  = PASTEL.green("✔")
-
-    def request(missing_licenses, &persist_callback)
-      logger.debug("Requesting a license for #{missing_licenses.map(&:name)}")
-      c = missing_licenses.size
-      s = c > 1 ? "s": ""
-
-      acceptance_question = "Do you accept the #{c} product license#{s} (#{YES}/no)?"
-      output.puts <<~EOM
-      #{BORDER}
-                  Chef License Acceptance
-
-      Before you can continue, #{c} product license#{s}
-      must be accepted. View the license at
-      https://www.chef.io/end-user-license-agreement/
-
-      License#{s} that need accepting:
-        * #{missing_licenses.map(&:pretty_name).join("\n  * ")}
-
-      #{acceptance_question}
-
-      EOM
-
-      if ask(output, c, s, persist_callback)
-        output.puts BORDER
-        return true
-      end
-
-      output.puts <<~EOM
-
-      If you do not accept this license you will
-      not be able to use Chef products.
-
-      #{acceptance_question}
-
-      EOM
-
-      answer = ask(output, c, s, persist_callback)
-      if answer != "yes"
-        output.puts BORDER
-      end
-      return answer
-    end
-
-    private
-
-    def ask(output, c, s, persist_callback)
-      logger.debug("Attempting to request interactive prompt on TTY")
-      prompt = TTY::Prompt.new(track_history: false, active_color: :bold, interrupt: :exit, output: output)
-
-      answer = "no"
-      begin
-        Timeout::timeout(60, PromptTimeout) do
-          answer = prompt.ask(">") do |q|
-            q.modify :down, :trim
-            q.required true
-            q.messages[:required?] = "You must enter 'yes' or 'no'"
-            q.validate /^\s*(yes|no)\s*$/i
-            q.messages[:valid?] = "You must enter 'yes' or 'no'"
-          end
-        end
-      rescue PromptTimeout
-        prompt.unsubscribe(prompt.reader)
-        output.puts "Prompt timed out. Use non-interactive flags or enter an answer within 60 seconds."
-      end
-
-      if answer == "yes"
-        output.puts
-        output.puts "Persisting #{c} product license#{s}..."
-        errs = persist_callback.call
-        if errs.empty?
-          output.puts "#{CHECK} #{c} product license#{s} persisted.\n\n"
-        else
-          output.puts <<~EOM
-          #{CHECK} #{c} product license#{s} accepted.
-          Could not persist acceptance:\n\t* #{errs.map(&:message).join("\n\t* ")}
-          EOM
-        end
-        return true
-      end
-      return false
-    end
-
-  end
-
-  class PromptTimeout < StandardError; end
-end

data/spec/license_acceptance/acceptor_spec.rb

@@ -1,272 +0,0 @@
-require "spec_helper"
-require "license_acceptance/acceptor"
-
-RSpec.describe LicenseAcceptance::Acceptor do
-  it "has a version number" do
-    expect(LicenseAcceptance::VERSION).not_to be nil
-  end
-
-  let(:output) do
-    d = StringIO.new
-    allow(d).to receive(:isatty).and_return(true)
-    d
-  end
-  let(:opts) { { output: output } }
-  let(:acc) { LicenseAcceptance::Acceptor.new(opts) }
-  let(:product) { "chef_client" }
-  let(:version) { "version" }
-  let(:relationship) { instance_double(LicenseAcceptance::ProductRelationship) }
-  let(:p1) { instance_double(LicenseAcceptance::Product) }
-  let(:missing) { [p1] }
-
-  describe "#check_and_persist!" do
-    let(:err) { LicenseAcceptance::LicenseNotAcceptedError.new([product]) }
-    it "outputs an error message to stdout and exits when license acceptance is declined" do
-      expect(acc).to receive(:check_and_persist).and_raise(err)
-      expect { acc.check_and_persist!(product, version) }.to raise_error(SystemExit)
-      expect(output.string).to match(/#{product}/)
-    end
-  end
-
-  describe "#check_and_persist" do
-    let(:reader) { instance_double(LicenseAcceptance::ProductReader) }
-    let(:file_acc) { instance_double(LicenseAcceptance::FileAcceptance) }
-    let(:arg_acc) { instance_double(LicenseAcceptance::ArgAcceptance) }
-    let(:prompt_acc) { instance_double(LicenseAcceptance::PromptAcceptance) }
-    let(:env_acc) { instance_double(LicenseAcceptance::EnvAcceptance) }
-
-    before do
-      expect(LicenseAcceptance::ProductReader).to receive(:new).and_return(reader)
-      expect(LicenseAcceptance::FileAcceptance).to receive(:new).and_return(file_acc)
-      expect(LicenseAcceptance::ArgAcceptance).to receive(:new).and_return(arg_acc)
-      expect(LicenseAcceptance::PromptAcceptance).to receive(:new).and_return(prompt_acc)
-      expect(LicenseAcceptance::EnvAcceptance).to receive(:new).and_return(env_acc)
-    end
-
-    describe "when check-no-persist environment variable is set" do
-      it "returns true" do
-        expect(env_acc).to receive(:no_persist?).and_return(true)
-        expect(acc.check_and_persist(product, version)).to eq(true)
-      end
-    end
-
-    describe "when check-no-persist command line argument is set" do
-      it "returns true" do
-        expect(env_acc).to receive(:no_persist?).and_return(false)
-        expect(arg_acc).to receive(:no_persist?).and_return(true)
-        expect(acc.check_and_persist(product, version)).to eq(true)
-      end
-    end
-
-    describe "when there are no missing licenses" do
-      it "returns true" do
-        expect(env_acc).to receive(:no_persist?).and_return(false)
-        expect(arg_acc).to receive(:no_persist?).and_return(false)
-        expect(reader).to receive(:read)
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return([])
-        expect(acc.check_and_persist(product, version)).to eq(true)
-      end
-    end
-
-    describe "when the user accepts as an environment variable" do
-      it "returns true" do
-        expect(env_acc).to receive(:no_persist?).and_return(false)
-        expect(arg_acc).to receive(:no_persist?).and_return(false)
-        expect(reader).to receive(:read)
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        expect(env_acc).to receive(:accepted?).with(ENV).and_return(true)
-        expect(env_acc).to receive(:silent?).with(ENV).and_return(false)
-        expect(arg_acc).to receive(:silent?).with(ARGV).and_return(false)
-        expect(file_acc).to receive(:persist).with(relationship, missing).and_return([])
-        expect(acc.check_and_persist(product, version)).to eq(true)
-        expect(output.string).to match(/1 product license accepted./)
-      end
-
-      describe "when persist is set to false" do
-        let(:opts) { { output: output, persist: false } }
-
-        it "returns true" do
-          expect(env_acc).to receive(:no_persist?).and_return(false)
-          expect(arg_acc).to receive(:no_persist?).and_return(false)
-          expect(reader).to receive(:read)
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(env_acc).to receive(:accepted?).with(ENV).and_return(true)
-          expect(acc.check_and_persist(product, version)).to eq(true)
-          expect(output.string).to_not match(/accepted./)
-        end
-      end
-
-      describe "when the silent option is used" do
-        let(:opts) { { output: output } }
-
-        it "returns true and silently persists the file" do
-          expect(env_acc).to receive(:no_persist?).and_return(false)
-          expect(arg_acc).to receive(:no_persist?).and_return(false)
-          expect(reader).to receive(:read)
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(env_acc).to receive(:accepted?).with(ENV).and_return(false)
-          expect(arg_acc).to receive(:accepted?).with(ARGV).and_return(false)
-          expect(env_acc).to receive(:silent?).with(ENV).twice.and_return(true)
-          expect(file_acc).to receive(:persist).with(relationship, missing).and_return([])
-          expect(acc.check_and_persist(product, version)).to eq(true)
-          expect(output.string).to be_empty
-        end
-      end
-
-      describe "when file persistance fails" do
-        it "returns true" do
-          expect(env_acc).to receive(:no_persist?).and_return(false)
-          expect(arg_acc).to receive(:no_persist?).and_return(false)
-          expect(reader).to receive(:read)
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(env_acc).to receive(:accepted?).with(ENV).and_return(true)
-          expect(file_acc).to receive(:persist).with(relationship, missing).and_return([StandardError.new("foo")])
-          expect(acc.check_and_persist(product, version)).to eq(true)
-          expect(output.string).to match(/Could not persist acceptance:/)
-        end
-      end
-    end
-
-    describe "when the user accepts as an arg" do
-      it "returns true" do
-        expect(env_acc).to receive(:no_persist?).and_return(false)
-        expect(arg_acc).to receive(:no_persist?).and_return(false)
-        expect(reader).to receive(:read)
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        expect(env_acc).to receive(:accepted?).and_return(false)
-        expect(arg_acc).to receive(:accepted?).with(ARGV).and_return(true)
-        expect(env_acc).to receive(:silent?).with(ENV).and_return(false)
-        expect(arg_acc).to receive(:silent?).with(ARGV).and_return(false)
-        expect(file_acc).to receive(:persist).with(relationship, missing).and_return([])
-        expect(acc.check_and_persist(product, version)).to eq(true)
-        expect(output.string).to match(/1 product license accepted./)
-      end
-
-      describe "when the silent option is used" do
-        let(:opts) { { output: output } }
-
-        it "returns true and silently persists the file" do
-          expect(env_acc).to receive(:no_persist?).and_return(false)
-          expect(arg_acc).to receive(:no_persist?).and_return(false)
-          expect(reader).to receive(:read)
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(env_acc).to receive(:accepted?).and_return(false)
-          expect(arg_acc).to receive(:accepted?).with(ARGV).and_return(false)
-          expect(env_acc).to receive(:silent?).with(ENV).twice.and_return(false)
-          expect(arg_acc).to receive(:silent?).with(ARGV).twice.and_return(true)
-          expect(file_acc).to receive(:persist).with(relationship, missing).and_return([])
-          expect(acc.check_and_persist(product, version)).to eq(true)
-          expect(output.string).to be_empty
-        end
-      end
-
-
-      describe "when persist is set to false" do
-        let(:opts) { { output: output, persist: false } }
-
-        it "returns true" do
-          expect(env_acc).to receive(:no_persist?).and_return(false)
-          expect(arg_acc).to receive(:no_persist?).and_return(false)
-          expect(reader).to receive(:read)
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(env_acc).to receive(:accepted?).and_return(false)
-          expect(arg_acc).to receive(:accepted?).with(ARGV).and_return(true)
-          expect(acc.check_and_persist(product, version)).to eq(true)
-          expect(output.string).to_not match(/accepted./)
-        end
-      end
-
-      describe "when file persistance fails" do
-        it "returns true" do
-          expect(env_acc).to receive(:no_persist?).and_return(false)
-          expect(arg_acc).to receive(:no_persist?).and_return(false)
-          expect(reader).to receive(:read)
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(env_acc).to receive(:accepted?).and_return(false)
-          expect(arg_acc).to receive(:accepted?).with(ARGV).and_return(true)
-          expect(file_acc).to receive(:persist).with(relationship, missing).and_return([StandardError.new("bar")])
-          expect(acc.check_and_persist(product, version)).to eq(true)
-          expect(output.string).to match(/Could not persist acceptance:/)
-        end
-      end
-    end
-
-    describe "when the prompt is not a tty" do
-      let(:opts) { { output: File.open(File::NULL, "w") } }
-      it "raises a LicenseNotAcceptedError error" do
-        expect(env_acc).to receive(:no_persist?).and_return(false)
-        expect(arg_acc).to receive(:no_persist?).and_return(false)
-        expect(reader).to receive(:read)
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        expect(env_acc).to receive(:accepted?).and_return(false)
-        expect(arg_acc).to receive(:accepted?).and_return(false)
-        expect(env_acc).to receive(:silent?).and_return(false)
-        expect(arg_acc).to receive(:silent?).and_return(false)
-        expect(prompt_acc).to_not receive(:request)
-        expect { acc.check_and_persist(product, version) }.to raise_error(LicenseAcceptance::LicenseNotAcceptedError)
-      end
-    end
-
-    describe "when the user accepts with the prompt" do
-      it "returns true" do
-        expect(env_acc).to receive(:no_persist?).and_return(false)
-        expect(arg_acc).to receive(:no_persist?).and_return(false)
-        expect(reader).to receive(:read)
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        expect(env_acc).to receive(:accepted?).and_return(false)
-        expect(arg_acc).to receive(:accepted?).and_return(false)
-        expect(env_acc).to receive(:silent?).and_return(false)
-        expect(arg_acc).to receive(:silent?).and_return(false)
-        expect(prompt_acc).to receive(:request).with(missing).and_yield.and_return(true)
-        expect(file_acc).to receive(:persist).with(relationship, missing)
-        expect(acc.check_and_persist(product, version)).to eq(true)
-      end
-
-      describe "when persist is set to false" do
-        let(:opts) { { output: output, persist: false } }
-
-        it "returns true" do
-          expect(env_acc).to receive(:no_persist?).and_return(false)
-          expect(arg_acc).to receive(:no_persist?).and_return(false)
-          expect(reader).to receive(:read)
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(env_acc).to receive(:accepted?).and_return(false)
-          expect(arg_acc).to receive(:accepted?).and_return(false)
-          expect(env_acc).to receive(:silent?).and_return(false)
-          expect(arg_acc).to receive(:silent?).and_return(false)
-          expect(prompt_acc).to receive(:request).with(missing).and_yield.and_return(true)
-          expect(acc.check_and_persist(product, version)).to eq(true)
-        end
-      end
-    end
-
-    describe "when the user declines with the prompt" do
-      it "raises a LicenseNotAcceptedError error" do
-        expect(env_acc).to receive(:no_persist?).and_return(false)
-        expect(arg_acc).to receive(:no_persist?).and_return(false)
-        expect(reader).to receive(:read)
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        expect(env_acc).to receive(:accepted?).and_return(false)
-        expect(arg_acc).to receive(:accepted?).and_return(false)
-        expect(env_acc).to receive(:silent?).and_return(false)
-        expect(arg_acc).to receive(:silent?).and_return(false)
-        expect(prompt_acc).to receive(:request).with(missing).and_return(false)
-        expect { acc.check_and_persist(product, version) }.to raise_error(LicenseAcceptance::LicenseNotAcceptedError)
-      end
-    end
-
-  end
-end

data/spec/license_acceptance/arg_acceptance_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-require "license_acceptance/arg_acceptance"
-
-RSpec.describe LicenseAcceptance::ArgAcceptance do
-  let(:acc) { LicenseAcceptance::ArgAcceptance.new }
-
-  describe "with an accept option" do
-    describe "#accepted?" do
-      it "returns true if the args contain the required flag with spaces" do
-        expect(acc.accepted?(["--chef-license", "accept"])).to eq(true)
-      end
-
-      it "returns true if the args contain the required flag with equal" do
-        expect(acc.accepted?(["--chef-license=accept"])).to eq(true)
-      end
-
-      it "returns false if the args do not contain the required value" do
-        expect(acc.accepted?(["--chef-license"])).to eq(false)
-        expect(acc.accepted?(["--chef-license=foo"])).to eq(false)
-        expect(acc.accepted?(["--chef-license", "foo"])).to eq(false)
-      end
-    end
-
-    describe "#silent?" do
-      it "returns true if the args contain the required flag with spaces" do
-        expect(acc.silent?(["--chef-license", "accept-silent"])).to eq(true)
-      end
-
-      it "returns true if the args contain the required flag with equal" do
-        expect(acc.silent?(["--chef-license=accept-silent"])).to eq(true)
-      end
-
-      it "returns false if the args do not contain the required value" do
-        expect(acc.silent?(["--chef-license"])).to eq(false)
-        expect(acc.silent?(["--chef-license=accept"])).to eq(false)
-        expect(acc.silent?(["--chef-license", "accept"])).to eq(false)
-      end
-    end
-  end
-
-  describe "#no_persist?" do
-    it "returns true if the args contain the required flag with spaces" do
-      expect(acc.no_persist?(["--chef-license", "accept-no-persist"])).to eq(true)
-    end
-
-    it "returns true if the args contain the required flag with equal" do
-      expect(acc.no_persist?(["--chef-license=accept-no-persist"])).to eq(true)
-    end
-
-    it "returns false if the args do not contain the required value" do
-      expect(acc.no_persist?(["--chef-license"])).to eq(false)
-      expect(acc.no_persist?(["--chef-license=accept"])).to eq(false)
-      expect(acc.no_persist?(["--chef-license", "accept"])).to eq(false)
-    end
-  end
-
-end

data/spec/license_acceptance/cli_flags/mixlib_cli_spec.rb

@@ -1,14 +0,0 @@
-require "spec_helper"
-require "license_acceptance/cli_flags/mixlib_cli"
-
-class TestMixlibKlass
-  include Mixlib::CLI
-  include LicenseAcceptance::CLIFlags::MixlibCLI
-end
-
-RSpec.describe LicenseAcceptance::CLIFlags::MixlibCLI do
-  let(:klass) { TestMixlibKlass.new }
-  it "adds the correct command line flag" do
-    expect(klass.options).to include(:chef_license)
-  end
-end

data/spec/license_acceptance/cli_flags/thor_spec.rb

@@ -1,14 +0,0 @@
-require "spec_helper"
-require "license_acceptance/cli_flags/thor"
-require "thor"
-
-class TestThorKlass < Thor
-  include LicenseAcceptance::CLIFlags::Thor
-end
-
-RSpec.describe LicenseAcceptance::CLIFlags::Thor do
-  let(:klass) { TestThorKlass.new }
-  it "adds the correct command line flag" do
-    expect(klass.class.class_options.keys).to eq([:chef_license])
-  end
-end

data/spec/license_acceptance/config_spec.rb

@@ -1,111 +0,0 @@
-require "spec_helper"
-require "climate_control"
-require "license_acceptance/config"
-require "license_acceptance/product_relationship"
-
-RSpec.describe LicenseAcceptance::Config do
-  let(:opts) { {} }
-  let(:config) { LicenseAcceptance::Config.new(opts) }
-
-  it "loads correctly with default values" do
-    config
-  end
-
-  describe "with overwritten values" do
-    let(:output) { StringIO.new }
-    let(:logger) { "logger" }
-    let(:license_locations) { [] }
-    let(:persist_location) { "foo" }
-    let(:persist) { false }
-    let(:opts) { { output: output, logger: logger, license_locations: license_locations, persist_location: persist_location, persist: persist } }
-
-    it "loads correctly" do
-      expect(config.output).to eq(output)
-      expect(config.logger).to eq(logger)
-      expect(config.license_locations).to eq(license_locations)
-      expect(config.persist_location).to eq("foo")
-      expect(config.persist).to eq(false)
-    end
-  end
-
-  describe "#default_license_locations and #default_persist_location" do
-    before do
-      expect(Process).to receive(:uid).and_return(uid)
-    end
-
-    describe "when platform is Windows" do
-      before do
-        stub_const("RUBY_PLATFORM", "mingw")
-      end
-
-      describe "when user is Administrator" do
-        let(:uid) { 0 }
-
-        it "returns the default value" do
-          ClimateControl.modify HOMEDRIVE: "C:" do
-            expect(config.license_locations).to eq(["C:/chef/accepted_licenses/"])
-            expect(config.persist_location).to eq("C:/chef/accepted_licenses/")
-          end
-        end
-      end
-
-      describe "when user is not Administrator" do
-        let(:uid) { 1000 }
-
-        it "returns the default USERPROFILE value" do
-          ClimateControl.modify HOMEDRIVE: "C:", USERPROFILE: "C:/Users/foo", HOME: nil do
-            expect(Dir).to receive(:exist?).with("C:/Users/foo").and_return(true)
-            expect(config.license_locations).to eq([
-              "C:/chef/accepted_licenses/",
-              "C:/Users/foo/.chef/accepted_licenses/"
-            ])
-            expect(config.persist_location).to eq("C:/Users/foo/.chef/accepted_licenses/")
-          end
-        end
-
-        it "returns the default HOMEDRIVE + HOMEPATH value" do
-          ClimateControl.modify HOMEDRIVE: "C:", USERPROFILE: "C:/Users/bar", HOME: nil do
-            expect(Dir).to receive(:exist?).with("C:/Users/bar").and_return(true)
-            expect(config.license_locations).to eq([
-              "C:/chef/accepted_licenses/",
-              "C:/Users/bar/.chef/accepted_licenses/"
-            ])
-            expect(config.persist_location).to eq("C:/Users/bar/.chef/accepted_licenses/")
-          end
-        end
-      end
-
-    end
-
-    describe "when platform is non-Windows" do
-      before do
-        stub_const("RUBY_PLATFORM", "darwin")
-      end
-
-      describe "when user is root" do
-        let(:uid) { 0 }
-
-        it "returns the default value" do
-          expect(config.license_locations).to eq(["/etc/chef/accepted_licenses/"])
-          expect(config.persist_location).to eq("/etc/chef/accepted_licenses/")
-        end
-      end
-
-      describe "when user is not root" do
-        let(:uid) { 1000 }
-
-        it "returns the default user value" do
-          ClimateControl.modify HOME: "/Users/foo" do
-            expect(config.license_locations).to eq([
-              "/etc/chef/accepted_licenses/",
-              "/Users/foo/.chef/accepted_licenses/"
-            ])
-            expect(config.persist_location).to eq("/Users/foo/.chef/accepted_licenses/")
-          end
-        end
-      end
-
-    end
-  end
-
-end