license-acceptance 1.0.13 → 2.1.2

data/spec/license_acceptance/strategy/file_spec.rb

@@ -1,127 +0,0 @@
-require "spec_helper"
-require "license_acceptance/config"
-require "license_acceptance/strategy/file"
-require "license_acceptance/product_relationship"
-require "license_acceptance/product"
-
-RSpec.describe LicenseAcceptance::Strategy::File do
-  let(:dir1) { "/dir1" }
-  let(:dir2) { "/dir2" }
-  let(:dir3) { "/dir3" }
-  let(:config) do
-    instance_double(LicenseAcceptance::Config, license_locations: [dir1, dir2], persist_location: dir3)
-  end
-  let(:acc) { LicenseAcceptance::Strategy::File.new(config) }
-  let(:p1_id) { "foo" }
-  let(:p1_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 }
-
-  describe "#check" 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.accepted?(product_relationship)).to eq([])
-      end
-    end
-
-    describe "when there is not an existing license file" 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.accepted?(product_relationship)).to eq([p1])
-      end
-    end
-
-    describe "#persist" do
-      let(:file) { double("file") }
-
-      it "stores a single license without children" do
-        expect(Dir).to receive(:exist?).with(dir3).and_return(true)
-        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["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_id) { "bar" }
-        let(:p2_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,
-            parent: p1,
-            children: [p2],
-            parent_version: version
-          )
-        }
-
-        it "stores a license file for all" do
-          expect(Dir).to receive(:exist?).with(dir3).and_return(true)
-          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["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["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([])
-        end
-
-        describe "when parent is already persisted" do
-          it "only stores a license file for the child" do
-            expect(Dir).to receive(:exist?).with(dir3).and_return(true)
-            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["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([])
-          end
-        end
-      end
-
-      describe "when the folder cannot be created" do
-        let(:err) { StandardError.new("foo") }
-        it "returns the error" do
-          expect(Dir).to receive(:exist?).with(dir3).and_return(false)
-          expect(FileUtils).to receive(:mkdir_p).and_raise(err)
-          expect(File).to_not receive(:open)
-          expect(acc.persist(product_relationship, [p1])).to eq([err])
-        end
-      end
-
-      describe "when the file cannot be written" do
-        let(:err) { StandardError.new("bar") }
-        it "returns the error" do
-          expect(Dir).to receive(:exist?).with(dir3).and_return(true)
-          expect(File).to receive(:open).with(File.join(dir3, p1_filename), mode).and_raise(err)
-          expect(acc.persist(product_relationship, [p1])).to eq([err])
-        end
-      end
-    end
-
-  end
-end

data/spec/license_acceptance/strategy/prompt_spec.rb

@@ -1,100 +0,0 @@
-require "spec_helper"
-require "license_acceptance/strategy/prompt"
-require "license_acceptance/product"
-require "tty-prompt"
-
-RSpec.describe LicenseAcceptance::Strategy::Prompt do
-  let(:output) { StringIO.new }
-  let(:config) do
-    instance_double(LicenseAcceptance::Config, output: output)
-  end
-  let(:acc) { LicenseAcceptance::Strategy::Prompt.new(config) }
-  let(:prompt) { instance_double(TTY::Prompt) }
-  let(:p1) { instance_double(LicenseAcceptance::Product, id: "foo", pretty_name: "Pretty Name") }
-  let(:missing_licenses) { [p1] }
-
-  before do
-    expect(TTY::Prompt).to receive(:new).at_least(:once).and_return(prompt)
-  end
-
-  describe "when the user accepts" do
-    it "returns true" do
-      expect(prompt).to receive(:ask).and_return("yes")
-      msg1 = /License that need accepting:\n  \* #{p1.pretty_name}/m
-      msg2 = /product license persisted\./
-      b = Proc.new { [] }
-      expect(acc.request(missing_licenses, &b)).to eq(true)
-      expect(output.string).to match(msg1)
-      expect(output.string).to match(msg2)
-    end
-
-    describe "when there are multiple products" do
-      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")
-        msg1 = /Licenses that need accepting:\n  \* #{p1.pretty_name}\n  \* #{p2.pretty_name}/m
-        msg2 = /product licenses persisted\./
-        msg3 = /2 product licenses\nmust be accepted/m
-        b = Proc.new { [] }
-        expect(acc.request(missing_licenses, &b)).to eq(true)
-        expect(output.string).to match(msg1)
-        expect(output.string).to match(msg2)
-        expect(output.string).to match(msg3)
-      end
-    end
-
-    describe "when the callback returns an error" do
-      it "returns true" do
-        expect(prompt).to receive(:ask).and_return("yes")
-        msg1 = /License that need accepting:\n  \* #{p1.pretty_name}/m
-        msg2 = /Could not persist acceptance:/
-        b = Proc.new { [StandardError.new("foo")] }
-        expect(acc.request(missing_licenses, &b)).to eq(true)
-        expect(output.string).to match(msg1)
-        expect(output.string).to match(msg2)
-      end
-    end
-  end
-
-  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::Strategy::PromptTimeout)
-      expect(prompt).to receive(:unsubscribe).twice
-      expect(prompt).to receive(:reader).twice
-      msg1 = /Prompt timed out./
-      b = Proc.new { [] }
-      expect(acc.request(missing_licenses, &b)).to eq(false)
-      expect(output.string).to match(msg1)
-    end
-  end
-
-  describe "when the user declines twice" do
-    it "returns false" do
-      expect(prompt).to receive(:ask).twice.and_return("no")
-      msg1 = /License that need accepting:\n  \* #{p1.pretty_name}/m
-      msg2 = /product license persisted\./
-      b = Proc.new { raise "should not be called" }
-      expect(acc.request(missing_licenses, &b)).to eq(false)
-      expect(output.string).to match(msg1)
-      expect(output.string).to_not match(msg2)
-    end
-  end
-
-  describe "when the user declines once then accepts" do
-    it "returns true" do
-      expect(prompt).to receive(:ask).and_return("no")
-      expect(prompt).to receive(:ask).and_return("yes")
-      msg1 = /License that need accepting:\n  \* #{p1.pretty_name}/m
-      msg2 = /product license persisted\./
-      msg3 = /If you do not accept this license you will\nnot be able to use Chef products/m
-      b = Proc.new { [] }
-      expect(acc.request(missing_licenses, &b)).to eq(true)
-      expect(output.string).to match(msg1)
-      expect(output.string).to match(msg2)
-      expect(output.string).to match(msg3)
-    end
-  end
-
-end

data/spec/license_acceptance/strategy/provided_value_spec.rb

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

data/spec/spec_helper.rb

@@ -1,25 +0,0 @@
-require "bundler/setup"
-require "license_acceptance/logger"
-require "logger"
-
-RSpec.configure do |config|
-  # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = ".rspec_status"
-
-  # Disable RSpec exposing methods globally on `Module` and `main`
-  config.disable_monkey_patching!
-
-  config.filter_run :focus => true
-  config.run_all_when_everything_filtered = true
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  config.before(:all) do
-    LicenseAcceptance::Logger.initialize(::Logger.new(IO::NULL))
-  end
-end