license-acceptance 0.0.1 → 0.2.1

data/lib/license_acceptance/logger.rb

@@ -0,0 +1,19 @@
+require "license_acceptance/config"
+
+module LicenseAcceptance
+  module Logger
+
+    def self.initialize(logger)
+      @logger ||= logger
+    end
+
+    def self.logger
+      @logger
+    end
+
+    def logger
+      Logger.logger
+    end
+
+  end
+end

data/lib/license_acceptance/product.rb

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

data/lib/license_acceptance/product_reader.rb

@@ -0,0 +1,108 @@
+require "tomlrb"
+require "license_acceptance/logger"
+require "license_acceptance/product"
+require "license_acceptance/product_relationship"
+
+module LicenseAcceptance
+  class ProductReader
+    include Logger
+
+    attr_accessor :products, :relationships
+
+    def read
+      logger.debug("Reading products and relationships...")
+      location = get_location
+      self.products = {}
+      self.relationships = {}
+
+      toml = Tomlrb.load_file(location, symbolize_keys: false)
+      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"])
+      end
+
+      for parent_name, children in toml["relationships"]
+        parent = products[parent_name]
+        raise UnknownParent.new(parent_name) 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?
+          child
+        end
+        relationships[parent] = children
+      end
+
+      logger.debug("Successfully read products and relationships")
+    end
+
+    def get_location
+      # For local development point this to the product_info.toml at the root of the repo.
+      # When bundled as a gem we will use the the relative path to find the file in the
+      # gem package.
+      if ENV["CHEF_LICENSE_PRODUCT_INFO"]
+        return ENV["CHEF_LICENSE_PRODUCT_INFO"]
+      end
+      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)
+      end
+      children = relationships.fetch(parent_product, [])
+      if !parent_version.is_a? String
+        raise ProductVersionTypeError.new(parent_version)
+      end
+      ProductRelationship.new(parent_product, children, parent_version)
+    end
+
+  end
+
+  class UnknownProduct < RuntimeError
+    def initialize(product)
+      msg = "Unknown product '#{product}' - this represents a developer error"
+      super(msg)
+    end
+  end
+
+  class InvalidProductInfo < RuntimeError
+    def initialize(path)
+      msg = "Product info at path #{path} is invalid. Must list Products and relationships."
+      super(msg)
+    end
+  end
+
+  class UnknownParent < RuntimeError
+    def initialize(product)
+      msg = "Could not find product #{product} from relationship parents"
+      super(msg)
+    end
+  end
+
+  class UnknownChild < RuntimeError
+    def initialize(product)
+      msg = "Could not find product #{product} from relationship children"
+      super(msg)
+    end
+  end
+
+  class NoChildRelationships < RuntimeError
+    def initialize(product)
+      msg = "No child relationships for #{product.name}, should be removed from product info or fixed"
+      super(msg)
+    end
+  end
+
+  class ProductVersionTypeError < RuntimeError
+    def initialize(product_version)
+      msg = "Product versions must be specified as a string, provided type is '#{product_version.class}'"
+      super(msg)
+    end
+  end
+end

data/lib/license_acceptance/product_relationship.rb

@@ -0,0 +1,13 @@
+module LicenseAcceptance
+  class ProductRelationship
+
+    attr_reader :parent, :children, :parent_version
+
+    def initialize(parent, children, parent_version)
+      @parent = parent
+      @children = children
+      @parent_version = parent_version
+    end
+
+  end
+end

data/lib/license_acceptance/prompt_acceptance.rb

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

data/lib/license_acceptance/version.rb

@@ -0,0 +1,3 @@
+module LicenseAcceptance
+  VERSION = "0.2.1"
+end

data/spec/license_acceptance/acceptor_spec.rb

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