license-acceptance 0.2.13 → 0.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4e838f450a28b5543cbf2ebf0a620b4274567cc1f42067d2ebd859a5e122005
-  data.tar.gz: 6257b8dd5964e8058e7614c219ebbe60234f9f060dff4c52cdd4df3a295daecb
+  metadata.gz: 2ff1d1fbab957952084fe44a975d3c4ddf8bbccfebda7e3a7c54caafd3f5bd28
+  data.tar.gz: 6a7274ee80f7da6465ab928c2e85e02a2da180028e449a2cc04ba7bc956bd655
 SHA512:
-  metadata.gz: 81e308d0664299c9797fa0b06470f550aac3087f9d154ee0f8b3737aff4cfc09fca669a80f81d4be726d01e4166124ea3747630720f32d8115bc1c5d5fb38722
-  data.tar.gz: 3677568ac06e369235ecba67c6ae38cd4f271a9ca19f495c8d2e789e32e18eea559fe40aea9a8f1b60cdef659828f5b892eacf1c70099ea83cae1b846bd27cf1
+  metadata.gz: 343c73d26b864e316cd742065d2b83527ee6d64ba5ff7bd97a00fa9c05c00c6fdf4ee61c9ddd3cfdd40225c6bdb7bf06fdcb601e425c529c1341e3b586523999
+  data.tar.gz: 3205485af5f026d1d888dec565c229e1c843acc9558693a217b74df70f217cf43124a9c438197a2b6e37874086c3b25dbdac7cf68d2e0724baeab110c1a019a5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    license-acceptance (0.2.13)
+    license-acceptance (0.2.15)
       pastel (~> 0.7)
       tomlrb (~> 1.2)
       tty-box (~> 0.3)

data/config/product_info.toml

@@ -6,6 +6,8 @@ name = "chef-client"
 pretty_name = "Chef Client"
 hab_pkg_id = "chef/chef-client"
 filename = "chef_client"
+mixlib_name = "chef"
+license_required_version = "15"
 
 [[products]]
 name = "inspec"

data/lib/license_acceptance/acceptor.rb

@@ -10,6 +10,11 @@ require "license_acceptance/strategy/prompt"
 require "license_acceptance/strategy/provided_value"
 
 module LicenseAcceptance
+
+  ACCEPT = "accept"
+  ACCEPT_SILENT = "accept-silent"
+  ACCEPT_NO_PERSIST = "accept-no-persist"
+
   class Acceptor
     extend Forwardable
     include Logger
@@ -20,11 +25,13 @@ module LicenseAcceptance
       @config = Config.new(opts)
       Logger.initialize(config.logger)
       @product_reader = ProductReader.new
+      product_reader.read
       @env_strategy = Strategy::Environment.new(ENV)
       @file_strategy = Strategy::File.new(config)
       @arg_strategy = Strategy::Argument.new(ARGV)
       @prompt_strategy = Strategy::Prompt.new(config)
       @provided_strategy = Strategy::ProvidedValue.new(opts.fetch(:provided, nil))
+      @acceptance_value = nil
     end
 
     def_delegator :@config, :output
@@ -42,10 +49,10 @@ module LicenseAcceptance
     def check_and_persist(product_name, version)
       if accepted_no_persist?
         logger.debug("Chef License accepted with no persistence")
+        @acceptance_value = ACCEPT_NO_PERSIST
         return true
       end
 
-      product_reader.read
       product_relationship = product_reader.lookup(product_name, version)
 
       missing_licenses = file_strategy.accepted?(product_relationship)
@@ -53,6 +60,7 @@ module LicenseAcceptance
       # They have already accepted all licenses and stored their acceptance in the persistent files
       if missing_licenses.empty?
         logger.debug("All licenses present")
+        @acceptance_value = ACCEPT
         return true
       end
 
@@ -65,11 +73,15 @@ module LicenseAcceptance
             output_persist_failed(errs)
           end
         end
+        @acceptance_value = accepted_silent? ? ACCEPT_SILENT : ACCEPT
         return true
       elsif config.output.isatty && prompt_strategy.request(missing_licenses) do
+          # We have to infer the acceptance value if they use the prompt to accept
           if config.persist
+            @acceptance_value = ACCEPT
             file_strategy.persist(product_relationship, missing_licenses)
           else
+            @acceptance_value = ACCEPT_NO_PERSIST
             []
           end
         end
@@ -87,6 +99,29 @@ module LicenseAcceptance
       new(opts).check_and_persist(product_name, version)
     end
 
+    # Check whether the specified product requires license acceptance for the given version.
+    def license_required?(mixlib_name, version)
+      product = product_reader.lookup_by_mixlib(mixlib_name)
+      return false if product.nil?
+      return true if version == :latest
+      Gem::Version.new(version) >= Gem::Version.new(product.license_required_version)
+    end
+
+    # Some callers only know about mixlib names so we need a way for them to get the product
+    # name as this library knows it.
+    def name_from_mixlib(mixlib_name)
+      product = product_reader.lookup_by_mixlib(mixlib_name)
+      return nil if product.nil?
+      product.name
+    end
+
+    # Return the value that was matched ("accept", "accept-no-persist", etc.). Used by callers so they do not
+    # have to know the precedence order between provided/environment/argument. Can just get back the value
+    # that was used. Value is only guaranteed to be set after calling check_and_persist.
+    def acceptance_value
+      @acceptance_value
+    end
+
     def accepted?
       provided_strategy.accepted? || env_strategy.accepted? || arg_strategy.accepted?
     end
@@ -125,7 +160,7 @@ module LicenseAcceptance
 
   class LicenseNotAcceptedError < RuntimeError
     def initialize(missing_licenses)
-      msg = "Missing licenses for the following:\n* " + missing_licenses.join("\n* ")
+      msg = "Missing licenses for the following:\n* " + missing_licenses.map(&:name).join("\n* ")
       super(msg)
     end
   end

data/lib/license_acceptance/product.rb

@@ -1,19 +1,23 @@
 module LicenseAcceptance
   class Product
 
-    attr_reader :name, :pretty_name, :filename
+    attr_reader :name, :pretty_name, :filename, :mixlib_name, :license_required_version
 
-    def initialize(name, pretty_name, filename)
+    def initialize(name, pretty_name, filename, mixlib_name, license_required_version)
       @name = name
       @pretty_name = pretty_name
       @filename = filename
+      @mixlib_name = mixlib_name
+      @license_required_version = license_required_version
     end
 
     def ==(other)
       return false if other.class != Product
       if other.name == name &&
          other.pretty_name == pretty_name &&
-         other.filename == filename
+         other.filename == filename &&
+         other.mixlib_name == mixlib_name
+         other.license_required_version == license_required_version
          return true
       end
       return false

data/lib/license_acceptance/product_reader.rb

@@ -19,7 +19,11 @@ module LicenseAcceptance
       raise InvalidProductInfo.new(location) if toml.empty? || toml["products"].nil? || toml["relationships"].nil?
 
       for product in toml["products"]
-        products[product["name"]] = Product.new(product["name"], product["pretty_name"], product["filename"])
+        products[product["name"]] = Product.new(
+          product["name"], product["pretty_name"],
+          product["filename"], product["mixlib_name"],
+          product["license_required_version"]
+        )
       end
 
       for parent_name, children in toml["relationships"]
@@ -62,6 +66,13 @@ module LicenseAcceptance
       ProductRelationship.new(parent_product, children, parent_version)
     end
 
+    def lookup_by_mixlib(mixlib_name)
+      found_product = products.values.find(nil) do |p|
+        p.mixlib_name == mixlib_name
+      end
+      found_product
+    end
+
   end
 
   class UnknownProduct < RuntimeError

data/lib/license_acceptance/strategy/base.rb

@@ -2,10 +2,6 @@ module LicenseAcceptance
   module Strategy
     class Base
 
-      ACCEPT = "accept"
-      ACCEPT_SILENT = "accept-silent"
-      ACCEPT_NO_PERSIST = "accept-no-persist"
-
     end
   end
 end

data/lib/license_acceptance/version.rb

@@ -1,3 +1,3 @@
 module LicenseAcceptance
-  VERSION = "0.2.13"
+  VERSION = "0.2.15"
 end

data/spec/license_acceptance/acceptor_spec.rb

@@ -13,18 +13,17 @@ RSpec.describe LicenseAcceptance::Acceptor do
   end
   let(:opts) { { output: output } }
   let(:acc) { LicenseAcceptance::Acceptor.new(opts) }
-  let(:product) { "chef_client" }
+  let(:product) { instance_double(LicenseAcceptance::Product, name: "chef_client") }
   let(:version) { "version" }
   let(:relationship) { instance_double(LicenseAcceptance::ProductRelationship) }
-  let(:p1) { instance_double(LicenseAcceptance::Product) }
-  let(:missing) { [p1] }
+  let(:missing) { [product] }
 
   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}/)
+      expect { acc.check_and_persist!(product.name, version) }.to raise_error(SystemExit)
+      expect(output.string).to match(/#{product.name}/)
     end
   end
 
@@ -53,12 +52,15 @@ RSpec.describe LicenseAcceptance::Acceptor do
       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
 
@@ -66,6 +68,7 @@ RSpec.describe LicenseAcceptance::Acceptor 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
 
@@ -73,39 +76,40 @@ RSpec.describe LicenseAcceptance::Acceptor 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(: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(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(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(: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(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
 
@@ -113,51 +117,51 @@ RSpec.describe LicenseAcceptance::Acceptor do
         let(:opts) { { output: output } }
 
         it "returns true and silently persists the file" do
-          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(:silent?).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(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(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(:read)
         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(:read)
           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?).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
 
@@ -166,24 +170,24 @@ RSpec.describe LicenseAcceptance::Acceptor do
         let(:opts) { { output: output, persist: false } }
 
         it "returns true" do
-          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(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(:read)
           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
@@ -191,44 +195,44 @@ 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(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(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(:read)
         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(:read)
           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(:read)
         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
 

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) { {"name" => "p1", "pretty_name" => "P1", "filename" => "f1", "mixlib_name" => "p1m", "license_required_version" => "p1v"} }
+  let(:p2) { {"name" => "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["name"], p1["pretty_name"], p1["filename"], p1["mixlib_name"], p1["license_required_version"]) }
+  let(:product2) { LicenseAcceptance::Product.new(p2["name"], 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("name", "Pretty Name", "filename", "mixlib_name", "version") }
 
   it "can lookup the product attributes" do
     expect(instance.name).to eq("name")
     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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: license-acceptance
 version: !ruby/object:Gem::Version
-  version: 0.2.13
+  version: 0.2.15
 platform: ruby
 authors:
 - tyler-ball
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-23 00:00:00.000000000 Z
+date: 2019-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pastel