puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/face/facts_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 require 'puppet/indirector/facts/facter'
@@ -27,26 +28,26 @@ CONF
       # Faces start in :user run mode
       Puppet.settings.preferred_run_mode = :user
 
-      allow(facter_terminus).to receive(:find).with(instance_of(Puppet::Indirector::Request)).and_return(test_data)
-      allow(rest_terminus).to receive(:save).with(instance_of(Puppet::Indirector::Request)).and_return(nil)
+      facter_terminus.stubs(:find).with(instance_of(Puppet::Indirector::Request)).returns(test_data)
+      rest_terminus.stubs(:save).with(instance_of(Puppet::Indirector::Request)).returns(nil)
     end
 
     it { is_expected.to be_action :upload }
 
     it "finds facts from terminus_class :facter" do
-      expect(facter_terminus).to receive(:find).with(instance_of(Puppet::Indirector::Request)).and_return(test_data)
+      facter_terminus.expects(:find).with(instance_of(Puppet::Indirector::Request)).returns(test_data)
 
       subject.upload
     end
 
     it "saves facts to terminus_class :rest" do
-      expect(rest_terminus).to receive(:save).with(instance_of(Puppet::Indirector::Request)).and_return(nil)
+      rest_terminus.expects(:save).with(instance_of(Puppet::Indirector::Request)).returns(nil)
 
       subject.upload
     end
 
     it "uses settings from the agent section of puppet.conf" do
-      expect(facter_terminus).to receive(:find).with(have_attributes(key: 'puppet.node.test')).and_return(test_data)
+      facter_terminus.expects(:find).with(responds_with(:key, 'puppet.node.test')).returns(test_data)
 
       subject.upload
     end

data/spec/unit/face/generate_spec.rb

@@ -126,7 +126,7 @@ describe Puppet::Face[:generate, :current] do
       end
 
       it 'sets pcore as the default format' do
-        expect(Puppet::Generate::Type).to receive(:find_inputs).with(:pcore).and_return([])
+        Puppet::Generate::Type.expects(:find_inputs).with(:pcore).returns([])
         genface.types()
       end
 
@@ -135,8 +135,8 @@ describe Puppet::Face[:generate, :current] do
         # (There is no way to call the original when mocking expected parameters).
         input1 = Puppet::Generate::Type::Input.new(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore)
         input2 = Puppet::Generate::Type::Input.new(m1, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore)
-        expect(Puppet::Generate::Type::Input).to receive(:new).with(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore).and_return(input1)
-        expect(Puppet::Generate::Type::Input).to receive(:new).with(m2, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore).and_return(input2)
+        Puppet::Generate::Type::Input.expects(:new).with(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore).returns(input1)
+        Puppet::Generate::Type::Input.expects(:new).with(m2, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore).returns(input2)
         genface.types
       end
 
@@ -224,6 +224,7 @@ describe Puppet::Face[:generate, :current] do
   end
 
   def from_an_interactive_terminal
-    allow(STDIN).to receive(:tty?).and_return(true)
+    STDIN.stubs(:tty?).returns(true)
   end
+
 end

data/spec/unit/face/help_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
@@ -49,7 +50,7 @@ describe Puppet::Face[:help, '0.0.1'] do
   context 'rendering has an error' do
     it 'raises an ArgumentError if the face raises a StandardError' do
       face = Puppet::Face[:module, :current]
-      allow(face).to receive(:short_description).and_raise(StandardError, 'whoops')
+      face.stubs(:short_description).raises(StandardError, 'whoops')
 
       expect {
         subject.help(:module)
@@ -58,7 +59,7 @@ describe Puppet::Face[:help, '0.0.1'] do
 
     it 'raises an ArgumentError if the face raises a LoadError' do
       face = Puppet::Face[:module, :current]
-      allow(face).to receive(:short_description).and_raise(LoadError, 'cannot load such file -- yard')
+      face.stubs(:short_description).raises(LoadError, 'cannot load such file -- yard')
 
       expect {
         subject.help(:module)
@@ -68,7 +69,7 @@ describe Puppet::Face[:help, '0.0.1'] do
     context 'with face actions' do
       it 'returns an error if we can not get an action for the module' do
         face = Puppet::Face[:module, :current]
-        allow(face).to receive(:get_action).and_return(nil)
+        face.stubs(:get_action).returns(nil)
 
         expect {subject.help('module', 'list')}.to raise_error(ArgumentError, /Unable to load action list from Puppet::Face/)
       end
@@ -134,7 +135,7 @@ describe Puppet::Face[:help, '0.0.1'] do
 
   context 'deprecated faces' do
     it 'prints a deprecation warning for deprecated faces' do
-      allow(Puppet::Face[:module, :current]).to receive(:deprecated?).and_return(true)
+      Puppet::Face[:module, :current].stubs(:deprecated?).returns(true)
       expect(Puppet::Face[:help, :current].help(:module)).to match(/Warning: 'puppet module' is deprecated/)
     end
   end
@@ -142,7 +143,7 @@ describe Puppet::Face[:help, '0.0.1'] do
   context '#all_application_summaries' do
     it 'appends a deprecation warning for deprecated faces' do
       # Stub the module face as deprecated
-      expect(Puppet::Face[:module, :current]).to receive(:deprecated?).and_return(true)
+      Puppet::Face[:module, :current].expects(:deprecated?).returns(true)
       Puppet::Face[:help, :current].all_application_summaries.each do |appname,summary|
         expect(summary).to match(/Deprecated/) if appname == 'module'
       end
@@ -189,7 +190,7 @@ describe Puppet::Face[:help, '0.0.1'] do
 
     context 'rendering has an error' do
       it 'raises an ArgumentError if a legacy application raises a StandardError' do
-        allow_any_instance_of(Puppet::Application[appname].class).to receive(:help).and_raise(StandardError, 'whoops')
+        Puppet::Application[appname].class.any_instance.stubs(:help).raises(StandardError, 'whoops')
 
         expect {
           subject.help(appname)
@@ -197,7 +198,7 @@ describe Puppet::Face[:help, '0.0.1'] do
       end
 
       it 'raises an ArgumentError if a legacy application raises a LoadError' do
-        allow_any_instance_of(Puppet::Application[appname].class).to receive(:help).and_raise(LoadError, 'cannot load such file -- yard')
+        Puppet::Application[appname].class.any_instance.stubs(:help).raises(LoadError, 'cannot load such file -- yard')
 
         expect {
           subject.help(appname)

data/spec/unit/face/key_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 

data/spec/unit/face/man_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
@@ -19,7 +20,7 @@ describe Puppet::Face[:man, '0.0.1'] do
   end
 
   it 'raises an ArgumentError when given to many arguments' do
-    allow(subject).to receive(:print_man_help)
+    subject.stubs(:print_man_help)
     expect { subject.man(:man, 'cert', 'extra') }.to raise_error(ArgumentError)
   end
 end

data/spec/unit/face/module/install_spec.rb

@@ -6,13 +6,15 @@ describe "puppet module install" do
   include PuppetSpec::Files
 
   describe "action" do
-    let(:name)        { double(:name) }
+    let(:name)        { stub(:name) }
     let(:target_dir)  { tmpdir('module install face action') }
     let(:options)     { { :target_dir => target_dir } }
 
     it 'should invoke the Installer app' do
-      expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
-      expect(Puppet::ModuleTool::Applications::Installer).to receive(:run) do |mod, target, opts|
+      Puppet::ModuleTool.expects(:set_option_defaults).with(options)
+      Puppet::ModuleTool::Applications::Installer.expects(:run).with do |*args|
+        mod, target, opts = args
+
         expect(mod).to eql(name)
         expect(opts).to eql(options)
         expect(target).to be_a(Puppet::ModuleTool::InstallDirectory)

data/spec/unit/face/module/list_spec.rb

@@ -207,7 +207,12 @@ describe "puppet module list" do
         }]
       })
 
-      expect(Puppet).to receive(:warning).with(match(/Missing dependency 'puppetlabs-dependable'/).and match(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/))
+      warning_expectations = [
+        regexp_matches(/Missing dependency 'puppetlabs-dependable'/),
+        regexp_matches(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/)
+      ]
+
+      Puppet.expects(:warning).with(all_of(*warning_expectations))
 
       console_output(:tree => true)
     end
@@ -222,7 +227,12 @@ describe "puppet module list" do
         }]
       })
 
-      expect(Puppet).to receive(:warning).with(match(/Module 'puppetlabs-dependable' \(v0\.0\.1\) fails to meet some dependencies/).and match(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/))
+      warning_expectations = [
+        regexp_matches(/Module 'puppetlabs-dependable' \(v0\.0\.1\) fails to meet some dependencies/),
+        regexp_matches(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/)
+      ]
+
+      Puppet.expects(:warning).with(all_of(*warning_expectations))
 
       console_output(:tree => true)
     end

data/spec/unit/face/module/search_spec.rb

@@ -13,14 +13,12 @@ describe "puppet module search" do
   describe Puppet::Application::Module do
     subject do
       app = Puppet::Application::Module.new
-      allow(app).to receive(:action).and_return(Puppet::Face.find_action(:module, :search))
+      app.stubs(:action).returns(Puppet::Face.find_action(:module, :search))
       app
     end
 
-    before do
-      subject.render_as = :console
-      allow(Puppet::Util::Terminal).to receive(:width).and_return(100)
-    end
+    before { subject.render_as = :console }
+    before { Puppet::Util::Terminal.stubs(:width).returns(100) }
 
     it 'should output nothing when receiving an empty dataset' do
       expect(subject.render({:answers => [], :result => :success}, ['apache', {}])).to eq("No results found for 'apache'.")
@@ -168,7 +166,7 @@ describe "puppet module search" do
           ]
         }
 
-        expect(Puppet::Util::Terminal).to receive(:width).and_return(width)
+        Puppet::Util::Terminal.expects(:width).returns(width)
         result = subject.render(results, ['apache', {}])
         expect(result.lines.sort_by(&:length).last.chomp.length).to be <= width
         expect(result).to eq(expectation)
@@ -185,13 +183,13 @@ describe "puppet module search" do
     end
 
     it "should accept the --module_repository option" do
-      forge = double("Puppet::Forge")
-      searcher = double("Searcher")
+      forge = mock("Puppet::Forge")
+      searcher = mock("Searcher")
       options[:module_repository] = "http://forge.example.com"
 
-      expect(Puppet::Forge).to receive(:new).with("http://forge.example.com").and_return(forge)
-      expect(Puppet::ModuleTool::Applications::Searcher).to receive(:new).with("puppetlabs-apache", forge, hash_including(options)).and_return(searcher)
-      expect(searcher).to receive(:run)
+      Puppet::Forge.expects(:new).with("http://forge.example.com").returns(forge)
+      Puppet::ModuleTool::Applications::Searcher.expects(:new).with("puppetlabs-apache", forge, has_entries(options)).returns(searcher)
+      searcher.expects(:run)
 
       subject.search("puppetlabs-apache", options)
     end

data/spec/unit/face/module/uninstall_spec.rb

@@ -10,8 +10,10 @@ describe "puppet module uninstall" do
     let(:options) { Hash.new }
 
     it 'should invoke the Uninstaller app' do
-      expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
-      expect(Puppet::ModuleTool::Applications::Uninstaller).to receive(:run).with(name, options)
+      args = [ name, options ]
+
+      Puppet::ModuleTool.expects(:set_option_defaults).with(options)
+      Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with(*args)
 
       Puppet::Face[:module, :current].uninstall(name, options)
     end
@@ -20,8 +22,10 @@ describe "puppet module uninstall" do
       let(:name) { 'module/name' }
 
       it 'should invoke the Uninstaller app' do
-        expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
-        expect(Puppet::ModuleTool::Applications::Uninstaller).to receive(:run).with('module-name', options)
+        args = [ 'module-name', options ]
+
+        Puppet::ModuleTool.expects(:set_option_defaults).with(options)
+        Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with(*args)
 
         Puppet::Face[:module, :current].uninstall(name, options)
       end

data/spec/unit/face/node_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
@@ -9,32 +10,32 @@ describe Puppet::Face[:node, '0.0.1'] do
         "cached_facts" => ['hostname'],
         "cached_node"  => ['hostname'],
         "reports"      => ['hostname'],
-      }.each { |k, v| expect(subject).to receive("clean_#{k}".to_sym).with(*v) }
+      }.each { |k, v| subject.expects("clean_#{k}".to_sym).with(*v) }
       subject.cleanup('hostname')
     end
   end
 
   describe 'when running #clean' do
     before :each do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
-      allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
-      allow(Puppet::Node).to receive(:terminus_class=)
-      allow(Puppet::Node).to receive(:cache_class=)
+      Puppet::Node::Facts.indirection.stubs(:terminus_class=)
+      Puppet::Node::Facts.indirection.stubs(:cache_class=)
+      Puppet::Node.stubs(:terminus_class=)
+      Puppet::Node.stubs(:cache_class=)
     end
 
     it 'should invoke #cleanup' do
-      expect(subject).to receive(:cleanup).with('hostname')
+      subject.expects(:cleanup).with('hostname', nil)
       subject.clean('hostname')
     end
   end
 
   describe "clean action" do
     before :each do
-      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
-      allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
-      allow(Puppet::Node).to receive(:terminus_class=)
-      allow(Puppet::Node).to receive(:cache_class=)
-      allow(subject).to receive(:cleanup)
+      Puppet::Node::Facts.indirection.stubs(:terminus_class=)
+      Puppet::Node::Facts.indirection.stubs(:cache_class=)
+      Puppet::Node.stubs(:terminus_class=)
+      Puppet::Node.stubs(:cache_class=)
+      subject.stubs(:cleanup)
     end
 
     it "should have a clean action" do
@@ -62,14 +63,14 @@ describe Puppet::Face[:node, '0.0.1'] do
     context "clean action" do
       subject { Puppet::Face[:node, :current] }
       before :each do
-        allow(Puppet::Util::Log).to receive(:newdestination)
-        allow(Puppet::Util::Log).to receive(:level=)
+        Puppet::Util::Log.stubs(:newdestination)
+        Puppet::Util::Log.stubs(:level=)
       end
 
       describe "during setup" do
         it "should set facts terminus and cache class to yaml" do
-          expect(Puppet::Node::Facts.indirection).to receive(:terminus_class=).with(:yaml)
-          expect(Puppet::Node::Facts.indirection).to receive(:cache_class=).with(:yaml)
+          Puppet::Node::Facts.indirection.expects(:terminus_class=).with(:yaml)
+          Puppet::Node::Facts.indirection.expects(:cache_class=).with(:yaml)
 
           subject.clean('hostname')
         end
@@ -80,8 +81,8 @@ describe Puppet::Face[:node, '0.0.1'] do
         end
 
         it "should set node cache as yaml" do
-          expect(Puppet::Node.indirection).to receive(:terminus_class=).with(:yaml)
-          expect(Puppet::Node.indirection).to receive(:cache_class=).with(:yaml)
+          Puppet::Node.indirection.expects(:terminus_class=).with(:yaml)
+          Puppet::Node.indirection.expects(:cache_class=).with(:yaml)
 
           subject.clean('hostname')
         end
@@ -89,13 +90,13 @@ describe Puppet::Face[:node, '0.0.1'] do
 
       describe "when cleaning certificate", :if => Puppet.features.puppetserver_ca? do
         it "should call the CA CLI gem's clean action" do
-          expect_any_instance_of(Puppetserver::Ca::Action::Clean).to receive(:run).with({ 'certnames' => ['hostname'] }).and_return(0)
+          Puppetserver::Ca::Action::Clean.any_instance.expects(:run).with({ 'certnames' => ['hostname'] }).returns(0)
           subject.clean_cert('hostname')
         end
 
         it "should not call the CA CLI gem's clean action if the gem is missing" do
-          expect(Puppet.features).to receive(:puppetserver_ca?).and_return(false)
-          expect_any_instance_of(Puppetserver::Ca::Action::Clean).not_to receive(:run)
+          Puppet.features.expects(:puppetserver_ca?).returns(false)
+          Puppetserver::Ca::Action::Clean.any_instance.expects(:run).never
           subject.clean_cert("hostname")
         end
       end
@@ -103,7 +104,7 @@ describe Puppet::Face[:node, '0.0.1'] do
       describe "when cleaning cached facts" do
         it "should destroy facts" do
           @host = 'node'
-          expect(Puppet::Node::Facts.indirection).to receive(:destroy).with(@host)
+          Puppet::Node::Facts.indirection.expects(:destroy).with(@host)
 
           subject.clean_cached_facts(@host)
         end
@@ -111,14 +112,14 @@ describe Puppet::Face[:node, '0.0.1'] do
 
       describe "when cleaning cached node" do
         it "should destroy the cached node" do
-          expect(Puppet::Node.indirection).to receive(:destroy).with(@host)
+          Puppet::Node.indirection.expects(:destroy).with(@host)
           subject.clean_cached_node(@host)
         end
       end
 
       describe "when cleaning archived reports" do
         it "should tell the reports to remove themselves" do
-          allow(Puppet::Transaction::Report.indirection).to receive(:destroy).with(@host)
+          Puppet::Transaction::Report.indirection.stubs(:destroy).with(@host)
 
           subject.clean_reports(@host)
         end

data/spec/unit/face/parser_spec.rb

@@ -35,6 +35,21 @@ describe Puppet::Face[:parser, :current] do
         expect { parser.validate(manifest) }.to exit_with(1)
       end
 
+      it "validates static heredoc with specified syntax" do
+        manifest = file_containing('site.pp', "@(EOT:pp)
+          { invalid =>
+          EOT
+        ")
+        expect { parser.validate(manifest) }.to exit_with(1)
+      end
+
+      it "does not validates dynamic heredoc with specified syntax" do
+        manifest = file_containing('site.pp', "@(\"EOT\":pp)
+        {invalid => ${1+1}
+        EOT")
+        expect { parser.validate(manifest) }.to_not exit_with(1)
+      end
+
       it "runs error free when there are no validation errors" do
         expect {
             manifest = file_containing('site.pp', "notify { valid: }")
@@ -226,11 +241,11 @@ describe Puppet::Face[:parser, :current] do
   end
 
   def from_an_interactive_terminal
-    allow(STDIN).to receive(:tty?).and_return(true)
+    STDIN.stubs(:tty?).returns(true)
   end
 
   def from_a_piped_input_of(contents)
-    allow(STDIN).to receive(:tty?).and_return(false)
-    allow(STDIN).to receive(:read).and_return(contents)
+    STDIN.stubs(:tty?).returns(false)
+    STDIN.stubs(:read).returns(contents)
   end
 end

data/spec/unit/face/plugin_spec.rb

@@ -1,7 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
 describe Puppet::Face[:plugin, :current] do
+
   let(:pluginface) { described_class }
   let(:action) { pluginface.get_action(:download) }
 
@@ -16,38 +18,22 @@ describe Puppet::Face[:plugin, :current] do
     end
 
     it "downloads plugins, external facts, and locales" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
 
       pluginface.download
-      expect(receive_count).to eq(3)
     end
 
     it "renders 'No plugins downloaded' if nothing was downloaded" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
 
       result = pluginface.download
-      expect(receive_count).to eq(3)
       expect(render(result)).to eq('No plugins downloaded.')
     end
 
     it "renders comma separate list of downloaded file names" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
-        receive_count += 1
-        case receive_count
-        when 1
-          %w[/a]
-        when 2
-          %w[/b]
-        when 3
-          %w[/c]
-        end
-      end
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns(%w[/a]).then.returns(%w[/b]).then.returns(%w[/c])
 
       result = pluginface.download
-      expect(receive_count).to eq(3)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b, /c')
     end
   end
@@ -59,21 +45,15 @@ describe Puppet::Face[:plugin, :current] do
     end
 
     it "downloads plugins, and external facts, but not locales" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1}.and_return([])
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns([])
 
       pluginface.download
     end
 
     it "renders comma separate list of downloaded file names that does not include locales" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
-        receive_count += 1
-        receive_count == 1 ? %w[/a] : %w[/b]
-      end
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
 
       result = pluginface.download
-      expect(receive_count).to eq(2)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b')
     end
   end
@@ -86,22 +66,15 @@ describe Puppet::Face[:plugin, :current] do
     end
 
     it "downloads plugins, and external facts, but not locales" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns([])
 
       pluginface.download
-      expect(receive_count).to eq(2)
     end
 
     it "renders comma separate list of downloaded file names that does not include locales" do
-      receive_count = 0
-      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
-        receive_count += 1
-        receive_count == 1 ? %w[/a] : %w[/b]
-      end
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
 
       result = pluginface.download
-      expect(receive_count).to eq(2)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b')
     end
   end