license-acceptance 0.2.10 → 0.2.13

data/spec/license_acceptance/{prompt_acceptance_spec.rb → strategy/prompt_spec.rb}

@@ -1,14 +1,14 @@
 require "spec_helper"
-require "license_acceptance/prompt_acceptance"
+require "license_acceptance/strategy/prompt"
 require "license_acceptance/product"
 require "tty-prompt"
 
-RSpec.describe LicenseAcceptance::PromptAcceptance do
+RSpec.describe LicenseAcceptance::Strategy::Prompt do
   let(:output) { StringIO.new }
   let(:config) do
     instance_double(LicenseAcceptance::Config, output: output)
   end
-  let(:acc) { LicenseAcceptance::PromptAcceptance.new(config) }
+  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(:missing_licenses) { [p1] }
@@ -60,7 +60,7 @@ RSpec.describe LicenseAcceptance::PromptAcceptance do
   describe "when the prompt times out" do
     it "returns false" do
       expect(Timeout).to receive(:timeout).twice.and_yield
-      expect(prompt).to receive(:ask).twice.and_raise(LicenseAcceptance::PromptTimeout)
+      expect(prompt).to receive(:ask).twice.and_raise(LicenseAcceptance::Strategy::PromptTimeout)
       expect(prompt).to receive(:unsubscribe).twice
       expect(prompt).to receive(:reader).twice
       msg1 = /Prompt timed out./

data/spec/license_acceptance/strategy/provided_value_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+require "license_acceptance/strategy/provided_value"
+
+RSpec.describe LicenseAcceptance::Strategy::ProvidedValue do
+  let(:acc) { LicenseAcceptance::Strategy::ProvidedValue.new(value) }
+
+  describe "#accepted?" do
+    describe "when the value is correct" do
+      let(:value) { "accept" }
+      it "returns true" do
+        expect(acc.accepted?).to eq(true)
+      end
+    end
+
+    describe "when the value is incorrect" do
+      let(:value) { nil }
+      it "returns false" do
+        expect(acc.accepted?).to eq(false)
+      end
+    end
+  end
+
+  describe "#silent?" do
+    describe "when the value is correct" do
+      let(:value) { "accept-silent" }
+      it "returns true" do
+        expect(acc.silent?).to eq(true)
+      end
+    end
+
+    describe "when the value is incorrect" do
+      let(:value) { "accept" }
+      it "returns false" do
+        expect(acc.silent?).to eq(false)
+      end
+    end
+  end
+
+  describe "#no_persist?" do
+    describe "when the value is correct" do
+      let(:value) { "accept-no-persist" }
+      it "returns true" do
+        expect(acc.no_persist?).to eq(true)
+      end
+    end
+
+    describe "when the value is incorrect" do
+      let(:value) { "accept-silent" }
+      it "returns false" do
+        expect(acc.no_persist?).to eq(false)
+      end
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: license-acceptance
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.13
 platform: ruby
 authors:
 - tyler-ball
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-16 00:00:00.000000000 Z
+date: 2019-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pastel
@@ -191,28 +191,31 @@ files:
 - Rakefile
 - config/product_info.toml
 - lib/license_acceptance/acceptor.rb
-- lib/license_acceptance/arg_acceptance.rb
 - lib/license_acceptance/cli_flags/mixlib_cli.rb
 - lib/license_acceptance/cli_flags/thor.rb
 - lib/license_acceptance/config.rb
-- lib/license_acceptance/env_acceptance.rb
-- lib/license_acceptance/file_acceptance.rb
 - lib/license_acceptance/logger.rb
 - lib/license_acceptance/product.rb
 - lib/license_acceptance/product_reader.rb
 - lib/license_acceptance/product_relationship.rb
-- lib/license_acceptance/prompt_acceptance.rb
+- lib/license_acceptance/strategy/argument.rb
+- lib/license_acceptance/strategy/base.rb
+- lib/license_acceptance/strategy/environment.rb
+- lib/license_acceptance/strategy/file.rb
+- lib/license_acceptance/strategy/prompt.rb
+- lib/license_acceptance/strategy/provided_value.rb
 - lib/license_acceptance/version.rb
 - spec/license_acceptance/acceptor_spec.rb
-- spec/license_acceptance/arg_acceptance_spec.rb
 - spec/license_acceptance/cli_flags/mixlib_cli_spec.rb
 - spec/license_acceptance/cli_flags/thor_spec.rb
 - spec/license_acceptance/config_spec.rb
-- spec/license_acceptance/env_acceptance_spec.rb
-- spec/license_acceptance/file_acceptance_spec.rb
 - spec/license_acceptance/product_reader_spec.rb
 - spec/license_acceptance/product_spec.rb
-- spec/license_acceptance/prompt_acceptance_spec.rb
+- spec/license_acceptance/strategy/argument_spec.rb
+- spec/license_acceptance/strategy/environment_spec.rb
+- spec/license_acceptance/strategy/file_spec.rb
+- spec/license_acceptance/strategy/prompt_spec.rb
+- spec/license_acceptance/strategy/provided_value_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/chef/license-acceptance/
 licenses:
@@ -226,7 +229,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/license_acceptance/arg_acceptance.rb

@@ -1,32 +0,0 @@
-module LicenseAcceptance
-  class ArgAcceptance
-
-    def accepted?(argv)
-      look_for_value(argv, "accept")
-    end
-
-    def silent?(argv)
-      look_for_value(argv, "accept-silent")
-    end
-
-    def no_persist?(argv)
-      look_for_value(argv, "accept-no-persist")
-    end
-
-    private
-
-    def look_for_value(argv, sought)
-      if argv.include?("--chef-license=#{sought}")
-        return true
-      end
-      i = argv.index("--chef-license")
-      unless i.nil?
-        val = argv[i+1]
-        if val != nil && val.downcase == sought
-          return true
-        end
-      end
-      return false
-    end
-  end
-end

data/lib/license_acceptance/env_acceptance.rb

@@ -1,26 +0,0 @@
-module LicenseAcceptance
-  class EnvAcceptance
-
-    def accepted?(env)
-      look_for_value(env, "accept")
-    end
-
-    def silent?(env)
-      look_for_value(env, "accept-silent")
-    end
-
-    def no_persist?(env)
-      look_for_value(env, "accept-no-persist")
-    end
-
-    private
-
-    def look_for_value(env, sought)
-      if env['CHEF_LICENSE'] && env['CHEF_LICENSE'].downcase == sought
-        return true
-      end
-      return false
-    end
-
-  end
-end

data/lib/license_acceptance/file_acceptance.rb

@@ -1,97 +0,0 @@
-require 'date'
-require 'yaml'
-require 'fileutils'
-require 'etc'
-require "license_acceptance/logger"
-
-module LicenseAcceptance
-  class FileAcceptance
-    include Logger
-
-    attr_reader :config
-
-    def initialize(config)
-      @config = config
-    end
-
-    INVOCATION_TIME = DateTime.now.freeze
-
-    # For all the given products in the product set, search all possible locations for the
-    # license acceptance files.
-    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)}")
-
-      searching.each do |product|
-        found = false
-        config.license_locations.each do |loc|
-          f = File.join(loc, product.filename)
-          if File.exist?(f)
-            found = true
-            logger.debug("Found license #{product.filename} at #{f}")
-            missing_licenses.delete(product)
-            break
-          end
-        end
-        break if missing_licenses.empty?
-      end
-      logger.debug("Missing licenses remaining: #{missing_licenses.map(&:name)}")
-      missing_licenses
-    end
-
-    def persist(product_relationship, missing_licenses)
-      parent = product_relationship.parent
-      parent_version = product_relationship.parent_version
-      root_dir = config.persist_location
-
-      if !Dir.exist?(root_dir)
-        begin
-          FileUtils.mkdir_p(root_dir)
-        rescue StandardError => e
-          msg = "Could not create license directory #{root_dir}"
-          logger.info "#{msg}\n\t#{e.message}\n\t#{e.backtrace.join("\n\t")}"
-          return [e]
-        end
-      end
-
-      errs = []
-      if missing_licenses.include?(parent)
-        err = persist_license(root_dir, parent, parent, parent_version)
-        errs << err unless err.nil?
-      end
-      product_relationship.children.each do |child|
-        if missing_licenses.include?(child)
-          err = persist_license(root_dir, child, parent, parent_version)
-          errs << err unless err.nil?
-        end
-      end
-      return errs
-    end
-
-    private
-
-    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}")
-      File.open(path, File::WRONLY | File::CREAT | File::EXCL) do |license_file|
-        contents = {
-          name: product.name,
-          date_accepted: INVOCATION_TIME.iso8601,
-          accepting_product: parent.name,
-          accepting_product_version: parent_version,
-          user: Etc.getlogin,
-          file_format: 1,
-        }
-        contents = Hash[contents.map { |k, v| [k.to_s, v] }]
-        license_file << YAML.dump(contents)
-      end
-      return nil
-    rescue StandardError => e
-      msg = "Could not persist license to #{path}"
-      logger.info "#{msg}\n\t#{e.message}\n\t#{e.backtrace.join("\n\t")}"
-      return e
-    end
-
-  end
-end

data/lib/license_acceptance/prompt_acceptance.rb

@@ -1,106 +0,0 @@
-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"
-      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

data/spec/license_acceptance/arg_acceptance_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-require "license_acceptance/arg_acceptance"
-
-RSpec.describe LicenseAcceptance::ArgAcceptance do
-  let(:acc) { LicenseAcceptance::ArgAcceptance.new }
-
-  describe "with an accept option" do
-    describe "#accepted?" do
-      it "returns true if the args contain the required flag with spaces" do
-        expect(acc.accepted?(["--chef-license", "accept"])).to eq(true)
-      end
-
-      it "returns true if the args contain the required flag with equal" do
-        expect(acc.accepted?(["--chef-license=accept"])).to eq(true)
-      end
-
-      it "returns false if the args do not contain the required value" do
-        expect(acc.accepted?(["--chef-license"])).to eq(false)
-        expect(acc.accepted?(["--chef-license=foo"])).to eq(false)
-        expect(acc.accepted?(["--chef-license", "foo"])).to eq(false)
-      end
-    end
-
-    describe "#silent?" do
-      it "returns true if the args contain the required flag with spaces" do
-        expect(acc.silent?(["--chef-license", "accept-silent"])).to eq(true)
-      end
-
-      it "returns true if the args contain the required flag with equal" do
-        expect(acc.silent?(["--chef-license=accept-silent"])).to eq(true)
-      end
-
-      it "returns false if the args do not contain the required value" do
-        expect(acc.silent?(["--chef-license"])).to eq(false)
-        expect(acc.silent?(["--chef-license=accept"])).to eq(false)
-        expect(acc.silent?(["--chef-license", "accept"])).to eq(false)
-      end
-    end
-  end
-
-  describe "#no_persist?" do
-    it "returns true if the args contain the required flag with spaces" do
-      expect(acc.no_persist?(["--chef-license", "accept-no-persist"])).to eq(true)
-    end
-
-    it "returns true if the args contain the required flag with equal" do
-      expect(acc.no_persist?(["--chef-license=accept-no-persist"])).to eq(true)
-    end
-
-    it "returns false if the args do not contain the required value" do
-      expect(acc.no_persist?(["--chef-license"])).to eq(false)
-      expect(acc.no_persist?(["--chef-license=accept"])).to eq(false)
-      expect(acc.no_persist?(["--chef-license", "accept"])).to eq(false)
-    end
-  end
-
-end