license-acceptance 0.2.10 → 2.1.13

data/spec/license_acceptance/env_acceptance_spec.rb

@@ -1,65 +0,0 @@
-require "spec_helper"
-require "license_acceptance/env_acceptance"
-
-RSpec.describe LicenseAcceptance::EnvAcceptance do
-  let(:acc) { LicenseAcceptance::EnvAcceptance.new }
-
-  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.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
-
-    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 "#no_persist?" do
-    it "returns true if the env contains the correct key and value" do
-      env = {"CHEF_LICENSE" => "accept-no-persist"}
-      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.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.no_persist?(env)).to eq(false)
-      env = {"CHEF_LICENSE" => "accept"}
-      expect(acc.no_persist?(env)).to eq(false)
-    end
-  end
-
-end

data/spec/license_acceptance/file_acceptance_spec.rb

@@ -1,121 +0,0 @@
-require "spec_helper"
-require "license_acceptance/config"
-require "license_acceptance/file_acceptance"
-require "license_acceptance/product_relationship"
-require "license_acceptance/product"
-
-RSpec.describe LicenseAcceptance::FileAcceptance 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::FileAcceptance.new(config) }
-  let(:p1_name) { "chef_client" }
-  let(:p1_filename) { "p1_filename" }
-  let(:p1) { instance_double(LicenseAcceptance::Product, name: p1_name, filename: p1_filename) }
-  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["name"]).to eq(p1_name)
-          expect(yaml["accepting_product"]).to eq(p1_name)
-          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_filename) { "p2_filename" }
-        let(:p2) { instance_double(LicenseAcceptance::Product, name: p2_name, filename: p2_filename) }
-        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["name"]).to eq(p1_name)
-            expect(yaml["accepting_product"]).to eq(p1_name)
-            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["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["name"]).to eq(p2_name)
-              expect(yaml["accepting_product"]).to eq(p1_name)
-              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/product_reader_spec.rb

@@ -1,139 +0,0 @@
-require "spec_helper"
-require "license_acceptance/product_reader"
-require "license_acceptance/product_relationship"
-
-RSpec.describe LicenseAcceptance::ProductReader do
-  let(:reader) { LicenseAcceptance::ProductReader.new }
-  let(:version) { "0.1.0" }
-  let(:location) { "location" }
-
-  let(:p1) { {"name" => "p1", "pretty_name" => "P1", "filename" => "f1"} }
-  let(:p2) { {"name" => "p2", "pretty_name" => "P2", "filename" => "f2"} }
-  # defined the `==` operator on Product for ease of comparison
-  let(:product1) { LicenseAcceptance::Product.new(p1["name"], p1["pretty_name"], p1["filename"]) }
-  let(:product2) { LicenseAcceptance::Product.new(p2["name"], p2["pretty_name"], p2["filename"]) }
-  let(:r1) { {p1 => p2} }
-  let(:toml) { {"products" => [p1, p2], "relationships" => {"p1" => ["p2"]}} }
-
-  describe "#read" do
-    it "reads products and relationships" do
-      expect(reader).to receive(:get_location).and_return(location)
-      expect(Tomlrb).to receive(:load_file).with(location, symbolize_keys: false).and_return(toml)
-      reader.read
-      expect(reader.products).to eq({
-        "p1" => product1,
-        "p2" => product2
-      })
-      expect(reader.relationships.size).to eq(1)
-      expect(reader.relationships.first).to eq([product1, [product2]])
-    end
-
-    describe "with an empty file" do
-      it "raises a InvalidProductInfo error" do
-        expect(reader).to receive(:get_location).and_return(location)
-        expect(Tomlrb).to receive(:load_file).with(location, symbolize_keys: false).and_return({})
-
-        expect { reader.read }.to raise_error(LicenseAcceptance::InvalidProductInfo)
-      end
-    end
-
-    describe "with an unknown parent" do
-      let(:toml) { {"products" => [p1, p2], "relationships" => {"p3" => ["p2"]}} }
-
-      it "raises a UnknownParent error" do
-        expect(reader).to receive(:get_location).and_return(location)
-        expect(Tomlrb).to receive(:load_file).with(location, symbolize_keys: false).and_return(toml)
-
-        expect { reader.read }.to raise_error(LicenseAcceptance::UnknownParent)
-      end
-    end
-
-    describe "with a relationship of nil children" do
-      let(:toml) { {"products" => [p1], "relationships" => {"p1" => nil}} }
-
-      it "raises a NoChildRelationships error" do
-        expect(reader).to receive(:get_location).and_return(location)
-        expect(Tomlrb).to receive(:load_file).with(location, symbolize_keys: false).and_return(toml)
-
-        expect { reader.read }.to raise_error(LicenseAcceptance::NoChildRelationships)
-      end
-    end
-
-    describe "with a relationship of empty children" do
-      let(:toml) { {"products" => [p1], "relationships" => {"p1" => []}} }
-
-      it "raises a NoChildRelationships error" do
-        expect(reader).to receive(:get_location).and_return(location)
-        expect(Tomlrb).to receive(:load_file).with(location, symbolize_keys: false).and_return(toml)
-
-        expect { reader.read }.to raise_error(LicenseAcceptance::NoChildRelationships)
-      end
-    end
-
-    describe "with a relationship of non-array children" do
-      let(:toml) { {"products" => [p1], "relationships" => {"p1" => "p2"}} }
-
-      it "raises a NoChildRelationships error" do
-        expect(reader).to receive(:get_location).and_return(location)
-        expect(Tomlrb).to receive(:load_file).with(location, symbolize_keys: false).and_return(toml)
-
-        expect { reader.read }.to raise_error(LicenseAcceptance::NoChildRelationships)
-      end
-    end
-
-    describe "with an unknown child" do
-      let(:toml) { {"products" => [p1, p2], "relationships" => {"p1" => ["p2", "p3"]}} }
-
-      it "raises a UnknownChild error" do
-        expect(reader).to receive(:get_location).and_return(location)
-        expect(Tomlrb).to receive(:load_file).with(location, symbolize_keys: false).and_return(toml)
-
-        expect { reader.read }.to raise_error(LicenseAcceptance::UnknownChild)
-      end
-    end
-  end
-
-  describe "::lookup" do
-    before do
-      expect(reader).to receive(:get_location).and_return(location)
-      expect(Tomlrb).to receive(:load_file).with(location, symbolize_keys: false).and_return(toml)
-      reader.read
-    end
-
-    it "returns a ProductRelationship instance successfully" do
-      expect(reader.lookup("p1", version)).to be_an_instance_of(LicenseAcceptance::ProductRelationship) do |instance|
-        expect(instance.parent_product).to eq(product1)
-        expect(instance.children).to eq([prouct2])
-        expect(instance.version).to eq(version)
-      end
-    end
-
-    describe "when called on an unknown product" do
-      it "raises an UnknownProduct error" do
-        expect { reader.lookup("DNE", nil) }.to raise_error(LicenseAcceptance::UnknownProduct)
-      end
-    end
-
-    let(:nonya) { LicenseAcceptance::Product.new("nonya", "NonYa", "nofile") }
-    describe "when called on a product with no relationship" do
-      before do
-        reader.products = { "nonya" => nonya }
-      end
-
-      it "returns the product" do
-        expect(reader.lookup('nonya', version)).to be_an_instance_of(LicenseAcceptance::ProductRelationship) do |instance|
-          expect(instance.parent_product).to eq(nonya)
-          expect(instance.children).to eq([])
-          expect(instance.version).to eq(version)
-        end
-      end
-    end
-
-    describe "when called with an invalid parent version type" do
-      it "raises an ProductVersionTypeError error" do
-        expect { reader.lookup("p1", 1) }.to raise_error(LicenseAcceptance::ProductVersionTypeError)
-      end
-    end
-  end
-
-end

data/spec/license_acceptance/product_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-require "license_acceptance/product"
-
-RSpec.describe LicenseAcceptance::Product do
-  let(:instance) { LicenseAcceptance::Product.new("name", "Pretty Name", "filename") }
-
-  it "can lookup the product attributes" do
-    expect(instance.name).to eq("name")
-    expect(instance.pretty_name).to eq("Pretty Name")
-    expect(instance.filename).to eq("filename")
-  end
-
-end

data/spec/license_acceptance/prompt_acceptance_spec.rb

@@ -1,100 +0,0 @@
-require "spec_helper"
-require "license_acceptance/prompt_acceptance"
-require "license_acceptance/product"
-require "tty-prompt"
-
-RSpec.describe LicenseAcceptance::PromptAcceptance do
-  let(:output) { StringIO.new }
-  let(:config) do
-    instance_double(LicenseAcceptance::Config, output: output)
-  end
-  let(:acc) { LicenseAcceptance::PromptAcceptance.new(config) }
-  let(:prompt) { instance_double(TTY::Prompt) }
-  let(:p1) { instance_double(LicenseAcceptance::Product, name: "name", 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, name: "other_name", 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::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/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