license-acceptance 1.0.0 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ee66c4765774b7f57b1ee20c55138e11bd72071d09cdd1d18fdce1f4888529f
-  data.tar.gz: 765218350bff46b378b62a103e28f6108f0bf105ed94695b1c51141cfa9e48b4
+  metadata.gz: e892e857adb140ddab6c76d173116f248180ced44a2e2ceeeecd9919b1a91b09
+  data.tar.gz: ce171bdadb89755fa39e0bd9ce5c5c63901d7949958a0de9a4883a823a35ae9f
 SHA512:
-  metadata.gz: 607159212194ba650b7c6a5661f7706977dd376192765da07c62d4ef54fcbbe0cfc7a6ed80d7520a1c5c5c97c7a8cdc986d53730deef6b9dd391ae26c7329065
-  data.tar.gz: 5a45bb60c410d73a286efa1a9c812f977ecc49c1070ac8705c4568f6f4f4ca073127ec6dc4115d108f9996665a309ec30328f9d9b2f461a91d4b36e95133fea2
+  metadata.gz: 0a6c4bb643dc44b5ca0ca0e0f48f6ac22ef590bc7645eea104aa584259d29a911054030749689d2be4424daed5d5a6fd2ace9554a2c7ee9989502d7f63e69d79
+  data.tar.gz: c5508cb4655eb0a02ba5c1067b9c58a8c03a08d9ff9eeed7bf0c864df31749ab649901db64c5fc3db6da1fee22f66c81e0bc27d32b02a0fc4899648033c2f408

data/Gemfile.lock

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

data/config/product_info.toml

@@ -2,29 +2,36 @@
 title = "All known products that require license acceptance, and the mapping of parent to child relationships"
 
 [[products]]
-name = "chef-infra"
-pretty_name = "Chef Infra"
+id = "infra-client"
+pretty_name = "Chef Infra Client"
 hab_pkg_id = "chef/chef-client"
-filename = "chef_infra"
+filename = "chef_infra_client"
 mixlib_name = "chef"
 license_required_version = "15"
 
 [[products]]
-name = "inspec"
-pretty_name = "InSpec"
+id = "inspec"
+pretty_name = "Chef InSpec"
 hab_pkg_id = "chef/inspec"
 filename = "inspec"
 
 [[products]]
-name = "supermarket"
+id = "supermarket"
 pretty_name = "Supermarket"
 filename = "supermarket"
 
 [[products]]
-name = "chef-server"
-pretty_name = "Chef Server"
+id = "infra-server"
+pretty_name = "Chef Infra Server"
 hab_pkg_id = "chef/oc_erchef"
-filename = "chef_server"
+filename = "chef_infra_server"
+
+[[products]]
+id = "push-jobs-server"
+pretty_name = "Chef Push Jobs Server"
+filename = "push_jobs_server"
 
 [relationships]
-"chef-infra" = ["inspec"]
+"infra-client" = ["inspec"]
+"infra-server" = ["infra-client"]
+"push-jobs-server" = ["infra-client", "infra-server"]

data/lib/license_acceptance/acceptor.rb

@@ -39,21 +39,21 @@ module LicenseAcceptance
     # For applications that just need simple logic to handle a failed license acceptance flow we include this small
     # wrapper. Apps with more complex logic (like logging to a logging engine) should call the non-bang version and
     # handle the exception.
-    def check_and_persist!(product_name, version)
-      check_and_persist(product_name, version)
-    rescue LicenseNotAcceptedError
-      output.puts "#{product_name} cannot execute without accepting the license"
+    def check_and_persist!(product_id, version)
+      check_and_persist(product_id, version)
+    rescue LicenseNotAcceptedError => e
+      output.puts "#{e.product.pretty_name} cannot execute without accepting the license"
       exit 172
     end
 
-    def check_and_persist(product_name, version)
+    def check_and_persist(product_id, version)
       if accepted_no_persist?
         logger.debug("Chef License accepted with no persistence")
         @acceptance_value = ACCEPT_NO_PERSIST
         return true
       end
 
-      product_relationship = product_reader.lookup(product_name, version)
+      product_relationship = product_reader.lookup(product_id, version)
 
       missing_licenses = file_strategy.accepted?(product_relationship)
 
@@ -87,32 +87,33 @@ module LicenseAcceptance
         end
         return true
       else
-        raise LicenseNotAcceptedError.new(missing_licenses)
+        raise LicenseNotAcceptedError.new(product_relationship.parent, missing_licenses)
       end
     end
 
-    def self.check_and_persist!(product_name, version, opts={})
-      new(opts).check_and_persist!(product_name, version)
+    def self.check_and_persist!(product_id, version, opts={})
+      new(opts).check_and_persist!(product_id, version)
     end
 
-    def self.check_and_persist(product_name, version, opts={})
-      new(opts).check_and_persist(product_name, version)
+    def self.check_and_persist(product_id, version, opts={})
+      new(opts).check_and_persist(product_id, 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
+      # If they don't pass a version we assume they want latest
+      return true if version == :latest || version.nil?
       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)
+    # id as this library knows it.
+    def id_from_mixlib(mixlib_name)
       product = product_reader.lookup_by_mixlib(mixlib_name)
       return nil if product.nil?
-      product.name
+      product.id
     end
 
     # Return the value that was matched ("accept", "accept-no-persist", etc.). Used by callers so they do not
@@ -159,8 +160,10 @@ module LicenseAcceptance
   end
 
   class LicenseNotAcceptedError < RuntimeError
-    def initialize(missing_licenses)
-      msg = "Missing licenses for the following:\n* " + missing_licenses.map(&:name).join("\n* ")
+    attr_reader :product
+    def initialize(product, missing_licenses)
+      @product = product
+      msg = "Missing licenses for the following:\n* " + missing_licenses.map(&:id).join("\n* ")
       super(msg)
     end
   end

data/lib/license_acceptance/product.rb

@@ -1,10 +1,11 @@
 module LicenseAcceptance
   class Product
 
-    attr_reader :name, :pretty_name, :filename, :mixlib_name, :license_required_version
+    attr_reader :id, :pretty_name, :filename, :mixlib_name, :license_required_version
 
-    def initialize(name, pretty_name, filename, mixlib_name, license_required_version)
-      @name = name
+    def initialize(id, pretty_name, filename, mixlib_name, license_required_version)
+      # id is the internal representation of this product as license-acceptance knows it
+      @id = id
       @pretty_name = pretty_name
       @filename = filename
       @mixlib_name = mixlib_name
@@ -13,7 +14,7 @@ module LicenseAcceptance
 
     def ==(other)
       return false if other.class != Product
-      if other.name == name &&
+      if other.id == id &&
          other.pretty_name == pretty_name &&
          other.filename == filename &&
          other.mixlib_name == mixlib_name

data/lib/license_acceptance/product_reader.rb

@@ -19,24 +19,24 @@ 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"],
+        products[product["id"]] = Product.new(
+          product["id"], product["pretty_name"],
           product["filename"], product["mixlib_name"],
           product["license_required_version"]
         )
       end
 
-      for parent_name, children in toml["relationships"]
-        parent = products[parent_name]
-        raise UnknownParent.new(parent_name) if parent.nil?
+      for parent_id, children in toml["relationships"]
+        parent = products[parent_id]
+        raise UnknownParent.new(parent_id) if parent.nil?
         # Its fine to not have a relationship entry, but not fine to have
         # a relationship where the children are nil or empty.
         if children.nil? || children.empty? || !children.is_a?(Array)
           raise NoChildRelationships.new(parent)
         end
-        children.map! do |child_name|
-          child = products[child_name]
-          raise UnknownChild.new(child_name) if child.nil?
+        children.map! do |child_id|
+          child = products[child_id]
+          raise UnknownChild.new(child_id) if child.nil?
           child
         end
         relationships[parent] = children
@@ -55,9 +55,9 @@ module LicenseAcceptance
       File.absolute_path(File.join(__FILE__, "../../../config/product_info.toml"))
     end
 
-    def lookup(parent_name, parent_version)
-      parent_product = products.fetch(parent_name) do
-        raise UnknownProduct.new(parent_name)
+    def lookup(parent_id, parent_version)
+      parent_product = products.fetch(parent_id) do
+        raise UnknownProduct.new(parent_id)
       end
       children = relationships.fetch(parent_product, [])
       if !parent_version.is_a? String
@@ -105,7 +105,7 @@ module LicenseAcceptance
 
   class NoChildRelationships < RuntimeError
     def initialize(product)
-      msg = "No child relationships for #{product.name}, should be removed from product info or fixed"
+      msg = "No child relationships for #{product.id}, should be removed from product info or fixed"
       super(msg)
     end
   end

data/lib/license_acceptance/strategy/file.rb

@@ -25,7 +25,7 @@ module LicenseAcceptance
       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)}")
+        logger.debug("Searching for the following licenses: #{missing_licenses.map(&:id)}")
 
         searching.each do |product|
           found = false
@@ -40,7 +40,7 @@ module LicenseAcceptance
           end
           break if missing_licenses.empty?
         end
-        logger.debug("Missing licenses remaining: #{missing_licenses.map(&:name)}")
+        logger.debug("Missing licenses remaining: #{missing_licenses.map(&:id)}")
         missing_licenses
       end
 
@@ -77,12 +77,13 @@ module LicenseAcceptance
 
       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}")
+        logger.info("Persisting a license for #{product.pretty_name} at path #{path}")
         ::File.open(path, ::File::WRONLY | ::File::CREAT | ::File::EXCL) do |license_file|
           contents = {
-            name: product.name,
+            id: product.id,
+            name: product.pretty_name,
             date_accepted: INVOCATION_TIME.iso8601,
-            accepting_product: parent.name,
+            accepting_product: parent.id,
             accepting_product_version: parent_version,
             user: Etc.getlogin,
             file_format: 1,

data/lib/license_acceptance/strategy/prompt.rb

@@ -24,7 +24,7 @@ module LicenseAcceptance
       CHECK  = PASTEL.green("✔")
 
       def request(missing_licenses, &persist_callback)
-        logger.debug("Requesting a license for #{missing_licenses.map(&:name)}")
+        logger.debug("Requesting a license for #{missing_licenses.map(&:id)}")
         c = missing_licenses.size
         s = c > 1 ? "s": ""
 

data/lib/license_acceptance/version.rb

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

data/spec/license_acceptance/acceptor_spec.rb

@@ -12,23 +12,28 @@ 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) { instance_double(LicenseAcceptance::Product, name: "chef-infra") }
+  let(:product) { instance_double(LicenseAcceptance::Product, id: "foo", pretty_name: "Foo") }
   let(:version) { "version" }
-  let(:relationship) { instance_double(LicenseAcceptance::ProductRelationship) }
+  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.name, version) }.to raise_error(SystemExit)
-      expect(output.string).to match(/#{product.name}/)
+      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::Strategy::File) }
     let(:arg_acc) { instance_double(LicenseAcceptance::Strategy::Argument) }
     let(:prompt_acc) { instance_double(LicenseAcceptance::Strategy::Prompt) }
@@ -235,6 +240,54 @@ RSpec.describe LicenseAcceptance::Acceptor do
         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", "mixlib_name" => "p1m", "license_required_version" => "p1v"} }
-  let(:p2) { {"name" => "p2", "pretty_name" => "P2", "filename" => "f2", "mixlib_name" => "p2m", "license_required_version" => "p2v"} }
+  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"], 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(: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"]}} }
 

data/spec/license_acceptance/product_spec.rb

@@ -2,10 +2,10 @@ require "spec_helper"
 require "license_acceptance/product"
 
 RSpec.describe LicenseAcceptance::Product do
-  let(:instance) { LicenseAcceptance::Product.new("name", "Pretty Name", "filename", "mixlib_name", "version") }
+  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")

data/spec/license_acceptance/strategy/file_spec.rb

@@ -12,9 +12,10 @@ RSpec.describe LicenseAcceptance::Strategy::File do
     instance_double(LicenseAcceptance::Config, license_locations: [dir1, dir2], persist_location: dir3)
   end
   let(:acc) { LicenseAcceptance::Strategy::File.new(config) }
-  let(:p1_name) { "chef-infra" }
+  let(:p1_id) { "foo" }
   let(:p1_filename) { "p1_filename" }
-  let(:p1) { instance_double(LicenseAcceptance::Product, name: p1_name, filename: p1_filename) }
+  let(:p1_pretty) { "Pretty Name" }
+  let(:p1) { instance_double(LicenseAcceptance::Product, id: p1_id, filename: p1_filename, pretty_name: p1_pretty) }
   let(:version) { "0.1.0" }
   let(:product_relationship) { instance_double(LicenseAcceptance::ProductRelationship, parent: p1, children: [], parent_version: version) }
   let(:mode) { File::WRONLY | File::CREAT | File::EXCL }
@@ -43,17 +44,19 @@ RSpec.describe LicenseAcceptance::Strategy::File do
         expect(File).to receive(:open).with(File.join(dir3, p1_filename), mode).and_yield(file)
         expect(file).to receive(:<<) do |yaml|
           yaml = YAML.load(yaml)
-          expect(yaml["name"]).to eq(p1_name)
-          expect(yaml["accepting_product"]).to eq(p1_name)
+          expect(yaml["id"]).to eq(p1_id)
+          expect(yaml["name"]).to eq(p1_pretty)
+          expect(yaml["accepting_product"]).to eq(p1_id)
           expect(yaml["accepting_product_version"]).to eq(version)
         end
         expect(acc.persist(product_relationship, [p1])).to eq([])
       end
 
       describe "when license has children" do
-        let(:p2_name) { "inspec" }
+        let(:p2_id) { "bar" }
         let(:p2_filename) { "p2_filename" }
-        let(:p2) { instance_double(LicenseAcceptance::Product, name: p2_name, filename: p2_filename) }
+        let(:p2_pretty) { "Other Pretty Name" }
+        let(:p2) { instance_double(LicenseAcceptance::Product, id: p2_id, filename: p2_filename, pretty_name: p2_pretty) }
         let(:product_relationship) {
           instance_double(
             LicenseAcceptance::ProductRelationship,
@@ -68,15 +71,17 @@ RSpec.describe LicenseAcceptance::Strategy::File do
           expect(File).to receive(:open).with(File.join(dir3, p1_filename), mode).and_yield(file)
           expect(file).to receive(:<<) do |yaml|
             yaml = YAML.load(yaml)
-            expect(yaml["name"]).to eq(p1_name)
-            expect(yaml["accepting_product"]).to eq(p1_name)
+            expect(yaml["id"]).to eq(p1_id)
+            expect(yaml["name"]).to eq(p1_pretty)
+            expect(yaml["accepting_product"]).to eq(p1_id)
             expect(yaml["accepting_product_version"]).to eq(version)
           end
           expect(File).to receive(:open).with(File.join(dir3, p2_filename), mode).and_yield(file)
           expect(file).to receive(:<<) do |yaml|
             yaml = YAML.load(yaml)
-            expect(yaml["name"]).to eq(p2_name)
-            expect(yaml["accepting_product"]).to eq(p1_name)
+            expect(yaml["id"]).to eq(p2_id)
+            expect(yaml["name"]).to eq(p2_pretty)
+            expect(yaml["accepting_product"]).to eq(p1_id)
             expect(yaml["accepting_product_version"]).to eq(version)
           end
           expect(acc.persist(product_relationship, [p1, p2])).to eq([])
@@ -88,8 +93,9 @@ RSpec.describe LicenseAcceptance::Strategy::File do
             expect(File).to receive(:open).once.with(File.join(dir3, p2_filename), mode).and_yield(file)
             expect(file).to receive(:<<) do |yaml|
               yaml = YAML.load(yaml)
-              expect(yaml["name"]).to eq(p2_name)
-              expect(yaml["accepting_product"]).to eq(p1_name)
+              expect(yaml["id"]).to eq(p2_id)
+              expect(yaml["name"]).to eq(p2_pretty)
+              expect(yaml["accepting_product"]).to eq(p1_id)
               expect(yaml["accepting_product_version"]).to eq(version)
             end
             expect(acc.persist(product_relationship, [p2])).to eq([])

data/spec/license_acceptance/strategy/prompt_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe LicenseAcceptance::Strategy::Prompt do
   end
   let(:acc) { LicenseAcceptance::Strategy::Prompt.new(config) }
   let(:prompt) { instance_double(TTY::Prompt) }
-  let(:p1) { instance_double(LicenseAcceptance::Product, name: "name", pretty_name: "Pretty Name") }
+  let(:p1) { instance_double(LicenseAcceptance::Product, id: "foo", pretty_name: "Pretty Name") }
   let(:missing_licenses) { [p1] }
 
   before do
@@ -29,7 +29,7 @@ RSpec.describe LicenseAcceptance::Strategy::Prompt do
     end
 
     describe "when there are multiple products" do
-      let(:p2) { instance_double(LicenseAcceptance::Product, name: "other_name", pretty_name: "Other") }
+      let(:p2) { instance_double(LicenseAcceptance::Product, id: "bar", pretty_name: "Other") }
       let(:missing_licenses) { [p1, p2] }
       it "returns true" do
         expect(prompt).to receive(:ask).and_return("yes")

metadata

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