license-acceptance 1.0.13 → 2.1.2

data/lib/license_acceptance/strategy/prompt.rb

@@ -1,13 +1,13 @@
-require 'tty-prompt'
-require 'pastel'
+autoload :TTY, "tty-prompt"
+require "pastel"
 require "license_acceptance/logger"
 require "license_acceptance/strategy/base"
-require "timeout"
+require "timeout" unless defined?(Timeout)
 
 module LicenseAcceptance
   module Strategy
 
-    # Interactive prompt for accepting and persistnce license acceptance, or failing with custom exit code
+    # Interactive prompt for accepting and persistence license acceptance, or failing with custom exit code
     class Prompt < Base
       include Logger
 
@@ -17,30 +17,30 @@ module LicenseAcceptance
         @output = config.output
       end
 
-      WIDTH = 50.freeze
+      WIDTH = 50
       PASTEL = Pastel.new
       BORDER = "+---------------------------------------------+".freeze
       YES = PASTEL.green.bold("yes")
-      CHECK  = PASTEL.green("✔")
+      CHECK = PASTEL.green("✔")
 
       def request(missing_licenses, &persist_callback)
         logger.debug("Requesting a license for #{missing_licenses.map(&:id)}")
         c = missing_licenses.size
-        s = c > 1 ? "s": ""
+        s = c > 1 ? "s" : ""
 
         acceptance_question = "Do you accept the #{c} product license#{s} (#{YES}/no)?"
         output.puts <<~EOM
-        #{BORDER}
-                    Chef License Acceptance
+          #{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/
+          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  * ")}
+          License#{s} that need accepting:
+            * #{missing_licenses.map(&:pretty_name).join("\n  * ")}
 
-        #{acceptance_question}
+          #{acceptance_question}
 
         EOM
 
@@ -51,10 +51,10 @@ module LicenseAcceptance
 
         output.puts <<~EOM
 
-        If you do not accept this license you will
-        not be able to use Chef products.
+          If you do not accept this license you will
+          not be able to use Chef products.
 
-        #{acceptance_question}
+          #{acceptance_question}
 
         EOM
 
@@ -62,7 +62,7 @@ module LicenseAcceptance
         if answer != "yes"
           output.puts BORDER
         end
-        return answer
+        answer
       end
 
       private
@@ -73,12 +73,12 @@ module LicenseAcceptance
 
         answer = "no"
         begin
-          Timeout::timeout(60, PromptTimeout) do
+          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.validate(/^\s*(yes|no)\s*$/i)
               q.messages[:valid?] = "You must enter 'yes' or 'no'"
             end
           end
@@ -95,13 +95,13 @@ module LicenseAcceptance
             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* ")}
+              #{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
+        false
       end
     end
 

data/lib/license_acceptance/strategy/provided_value.rb

@@ -12,17 +12,20 @@ module LicenseAcceptance
       end
 
       def accepted?
-        value == ACCEPT
+        String(value).downcase == ACCEPT
       end
 
       def silent?
-        value == ACCEPT_SILENT
+        String(value).downcase == ACCEPT_SILENT
       end
 
       def no_persist?
-        value == ACCEPT_NO_PERSIST
+        String(value).downcase == ACCEPT_NO_PERSIST
       end
-    end
 
+      def value?
+        !!value
+      end
+    end
   end
 end

data/lib/license_acceptance/version.rb

@@ -1,3 +1,3 @@
 module LicenseAcceptance
-  VERSION = "1.0.13"
+  VERSION = "2.1.2".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: license-acceptance
 version: !ruby/object:Gem::Version
-  version: 1.0.13
+  version: 2.1.2
 platform: ruby
 authors:
 - tyler-ball
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-12 00:00:00.000000000 Z
+date: 2020-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pastel
@@ -44,140 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: tty-prompt
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.18'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.18'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.12'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.12'
-- !ruby/object:Gem::Dependency
-  name: pry-byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.6'
-- !ruby/object:Gem::Dependency
-  name: pry-stack_explorer
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.4'
-- !ruby/object:Gem::Dependency
-  name: mixlib-cli
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.7'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.7'
-- !ruby/object:Gem::Dependency
-  name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.20'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.20'
-- !ruby/object:Gem::Dependency
-  name: climate_control
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
 description: Chef End User License Agreement Acceptance for Ruby products
 email:
 - tball@chef.io
@@ -186,9 +74,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
-- Gemfile.lock
 - LICENSE
-- Rakefile
 - config/product_info.toml
 - lib/license_acceptance/acceptor.rb
 - lib/license_acceptance/cli_flags/mixlib_cli.rb
@@ -205,18 +91,6 @@ files:
 - lib/license_acceptance/strategy/prompt.rb
 - lib/license_acceptance/strategy/provided_value.rb
 - lib/license_acceptance/version.rb
-- spec/license_acceptance/acceptor_spec.rb
-- spec/license_acceptance/cli_flags/mixlib_cli_spec.rb
-- spec/license_acceptance/cli_flags/thor_spec.rb
-- spec/license_acceptance/config_spec.rb
-- spec/license_acceptance/product_reader_spec.rb
-- spec/license_acceptance/product_spec.rb
-- spec/license_acceptance/strategy/argument_spec.rb
-- spec/license_acceptance/strategy/environment_spec.rb
-- spec/license_acceptance/strategy/file_spec.rb
-- spec/license_acceptance/strategy/prompt_spec.rb
-- spec/license_acceptance/strategy/provided_value_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/chef/license-acceptance/
 licenses:
 - Apache-2.0
@@ -229,7 +103,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/Gemfile.lock

@@ -1,91 +0,0 @@
-PATH
-  remote: .
-  specs:
-    license-acceptance (1.0.13)
-      pastel (~> 0.7)
-      tomlrb (~> 1.2)
-      tty-box (~> 0.3)
-      tty-prompt (~> 0.18)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    binding_of_caller (0.8.0)
-      debug_inspector (>= 0.0.1)
-    byebug (11.0.1)
-    climate_control (0.2.0)
-    coderay (1.1.2)
-    debug_inspector (0.0.3)
-    diff-lcs (1.3)
-    equatable (0.5.0)
-    method_source (0.9.2)
-    mixlib-cli (1.7.0)
-    necromancer (0.5.0)
-    pastel (0.7.2)
-      equatable (~> 0.5.0)
-      tty-color (~> 0.4.0)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    pry-byebug (3.7.0)
-      byebug (~> 11.0)
-      pry (~> 0.10)
-    pry-stack_explorer (0.4.9.3)
-      binding_of_caller (>= 0.7)
-      pry (>= 0.9.11)
-    rake (10.5.0)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.0)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.4)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
-    strings (0.1.5)
-      strings-ansi (~> 0.1)
-      unicode-display_width (~> 1.5)
-      unicode_utils (~> 1.4)
-    strings-ansi (0.1.0)
-    thor (0.20.3)
-    tomlrb (1.2.8)
-    tty-box (0.4.0)
-      pastel (~> 0.7.2)
-      strings (~> 0.1.5)
-      tty-cursor (~> 0.7)
-    tty-color (0.4.3)
-    tty-cursor (0.7.0)
-    tty-prompt (0.19.0)
-      necromancer (~> 0.5.0)
-      pastel (~> 0.7.0)
-      tty-reader (~> 0.6.0)
-    tty-reader (0.6.0)
-      tty-cursor (~> 0.7)
-      tty-screen (~> 0.7)
-      wisper (~> 2.0.0)
-    tty-screen (0.7.0)
-    unicode-display_width (1.6.0)
-    unicode_utils (1.4.0)
-    wisper (2.0.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  climate_control (~> 0.2)
-  license-acceptance!
-  mixlib-cli (~> 1.7)
-  pry (~> 0.12)
-  pry-byebug (~> 3.6)
-  pry-stack_explorer (~> 0.4)
-  rake (~> 10.0)
-  rspec (~> 3.0)
-  thor (~> 0.20)
-
-BUNDLED WITH
-   1.17.3

data/Rakefile

@@ -1,6 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec

data/spec/license_acceptance/acceptor_spec.rb

@@ -1,302 +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(:reader) { instance_double(LicenseAcceptance::ProductReader) }
-  let(:acc) { LicenseAcceptance::Acceptor.new(opts) }
-  let(:product) { instance_double(LicenseAcceptance::Product, id: "foo", pretty_name: "Foo") }
-  let(:version) { "version" }
-  let(:relationship) { instance_double(LicenseAcceptance::ProductRelationship, parent: product) }
-  let(:missing) { [product] }
-
-  describe "#check_and_persist!" do
-    before do
-      expect(LicenseAcceptance::ProductReader).to receive(:new).and_return(reader)
-      expect(reader).to receive(:read)
-    end
-
-    let(:err) { LicenseAcceptance::LicenseNotAcceptedError.new(product, [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.id, version) }.to raise_error(SystemExit)
-      expect(output.string).to match(/#{product.pretty_name}/)
-    end
-  end
-
-  describe "#check_and_persist" do
-    let(:file_acc) { instance_double(LicenseAcceptance::Strategy::File) }
-    let(:arg_acc) { instance_double(LicenseAcceptance::Strategy::Argument) }
-    let(:prompt_acc) { instance_double(LicenseAcceptance::Strategy::Prompt) }
-    let(:env_acc) { instance_double(LicenseAcceptance::Strategy::Environment) }
-    let(:provided_acc) { instance_double(LicenseAcceptance::Strategy::ProvidedValue) }
-
-    before do
-      expect(LicenseAcceptance::ProductReader).to receive(:new).and_return(reader)
-      expect(LicenseAcceptance::Strategy::File).to receive(:new).and_return(file_acc)
-      expect(LicenseAcceptance::Strategy::Argument).to receive(:new).and_return(arg_acc)
-      expect(LicenseAcceptance::Strategy::Prompt).to receive(:new).and_return(prompt_acc)
-      expect(LicenseAcceptance::Strategy::Environment).to receive(:new).and_return(env_acc)
-      expect(LicenseAcceptance::Strategy::ProvidedValue).to receive(:new).and_return(provided_acc)
-
-      allow(provided_acc).to receive(:no_persist?).and_return(false)
-      allow(env_acc).to receive(:no_persist?).and_return(false)
-      allow(arg_acc).to receive(:no_persist?).and_return(false)
-      allow(provided_acc).to receive(:accepted?).and_return(false)
-      allow(env_acc).to receive(:accepted?).and_return(false)
-      allow(arg_acc).to receive(:accepted?).and_return(false)
-      allow(provided_acc).to receive(:silent?).and_return(false)
-      allow(env_acc).to receive(:silent?).and_return(false)
-      allow(arg_acc).to receive(:silent?).and_return(false)
-
-      expect(reader).to receive(:read)
-    end
-
-    describe "when accept-no-persist is provided from the caller" do
-      it "returns true" do
-        expect(provided_acc).to receive(:no_persist?).and_return(true)
-        expect(acc.check_and_persist(product, version)).to eq(true)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT_NO_PERSIST)
-      end
-    end
-
-    describe "when accept-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)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT_NO_PERSIST)
-      end
-    end
-
-    describe "when accept-no-persist command line argument is set" do
-      it "returns true" do
-        expect(arg_acc).to receive(:no_persist?).and_return(true)
-        expect(acc.check_and_persist(product, version)).to eq(true)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT_NO_PERSIST)
-      end
-    end
-
-    describe "when there are no missing licenses" do
-      it "returns true" do
-        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)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-      end
-    end
-
-    describe "when the user accepts as an environment variable" do
-      it "returns true" do
-        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(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 match(/1 product license accepted./)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-      end
-
-      describe "when persist is set to false" do
-        let(:opts) { { output: output, persist: false } }
-
-        it "returns true" do
-          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(true)
-          expect(acc.check_and_persist(product, version)).to eq(true)
-          expect(output.string).to_not match(/accepted./)
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-        end
-      end
-
-      describe "when the silent option is used" do
-        let(:opts) { { output: output } }
-
-        it "returns true and silently persists the file" do
-          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(:silent?).times.exactly(3).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
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT_SILENT)
-        end
-      end
-
-      describe "when file persistance fails" do
-        it "returns true" do
-          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(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:/)
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-        end
-      end
-    end
-
-    describe "when the user accepts as an arg" do
-      it "returns true" do
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        expect(arg_acc).to receive(:accepted?).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 match(/1 product license accepted./)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-      end
-
-      describe "when the silent option is used" do
-        let(:opts) { { output: output } }
-
-        it "returns true and silently persists the file" do
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(arg_acc).to receive(:silent?).times.exactly(3).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
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT_SILENT)
-        end
-      end
-
-
-      describe "when persist is set to false" do
-        let(:opts) { { output: output, persist: false } }
-
-        it "returns true" do
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(arg_acc).to receive(:accepted?).and_return(true)
-          expect(acc.check_and_persist(product, version)).to eq(true)
-          expect(output.string).to_not match(/accepted./)
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-        end
-      end
-
-      describe "when file persistance fails" do
-        it "returns true" do
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(arg_acc).to receive(:accepted?).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:/)
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-        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(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        expect(prompt_acc).to_not receive(:request)
-        expect { acc.check_and_persist(product, version) }.to raise_error(LicenseAcceptance::LicenseNotAcceptedError)
-        expect(acc.acceptance_value).to eq(nil)
-      end
-    end
-
-    describe "when the user accepts with the prompt" do
-      it "returns true" do
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        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)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-      end
-
-      describe "when persist is set to false" do
-        let(:opts) { { output: output, persist: false } }
-
-        it "returns true" do
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(prompt_acc).to receive(:request).with(missing).and_yield.and_return(true)
-          expect(acc.check_and_persist(product, version)).to eq(true)
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT_NO_PERSIST)
-        end
-      end
-    end
-
-    describe "when the user declines with the prompt" do
-      it "raises a LicenseNotAcceptedError error" do
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        expect(prompt_acc).to receive(:request).with(missing).and_return(false)
-        expect { acc.check_and_persist(product, version) }.to raise_error(LicenseAcceptance::LicenseNotAcceptedError)
-        expect(acc.acceptance_value).to eq(nil)
-      end
-    end
-  end
-
-  describe "#license_required?" do
-    let(:reader) { instance_double(LicenseAcceptance::ProductReader) }
-    let(:mixlib_name) { "chef" }
-    let(:version) { "15.0.0" }
-    let(:product) { instance_double(LicenseAcceptance::Product, id: "foo", license_required_version: "15.0.0") }
-
-    before do
-      expect(LicenseAcceptance::ProductReader).to receive(:new).and_return(reader)
-      expect(reader).to receive(:read)
-    end
-
-    it "returns false if no product can be found" do
-      expect(reader).to receive(:lookup_by_mixlib).with(mixlib_name).and_return nil
-      expect(acc.license_required?(mixlib_name, version)).to eq(false)
-    end
-
-    describe "when version is :latest" do
-      let(:version) { :latest }
-      it "returns true" do
-        expect(reader).to receive(:lookup_by_mixlib).with(mixlib_name).and_return product
-        expect(acc.license_required?(mixlib_name, version)).to eq(true)
-      end
-    end
-
-    ["latest", "unstable", "current", "stable"].each do |version|
-      describe "when version is '#{version}'" do
-        it "returns true" do
-          expect(reader).to receive(:lookup_by_mixlib).with(mixlib_name).and_return product
-          expect(acc.license_required?(mixlib_name, version)).to eq(true)
-        end
-      end
-    end
-
-    describe "when version is nil" do
-      let(:version) { nil }
-      it "returns true" do
-        expect(reader).to receive(:lookup_by_mixlib).with(mixlib_name).and_return product
-        expect(acc.license_required?(mixlib_name, version)).to eq(true)
-      end
-    end
-
-    describe "when version is >= than required version" do
-      let(:version) { "15.0.0" }
-      it "returns true" do
-        expect(reader).to receive(:lookup_by_mixlib).with(mixlib_name).and_return product
-        expect(acc.license_required?(mixlib_name, version)).to eq(true)
-      end
-    end
-
-    describe "when version is < required version" do
-      let(:version) { "14.99.99" }
-      it "returns false" do
-        expect(reader).to receive(:lookup_by_mixlib).with(mixlib_name).and_return product
-        expect(acc.license_required?(mixlib_name, version)).to eq(false)
-      end
-    end
-  end
-end