license-acceptance 1.0.11 → 2.0.0

data/spec/license_acceptance/cli_flags/mixlib_cli_spec.rb

@@ -1,14 +0,0 @@
-require "spec_helper"
-require "license_acceptance/cli_flags/mixlib_cli"
-
-class TestMixlibKlass
-  include Mixlib::CLI
-  include LicenseAcceptance::CLIFlags::MixlibCLI
-end
-
-RSpec.describe LicenseAcceptance::CLIFlags::MixlibCLI do
-  let(:klass) { TestMixlibKlass.new }
-  it "adds the correct command line flag" do
-    expect(klass.options).to include(:chef_license)
-  end
-end

data/spec/license_acceptance/cli_flags/thor_spec.rb

@@ -1,14 +0,0 @@
-require "spec_helper"
-require "license_acceptance/cli_flags/thor"
-require "thor"
-
-class TestThorKlass < Thor
-  include LicenseAcceptance::CLIFlags::Thor
-end
-
-RSpec.describe LicenseAcceptance::CLIFlags::Thor do
-  let(:klass) { TestThorKlass.new }
-  it "adds the correct command line flag" do
-    expect(klass.class.class_options.keys).to eq([:chef_license])
-  end
-end

data/spec/license_acceptance/config_spec.rb

@@ -1,111 +0,0 @@
-require "spec_helper"
-require "climate_control"
-require "license_acceptance/config"
-require "license_acceptance/product_relationship"
-
-RSpec.describe LicenseAcceptance::Config do
-  let(:opts) { {} }
-  let(:config) { LicenseAcceptance::Config.new(opts) }
-
-  it "loads correctly with default values" do
-    config
-  end
-
-  describe "with overwritten values" do
-    let(:output) { StringIO.new }
-    let(:logger) { "logger" }
-    let(:license_locations) { [] }
-    let(:persist_location) { "foo" }
-    let(:persist) { false }
-    let(:opts) { { output: output, logger: logger, license_locations: license_locations, persist_location: persist_location, persist: persist } }
-
-    it "loads correctly" do
-      expect(config.output).to eq(output)
-      expect(config.logger).to eq(logger)
-      expect(config.license_locations).to eq(license_locations)
-      expect(config.persist_location).to eq("foo")
-      expect(config.persist).to eq(false)
-    end
-  end
-
-  describe "#default_license_locations and #default_persist_location" do
-    before do
-      expect(Process).to receive(:uid).and_return(uid)
-    end
-
-    describe "when platform is Windows" do
-      before do
-        stub_const("RUBY_PLATFORM", "mingw")
-      end
-
-      describe "when user is Administrator" do
-        let(:uid) { 0 }
-
-        it "returns the default value" do
-          ClimateControl.modify HOMEDRIVE: "C:" do
-            expect(config.license_locations).to eq(["C:/chef/accepted_licenses/"])
-            expect(config.persist_location).to eq("C:/chef/accepted_licenses/")
-          end
-        end
-      end
-
-      describe "when user is not Administrator" do
-        let(:uid) { 1000 }
-
-        it "returns the default USERPROFILE value" do
-          ClimateControl.modify HOMEDRIVE: "C:", USERPROFILE: "C:/Users/foo", HOME: nil do
-            expect(Dir).to receive(:exist?).with("C:/Users/foo").and_return(true)
-            expect(config.license_locations).to eq([
-              "C:/chef/accepted_licenses/",
-              "C:/Users/foo/.chef/accepted_licenses/"
-            ])
-            expect(config.persist_location).to eq("C:/Users/foo/.chef/accepted_licenses/")
-          end
-        end
-
-        it "returns the default HOMEDRIVE + HOMEPATH value" do
-          ClimateControl.modify HOMEDRIVE: "C:", USERPROFILE: "C:/Users/bar", HOME: nil do
-            expect(Dir).to receive(:exist?).with("C:/Users/bar").and_return(true)
-            expect(config.license_locations).to eq([
-              "C:/chef/accepted_licenses/",
-              "C:/Users/bar/.chef/accepted_licenses/"
-            ])
-            expect(config.persist_location).to eq("C:/Users/bar/.chef/accepted_licenses/")
-          end
-        end
-      end
-
-    end
-
-    describe "when platform is non-Windows" do
-      before do
-        stub_const("RUBY_PLATFORM", "darwin")
-      end
-
-      describe "when user is root" do
-        let(:uid) { 0 }
-
-        it "returns the default value" do
-          expect(config.license_locations).to eq(["/etc/chef/accepted_licenses/"])
-          expect(config.persist_location).to eq("/etc/chef/accepted_licenses/")
-        end
-      end
-
-      describe "when user is not root" do
-        let(:uid) { 1000 }
-
-        it "returns the default user value" do
-          ClimateControl.modify HOME: "/Users/foo" do
-            expect(config.license_locations).to eq([
-              "/etc/chef/accepted_licenses/",
-              "/Users/foo/.chef/accepted_licenses/"
-            ])
-            expect(config.persist_location).to eq("/Users/foo/.chef/accepted_licenses/")
-          end
-        end
-      end
-
-    end
-  end
-
-end

data/spec/license_acceptance/product_reader_spec.rb

@@ -1,155 +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) { {"id" => "p1", "pretty_name" => "P1", "filename" => "f1", "mixlib_name" => "p1m", "license_required_version" => "p1v"} }
-  let(:p2) { {"id" => "p2", "pretty_name" => "P2", "filename" => "f2", "mixlib_name" => "p2m", "license_required_version" => "p2v"} }
-  # defined the `==` operator on Product for ease of comparison
-  let(:product1) { LicenseAcceptance::Product.new(p1["id"], p1["pretty_name"], p1["filename"], p1["mixlib_name"], p1["license_required_version"]) }
-  let(:product2) { LicenseAcceptance::Product.new(p2["id"], p2["pretty_name"], p2["filename"], p2["mixlib_name"], p2["license_required_version"]) }
-  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", "no_mixlib", "no_version") }
-    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
-
-  describe "::lookup_by_mixlib" 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 Product successfully" do
-      expect(reader.lookup_by_mixlib("p1m")).to eq(product1)
-    end
-
-    it "returns nil for an unknown product" do
-      expect(reader.lookup_by_mixlib("foo")).to eq(nil)
-    end
-  end
-
-end

data/spec/license_acceptance/product_spec.rb

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

data/spec/license_acceptance/strategy/argument_spec.rb

@@ -1,82 +0,0 @@
-require "spec_helper"
-require "license_acceptance/strategy/argument"
-
-RSpec.describe LicenseAcceptance::Strategy::Argument do
-  let(:acc) { LicenseAcceptance::Strategy::Argument.new(argv) }
-
-  describe "#accepted?" do
-    describe "when value is space seperated" do
-      let(:argv) { ["--chef-license", "accept"] }
-      it "returns true if the args contain the required flag with spaces" do
-        expect(acc.accepted?).to eq(true)
-      end
-    end
-
-    describe "when the value is equal seperated" do
-      let(:argv) { ["--chef-license=accept"] }
-      it "returns true if the args contain the required flag with equal" do
-        expect(acc.accepted?).to eq(true)
-      end
-    end
-
-    [ ["--chef-license"], ["--chef-license=foo"], ["--chef-license", "foo"] ].each do |v|
-      describe "when the value is #{v}" do
-        let(:argv) { v }
-        it "returns false if the args do not contain the required value" do
-          expect(acc.accepted?).to eq(false)
-        end
-      end
-    end
-  end
-
-  describe "#silent?" do
-    describe "when value is space seperated" do
-      let(:argv) { ["--chef-license", "accept-silent"] }
-      it "returns true if the args contain the required flag with spaces" do
-        expect(acc.silent?).to eq(true)
-      end
-    end
-
-    describe "when the value is equal seperated" do
-      let(:argv) { ["--chef-license=accept-silent"] }
-      it "returns true if the args contain the required flag with equal" do
-        expect(acc.silent?).to eq(true)
-      end
-    end
-
-    [ ["--chef-license"], ["--chef-license=accept"], ["--chef-license", "accept"] ].each do |v|
-      describe "when the value is #{v}" do
-        let(:argv) { v }
-        it "returns false if the args do not contain the required value" do
-          expect(acc.silent?).to eq(false)
-        end
-      end
-    end
-  end
-
-  describe "#no_persist?" do
-    describe "when value is space seperated" do
-      let(:argv) { ["--chef-license", "accept-no-persist"] }
-      it "returns true if the args contain the required flag with spaces" do
-        expect(acc.no_persist?).to eq(true)
-      end
-    end
-
-    describe "when the value is equal seperated" do
-      let(:argv) { ["--chef-license=accept-no-persist"] }
-      it "returns true if the args contain the required flag with equal" do
-        expect(acc.no_persist?).to eq(true)
-      end
-    end
-
-    [ ["--chef-license"], ["--chef-license=accept"], ["--chef-license", "accept"] ].each do |v|
-      describe "when the value is #{v}" do
-        let(:argv) { v }
-        it "returns false if the args do not contain the required value" do
-          expect(acc.no_persist?).to eq(false)
-        end
-      end
-    end
-  end
-
-end

data/spec/license_acceptance/strategy/environment_spec.rb

@@ -1,76 +0,0 @@
-require "spec_helper"
-require "license_acceptance/strategy/environment"
-
-RSpec.describe LicenseAcceptance::Strategy::Environment do
-  let(:acc) { LicenseAcceptance::Strategy::Environment.new(env) }
-
-  describe "#accepted?" do
-    describe "when the environment contains the correct key and value" do
-      let(:env) { {"CHEF_LICENSE" => "accept"} }
-      it "returns true" do
-        expect(acc.accepted?).to eq(true)
-      end
-    end
-
-    describe "when the env has a key but nil value" do
-      let(:env) { {"CHEF_LICENSE" => nil} }
-      it "returns false" do
-        expect(acc.accepted?).to eq(false)
-      end
-    end
-
-    describe "when the env has a key but incorrect value" do
-      let(:env) { {"CHEF_LICENSE" => "foo"} }
-      it "returns false" do
-        expect(acc.accepted?).to eq(false)
-      end
-    end
-  end
-
-  describe "#silent?" do
-    describe "when the environment contains the correct key and value" do
-      let(:env) { {"CHEF_LICENSE" => "accept-silent"} }
-      it "returns true" do
-        expect(acc.silent?).to eq(true)
-      end
-    end
-
-    describe "when the env has a key but nil value" do
-      let(:env) { {"CHEF_LICENSE" => nil} }
-      it "returns false" do
-        expect(acc.silent?).to eq(false)
-      end
-    end
-
-    describe "when the env has a key but incorrect value" do
-      let(:env) { {"CHEF_LICENSE" => "accept"} }
-      it "returns false" do
-        expect(acc.silent?).to eq(false)
-      end
-    end
-  end
-
-  describe "#no_persist?" do
-    describe "when the environment contains the correct key and value" do
-      let(:env) { {"CHEF_LICENSE" => "accept-no-persist"} }
-      it "returns true" do
-        expect(acc.no_persist?).to eq(true)
-      end
-    end
-
-    describe "when the env has a key but nil value" do
-      let(:env) { {"CHEF_LICENSE" => nil} }
-      it "returns false" do
-        expect(acc.no_persist?).to eq(false)
-      end
-    end
-
-    describe "when the env has a key but incorrect value" do
-      let(:env) { {"CHEF_LICENSE" => "accept-silent"} }
-      it "returns false" do
-        expect(acc.no_persist?).to eq(false)
-      end
-    end
-  end
-
-end