license-acceptance 0.0.1 → 0.2.1

data/spec/license_acceptance/arg_acceptance_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+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)
+    end
+
+    it "returns true if the args contain the required flag with equal" do
+      expect(acc.check(["--chef-license=accept"])).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)
+    end
+  end
+
+  describe "#check_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)
+    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)
+    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)
+    end
+  end
+
+end

data/spec/license_acceptance/cli_flags/mixlib_cli_spec.rb

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

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

@@ -0,0 +1,113 @@
+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) }
+  let(:platform) { instance_double(TTY::Platform) }
+
+  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(TTY::Platform).to receive(:new).and_return(platform)
+      expect(Process).to receive(:uid).and_return(uid)
+    end
+
+    describe "when platform is Windows" do
+      before do
+        expect(platform).to receive(:windows?).and_return(true)
+      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
+        expect(platform).to receive(:windows?).and_return(false)
+      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/env_acceptance_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+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
+
+    it "returns false if the env has a key but nil value" do
+      env = {"CHEF_LICENSE" => nil}
+      expect(acc.check(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(env)).to eq(false)
+    end
+  end
+
+  describe "#check_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)
+    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)
+    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)
+      env = {"CHEF_LICENSE" => "accept"}
+      expect(acc.check_no_persist(env)).to eq(false)
+    end
+  end
+
+end

data/spec/license_acceptance/file_acceptance_spec.rb

@@ -0,0 +1,121 @@
+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.check(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.check(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

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