puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/lib/puppet_spec/files.rb

@@ -84,6 +84,6 @@ module PuppetSpec::Files
     else
       "10" + "%04i" % mode.to_i
     end
-    actual_mode.should == target_mode
+    expect(actual_mode).to eq(target_mode)
   end
 end

data/spec/lib/puppet_spec/handler.rb

@@ -0,0 +1,53 @@
+require 'puppet/network/http/handler'
+
+class PuppetSpec::Handler
+  include Puppet::Network::HTTP::Handler
+
+  def initialize(* routes)
+    register(routes)
+  end
+
+  def set_content_type(response, format)
+    response[:content_type_header] = format
+  end
+
+  def set_response(response, body, status = 200)
+    response[:body] = body
+    response[:status] = status
+  end
+
+  def http_method(request)
+    request[:method]
+  end
+
+  def path(request)
+    request[:path]
+  end
+
+  def params(request)
+    request[:params]
+  end
+
+  def client_cert(request)
+    request[:client_cert]
+  end
+
+  def body(request)
+    request[:body]
+  end
+
+  def headers(request)
+    request[:headers] || {}
+  end
+end
+
+class PuppetSpec::HandlerProfiler
+  def start(metric, description)
+  end
+
+  def finish(context, metric, description)
+  end
+
+  def shutdown()
+  end
+end

data/spec/lib/puppet_spec/matchers.rb

@@ -37,13 +37,18 @@ RSpec::Matchers.define :exit_with do |expected|
     end
     actual and actual == expected
   end
-  failure_message_for_should do |block|
+
+  supports_block_expectations
+
+  failure_message do |block|
     "expected exit with code #{expected} but " +
       (actual.nil? ? " exit was not called" : "we exited with #{actual} instead")
   end
-  failure_message_for_should_not do |block|
+
+  failure_message_when_negated do |block|
     "expected that exit would not be called with #{expected}"
   end
+
   description do
     "expect exit with #{expected}"
   end
@@ -99,7 +104,9 @@ RSpec::Matchers.define :have_printed do |expected|
     matches_output?(@actual) && matches_exit_code?(@actual_exit_code)
   end
 
-  failure_message_for_should do |actual|
+  supports_block_expectations
+
+  failure_message do |actual|
     if actual.nil? then
       "expected #{expected.inspect}, but nothing was printed"
     else
@@ -112,7 +119,7 @@ RSpec::Matchers.define :have_printed do |expected|
     end
   end
 
-  failure_message_for_should_not do |actual|
+  failure_message_when_negated do |actual|
     if @expected_exit_code && matches_exit_code?(@actual_exit_code)
       "expected exit code to not be #{@actual_exit_code}"
     else
@@ -146,7 +153,7 @@ RSpec::Matchers.define :be_one_of do |*expected|
     expected.include? actual
   end
 
-  failure_message_for_should do |actual|
+  failure_message do |actual|
     "expected #{actual.inspect} to be one of #{expected.map(&:inspect).join(' or ')}"
   end
 end

data/spec/lib/puppet_spec/module_tool/shared_functions.rb

@@ -29,7 +29,7 @@ module PuppetSpec
         release = releases.find { |x| x[:name] == name }
 
         if options.nil?
-          release.should be_nil
+          expect(release).to be_nil
         else
           from = options.keys.find { |k| k.nil? || k.is_a?(Semantic::Version) }
           to   = options.delete(from)
@@ -39,8 +39,8 @@ module PuppetSpec
             options[:version] ||= to
           end
 
-          release.should_not be_nil
-          release.should include options
+          expect(release).not_to be_nil
+          expect(release).to include options
         end
       end
 

data/spec/lib/puppet_spec/modules.rb

@@ -22,5 +22,16 @@ module PuppetSpec::Modules
 
       Puppet::Module.new(name, module_dir, environment)
     end
+
+    def generate_files(name, dir, options = {})
+      module_dir = File.join(dir, name)
+      FileUtils.mkdir_p(module_dir)
+
+      if metadata = options[:metadata]
+        File.open(File.join(module_dir, 'metadata.json'), 'w') do |f|
+          f.write(metadata.to_pson)
+        end
+      end
+    end
   end
 end

data/spec/lib/puppet_spec/network.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+require 'puppet/network/http'
+require 'puppet/network/http/api/indirected_routes'
+require 'puppet/indirector_testing'
+
+module PuppetSpec::Network
+  def not_found_code
+    Puppet::Network::HTTP::Error::HTTPNotFoundError::CODE
+  end
+
+  def not_acceptable_code
+    Puppet::Network::HTTP::Error::HTTPNotAcceptableError::CODE
+  end
+
+  def bad_request_code
+    Puppet::Network::HTTP::Error::HTTPBadRequestError::CODE
+  end
+
+  def not_authorized_code
+    Puppet::Network::HTTP::Error::HTTPNotAuthorizedError::CODE
+  end
+
+  def params
+    { :environment => "production" }
+  end
+
+  def master_url_prefix
+    "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3"
+  end
+
+  def ca_url_prefix
+    "#{Puppet::Network::HTTP::CA_URL_PREFIX}/v1"
+  end
+
+  def a_request_that_heads(data, request = {}, params = params())
+    Puppet::Network::HTTP::Request.from_hash({
+      :headers => {
+        'accept' => request[:accept_header],
+        'content-type' => "text/pson"
+      },
+      :method => "HEAD",
+      :path => "#{master_url_prefix}/#{data.class.indirection.name}/#{data.value}",
+      :params => params,
+    })
+  end
+
+  def a_request_that_submits(data, request = {}, params = params())
+    Puppet::Network::HTTP::Request.from_hash({
+      :headers => {
+        'accept' => request[:accept_header],
+        'content-type' => request[:content_type_header] || "text/pson"
+      },
+      :method => "PUT",
+      :path => "#{master_url_prefix}/#{data.class.indirection.name}/#{data.value}",
+      :params => params,
+      :body => request[:body].nil? ? data.render("pson") : request[:body]
+    })
+  end
+
+  def a_request_that_destroys(data, request = {}, params = params())
+    Puppet::Network::HTTP::Request.from_hash({
+      :headers => {
+        'accept' => request[:accept_header],
+        'content-type' => "text/pson"
+      },
+      :method => "DELETE",
+      :path => "#{master_url_prefix}/#{data.class.indirection.name}/#{data.value}",
+      :params => params,
+      :body => ''
+    })
+  end
+
+  def a_request_that_finds(data, request = {}, params = params())
+    Puppet::Network::HTTP::Request.from_hash({
+      :headers => {
+        'accept' => request[:accept_header],
+        'content-type' => "text/pson"
+      },
+      :method => "GET",
+      :path => "#{master_url_prefix}/#{data.class.indirection.name}/#{data.value}",
+      :params => params,
+      :body => ''
+    })
+  end
+
+  def a_request_that_searches(data, request = {}, params = params())
+    Puppet::Network::HTTP::Request.from_hash({
+      :headers => {
+        'accept' => request[:accept_header],
+        'content-type' => "text/pson"
+      },
+      :method => "GET",
+      :path => "#{master_url_prefix}/#{data.class.indirection.name}s/#{data.name}",
+      :params => params,
+      :body => ''
+    })
+  end
+
+end
+

data/spec/lib/puppet_spec/pops.rb

@@ -6,10 +6,10 @@ module PuppetSpec::Pops
     match do |actual|
       actual.diagnostics.index { |i| i.issue == expected } != nil
     end
-    failure_message_for_should do |actual|
+    failure_message do |actual|
       "expected Acceptor[#{actual.diagnostics.collect { |i| i.issue.issue_code }.join(',')}] to contain issue #{expected.issue_code}"
     end
-    failure_message_for_should_not do |actual|
+    failure_message_when_negated do |actual|
       "expected Acceptor[#{actual.diagnostics.collect { |i| i.issue.issue_code }.join(',')}] to not contain issue #{expected.issue_code}"
     end
   end

data/spec/lib/puppet_spec/settings.rb

@@ -9,7 +9,24 @@ module PuppetSpec::Settings
     :name         => { :default => "test", :desc => "name" },
     :logdir       => { :type => :directory, :default => "test", :desc => "logdir" },
     :confdir      => { :type => :directory, :default => "test", :desc => "confdir" },
+    :codedir      => { :type => :directory, :default => "test", :desc => "codedir" },
     :vardir       => { :type => :directory, :default => "test", :desc => "vardir" },
     :rundir       => { :type => :directory, :default => "test", :desc => "rundir" },
   }
+
+  def set_puppet_conf(confdir, settings)
+    write_file(File.join(confdir, "puppet.conf"), settings)
+  end
+
+  def set_environment_conf(environmentpath, environment, settings)
+    envdir = File.join(environmentpath, environment)
+    FileUtils.mkdir_p(envdir)
+    write_file(File.join(envdir, 'environment.conf'), settings)
+  end
+
+  def write_file(file, contents)
+    File.open(file, "w") do |f|
+      f.puts(contents)
+    end
+  end
 end

data/spec/shared_behaviours/all_parsedfile_providers.rb

@@ -14,7 +14,7 @@ shared_examples_for "all parsedfile providers" do |provider, *files|
       oldlines = File.readlines(file)
       newlines = text.chomp.split "\n"
       oldlines.zip(newlines).each do |old, new|
-        new.gsub(/\s+/, '').should == old.chomp.gsub(/\s+/, '')
+        expect(new.gsub(/\s+/, '')).to eq(old.chomp.gsub(/\s+/, ''))
       end
     end
   end

data/spec/shared_behaviours/an_indirector_face.rb

@@ -1,6 +1,6 @@
 shared_examples_for "an indirector face" do
   [:find, :search, :save, :destroy, :info].each do |action|
-    it { should be_action action }
-    it { should respond_to action }
+    it { is_expected.to be_action action }
+    it { is_expected.to respond_to action }
   end
 end

data/spec/shared_behaviours/documentation_on_faces.rb

@@ -10,13 +10,13 @@ shared_examples_for "documentation on faces" do
   Attrs.each do |attr|
     it "should accept a #{attr}" do
       expect { subject.send("#{attr}=", "hello") }.not_to raise_error
-      subject.send(attr).should == "hello"
+      expect(subject.send(attr)).to eq("hello")
     end
 
     it "should accept a long (single line) value for #{attr}" do
       text = "I never know when to stop with the word banana" + ("na" * 1000)
       expect { subject.send("#{attr}=", text) }.to_not raise_error
-      subject.send(attr).should == text
+      expect(subject.send(attr)).to eq(text)
     end
   end
 
@@ -25,17 +25,17 @@ shared_examples_for "documentation on faces" do
     context "#{getter}" do
       it "should strip leading whitespace on a single line" do
         subject.send(setter, "  death to whitespace")
-        subject.send(getter).should == "death to whitespace"
+        expect(subject.send(getter)).to eq("death to whitespace")
       end
 
       it "should strip trailing whitespace on a single line" do
         subject.send(setter, "death to whitespace  ")
-        subject.send(getter).should == "death to whitespace"
+        expect(subject.send(getter)).to eq("death to whitespace")
       end
 
       it "should strip whitespace at both ends at once" do
         subject.send(setter, "  death to whitespace  ")
-        subject.send(getter).should == "death to whitespace"
+        expect(subject.send(getter)).to eq("death to whitespace")
       end
 
       multiline_text = "with\nnewlines"
@@ -43,12 +43,12 @@ shared_examples_for "documentation on faces" do
         it "should not accept multiline values" do
           expect { subject.send(setter, multiline_text) }.
             to raise_error ArgumentError, /#{getter} should be a single line/
-          subject.send(getter).should be_nil
+          expect(subject.send(getter)).to be_nil
         end
       else
         it "should accept multiline values" do
           expect { subject.send(setter, multiline_text) }.not_to raise_error
-          subject.send(getter).should == multiline_text
+          expect(subject.send(getter)).to eq(multiline_text)
         end
 
         [1, 2, 4, 7, 25].each do |length|
@@ -58,20 +58,20 @@ shared_examples_for "documentation on faces" do
             it "should strip leading whitespace on multiple lines" do
               text = "this\nis\the\final\outcome"
               subject.send(setter, text.gsub(/^/, indent))
-              subject.send(getter).should == text
+              expect(subject.send(getter)).to eq(text)
             end
 
             it "should not remove formatting whitespace, only global indent" do
               text = "this\n  is\n    the\n  ultimate\ntest"
               subject.send(setter, text.gsub(/^/, indent))
-              subject.send(getter).should == text
+              expect(subject.send(getter)).to eq(text)
             end
           end
         end
 
         it "should strip whitespace with a blank line" do
           subject.send(setter, "  this\n\n  should outdent")
-          subject.send(getter).should == "this\n\nshould outdent"
+          expect(subject.send(getter)).to eq("this\n\nshould outdent")
         end
       end
     end
@@ -81,46 +81,46 @@ shared_examples_for "documentation on faces" do
     it "should return the set value if set after description" do
       subject.description = "hello\ngoodbye"
       subject.short_description = "whatever"
-      subject.short_description.should == "whatever"
+      expect(subject.short_description).to eq("whatever")
     end
 
     it "should return the set value if set before description" do
       subject.short_description = "whatever"
       subject.description = "hello\ngoodbye"
-      subject.short_description.should == "whatever"
+      expect(subject.short_description).to eq("whatever")
     end
 
     it "should return nothing if not set and no description" do
-      subject.short_description.should be_nil
+      expect(subject.short_description).to be_nil
     end
 
     it "should return the first paragraph of description if not set (where it is one line long)" do
       subject.description = "hello"
-      subject.short_description.should == subject.description
+      expect(subject.short_description).to eq(subject.description)
     end
 
     it "should return the first paragraph of description if not set (where there is no paragraph break)" do
       subject.description = "hello\ngoodbye"
-      subject.short_description.should == subject.description
+      expect(subject.short_description).to eq(subject.description)
     end
 
     it "should return the first paragraph of description if not set (where there is a paragraph break)" do
       subject.description = "hello\ngoodbye\n\nmore\ntext\nhere\n\nfinal\nparagraph"
-      subject.short_description.should == "hello\ngoodbye"
+      expect(subject.short_description).to eq("hello\ngoodbye")
     end
 
     it "should trim a very, very long first paragraph and add ellipsis" do
       line = "this is a very, very, very long long line full of text\n"
       subject.description = line * 20 + "\n\nwhatever, dude."
 
-      subject.short_description.should == (line * 5).chomp + ' [...]'
+      expect(subject.short_description).to eq((line * 5).chomp + ' [...]')
     end
 
     it "should trim a very very long only paragraph even if it is followed by a new paragraph" do
       line = "this is a very, very, very long long line full of text\n"
       subject.description = line * 20
 
-      subject.short_description.should == (line * 5).chomp + ' [...]'
+      expect(subject.short_description).to eq((line * 5).chomp + ' [...]')
     end
   end
 
@@ -131,9 +131,9 @@ shared_examples_for "documentation on faces" do
       it "should support multiple authors" do
 
         authors.each {|name| subject.author name }
-        subject.authors.should =~ authors
+        expect(subject.authors).to match_array(authors)
 
-        subject.author.should == authors.join("\n")
+        expect(subject.author).to eq(authors.join("\n"))
       end
 
       it "should reject author as an array" do
@@ -145,19 +145,19 @@ shared_examples_for "documentation on faces" do
     context "#author=" do
       it "should accept a single name" do
         subject.author = "Fred"
-        subject.author.should == "Fred"
+        expect(subject.author).to eq("Fred")
       end
 
       it "should accept an array of names" do
         subject.author = authors
-        subject.authors.should =~ authors
-        subject.author.should == authors.join("\n")
+        expect(subject.authors).to match_array(authors)
+        expect(subject.author).to eq(authors.join("\n"))
       end
 
       it "should not append when set multiple times" do
         subject.author = "Fred"
         subject.author = "John"
-        subject.author.should == "John"
+        expect(subject.author).to eq("John")
       end
 
       it "should reject arrays with embedded newlines" do
@@ -169,12 +169,12 @@ shared_examples_for "documentation on faces" do
 
   describe "#license" do
     it "should default to reserving rights" do
-      subject.license.should =~ /All Rights Reserved/
+      expect(subject.license).to match(/All Rights Reserved/)
     end
 
     it "should accept an arbitrary license string on the object" do
       subject.license = "foo"
-      subject.license.should == "foo"
+      expect(subject.license).to eq("foo")
     end
 
     it "should accept symbols to specify existing licenses..."
@@ -189,45 +189,45 @@ shared_examples_for "documentation on faces" do
     [1997, "1997"].each do |year|
       it "should accept an entity name and a #{year.class.name} year" do
         subject.copyright("me", year)
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /#{year}/
+        expect(subject.copyright).to match(/\bme\b/)
+        expect(subject.copyright).to match(/#{year}/)
       end
 
       it "should accept multiple entity names and a #{year.class.name} year" do
         subject.copyright ["me", "you"], year
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /\byou\b/
-        subject.copyright.should =~ /#{year}/
+        expect(subject.copyright).to match(/\bme\b/)
+        expect(subject.copyright).to match(/\byou\b/)
+        expect(subject.copyright).to match(/#{year}/)
       end
     end
 
     ["1997-2003", "1997 - 2003", 1997..2003].each do |range|
       it "should accept a #{range.class.name} range of years" do
         subject.copyright("me", range)
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /1997-2003/
+        expect(subject.copyright).to match(/\bme\b/)
+        expect(subject.copyright).to match(/1997-2003/)
       end
 
       it "should accept a #{range.class.name} range of years" do
         subject.copyright ["me", "you"], range
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /\byou\b/
-        subject.copyright.should =~ /1997-2003/
+        expect(subject.copyright).to match(/\bme\b/)
+        expect(subject.copyright).to match(/\byou\b/)
+        expect(subject.copyright).to match(/1997-2003/)
       end
     end
 
     [[1997, 2003], ["1997", 2003], ["1997", "2003"]].each do |input|
       it "should accept the set of years #{input.inspect} in an array" do
         subject.copyright "me", input
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /1997, 2003/
+        expect(subject.copyright).to match(/\bme\b/)
+        expect(subject.copyright).to match(/1997, 2003/)
       end
 
       it "should accept the set of years #{input.inspect} in an array" do
         subject.copyright ["me", "you"], input
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /\byou\b/
-        subject.copyright.should =~ /1997, 2003/
+        expect(subject.copyright).to match(/\bme\b/)
+        expect(subject.copyright).to match(/\byou\b/)
+        expect(subject.copyright).to match(/1997, 2003/)
       end
     end
 
@@ -239,8 +239,8 @@ shared_examples_for "documentation on faces" do
     it "should accept complex copyright years" do
       years = [1997, 1999, 2000..2002, 2005].reverse
       subject.copyright "me", years
-      subject.copyright.should =~ /\bme\b/
-      subject.copyright.should =~ /1997, 1999, 2000-2002, 2005/
+      expect(subject.copyright).to match(/\bme\b/)
+      expect(subject.copyright).to match(/1997, 1999, 2000-2002, 2005/)
     end
   end
 
@@ -248,15 +248,15 @@ shared_examples_for "documentation on faces" do
   [:name, :options, :synopsis].each do |attr|
     describe "##{attr}" do
       it "should not allow you to set #{attr}" do
-        subject.should_not respond_to :"#{attr}="
+        expect(subject).not_to respond_to :"#{attr}="
       end
 
       it "should have a #{attr}" do
-        subject.send(attr).should_not be_nil
+        expect(subject.send(attr)).not_to be_nil
       end
 
       it "'s #{attr} should not be empty..." do
-        subject.send(attr).should_not == ''
+        expect(subject.send(attr)).not_to eq('')
       end
     end
   end