puppet 5.0.0 → 6.0.0

data/spec/unit/face/help_spec.rb

@@ -3,31 +3,30 @@ require 'spec_helper'
 require 'puppet/face'
 
 describe Puppet::Face[:help, '0.0.1'] do
-  it "has a help action" do
+  it 'has a help action' do
     expect(subject).to be_action :help
   end
 
-  it "has a default action of help" do
+  it 'has a default action of help' do
     expect(subject.get_action('help')).to be_default
   end
 
-  it "accepts a call with no arguments" do
+  it 'accepts a call with no arguments' do
     expect {
       subject.help()
     }.to_not raise_error
   end
 
-  it "accepts a face name" do
+  it 'accepts a face name' do
     expect { subject.help(:help) }.to_not raise_error
   end
 
-  it "accepts a face and action name" do
+  it 'accepts a face and action name' do
     expect { subject.help(:help, :help) }.to_not raise_error
   end
 
-  it "fails if more than a face and action are given" do
-    expect { subject.help(:help, :help, :for_the_love_of_god) }.
-      to raise_error ArgumentError
+  it 'fails if more than a face and action are given' do
+    expect { subject.help(:help, :help, :for_the_love_of_god) }.to raise_error ArgumentError
   end
 
   it "treats :current and 'current' identically" do
@@ -36,37 +35,48 @@ describe Puppet::Face[:help, '0.0.1'] do
     )
   end
 
-  it "raises an error when the face is unavailable" do
+  it 'raises an error when the face is unavailable' do
     expect {
       subject.help(:huzzah, :bar, :version => '17.0.0')
     }.to raise_error(ArgumentError, /Could not find version 17\.0\.0/)
   end
 
-  it "finds a face by version" do
+  it 'finds a face by version' do
     face = Puppet::Face[:huzzah, :current]
     expect(subject.help(:huzzah, :version => face.version)).
       to eq(subject.help(:huzzah, :version => :current))
   end
 
-  it "raises an ArgumentError if the face raises a StandardError" do
-    face = Puppet::Face[:module, :current]
-    face.stubs(:short_description).raises(StandardError, "whoops")
+  context 'rendering has an error' do
+    it 'raises an ArgumentError if the face raises a StandardError' do
+      face = Puppet::Face[:module, :current]
+      face.stubs(:short_description).raises(StandardError, 'whoops')
 
-    expect {
-      subject.help(:module)
-    }.to raise_error(ArgumentError, /Detail: "whoops"/)
-  end
+      expect {
+        subject.help(:module)
+      }.to raise_error(ArgumentError, /Detail: "whoops"/)
+    end
 
-  it "raises an ArgumentError if the face raises a LoadError" do
-    face = Puppet::Face[:module, :current]
-    face.stubs(:short_description).raises(LoadError, "cannot load such file -- yard")
+    it 'raises an ArgumentError if the face raises a LoadError' do
+      face = Puppet::Face[:module, :current]
+      face.stubs(:short_description).raises(LoadError, 'cannot load such file -- yard')
 
-    expect {
-      subject.help(:module)
-    }.to raise_error(ArgumentError, /Detail: "cannot load such file -- yard"/)
+      expect {
+        subject.help(:module)
+      }.to raise_error(ArgumentError, /Detail: "cannot load such file -- yard"/)
+    end
+
+    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]
+        face.stubs(:get_action).returns(nil)
+
+        expect {subject.help('module', 'list')}.to raise_error(ArgumentError, /Unable to load action list from Puppet::Face/)
+      end
+    end
   end
 
-  context "when listing subcommands" do
+  context 'when listing subcommands' do
     subject { Puppet::Face[:help, :current].help }
 
     RSpec::Matchers.define :have_a_summary do
@@ -78,13 +88,13 @@ describe Puppet::Face[:help, '0.0.1'] do
     # Check a precondition for the next block; if this fails you have
     # something odd in your set of face, and we skip testing things that
     # matter. --daniel 2011-04-10
-    it "has at least one face with a summary" do
+    it 'has at least one face with a summary' do
       expect(Puppet::Face.faces).to be_any do |name|
         Puppet::Face[name, :current].summary
       end
     end
 
-    it "lists all faces which are runnable from the command line" do
+    it 'lists all faces which are runnable from the command line' do
       help_face = Puppet::Face[:help, :current]
       # The main purpose of the help face is to provide documentation for
       #  command line users.  It shouldn't show documentation for faces
@@ -102,63 +112,45 @@ describe Puppet::Face[:help, '0.0.1'] do
       end
     end
 
-    it "returns an 'unavailable' summary if the 'agent' application fails to generate help" do
-      Puppet::Application['agent'].class.any_instance.stubs(:help).raises(ArgumentError, "whoops")
-
-      expect(subject).to match(/agent\s+! Subcommand unavailable due to error\. Check error logs\./)
-    end
-
-    it "returns an 'unavailable' summary if the legacy application raises a LoadError" do
-      Puppet::Application['agent'].class.any_instance.stubs(:help).raises(LoadError, "cannot load such file -- yard")
-
-      expect(subject).to match(/agent\s+! Subcommand unavailable due to error\. Check error logs\./)
-    end
-
-    context "face summaries" do
-      it "can generate face summaries" do
+    context 'face summaries' do
+      it 'can generate face summaries' do
         faces = Puppet::Face.faces
         expect(faces.length).to be > 0
         faces.each do |name|
           expect(Puppet::Face[name, :current]).to have_a_summary
         end
       end
-
-      it "returns an 'unavailable' summary if the face application raises a LoadError" do
-        face = Puppet::Face[:module, :current]
-        face.stubs(:summary).raises(LoadError, "cannot load such file -- yard")
-
-        expect(Puppet::Face[:help, :current].help).to match(/module\s+! Subcommand unavailable due to error\. Check error logs\./)
-      end
     end
 
-    it "lists all legacy applications" do
+    it 'lists all legacy applications' do
       Puppet::Face[:help, :current].legacy_applications.each do |appname|
         expect(subject).to match(%r{ #{appname} })
 
         summary = Puppet::Face[:help, :current].horribly_extract_summary_from(appname)
-        summary and expect(subject).to match(%r{ #{summary}\b})
+        summary_regex = Regexp.escape(summary)
+        summary and expect(subject).to match(%r{ #{summary_regex}$})
       end
     end
   end
 
-  context "deprecated faces" do
-    it "prints a deprecation warning for deprecated faces" do
+  context 'deprecated faces' do
+    it 'prints a deprecation warning for deprecated faces' do
       Puppet::Face[:module, :current].stubs(:deprecated?).returns(true)
       expect(Puppet::Face[:help, :current].help(:module)).to match(/Warning: 'puppet module' is deprecated/)
     end
   end
 
-  context "#all_application_summaries" do
-    it "appends a deprecation warning for deprecated faces" do
+  context '#all_application_summaries' do
+    it 'appends a deprecation warning for deprecated faces' do
       # Stub the module face as deprecated
       Puppet::Face[:module, :current].expects(:deprecated?).returns(true)
-      result = Puppet::Face[:help, :current].all_application_summaries.each do |appname,summary|
+      Puppet::Face[:help, :current].all_application_summaries.each do |appname,summary|
         expect(summary).to match(/Deprecated/) if appname == 'module'
       end
     end
   end
 
-  context "#legacy_applications" do
+  context '#legacy_applications' do
     subject { Puppet::Face[:help, :current].legacy_applications }
 
     # If we don't, these tests are ... less than useful, because they assume
@@ -175,7 +167,7 @@ describe Puppet::Face[:help, '0.0.1'] do
     end
   end
 
-  context "help for legacy applications" do
+  context 'help for legacy applications' do
     subject { Puppet::Face[:help, :current] }
     let :appname do subject.legacy_applications.first end
 
@@ -183,7 +175,7 @@ describe Puppet::Face[:help, '0.0.1'] do
     # we don't get into a loop where we either test a face-based replacement
     # and fail to notice breakage, or where we have to constantly rewrite this
     # test and all. --daniel 2011-04-11
-    it "returns the legacy help when given the subcommand" do
+    it 'returns the legacy help when given the subcommand' do
       help = subject.help(appname)
       expect(help).to match(/puppet-#{appname}/)
       %w{SYNOPSIS USAGE DESCRIPTION OPTIONS COPYRIGHT}.each do |heading|
@@ -191,25 +183,27 @@ describe Puppet::Face[:help, '0.0.1'] do
       end
     end
 
-    it "fails when asked for an action on a legacy command" do
+    it 'fails when asked for an action on a legacy command' do
       expect { subject.help(appname, :whatever) }.
-        to raise_error ArgumentError, /Legacy subcommands don't take actions/
+        to raise_error(ArgumentError, /The legacy subcommand '#{appname}' does not support supplying an action/)
     end
 
-    it "raises an ArgumentError if a legacy application raises a StandardError" do
-      Puppet::Application[appname].class.any_instance.stubs(:help).raises(StandardError, "whoops")
+    context 'rendering has an error' do
+      it 'raises an ArgumentError if a legacy application raises a StandardError' do
+        Puppet::Application[appname].class.any_instance.stubs(:help).raises(StandardError, 'whoops')
 
-      expect {
-        subject.help(appname)
-      }.to raise_error ArgumentError, /Detail: "whoops"/
-    end
+        expect {
+          subject.help(appname)
+        }.to raise_error(ArgumentError, /Detail: "whoops"/)
+      end
 
-    it "raises an ArgumentError if a legacy application raises a LoadError" do
-      Puppet::Application[appname].class.any_instance.stubs(:help).raises(LoadError, "cannot load such file -- yard")
+      it 'raises an ArgumentError if a legacy application raises a LoadError' do
+        Puppet::Application[appname].class.any_instance.stubs(:help).raises(LoadError, 'cannot load such file -- yard')
 
-      expect {
-        subject.help(appname)
-      }.to raise_error ArgumentError, /Detail: "cannot load such file -- yard"/
+        expect {
+          subject.help(appname)
+        }.to raise_error(ArgumentError, /Detail: "cannot load such file -- yard"/)
+      end
     end
   end
 end

data/spec/unit/face/man_spec.rb

@@ -0,0 +1,26 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:man, '0.0.1'] do
+  it 'should be deprecated' do
+    expect(subject.deprecated?).to be_truthy
+  end
+
+  it 'has a man action' do
+    expect(subject).to be_action(:man)
+  end
+
+  it 'has a default action of man' do
+    expect(subject.get_action('man')).to be_default
+  end
+
+  it 'accepts a call with no arguments' do
+    expect { subject.man() }.to have_printed(/USAGE: puppet man <action>/)
+  end
+
+  it 'raises an ArgumentError when given to many arguments' do
+    subject.stubs(:print_man_help)
+    expect { subject.man(:man, 'cert', 'extra') }.to raise_error(ArgumentError)
+  end
+end

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

@@ -83,7 +83,6 @@ describe "puppet module list" do
   it "prefers a given modulepath over the modulepath from the given environment" do
     foomod = PuppetSpec::Modules.create('foo', @modpath1)
     barmod = PuppetSpec::Modules.create('bar', @modpath2)
-    env = Puppet::Node::Environment.create(:myenv, ['/tmp/notused'])
 
     modules = Puppet::Face[:module, :current].list(:environment => 'myenv', :modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}")[:modules_by_path]
 
@@ -218,66 +217,6 @@ describe "puppet module list" do
       console_output(:tree => true)
     end
 
-    it 'should not warn about dependent module with pre-release version by default' do
-      PuppetSpec::Modules.create('depender', @modpath1, :metadata => {
-        :version => '1.0.0',
-        :dependencies => [{
-          "version_requirement" => ">= 1.0.0",
-          "name"                => "puppetlabs/dependable"
-        }]
-      })
-      PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '1.0.0-rc1' })
-
-      expected = <<-OUTPUT.unindent
-      #{@modpath1}
-      ├── puppetlabs-dependable (\e[0;36mv1.0.0-rc1\e[0m)
-      └── puppetlabs-depender (\e[0;36mv1.0.0\e[0m)
-      #{@modpath2} (no modules installed)
-      OUTPUT
-
-      expect(console_output).to eq(expected)
-    end
-
-    it 'should warn about dependent module with pre-release version by if pre-release is less than given pre-release' do
-      PuppetSpec::Modules.create('depender', @modpath1, :metadata => {
-        :version => '1.0.0',
-        :dependencies => [{
-          "version_requirement" => ">= 1.0.0-rc1",
-          "name"                => "puppetlabs/dependable"
-        }]
-      })
-      PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '1.0.0-rc0' })
-
-      expected = <<-OUTPUT.unindent
-      #{@modpath1}
-      ├── puppetlabs-dependable (\e[0;36mv1.0.0-rc0\e[0m)  \e[0;31minvalid\e[0m
-      └── puppetlabs-depender (\e[0;36mv1.0.0\e[0m)
-      #{@modpath2} (no modules installed)
-      OUTPUT
-
-      expect(console_output).to eq(expected)
-    end
-
-    it 'should warn about dependent module with pre-release version when using strict SemVer' do
-      PuppetSpec::Modules.create('depender', @modpath1, :metadata => {
-        :version => '1.0.0',
-        :dependencies => [{
-          "version_requirement" => ">= 1.0.0",
-          "name"                => "puppetlabs/dependable"
-        }]
-      })
-      PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '1.0.0-rc1' })
-
-      expected = <<-OUTPUT.unindent
-      #{@modpath1}
-      ├── puppetlabs-dependable (\e[0;36mv1.0.0-rc1\e[0m)  \e[0;31minvalid\e[0m
-      └── puppetlabs-depender (\e[0;36mv1.0.0\e[0m)
-      #{@modpath2} (no modules installed)
-      OUTPUT
-
-      expect(console_output(:strict_semver => true)).to eq(expected)
-    end
-
     it "should warn about out of range dependencies" do
       PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '0.0.1'})
       PuppetSpec::Modules.create('depender', @modpath1, :metadata => {

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

@@ -64,6 +64,17 @@ describe "puppet module search" do
       expect(subject.render(results, ['apache', {}])).to match(/tag2/)
     end
 
+    it 'should mark deprecated modules in search results' do
+      results = {
+        :result => :success,
+        :answers => [
+          {'full_name' => 'puppetlabs-corosync', 'deprecated_at' => Time.new, 'author' => 'Author', 'desc' => 'Summary', 'tag_list' => ['tag1', 'tag2'] },
+        ]
+      }
+
+      expect(subject.render(results, ['apache', {}])).to match(/puppetlabs-corosync.*DEPRECATED/i)
+    end
+
     it 'should elide really long descriptions' do
       results = {
         :result => :success,
@@ -176,7 +187,7 @@ describe "puppet module search" do
       searcher = mock("Searcher")
       options[:module_repository] = "http://forge.example.com"
 
-      Puppet::Forge.expects(:new).with().returns(forge)
+      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)
 

data/spec/unit/face/node_spec.rb

@@ -2,11 +2,9 @@
 require 'spec_helper'
 require 'puppet/face'
 
-describe Puppet::Face[:node, '0.0.1'] do
-  after :all do
-    Puppet::SSL::Host.ca_location = :none
-  end
+require 'puppetserver/ca/cli'
 
+describe Puppet::Face[:node, '0.0.1'] do
   describe '#cleanup' do
     it "should clean everything" do
       {
@@ -90,39 +88,18 @@ describe Puppet::Face[:node, '0.0.1'] do
 
           subject.clean('hostname')
         end
-
-        it "should manage the certs if the host is a CA" do
-          Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
-          Puppet::SSL::Host.expects(:ca_location=).with(:local)
-          subject.clean('hostname')
-        end
-
-        it "should not manage the certs if the host is not a CA" do
-          Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(false)
-          Puppet::SSL::Host.expects(:ca_location=).with(:none)
-          subject.clean('hostname')
-        end
       end
 
       describe "when cleaning certificate" do
-        before :each do
-          Puppet::SSL::Host.stubs(:destroy)
-          @ca = mock()
-          Puppet::SSL::CertificateAuthority.stubs(:instance).returns(@ca)
-        end
-
-        it "should send the :destroy order to the ca if we are a CA" do
-          Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
-          @ca.expects(:revoke).with(@host)
-          @ca.expects(:destroy).with(@host)
-          subject.clean_cert(@host)
+        it "should call the CA CLI gem's clean action" do
+          Puppetserver::Ca::Action::Clean.any_instance.expects(:run).with({ 'certnames' => ['hostname'] }).returns(0)
+          subject.clean_cert('hostname')
         end
 
-        it "should not destroy the certs if we are not a CA" do
-          Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(false)
-          @ca.expects(:revoke).never
-          @ca.expects(:destroy).never
-          subject.clean_cert(@host)
+        it "should not call the CA CLI gem's clean action if the gem is missing" do
+          Puppet.features.expects(:puppetserver_ca?).returns(false)
+          Puppetserver::Ca::Action::Clean.any_instance.expects(:run).never
+          subject.clean_cert("hostname")
         end
       end
 

data/spec/unit/face/parser_spec.rb

@@ -72,7 +72,7 @@ describe Puppet::Face[:parser, :current] do
           expect { parser.validate(manifest) }.to exit_with(1)
         end
 
-        expect(@logs.join).to match(/environment special.*Syntax error at end of file/)
+        expect(@logs.join).to match(/environment special.*Syntax error at end of input/)
       end
 
     end
@@ -117,7 +117,7 @@ describe Puppet::Face[:parser, :current] do
       output = parser.dump({ :e => '{ invalid =>' })
 
       expect(output).to eq("")
-      expect(@logs[0].message).to eq("Syntax error at end of file")
+      expect(@logs[0].message).to eq("Syntax error at end of input")
       expect(@logs[0].level).to eq(:err)
     end
 
@@ -145,6 +145,84 @@ describe Puppet::Face[:parser, :current] do
         parser.dump(manifest)
       }.to_not raise_error
     end
+
+    context "using 'pn' format" do
+      it "prints the AST of the given expression in PN format" do
+        expect(parser.dump({ :format => 'pn', :e => 'if $x { "hi ${x[2]}" }' })).to eq(
+          '(if {:test (var "x") :then [(concat "hi " (str (access (var "x") 2)))]})')
+      end
+
+      it "pretty prints the AST of the given expression in PN format when --pretty is given" do
+        expect(parser.dump({ :pretty => true, :format => 'pn', :e => 'if $x { "hi ${x[2]}" }' })).to eq(<<-RESULT.unindent[0..-2])
+        (if
+          {
+            :test (var
+              "x")
+            :then [
+              (concat
+                "hi "
+                (str
+                  (access
+                    (var
+                      "x")
+                    2)))]})
+        RESULT
+      end
+    end
+
+    context "using 'json' format" do
+      it "prints the AST of the given expression in JSON based on the PN format" do
+        expect(parser.dump({ :format => 'json', :e => 'if $x { "hi ${x[2]}" }' })).to eq(
+          '{"^":["if",{"#":["test",{"^":["var","x"]},"then",[{"^":["concat","hi ",{"^":["str",{"^":["access",{"^":["var","x"]},2]}]}]}]]}]}')
+      end
+
+      it "pretty prints the AST of the given expression in JSON based on the PN format when --pretty is given" do
+        expect(parser.dump({ :pretty => true, :format => 'json', :e => 'if $x { "hi ${x[2]}" }' })).to eq(<<-RESULT.unindent[0..-2])
+        {
+          "^": [
+            "if",
+            {
+              "#": [
+                "test",
+                {
+                  "^": [
+                    "var",
+                    "x"
+                  ]
+                },
+                "then",
+                [
+                  {
+                    "^": [
+                      "concat",
+                      "hi ",
+                      {
+                        "^": [
+                          "str",
+                          {
+                            "^": [
+                              "access",
+                              {
+                                "^": [
+                                  "var",
+                                  "x"
+                                ]
+                              },
+                              2
+                            ]
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              ]
+            }
+          ]
+        }
+        RESULT
+      end
+    end
   end
 
   def from_an_interactive_terminal

data/spec/unit/face/plugin_spec.rb

@@ -12,21 +12,67 @@ describe Puppet::Face[:plugin, :current] do
   end
 
   context "download" do
-    it "downloads plugins and external facts" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns([])
+    before :each do
+      #Server_agent version needs to be at 5.3.4 in order to mount locales
+      Puppet.push_context({:server_agent_version => "5.3.4"})
+    end
+
+    it "downloads plugins, external facts, and locales" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
 
       pluginface.download
     end
 
     it "renders 'No plugins downloaded' if nothing was downloaded" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns([])
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
 
       result = pluginface.download
       expect(render(result)).to eq('No plugins downloaded.')
     end
 
     it "renders comma separate list of downloaded file names" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns(%w[/a]).then.returns(%w[/b])
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns(%w[/a]).then.returns(%w[/b]).then.returns(%w[/c])
+
+      result = pluginface.download
+      expect(render(result)).to eq('Downloaded these plugins: /a, /b, /c')
+    end
+  end
+
+  context "download when server_agent_version is 5.3.3" do
+    before :each do
+      #Server_agent version needs to be at 5.3.4 in order to mount locales
+      Puppet.push_context({:server_agent_version => "5.3.3"})
+    end
+
+    it "downloads plugins, and external facts, but not locales" do
+      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
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
+
+      result = pluginface.download
+      expect(render(result)).to eq('Downloaded these plugins: /a, /b')
+    end
+  end
+
+  context "download when server_agent_version is blank" do
+    before :each do
+      #Server_agent version needs to be at 5.3.4 in order to mount locales
+      #A blank version will default to 0.0
+      Puppet.push_context({:server_agent_version => ""})
+    end
+
+    it "downloads plugins, and external facts, but not locales" do
+      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
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
 
       result = pluginface.download
       expect(render(result)).to eq('Downloaded these plugins: /a, /b')