license-acceptance 1.0.5 → 2.1.13

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