license-acceptance 1.0.13 → 1.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fef5c00ef5400506f147e81de6189cac6b2b62a3072c3b5ce947e1ea1cf45d9b
-  data.tar.gz: 05a004b7385c49d4b32b45df716e720ca406b011e15a8f270e9f27e79f13a740
+  metadata.gz: 857078f9f2d4c9d74fcb5a08876039fa5930c3f7286b1a7d03e2a84bda4d229b
+  data.tar.gz: c7c4d34ac946733f0f980f33d1b5fd0dd518e1c8fc1927a9a406580f3ac491c0
 SHA512:
-  metadata.gz: 3133cff2199bf4131a40065512443e648dec1f406c0198f094cfcebcd0876ef1c86801d5b103caf55d6036cc2a8e7acdac089999c81aedfc9e758e7a2db449ce
-  data.tar.gz: 8e27b606ef2f4a55b3b67e474cf14f247ec186520e372657982488eadd8e868a45c9c2800c790052b8343fec90a6a44b9edba62a70e88ad79d0b6009ab150d01
+  metadata.gz: c813cf96544c839b605631e587cad4ee3e798d6950022f454e417ac5f83234e969418f0d500f69ee730a102a046e5f20bf97782582fde203d58815d9dae30c9a
+  data.tar.gz: 6b497916918c9537c1cc234e6abace8ed448713640ac937b34593a8ac69b93bec72cfe4cca184514b4fe667203c5ec9af1546b1dcaf696a23d3318a47c37b4dd

data/lib/license_acceptance/version.rb

@@ -1,3 +1,3 @@
 module LicenseAcceptance
-  VERSION = "1.0.13"
+  VERSION = "1.0.18"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: license-acceptance
 version: !ruby/object:Gem::Version
-  version: 1.0.13
+  version: 1.0.18
 platform: ruby
 authors:
 - tyler-ball
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-12 00:00:00.000000000 Z
+date: 2020-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pastel
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -154,16 +154,22 @@ dependencies:
   name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.20'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.20'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: climate_control
   requirement: !ruby/object:Gem::Requirement
@@ -186,9 +192,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
-- Gemfile.lock
 - LICENSE
-- Rakefile
 - config/product_info.toml
 - lib/license_acceptance/acceptor.rb
 - lib/license_acceptance/cli_flags/mixlib_cli.rb
@@ -205,18 +209,6 @@ files:
 - lib/license_acceptance/strategy/prompt.rb
 - lib/license_acceptance/strategy/provided_value.rb
 - lib/license_acceptance/version.rb
-- spec/license_acceptance/acceptor_spec.rb
-- spec/license_acceptance/cli_flags/mixlib_cli_spec.rb
-- spec/license_acceptance/cli_flags/thor_spec.rb
-- spec/license_acceptance/config_spec.rb
-- spec/license_acceptance/product_reader_spec.rb
-- spec/license_acceptance/product_spec.rb
-- spec/license_acceptance/strategy/argument_spec.rb
-- spec/license_acceptance/strategy/environment_spec.rb
-- spec/license_acceptance/strategy/file_spec.rb
-- spec/license_acceptance/strategy/prompt_spec.rb
-- spec/license_acceptance/strategy/provided_value_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/chef/license-acceptance/
 licenses:
 - Apache-2.0

data/Gemfile.lock

@@ -1,91 +0,0 @@
-PATH
-  remote: .
-  specs:
-    license-acceptance (1.0.13)
-      pastel (~> 0.7)
-      tomlrb (~> 1.2)
-      tty-box (~> 0.3)
-      tty-prompt (~> 0.18)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    binding_of_caller (0.8.0)
-      debug_inspector (>= 0.0.1)
-    byebug (11.0.1)
-    climate_control (0.2.0)
-    coderay (1.1.2)
-    debug_inspector (0.0.3)
-    diff-lcs (1.3)
-    equatable (0.5.0)
-    method_source (0.9.2)
-    mixlib-cli (1.7.0)
-    necromancer (0.5.0)
-    pastel (0.7.2)
-      equatable (~> 0.5.0)
-      tty-color (~> 0.4.0)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    pry-byebug (3.7.0)
-      byebug (~> 11.0)
-      pry (~> 0.10)
-    pry-stack_explorer (0.4.9.3)
-      binding_of_caller (>= 0.7)
-      pry (>= 0.9.11)
-    rake (10.5.0)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.0)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.4)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
-    strings (0.1.5)
-      strings-ansi (~> 0.1)
-      unicode-display_width (~> 1.5)
-      unicode_utils (~> 1.4)
-    strings-ansi (0.1.0)
-    thor (0.20.3)
-    tomlrb (1.2.8)
-    tty-box (0.4.0)
-      pastel (~> 0.7.2)
-      strings (~> 0.1.5)
-      tty-cursor (~> 0.7)
-    tty-color (0.4.3)
-    tty-cursor (0.7.0)
-    tty-prompt (0.19.0)
-      necromancer (~> 0.5.0)
-      pastel (~> 0.7.0)
-      tty-reader (~> 0.6.0)
-    tty-reader (0.6.0)
-      tty-cursor (~> 0.7)
-      tty-screen (~> 0.7)
-      wisper (~> 2.0.0)
-    tty-screen (0.7.0)
-    unicode-display_width (1.6.0)
-    unicode_utils (1.4.0)
-    wisper (2.0.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  climate_control (~> 0.2)
-  license-acceptance!
-  mixlib-cli (~> 1.7)
-  pry (~> 0.12)
-  pry-byebug (~> 3.6)
-  pry-stack_explorer (~> 0.4)
-  rake (~> 10.0)
-  rspec (~> 3.0)
-  thor (~> 0.20)
-
-BUNDLED WITH
-   1.17.3

data/Rakefile

@@ -1,6 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec

data/spec/license_acceptance/acceptor_spec.rb

@@ -1,302 +0,0 @@
-require "spec_helper"
-require "license_acceptance/acceptor"
-
-RSpec.describe LicenseAcceptance::Acceptor do
-  it "has a version number" do
-    expect(LicenseAcceptance::VERSION).not_to be nil
-  end
-
-  let(:output) do
-    d = StringIO.new
-    allow(d).to receive(:isatty).and_return(true)
-    d
-  end
-  let(:opts) { { output: output } }
-  let(:reader) { instance_double(LicenseAcceptance::ProductReader) }
-  let(:acc) { LicenseAcceptance::Acceptor.new(opts) }
-  let(:product) { instance_double(LicenseAcceptance::Product, id: "foo", pretty_name: "Foo") }
-  let(:version) { "version" }
-  let(:relationship) { instance_double(LicenseAcceptance::ProductRelationship, parent: product) }
-  let(:missing) { [product] }
-
-  describe "#check_and_persist!" do
-    before do
-      expect(LicenseAcceptance::ProductReader).to receive(:new).and_return(reader)
-      expect(reader).to receive(:read)
-    end
-
-    let(:err) { LicenseAcceptance::LicenseNotAcceptedError.new(product, [product]) }
-    it "outputs an error message to stdout and exits when license acceptance is declined" do
-      expect(acc).to receive(:check_and_persist).and_raise(err)
-      expect { acc.check_and_persist!(product.id, version) }.to raise_error(SystemExit)
-      expect(output.string).to match(/#{product.pretty_name}/)
-    end
-  end
-
-  describe "#check_and_persist" do
-    let(:file_acc) { instance_double(LicenseAcceptance::Strategy::File) }
-    let(:arg_acc) { instance_double(LicenseAcceptance::Strategy::Argument) }
-    let(:prompt_acc) { instance_double(LicenseAcceptance::Strategy::Prompt) }
-    let(:env_acc) { instance_double(LicenseAcceptance::Strategy::Environment) }
-    let(:provided_acc) { instance_double(LicenseAcceptance::Strategy::ProvidedValue) }
-
-    before do
-      expect(LicenseAcceptance::ProductReader).to receive(:new).and_return(reader)
-      expect(LicenseAcceptance::Strategy::File).to receive(:new).and_return(file_acc)
-      expect(LicenseAcceptance::Strategy::Argument).to receive(:new).and_return(arg_acc)
-      expect(LicenseAcceptance::Strategy::Prompt).to receive(:new).and_return(prompt_acc)
-      expect(LicenseAcceptance::Strategy::Environment).to receive(:new).and_return(env_acc)
-      expect(LicenseAcceptance::Strategy::ProvidedValue).to receive(:new).and_return(provided_acc)
-
-      allow(provided_acc).to receive(:no_persist?).and_return(false)
-      allow(env_acc).to receive(:no_persist?).and_return(false)
-      allow(arg_acc).to receive(:no_persist?).and_return(false)
-      allow(provided_acc).to receive(:accepted?).and_return(false)
-      allow(env_acc).to receive(:accepted?).and_return(false)
-      allow(arg_acc).to receive(:accepted?).and_return(false)
-      allow(provided_acc).to receive(:silent?).and_return(false)
-      allow(env_acc).to receive(:silent?).and_return(false)
-      allow(arg_acc).to receive(:silent?).and_return(false)
-
-      expect(reader).to receive(:read)
-    end
-
-    describe "when accept-no-persist is provided from the caller" do
-      it "returns true" do
-        expect(provided_acc).to receive(:no_persist?).and_return(true)
-        expect(acc.check_and_persist(product, version)).to eq(true)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT_NO_PERSIST)
-      end
-    end
-
-    describe "when accept-no-persist environment variable is set" do
-      it "returns true" do
-        expect(env_acc).to receive(:no_persist?).and_return(true)
-        expect(acc.check_and_persist(product, version)).to eq(true)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT_NO_PERSIST)
-      end
-    end
-
-    describe "when accept-no-persist command line argument is set" do
-      it "returns true" do
-        expect(arg_acc).to receive(:no_persist?).and_return(true)
-        expect(acc.check_and_persist(product, version)).to eq(true)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT_NO_PERSIST)
-      end
-    end
-
-    describe "when there are no missing licenses" do
-      it "returns true" do
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return([])
-        expect(acc.check_and_persist(product, version)).to eq(true)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-      end
-    end
-
-    describe "when the user accepts as an environment variable" do
-      it "returns true" do
-        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(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 match(/1 product license accepted./)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-      end
-
-      describe "when persist is set to false" do
-        let(:opts) { { output: output, persist: false } }
-
-        it "returns true" do
-          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(true)
-          expect(acc.check_and_persist(product, version)).to eq(true)
-          expect(output.string).to_not match(/accepted./)
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-        end
-      end
-
-      describe "when the silent option is used" do
-        let(:opts) { { output: output } }
-
-        it "returns true and silently persists the file" do
-          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(:silent?).times.exactly(3).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
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT_SILENT)
-        end
-      end
-
-      describe "when file persistance fails" do
-        it "returns true" do
-          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(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:/)
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-        end
-      end
-    end
-
-    describe "when the user accepts as an arg" do
-      it "returns true" do
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        expect(arg_acc).to receive(:accepted?).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 match(/1 product license accepted./)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-      end
-
-      describe "when the silent option is used" do
-        let(:opts) { { output: output } }
-
-        it "returns true and silently persists the file" do
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(arg_acc).to receive(:silent?).times.exactly(3).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
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT_SILENT)
-        end
-      end
-
-
-      describe "when persist is set to false" do
-        let(:opts) { { output: output, persist: false } }
-
-        it "returns true" do
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(arg_acc).to receive(:accepted?).and_return(true)
-          expect(acc.check_and_persist(product, version)).to eq(true)
-          expect(output.string).to_not match(/accepted./)
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-        end
-      end
-
-      describe "when file persistance fails" do
-        it "returns true" do
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(arg_acc).to receive(:accepted?).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:/)
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-        end
-      end
-    end
-
-    describe "when the prompt is not a tty" do
-      let(:opts) { { output: File.open(File::NULL, "w") } }
-      it "raises a LicenseNotAcceptedError error" do
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        expect(prompt_acc).to_not receive(:request)
-        expect { acc.check_and_persist(product, version) }.to raise_error(LicenseAcceptance::LicenseNotAcceptedError)
-        expect(acc.acceptance_value).to eq(nil)
-      end
-    end
-
-    describe "when the user accepts with the prompt" do
-      it "returns true" do
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        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)
-        expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT)
-      end
-
-      describe "when persist is set to false" do
-        let(:opts) { { output: output, persist: false } }
-
-        it "returns true" do
-          expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-          expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-          expect(prompt_acc).to receive(:request).with(missing).and_yield.and_return(true)
-          expect(acc.check_and_persist(product, version)).to eq(true)
-          expect(acc.acceptance_value).to eq(LicenseAcceptance::ACCEPT_NO_PERSIST)
-        end
-      end
-    end
-
-    describe "when the user declines with the prompt" do
-      it "raises a LicenseNotAcceptedError error" do
-        expect(reader).to receive(:lookup).with(product, version).and_return(relationship)
-        expect(file_acc).to receive(:accepted?).with(relationship).and_return(missing)
-        expect(prompt_acc).to receive(:request).with(missing).and_return(false)
-        expect { acc.check_and_persist(product, version) }.to raise_error(LicenseAcceptance::LicenseNotAcceptedError)
-        expect(acc.acceptance_value).to eq(nil)
-      end
-    end
-  end
-
-  describe "#license_required?" do
-    let(:reader) { instance_double(LicenseAcceptance::ProductReader) }
-    let(:mixlib_name) { "chef" }
-    let(:version) { "15.0.0" }
-    let(:product) { instance_double(LicenseAcceptance::Product, id: "foo", license_required_version: "15.0.0") }
-
-    before do
-      expect(LicenseAcceptance::ProductReader).to receive(:new).and_return(reader)
-      expect(reader).to receive(:read)
-    end
-
-    it "returns false if no product can be found" do
-      expect(reader).to receive(:lookup_by_mixlib).with(mixlib_name).and_return nil
-      expect(acc.license_required?(mixlib_name, version)).to eq(false)
-    end
-
-    describe "when version is :latest" do
-      let(:version) { :latest }
-      it "returns true" do
-        expect(reader).to receive(:lookup_by_mixlib).with(mixlib_name).and_return product
-        expect(acc.license_required?(mixlib_name, version)).to eq(true)
-      end
-    end
-
-    ["latest", "unstable", "current", "stable"].each do |version|
-      describe "when version is '#{version}'" do
-        it "returns true" do
-          expect(reader).to receive(:lookup_by_mixlib).with(mixlib_name).and_return product
-          expect(acc.license_required?(mixlib_name, version)).to eq(true)
-        end
-      end
-    end
-
-    describe "when version is nil" do
-      let(:version) { nil }
-      it "returns true" do
-        expect(reader).to receive(:lookup_by_mixlib).with(mixlib_name).and_return product
-        expect(acc.license_required?(mixlib_name, version)).to eq(true)
-      end
-    end
-
-    describe "when version is >= than required version" do
-      let(:version) { "15.0.0" }
-      it "returns true" do
-        expect(reader).to receive(:lookup_by_mixlib).with(mixlib_name).and_return product
-        expect(acc.license_required?(mixlib_name, version)).to eq(true)
-      end
-    end
-
-    describe "when version is < required version" do
-      let(:version) { "14.99.99" }
-      it "returns false" do
-        expect(reader).to receive(:lookup_by_mixlib).with(mixlib_name).and_return product
-        expect(acc.license_required?(mixlib_name, version)).to eq(false)
-      end
-    end
-  end
-end

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

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