puppet 5.4.0-x64-mingw32 → 5.5.0-x64-mingw32

data/spec/unit/face/epp_face_spec.rb

@@ -174,6 +174,59 @@ describe Puppet::Face[:epp, :current] do
       expect(@logs[0].message).to match(/Syntax error at 'b'/)
       expect(@logs[0].level).to eq(:err)
     end
+
+    context "using 'pn' format" do
+      it "prints the AST of the given expression in PN format" do
+        expect(eppface.dump({ :format => 'pn', :e => 'hello world' })).to eq(
+          '(lambda {:body [(epp (render-s "hello world"))]})')
+      end
+
+      it "pretty prints the AST of the given expression in PN format when --pretty is given" do
+        expect(eppface.dump({ :pretty => true, :format => 'pn', :e => 'hello world' })).to eq(<<-RESULT.unindent[0..-2])
+        (lambda
+          {
+            :body [
+              (epp
+                (render-s
+                  "hello world"))]})
+        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(eppface.dump({ :format => 'json', :e => 'hello world' })).to eq(
+          '{"^":["lambda",{"#":["body",[{"^":["epp",{"^":["render-s","hello world"]}]}]]}]}')
+      end
+
+      it "pretty prints the AST of the given expression in JSON based on the PN format when --pretty is given" do
+        expect(eppface.dump({ :pretty => true, :format => 'json', :e => 'hello world' })).to eq(<<-RESULT.unindent[0..-2])
+        {
+          "^": [
+            "lambda",
+            {
+              "#": [
+                "body",
+                [
+                  {
+                    "^": [
+                      "epp",
+                      {
+                        "^": [
+                          "render-s",
+                          "hello world"
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              ]
+            }
+          ]
+        }
+        RESULT
+      end
+    end
   end
 
   context "render" do
@@ -307,7 +360,6 @@ describe Puppet::Face[:epp, :current] do
       end
 
       it "renders multiple files separated by headers by default" do
-        modules_dir = File.join(dir, 'environments', 'production', 'modules')
         # chomp the last newline, it is put there by heredoc
         expect(eppface.render('m1/greetings.epp', 'm2/goodbye.epp')).to eq(<<-EOT.chomp)
 --- m1/greetings.epp
@@ -318,7 +370,6 @@ goodbye world
       end
 
       it "outputs multiple files verbatim when --no-headers is given" do
-        modules_dir = File.join(dir, 'environments', 'production', 'modules')
         expect(eppface.render('m1/greetings.epp', 'm2/goodbye.epp', :header => false)).to eq("hello worldgoodbye world")
       end
     end

data/spec/unit/face/facts_spec.rb

@@ -1,9 +1,62 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
+require 'puppet/indirector/facts/facter'
+require 'puppet/indirector/facts/rest'
 
 describe Puppet::Face[:facts, '0.0.1'] do
   describe "#find" do
     it { is_expected.to be_action :find }
   end
+
+  describe '#upload' do
+    let(:model) { Puppet::Node::Facts }
+    let(:test_data) { model.new('puppet.node.test', {test_fact: 'test value'}) }
+    let(:facter_terminus) { model.indirection.terminus(:facter) }
+    let(:rest_terminus) { model.indirection.terminus(:rest) }
+
+    before(:each) do
+      Puppet.settings.parse_config(<<-CONF)
+[main]
+server=puppet.server.invalid
+certname=puppet.node.invalid
+[agent]
+server=puppet.server.test
+node_name_value=puppet.node.test
+CONF
+
+      # Faces start in :user run mode
+      Puppet.settings.preferred_run_mode = :user
+
+      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
+      facter_terminus.expects(:find).with(instance_of(Puppet::Indirector::Request)).returns(test_data)
+
+      subject.upload
+    end
+
+    it "saves facts to terminus_class :rest" do
+      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
+      facter_terminus.expects(:find).with(responds_with(:key, 'puppet.node.test')).returns(test_data)
+
+      subject.upload
+    end
+
+    it "logs the name of the server that received the upload" do
+      subject.upload
+
+      expect(@logs).to be_any {|log| log.level == :notice &&
+                               log.message =~ /Uploading facts for '.*' to: 'puppet\.server\.test'/}
+    end
+  end
 end

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,36 +112,17 @@ 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(:summary).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(:summary).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} })
 
@@ -141,24 +132,24 @@ describe Puppet::Face[:help, '0.0.1'] do
     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 +166,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 +174,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 +182,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]
 

data/spec/unit/face/parser_spec.rb

@@ -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