puppet 6.17.0-universal-darwin → 7.1.0-universal-darwin

data/spec/unit/pops/types/type_factory_spec.rb

@@ -151,7 +151,7 @@ describe 'The type factory' do
       expect(hc.class_name).to eq('x')
     end
 
-    it 'array_of(fixnum) returns PArrayType[PIntegerType]' do
+    it 'array_of(integer) returns PArrayType[PIntegerType]' do
       at = TypeFactory.array_of(1)
       expect(at.class()).to eq(PArrayType)
       expect(at.element_type.class).to eq(PIntegerType)

data/spec/unit/pops/validator/validator_spec.rb

@@ -179,17 +179,17 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
 
-    it 'produces a warning for virtual class resource' do
+    it 'produces an error for virtual class resource' do
       acceptor = validate(parse('@class { test: }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a warning for exported class resource' do
+    it 'produces an error for exported class resource' do
       acceptor = validate(parse('@@class { test: }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
@@ -310,17 +310,17 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
     end
 
-    it 'produces a warning for virtual class resource' do
+    it 'produces an error for virtual class resource' do
       acceptor = validate(parse('@class { test: }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a warning for exported class resource' do
+    it 'produces an error for exported class resource' do
       acceptor = validate(parse('@@class { test: }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
   end
@@ -344,16 +344,16 @@ describe "validating 4x" do
       end
     end
 
-    it 'produces an error for application' do
-      acceptor = validate(parse('application test {}'))
-      expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    it 'produces a syntax error for application' do
+      expect {
+        parse('application test {}')
+      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'application'/)
     end
 
-    it 'produces an error for capability mapping' do
-      acceptor = validate(parse('Foo produces Sql {}'))
-      expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    it 'produces a syntax error for capability mapping' do
+      expect {
+        parse('Foo produces Sql {}')
+      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'produces'/)
     end
 
     it 'produces an error for collect expressions with virtual query' do
@@ -410,10 +410,10 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     end
 
-    it 'produces an error for site definitions' do
-      acceptor = validate(parse('site {}'))
-      expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    it 'produces a syntax error for site definitions' do
+      expect {
+        parse('site {}')
+      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'site'/)
     end
 
     context 'validating apply() blocks' do
@@ -468,16 +468,16 @@ describe "validating 4x" do
         expect(acceptor.error_count).to eql(0)
       end
 
-      it 'produces an error for application' do
-        acceptor = validate(parse('apply("foo.example.com") { application test {} }'))
-        expect(acceptor.error_count).to eql(1)
-        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      it 'produces a syntax error for application' do
+        expect {
+          parse('apply("foo.example.com") { application test {} }')
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'application'/)
       end
 
-      it 'produces an error for capability mapping' do
-        acceptor = validate(parse('apply("foo.example.com") { Foo produces Sql {} }'))
-        expect(acceptor.error_count).to eql(1)
-        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      it 'produces a syntax error for capability mapping' do
+        expect {
+          parse('apply("foo.example.com") { Foo produces Sql {} }')
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'produces'/)
       end
 
       it 'produces an error for class expressions' do
@@ -504,9 +504,9 @@ describe "validating 4x" do
       end
 
       it 'produces an error for site definitions' do
-        acceptor = validate(parse('apply("foo.example.com") { site {} }'))
-        expect(acceptor.error_count).to eql(1)
-        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+        expect {
+          parse('apply("foo.example.com") { site {} }')
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'site'/)
       end
 
       it 'produces an error for apply() inside apply()' do
@@ -669,6 +669,15 @@ describe "validating 4x" do
     'regexp',
     'pattern',
     'runtime',
+    'init',
+    'object',
+    'sensitive',
+    'semver',
+    'semverrange',
+    'string',
+    'timestamp',
+    'timespan',
+    'typeset',
     ].each do |name|
 
       it "produces an error for 'class #{name}'" do
@@ -693,6 +702,7 @@ describe "validating 4x" do
       source = "type('a', 'b')"
       expect(validate(parse(source))).not_to have_any_issues
     end
+
     it "should allow using the 'type' as the name of a function with no parameters and a block" do
       source = "type() |$x| { $x }"
       expect(validate(parse(source))).not_to have_any_issues
@@ -968,6 +978,18 @@ describe "validating 4x" do
       end
     end
 
+    it "allows a reserved type name" do
+      source = <<-SOURCE
+      class foo {
+        define string() {}
+        foo::string { 'a': }
+      }
+      SOURCE
+
+      acceptor = validate(parse(source, 'path/foo/manifests/init.pp'))
+      expect(acceptor.error_count).to eql(0)
+    end
+
     it "will give multiple errors in one file with multiple issues" do
       source = <<-SOURCE
       class foo {}
@@ -992,17 +1014,10 @@ describe "validating 4x" do
 
   context "capability annotations" do
     ['produces', 'consumes'].each do |word|
-      it "rejects illegal resource types in #{word} clauses" do
-        expect(validate(parse("foo produces Bar {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
-      end
-
-      it "accepts legal resource and capability types in #{word} clauses" do
-        expect(validate(parse("Foo produces Bar {}"))).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
-        expect(validate(parse("Mod::Foo produces ::Mod2::Bar {}"))).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
-      end
-
-      it "rejects illegal capability types in #{word} clauses" do
-        expect(validate(parse("Foo produces bar {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
+      it "raises a syntax error in #{word} clauses" do
+        expect {
+          parse("foo #{word} Bar {}")
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at '#{word}'/)
       end
     end
   end

data/spec/unit/pops/visitor_spec.rb

@@ -39,7 +39,7 @@ describe Puppet::Pops::Visitor do
 
     it "should select method for superclass" do
       duck_processor = DuckProcessor.new
-      expect(duck_processor.hi(42)).to match(/Howdy (?:Fixnum|Integer)/)
+      expect(duck_processor.hi(42)).to match(/Howdy Integer/)
     end
 
     it "should select method for superclass" do

data/spec/unit/provider/exec_spec.rb

@@ -49,9 +49,10 @@ describe Puppet::Provider::Exec do
         # we can't reference that in our manifest. Windows PATHs can contain
         # double quotes and trailing backslashes, which confuse HEREDOC
         # interpolation below. So sanitize it:
-        ENV['PATH'].split(File::PATH_SEPARATOR).map do |dir|
-          dir.gsub(/"/, '\"').gsub(/\\$/, '')
-        end.join(File::PATH_SEPARATOR)
+        ENV['PATH'].split(File::PATH_SEPARATOR)
+                   .map { |dir| dir.gsub(/"/, '\"').gsub(/\\$/, '') }
+                   .map { |dir| Pathname.new(dir).cleanpath.to_s }
+                   .join(File::PATH_SEPARATOR)
       else
         ENV['PATH']
       end

data/spec/unit/provider/nameservice_spec.rb

@@ -149,63 +149,6 @@ describe Puppet::Provider::NameService do
     end
   end
 
-  describe "#listbyname" do
-    it "should be deprecated" do
-      expect(Puppet).to receive(:deprecation_warning).with(/listbyname is deprecated/)
-      described_class.listbyname
-    end
-
-    it "should return a list of users if resource_type is user" do
-      described_class.resource_type = Puppet::Type.type(:user)
-      expect(Puppet::Etc).to receive(:setpwent)
-      allow(Puppet::Etc).to receive(:getpwent).and_return(*users)
-      expect(Puppet::Etc).to receive(:endpwent)
-      expect(described_class.listbyname).to eq(%w{root foo})
-    end
-
-    context "encoding handling" do
-      described_class.resource_type = Puppet::Type.type(:user)
-
-      # These two tests simulate an environment where there are two users with
-      # the same name on disk, but each name is stored on disk in a different
-      # encoding
-      it "should return names with invalid byte sequences replaced with '?'" do
-        allow(Etc).to receive(:getpwent).and_return(*utf_8_mixed_users)
-        expect(invalid_utf_8_jose).to_not be_valid_encoding
-        result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
-          described_class.listbyname
-        end
-        expect(result).to eq(['root', 'foo', utf_8_jose, escaped_utf_8_jose])
-      end
-
-      it "should return names in their original encoding/bytes if they would not be valid UTF-8" do
-        allow(Etc).to receive(:getpwent).and_return(*latin_1_mixed_users)
-        result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
-          described_class.listbyname
-        end
-        expect(result).to eq(['root'.force_encoding(Encoding::UTF_8), 'foo'.force_encoding(Encoding::UTF_8), utf_8_jose, valid_latin1_jose])
-      end
-    end
-
-    it "should return a list of groups if resource_type is group", :unless => Puppet::Util::Platform.windows? do
-      described_class.resource_type = Puppet::Type.type(:group)
-      expect(Puppet::Etc).to receive(:setgrent)
-      allow(Puppet::Etc).to receive(:getgrent).and_return(*groups)
-      expect(Puppet::Etc).to receive(:endgrent)
-      expect(described_class.listbyname).to eq(%w{root bin})
-    end
-
-    it "should yield if a block given" do
-      yield_results = []
-      described_class.resource_type = Puppet::Type.type(:user)
-      expect(Puppet::Etc).to receive(:setpwent)
-      allow(Puppet::Etc).to receive(:getpwent).and_return(*users)
-      expect(Puppet::Etc).to receive(:endpwent)
-      described_class.listbyname {|x| yield_results << x }
-      expect(yield_results).to eq(%w{root foo})
-    end
-  end
-
   describe "instances" do
     it "should return a list of objects in UTF-8 with any invalid characters replaced with '?'" do
       # These two tests simulate an environment where there are two users with

data/spec/unit/provider/package/apt_spec.rb

@@ -86,6 +86,83 @@ Version table:
     provider.run_preseed
   end
 
+  describe ".instances" do
+    before do
+      allow(Puppet::Type::Package::ProviderDpkg).to receive(:instances).and_return([resource])
+    end
+
+    context "when package is manual marked" do
+      before do
+        allow(described_class).to receive(:aptmark).with('showmanual').and_return("#{resource.name}\n")
+      end
+
+      it 'sets mark to manual' do
+        expect(resource).to receive(:mark=).with(:manual)
+        described_class.instances
+      end
+    end
+
+    context 'when package is not manual marked ' do
+      before do
+        allow(described_class).to receive(:aptmark).with('showmanual').and_return('')
+      end
+
+      it 'does not set mark to manual' do
+        expect(resource).not_to receive(:mark=).with(:manual)
+        described_class.instances
+      end
+    end
+  end
+
+  describe 'query' do
+    before do
+      allow(provider).to receive(:dpkgquery).and_return("name: #{resource.name}" )
+    end
+
+    context "when package is manual marked" do
+      before do
+        allow(described_class).to receive(:aptmark).with('showmanual').and_return("#{resource.name}\n")
+      end
+
+      it 'sets mark to manual' do
+        result = provider.query
+        expect(result[:mark]).to eql(:manual)
+      end
+    end
+
+    context 'when package is not manual marked ' do
+      before do
+        allow(described_class).to receive(:aptmark).with('showmanual').and_return('')
+      end
+
+      it 'does not set mark to manual' do
+        result = provider.query
+        expect(result[:mark]).to be_nil
+      end
+    end
+  end
+
+  describe 'flush' do
+
+    context "when package is manual marked" do
+      before do
+        provider.mark = :manual
+      end
+
+      it 'does not call aptmark' do
+        expect(provider).not_to receive(:aptmark)
+        provider.flush
+      end
+    end
+
+    context 'when package is not manual marked ' do
+      it 'calls aptmark' do
+        expect(described_class).to receive(:aptmark).with('manual', resource.name)
+        provider.flush
+      end
+    end
+  end
+
   describe "when installing" do
     it "should preseed if a responsefile is provided" do
       resource[:responsefile] = "/my/file"

data/spec/unit/provider/package/aptitude_spec.rb

@@ -13,6 +13,7 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
 
     before do
       allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
+      allow(described_class).to receive(:aptmark).with('showmanual').and_return("")
     end
 
     { :absent   => "deinstall ok config-files faff 1.2.3-1\n",

data/spec/unit/provider/package/dpkg_spec.rb

@@ -32,7 +32,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(bash_installed_io)
 
       installed = double('bash')
-      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(installed)
+      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg).and_return(installed)
 
       expect(described_class.instances).to eq([installed])
     end
@@ -41,9 +41,9 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(all_installed_io)
 
       bash = double('bash')
-      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(bash)
+      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg).and_return(bash)
       vim = double('vim')
-      expect(described_class).to receive(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :status => "installed", :provider => :dpkg).and_return(vim)
+      expect(described_class).to receive(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :mark => :none, :status => "installed", :provider => :dpkg).and_return(vim)
 
       expect(described_class.instances).to eq([bash, vim])
     end
@@ -107,7 +107,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
         it "returns a hash of the found package status for an installed package" do
           dpkg_query_execution_with_multiple_args_returns(query_output, args_with_provides,virtual_packages_query_args)
           dpkg_query_execution_with_multiple_args_returns(dpkg_query_result, args, query_args)
-          expect(provider.query).to eq(:ensure => "2.7.13", :error => "ok", :desired => "install", :name => "python", :status => "installed", :provider => :dpkg)
+          expect(provider.query).to eq(:ensure => "2.7.13", :error => "ok", :desired => "install", :name => "python", :mark => :none, :status => "installed", :provider => :dpkg)
         end
 
         it "considers the package absent if the dpkg-query result cannot be interpreted" do
@@ -160,6 +160,20 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
           expect(provider.query[:mark]).to eq(:hold)
         end
 
+        it "considers the package held if its state is 'hold'" do
+          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("install","hold"),args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("install","hold"), args, query_args)
+          expect(provider.query[:ensure]).to eq("2.7.13")
+          expect(provider.query[:mark]).to eq(:hold)
+        end
+
+        it "considers mark status to be none if package is not held" do
+          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("install","ok"),args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("install","ok"), args, query_args)
+          expect(provider.query[:ensure]).to eq("2.7.13")
+          expect(provider.query[:mark]).to eq(:none)
+        end
+
         context "regex check for query search" do
           let(:resource_name) { 'python-email' }
           let(:resource) { instance_double('Puppet::Type::Package') }
@@ -168,10 +182,10 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
             allow(resource).to receive(:[]=)
           end
 
-          it "checks if virtual package regex for query is correctand phisical package is installed" do
+          it "checks if virtual package regex for query is correct and physical package is installed" do
             dpkg_query_execution_with_multiple_args_returns(query_output,args_with_provides,virtual_packages_query_args)
             dpkg_query_execution_with_multiple_args_returns(dpkg_query_result, args, query_args)
-            expect(provider.query).to match({:desired=>"install", :ensure=>"2.7.13", :error=>"ok", :name=>"python", :provider=>:dpkg, :status=>"installed"})
+            expect(provider.query).to match({:desired => "install", :ensure => "2.7.13", :error => "ok", :name => "python", :mark => :none, :provider => :dpkg, :status => "installed"})
           end
 
           context "regex check with no partial matching" do
@@ -208,7 +222,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       it "returns a hash of the found package status for an installed package" do
         dpkg_query_execution_returns(bash_installed_output)
 
-        expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg})
+        expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg})
       end
 
       it "considers the package absent if the dpkg-query result cannot be interpreted" do
@@ -271,6 +285,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
             :error => 'ok',
             :status => 'status',
             :name => resource_name,
+            :mark => :none,
             :ensure => 'ensure',
             :provider => :dpkg,
           }
@@ -377,39 +392,13 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       allow(Tempfile).to receive(:open).and_yield(tempfile)
     end
 
-    it "installs first if package is not present and ensure holding" do
-      allow(provider).to receive(:execute)
-      allow(provider).to receive(:package_not_installed?).and_return(true)
-      expect(provider).to receive(:install).once
-      expect(provider).to receive(:hold)
-      provider.deprecated_hold
-    end
-
-    it "skips install new package if hold is true" do
-      allow(provider).to receive(:execute)
-      allow(provider).to receive(:package_not_installed?).and_return(true)
-      expect(provider).to receive(:install).once
-      expect(provider).to receive(:hold)
-      provider.deprecated_hold
-    end
-
-    it "skips install new package if package is allready installed" do
-      allow(provider).to receive(:execute)
-      allow(provider).to receive(:package_not_installed?).and_return(false)
-      expect(provider).not_to receive(:install)
-      expect(provider).to receive(:hold)
-      provider.deprecated_hold
-    end
-
     it "executes dpkg --set-selections when holding" do
-      allow(provider).to receive(:package_not_installed?).and_return(false)
       allow(provider).to receive(:install)
       expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
     end
 
     it "executes dpkg --set-selections when unholding" do
-      allow(provider).to receive(:package_not_installed?).and_return(false)
       allow(provider).to receive(:install)
       expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
@@ -452,26 +441,4 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
     provider.purge
   end
 
-  context "package_not_installed?" do
-    context "allow_virtual false" do
-        before do
-          allow(resource).to receive(:allow_virtual?).and_return(false)
-        end
-
-      it "returns true if package is not found" do
-        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_raise(Puppet::ExecutionFailure.new("eh"))
-        expect(provider.package_not_installed?).to eq(true)
-      end
-
-      it "returns true if package is not installed" do
-        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_return("unknown ok not-installed #{resource_name}")
-        expect(provider.package_not_installed?).to eq(true)
-      end
-
-      it "returns false if package is installed" do
-        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_return("install ok installed resource_name 1.2.3")
-        expect(provider.package_not_installed?).to eq(false)
-      end
-    end
-  end
 end