license-acceptance 0.2.6 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f86114ca5b22ab56cb28a423f3c60cd092241b8541bbf569002a5003e08da1f7
-  data.tar.gz: 1347d3b7392ecbb2730b8fb4b5a7039efede80f8518443bd816b307af0c986e4
+  metadata.gz: d112a4c55882d1077473a7a895c41dc1ea39a44318fd875cf67e3055bf71e3ba
+  data.tar.gz: f37d0e22fb520876b151b063779355eb9f8ce6453ebc53c28880f2622de03297
 SHA512:
-  metadata.gz: d8bbb8bae60146e0736abdc9b7492b69c0b822936f13411b9159b7267d341910f2a6d6a76dd9f2e5120b7e7bb7568c88c0a8b0a9ed61d1e99b7c11f0ca0757fd
-  data.tar.gz: b829ddf04523ec275a961449befde2f0b978e313e0264c799a77659a13fa95ff6d3b17bf00a3a5dc768867d8b1bb652fa9dbfc94746a49c5aa8834b1fce5be89
+  metadata.gz: 0b44866f1295dd5b862df99648fb8904e7041d90edfa502b8d2ee122d1da8bfc93075b83fa614102a190607a5b900c97479491fbad894cbcd61b69cebab7b1ea
+  data.tar.gz: eecca8e33010d24877e1e5839cb6bddc89c6fc8467feba8f2a41b6f5dbe06fe9ceb9fc438712999c8a7db5baa73b422e572ffe46d6eb9fec2a0df78c25159101

data/Gemfile.lock

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

data/lib/license_acceptance/acceptor.rb

@@ -38,7 +38,7 @@ module LicenseAcceptance
     end
 
     def check_and_persist(product_name, version)
-      if env_acceptance.check_no_persist(ENV) || arg_acceptance.check_no_persist(ARGV)
+      if accepted_no_persist?
         logger.debug("Chef License accepted with no persistence")
         return true
       end
@@ -46,7 +46,7 @@ module LicenseAcceptance
       product_reader.read
       product_relationship = product_reader.lookup(product_name, version)
 
-      missing_licenses = file_acceptance.check(product_relationship)
+      missing_licenses = file_acceptance.accepted?(product_relationship)
 
       # They have already accepted all licenses and stored their acceptance in the persistent files
       if missing_licenses.empty?
@@ -54,11 +54,11 @@ module LicenseAcceptance
         return true
       end
 
-      if env_acceptance.check(ENV) || arg_acceptance.check(ARGV)
+      if accepted? || accepted_silent?
         if config.persist
           errs = file_acceptance.persist(product_relationship, missing_licenses)
           if errs.empty?
-            output_num_persisted(missing_licenses.size)
+            output_num_persisted(missing_licenses.size) unless accepted_silent?
           else
             output_persist_failed(errs)
           end
@@ -85,6 +85,20 @@ module LicenseAcceptance
       new(opts).check_and_persist(product_name, version)
     end
 
+    def accepted?
+      env_acceptance.accepted?(ENV) || arg_acceptance.accepted?(ARGV)
+    end
+
+    # no-persist is silent too
+    def accepted_no_persist?
+      env_acceptance.no_persist?(ENV) || arg_acceptance.no_persist?(ARGV)
+    end
+
+    # persist but be silent like no-persist
+    def accepted_silent?
+      env_acceptance.silent?(ENV) || arg_acceptance.silent?(ARGV)
+    end
+
     # In the case where users accept with a command line argument or environment variable
     # we still want to output the fact that the filesystem was changed.
     def output_num_persisted(count)

data/lib/license_acceptance/arg_acceptance.rb

@@ -1,33 +1,32 @@
 module LicenseAcceptance
   class ArgAcceptance
 
-    def check(argv)
-      if argv.include?("--chef-license=accept")
-        return true
-      end
-      i = argv.index("--chef-license")
-      unless i.nil?
-        val = argv[i+1]
-        if val != nil && val.downcase == "accept"
-          return true
-        end
-      end
-      return false
+    def accepted?(argv)
+      look_for_value(argv, "accept")
+    end
+
+    def silent?(argv)
+      look_for_value(argv, "accept-silent")
     end
 
-    def check_no_persist(argv)
-      if argv.include?("--chef-license=accept-no-persist")
+    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 == "accept-no-persist"
+        if val != nil && val.downcase == sought
           return true
         end
       end
       return false
     end
-
   end
 end

data/lib/license_acceptance/cli_flags/mixlib_cli.rb

@@ -12,7 +12,7 @@ module LicenseAcceptance
       def self.included(klass)
         klass.option :chef_license,
           long: "--chef-license ACCEPTANCE",
-          description: "Accept the license for this product and any contained products ('accept' or 'accept-no-persist')",
+          description: "Accept the license for this product and any contained products ('accept', 'accept-no-persist', or 'accept-silent')",
           required: false
       end
 

data/lib/license_acceptance/cli_flags/thor.rb

@@ -12,7 +12,7 @@ module LicenseAcceptance
       def self.included(klass)
         klass.class_option :chef_license,
           type: :string,
-          desc: 'Accept the license for this product and any contained products: accept, accept-no-persist'
+          desc: 'Accept the license for this product and any contained products: accept, accept-no-persist, accept-silent'
       end
 
     end

data/lib/license_acceptance/env_acceptance.rb

@@ -1,15 +1,22 @@
 module LicenseAcceptance
   class EnvAcceptance
 
-    def check(env)
-      if env['CHEF_LICENSE'] && env['CHEF_LICENSE'].downcase == 'accept'
-        return true
-      end
-      return false
+    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
 
-    def check_no_persist(env)
-      if env['CHEF_LICENSE'] && env['CHEF_LICENSE'].downcase == 'accept-no-persist'
+    private
+
+    def look_for_value(env, sought)
+      if env['CHEF_LICENSE'] && env['CHEF_LICENSE'].downcase == sought
         return true
       end
       return false

data/lib/license_acceptance/file_acceptance.rb

@@ -18,7 +18,7 @@ module LicenseAcceptance
 
     # For all the given products in the product set, search all possible locations for the
     # license acceptance files.
-    def check(product_relationship)
+    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)}")

data/lib/license_acceptance/version.rb

@@ -1,3 +1,3 @@
 module LicenseAcceptance
-  VERSION = "0.2.6"
+  VERSION = "0.2.8"
 end

data/spec/license_acceptance/acceptor_spec.rb

@@ -45,38 +45,40 @@ RSpec.describe LicenseAcceptance::Acceptor do
 
     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(env_acc).to receive(: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(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)
       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(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(:check).with(relationship).and_return([])
+        expect(file_acc).to receive(:accepted?).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(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(:check).with(relationship).and_return(missing)
-        expect(env_acc).to receive(:check).with(ENV).and_return(true)
+        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(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./)
@@ -86,25 +88,43 @@ RSpec.describe LicenseAcceptance::Acceptor 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(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(:check).with(relationship).and_return(missing)
-          expect(env_acc).to receive(:check).with(ENV).and_return(true)
+          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
+          expect(env_acc).to receive(:accepted?).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 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?).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(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
+        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(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(:check).with(relationship).and_return(missing)
-          expect(env_acc).to receive(:check).with(ENV).and_return(true)
+          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
+          expect(env_acc).to receive(:accepted?).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:/)
@@ -114,29 +134,51 @@ RSpec.describe LicenseAcceptance::Acceptor do
 
     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(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(: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(: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(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 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(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
+        end
+      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(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(: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(: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(acc.check_and_persist(product, version)).to eq(true)
           expect(output.string).to_not match(/accepted./)
         end
@@ -144,13 +186,13 @@ RSpec.describe LicenseAcceptance::Acceptor do
 
       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(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(: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(: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(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:/)
@@ -161,13 +203,15 @@ 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(:check_no_persist).and_return(false)
-        expect(arg_acc).to receive(:check_no_persist).and_return(false)
+        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(: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(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)
       end
@@ -175,13 +219,15 @@ RSpec.describe LicenseAcceptance::Acceptor do
 
     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(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(: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(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)
@@ -191,13 +237,15 @@ RSpec.describe LicenseAcceptance::Acceptor 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(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(: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(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)
         end
@@ -206,13 +254,15 @@ RSpec.describe LicenseAcceptance::Acceptor do
 
     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(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(: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(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)
       end

data/spec/license_acceptance/arg_acceptance_spec.rb

@@ -4,33 +4,53 @@ require "license_acceptance/arg_acceptance"
 RSpec.describe LicenseAcceptance::ArgAcceptance do
   let(:acc) { LicenseAcceptance::ArgAcceptance.new }
 
-  describe "#check" do
-    it "returns true if the args contain the required flag with spaces" do
-      expect(acc.check(["--chef-license", "accept"])).to eq(true)
+  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
 
-    it "returns true if the args contain the required flag with equal" do
-      expect(acc.check(["--chef-license=accept"])).to eq(true)
-    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 false if the args do not contain the required value" do
-      expect(acc.check(["--chef-license"])).to eq(false)
+      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 "#check_no_persist" do
+  describe "#no_persist?" do
     it "returns true if the args contain the required flag with spaces" do
-      expect(acc.check_no_persist(["--chef-license", "accept-no-persist"])).to eq(true)
+      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.check_no_persist(["--chef-license=accept-no-persist"])).to eq(true)
+      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.check_no_persist(["--chef-license"])).to eq(false)
-      expect(acc.check_no_persist(["--chef-license=accept"])).to eq(false)
-      expect(acc.check_no_persist(["--chef-license","accept"])).to eq(false)
+      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
 

data/spec/license_acceptance/env_acceptance_spec.rb

@@ -4,39 +4,61 @@ require "license_acceptance/env_acceptance"
 RSpec.describe LicenseAcceptance::EnvAcceptance do
   let(:acc) { LicenseAcceptance::EnvAcceptance.new }
 
-  describe "#check" do
-    it "returns true if the env contains the correct key and value" do
-      env = {"CHEF_LICENSE" => "accept"}
-      expect(acc.check(env)).to eq(true)
-    end
+  describe "when passed an accept value" do
+    describe "#accepted?" do
+      it "returns true if the env contains the correct key and value" do
+        env = {"CHEF_LICENSE" => "accept"}
+        expect(acc.accepted?(env)).to eq(true)
+      end
 
-    it "returns false if the env has a key but nil value" do
-      env = {"CHEF_LICENSE" => nil}
-      expect(acc.check(env)).to eq(false)
+      it "returns false if the env has a key but nil value" do
+        env = {"CHEF_LICENSE" => nil}
+        expect(acc.accepted?(env)).to eq(false)
+      end
+
+      it "returns false if the env has a key but incorrect value" do
+        env = {"CHEF_LICENSE" => "foo"}
+        expect(acc.accepted?(env)).to eq(false)
+      end
     end
 
-    it "returns false if the env has a key but incorrect value" do
-      env = {"CHEF_LICENSE" => "foo"}
-      expect(acc.check(env)).to eq(false)
+    describe "#silent?" do
+      it "returns true if the env contains the correct key and value" do
+        env = {"CHEF_LICENSE" => "accept-silent"}
+        expect(acc.silent?(env)).to eq(true)
+      end
+
+      it "returns false if the env has a key but nil value" do
+        env = {"CHEF_LICENSE" => nil}
+        expect(acc.silent?(env)).to eq(false)
+      end
+
+      it "returns false if the env has a key but incorrect value" do
+        env = {"CHEF_LICENSE" => "foo"}
+        expect(acc.silent?(env)).to eq(false)
+        env = {"CHEF_LICENSE" => "accept"}
+        expect(acc.silent?(env)).to eq(false)
+      end
     end
+
   end
 
-  describe "#check_no_persist" do
+  describe "#no_persist?" do
     it "returns true if the env contains the correct key and value" do
       env = {"CHEF_LICENSE" => "accept-no-persist"}
-      expect(acc.check_no_persist(env)).to eq(true)
+      expect(acc.no_persist?(env)).to eq(true)
     end
 
     it "returns false if the env has a key but nil value" do
       env = {"CHEF_LICENSE" => nil}
-      expect(acc.check_no_persist(env)).to eq(false)
+      expect(acc.no_persist?(env)).to eq(false)
     end
 
     it "returns false if the env has a key but incorrect value" do
       env = {"CHEF_LICENSE" => "foo"}
-      expect(acc.check_no_persist(env)).to eq(false)
+      expect(acc.no_persist?(env)).to eq(false)
       env = {"CHEF_LICENSE" => "accept"}
-      expect(acc.check_no_persist(env)).to eq(false)
+      expect(acc.no_persist?(env)).to eq(false)
     end
   end
 

data/spec/license_acceptance/file_acceptance_spec.rb

@@ -23,7 +23,7 @@ RSpec.describe LicenseAcceptance::FileAcceptance do
     describe "when there is an existing license file" do
       it "returns an empty missing product list" do
         expect(File).to receive(:exist?).with(File.join(dir1, p1_filename)).and_return(true)
-        expect(acc.check(product_relationship)).to eq([])
+        expect(acc.accepted?(product_relationship)).to eq([])
       end
     end
 
@@ -31,7 +31,7 @@ RSpec.describe LicenseAcceptance::FileAcceptance do
       it "returns the product in the missing product list" do
         expect(File).to receive(:exist?).with(File.join(dir1, p1_filename)).and_return(false)
         expect(File).to receive(:exist?).with(File.join(dir2, p1_filename)).and_return(false)
-        expect(acc.check(product_relationship)).to eq([p1])
+        expect(acc.accepted?(product_relationship)).to eq([p1])
       end
     end
 

metadata

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