license-acceptance 0.2.10 → 1.0.5

data/lib/license_acceptance/strategy/prompt.rb

@@ -0,0 +1,111 @@
+require 'tty-prompt'
+require 'pastel'
+require "license_acceptance/logger"
+require "license_acceptance/strategy/base"
+require "timeout"
+
+module LicenseAcceptance
+  module Strategy
+
+    # Interactive prompt for accepting and persistnce license acceptance, or failing with custom exit code
+    class Prompt < Base
+      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(&:id)}")
+        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
+end

data/lib/license_acceptance/strategy/provided_value.rb

@@ -0,0 +1,28 @@
+require "license_acceptance/strategy/base"
+
+module LicenseAcceptance
+  module Strategy
+
+    # Used for library consumers to parse their own form of acceptance (knife config, omnibus config, etc.) and pass it in
+    class ProvidedValue < Base
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def accepted?
+        value == ACCEPT
+      end
+
+      def silent?
+        value == ACCEPT_SILENT
+      end
+
+      def no_persist?
+        value == ACCEPT_NO_PERSIST
+      end
+    end
+
+  end
+end

data/lib/license_acceptance/version.rb

@@ -1,3 +1,3 @@
 module LicenseAcceptance
-  VERSION = "0.2.10"
+  VERSION = "1.0.5"
 end

data/spec/license_acceptance/acceptor_spec.rb

@@ -12,90 +12,109 @@ RSpec.describe LicenseAcceptance::Acceptor do
     d
   end
   let(:opts) { { output: output } }
+  let(:reader) { instance_double(LicenseAcceptance::ProductReader) }
   let(:acc) { LicenseAcceptance::Acceptor.new(opts) }
-  let(:product) { "chef_client" }
+  let(:product) { instance_double(LicenseAcceptance::Product, id: "foo", pretty_name: "Foo") }
   let(:version) { "version" }
-  let(:relationship) { instance_double(LicenseAcceptance::ProductRelationship) }
-  let(:p1) { instance_double(LicenseAcceptance::Product) }
-  let(:missing) { [p1] }
+  let(:relationship) { instance_double(LicenseAcceptance::ProductRelationship, parent: product) }
+  let(:missing) { [product] }
 
   describe "#check_and_persist!" do
-    let(:err) { LicenseAcceptance::LicenseNotAcceptedError.new([product]) }
+    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, version) }.to raise_error(SystemExit)
-      expect(output.string).to match(/#{product}/)
+      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(: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) }
+    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::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)
+      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 check-no-persist environment variable is set" do
+    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 check-no-persist command line argument is set" do
+    describe "when accept-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)
+        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(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)
+        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(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(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(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(: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
 
@@ -103,67 +122,51 @@ RSpec.describe LicenseAcceptance::Acceptor 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(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(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(: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(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(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(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(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
 
@@ -172,30 +175,24 @@ RSpec.describe LicenseAcceptance::Acceptor 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(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(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(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
@@ -203,70 +200,94 @@ RSpec.describe LicenseAcceptance::Acceptor do
     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)
+        expect(acc.acceptance_value).to eq(nil)
       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)
+        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(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)
+          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(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)
+        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
+
+    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

data/spec/license_acceptance/product_reader_spec.rb

@@ -7,11 +7,11 @@ RSpec.describe LicenseAcceptance::ProductReader do
   let(:version) { "0.1.0" }
   let(:location) { "location" }
 
-  let(:p1) { {"name" => "p1", "pretty_name" => "P1", "filename" => "f1"} }
-  let(:p2) { {"name" => "p2", "pretty_name" => "P2", "filename" => "f2"} }
+  let(:p1) { {"id" => "p1", "pretty_name" => "P1", "filename" => "f1", "mixlib_name" => "p1m", "license_required_version" => "p1v"} }
+  let(:p2) { {"id" => "p2", "pretty_name" => "P2", "filename" => "f2", "mixlib_name" => "p2m", "license_required_version" => "p2v"} }
   # defined the `==` operator on Product for ease of comparison
-  let(:product1) { LicenseAcceptance::Product.new(p1["name"], p1["pretty_name"], p1["filename"]) }
-  let(:product2) { LicenseAcceptance::Product.new(p2["name"], p2["pretty_name"], p2["filename"]) }
+  let(:product1) { LicenseAcceptance::Product.new(p1["id"], p1["pretty_name"], p1["filename"], p1["mixlib_name"], p1["license_required_version"]) }
+  let(:product2) { LicenseAcceptance::Product.new(p2["id"], p2["pretty_name"], p2["filename"], p2["mixlib_name"], p2["license_required_version"]) }
   let(:r1) { {p1 => p2} }
   let(:toml) { {"products" => [p1, p2], "relationships" => {"p1" => ["p2"]}} }
 
@@ -114,7 +114,7 @@ RSpec.describe LicenseAcceptance::ProductReader do
       end
     end
 
-    let(:nonya) { LicenseAcceptance::Product.new("nonya", "NonYa", "nofile") }
+    let(:nonya) { LicenseAcceptance::Product.new("nonya", "NonYa", "nofile", "no_mixlib", "no_version") }
     describe "when called on a product with no relationship" do
       before do
         reader.products = { "nonya" => nonya }
@@ -136,4 +136,20 @@ RSpec.describe LicenseAcceptance::ProductReader do
     end
   end
 
+  describe "::lookup_by_mixlib" do
+    before do
+      expect(reader).to receive(:get_location).and_return(location)
+      expect(Tomlrb).to receive(:load_file).with(location, symbolize_keys: false).and_return(toml)
+      reader.read
+    end
+
+    it "returns a Product successfully" do
+      expect(reader.lookup_by_mixlib("p1m")).to eq(product1)
+    end
+
+    it "returns nil for an unknown product" do
+      expect(reader.lookup_by_mixlib("foo")).to eq(nil)
+    end
+  end
+
 end

data/spec/license_acceptance/product_spec.rb

@@ -2,12 +2,14 @@ require "spec_helper"
 require "license_acceptance/product"
 
 RSpec.describe LicenseAcceptance::Product do
-  let(:instance) { LicenseAcceptance::Product.new("name", "Pretty Name", "filename") }
+  let(:instance) { LicenseAcceptance::Product.new("id", "Pretty Name", "filename", "mixlib_name", "version") }
 
   it "can lookup the product attributes" do
-    expect(instance.name).to eq("name")
+    expect(instance.id).to eq("id")
     expect(instance.pretty_name).to eq("Pretty Name")
     expect(instance.filename).to eq("filename")
+    expect(instance.mixlib_name).to eq("mixlib_name")
+    expect(instance.license_required_version).to eq("version")
   end
 
 end

data/spec/license_acceptance/strategy/argument_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+require "license_acceptance/strategy/argument"
+
+RSpec.describe LicenseAcceptance::Strategy::Argument do
+  let(:acc) { LicenseAcceptance::Strategy::Argument.new(argv) }
+
+  describe "#accepted?" do
+    describe "when value is space seperated" do
+      let(:argv) { ["--chef-license", "accept"] }
+      it "returns true if the args contain the required flag with spaces" do
+        expect(acc.accepted?).to eq(true)
+      end
+    end
+
+    describe "when the value is equal seperated" do
+      let(:argv) { ["--chef-license=accept"] }
+      it "returns true if the args contain the required flag with equal" do
+        expect(acc.accepted?).to eq(true)
+      end
+    end
+
+    [ ["--chef-license"], ["--chef-license=foo"], ["--chef-license", "foo"] ].each do |v|
+      describe "when the value is #{v}" do
+        let(:argv) { v }
+        it "returns false if the args do not contain the required value" do
+          expect(acc.accepted?).to eq(false)
+        end
+      end
+    end
+  end
+
+  describe "#silent?" do
+    describe "when value is space seperated" do
+      let(:argv) { ["--chef-license", "accept-silent"] }
+      it "returns true if the args contain the required flag with spaces" do
+        expect(acc.silent?).to eq(true)
+      end
+    end
+
+    describe "when the value is equal seperated" do
+      let(:argv) { ["--chef-license=accept-silent"] }
+      it "returns true if the args contain the required flag with equal" do
+        expect(acc.silent?).to eq(true)
+      end
+    end
+
+    [ ["--chef-license"], ["--chef-license=accept"], ["--chef-license", "accept"] ].each do |v|
+      describe "when the value is #{v}" do
+        let(:argv) { v }
+        it "returns false if the args do not contain the required value" do
+          expect(acc.silent?).to eq(false)
+        end
+      end
+    end
+  end
+
+  describe "#no_persist?" do
+    describe "when value is space seperated" do
+      let(:argv) { ["--chef-license", "accept-no-persist"] }
+      it "returns true if the args contain the required flag with spaces" do
+        expect(acc.no_persist?).to eq(true)
+      end
+    end
+
+    describe "when the value is equal seperated" do
+      let(:argv) { ["--chef-license=accept-no-persist"] }
+      it "returns true if the args contain the required flag with equal" do
+        expect(acc.no_persist?).to eq(true)
+      end
+    end
+
+    [ ["--chef-license"], ["--chef-license=accept"], ["--chef-license", "accept"] ].each do |v|
+      describe "when the value is #{v}" do
+        let(:argv) { v }
+        it "returns false if the args do not contain the required value" do
+          expect(acc.no_persist?).to eq(false)
+        end
+      end
+    end
+  end
+
+end