puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/face/parser_spec.rb

@@ -50,7 +50,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 '\{'/)
+        expect(@logs.join).to match(/environment special.*Syntax error at end of file/)
       end
 
     end

data/spec/unit/face/plugin_spec.rb

@@ -4,7 +4,7 @@ require 'puppet/face'
 
 describe Puppet::Face[:plugin, '0.0.1'] do
   [:download].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/unit/file_bucket/dipper_spec.rb

@@ -18,19 +18,19 @@ shared_examples_for "a restorable file" do
 
         klass.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new(plaintext))
 
-        dipper.restore(dest, checksum).should == checksum
-        digest(Puppet::FileSystem.binread(dest)).should == checksum
+        expect(dipper.restore(dest, checksum)).to eq(checksum)
+        expect(digest(Puppet::FileSystem.binread(dest))).to eq(checksum)
 
-        request.key.should == "#{digest_algorithm}/#{checksum}"
-        request.server.should == server
-        request.port.should == port
+        expect(request.key).to eq("#{digest_algorithm}/#{checksum}")
+        expect(request.server).to eq(server)
+        expect(request.port).to eq(port)
       end
 
       it "should skip restoring if existing file has the same checksum" do
         File.open(dest, 'wb') {|f| f.print(plaintext) }
 
         dipper.expects(:getfile).never
-        dipper.restore(dest, checksum).should be_nil
+        expect(dipper.restore(dest, checksum)).to be_nil
       end
 
       it "should overwrite existing file if it has different checksum" do
@@ -38,7 +38,7 @@ shared_examples_for "a restorable file" do
 
         File.open(dest, 'wb') {|f| f.print('other contents') }
 
-        dipper.restore(dest, checksum).should == checksum
+        expect(dipper.restore(dest, checksum)).to eq(checksum)
       end
     end
   end
@@ -59,7 +59,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
     file = make_tmp_file('contents')
     Puppet::FileBucket::File.indirection.expects(:head).raises ArgumentError
 
-    lambda { @dipper.backup(file) }.should raise_error(Puppet::Error)
+    expect { @dipper.backup(file) }.to raise_error(Puppet::Error)
   end
 
   it "should fail in an informative way when there are failures backing up to the server" do
@@ -69,7 +69,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
     Puppet::FileBucket::File.indirection.expects(:head).returns false
     Puppet::FileBucket::File.indirection.expects(:save).raises ArgumentError
 
-    lambda { @dipper.backup(file) }.should raise_error(Puppet::Error)
+    expect { @dipper.backup(file) }.to raise_error(Puppet::Error)
   end
 
   describe "backing up and retrieving local files" do
@@ -81,10 +81,10 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
         @dipper = Puppet::FileBucket::Dipper.new(:Path => file_bucket)
 
         file = make_tmp_file(plaintext)
-        digest(plaintext).should == checksum
+        expect(digest(plaintext)).to eq(checksum)
 
-        @dipper.backup(file).should == checksum
-        Puppet::FileSystem.exist?("#{file_bucket}/#{bucket_dir}/contents").should == true
+        expect(@dipper.backup(file)).to eq(checksum)
+        expect(Puppet::FileSystem.exist?("#{file_bucket}/#{bucket_dir}/contents")).to eq(true)
       end
 
       it "should not backup a file that is already in the bucket" do
@@ -94,7 +94,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
 
         Puppet::FileBucket::File.indirection.expects(:head).returns true
         Puppet::FileBucket::File.indirection.expects(:save).never
-        @dipper.backup(file).should == checksum
+        expect(@dipper.backup(file)).to eq(checksum)
       end
 
       it "should retrieve files from a local bucket" do
@@ -104,9 +104,9 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
 
         Puppet::FileBucketFile::File.any_instance.expects(:find).with{ |r| request = r }.once.returns(Puppet::FileBucket::File.new(plaintext))
 
-        @dipper.getfile(checksum).should == plaintext
+        expect(@dipper.getfile(checksum)).to eq(plaintext)
 
-        request.key.should == "#{digest_algorithm}/#{checksum}"
+        expect(request.key).to eq("#{digest_algorithm}/#{checksum}")
       end
     end
   end
@@ -126,11 +126,11 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
         Puppet::FileBucketFile::Rest.any_instance.expects(:head).with { |r| request1 = r }.once.returns(nil)
         Puppet::FileBucketFile::Rest.any_instance.expects(:save).with { |r| request2 = r }.once
 
-        @dipper.backup(file).should == checksum
+        expect(@dipper.backup(file)).to eq(checksum)
         [request1, request2].each do |r|
-          r.server.should == 'puppetmaster'
-          r.port.should == 31337
-          r.key.should == "#{digest_algorithm}/#{checksum}/#{real_path}"
+          expect(r.server).to eq('puppetmaster')
+          expect(r.port).to eq(31337)
+          expect(r.key).to eq("#{digest_algorithm}/#{checksum}/#{real_path}")
         end
       end
 
@@ -141,11 +141,11 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
 
         Puppet::FileBucketFile::Rest.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new(plaintext))
 
-        @dipper.getfile(checksum).should == plaintext
+        expect(@dipper.getfile(checksum)).to eq(plaintext)
 
-        request.server.should == 'puppetmaster'
-        request.port.should == 31337
-        request.key.should == "#{digest_algorithm}/#{checksum}"
+        expect(request.server).to eq('puppetmaster')
+        expect(request.port).to eq(31337)
+        expect(request.key).to eq("#{digest_algorithm}/#{checksum}")
       end
     end
   end

data/spec/unit/file_bucket/file_spec.rb

@@ -9,25 +9,19 @@ describe Puppet::FileBucket::File, :uses_checksums => true do
   # this is the default from spec_helper, but it keeps getting reset at odd times
   let(:bucketdir) { Puppet[:bucketdir] = tmpdir('bucket') }
 
-  it "defaults to serializing to `:s`" do
-    expect(Puppet::FileBucket::File.default_format).to eq(:s)
+  it "defaults to serializing to `:binary`" do
+    expect(Puppet::FileBucket::File.default_format).to eq(:binary)
   end
 
-  it "accepts s and pson" do
-    expect(Puppet::FileBucket::File.supported_formats).to include(:s, :pson)
+  it "accepts binary" do
+    expect(Puppet::FileBucket::File.supported_formats).to include(:binary)
   end
 
   describe "making round trips through network formats" do
     with_digest_algorithms do
-      it "can make a round trip through `s`" do
+      it "can make a round trip through `binary`" do
         file = Puppet::FileBucket::File.new(plaintext)
-        tripped = Puppet::FileBucket::File.convert_from(:s, file.render)
-        expect(tripped.contents).to eq(plaintext)
-      end
-
-      it "can make a round trip through `pson`" do
-        file = Puppet::FileBucket::File.new(plaintext)
-        tripped = Puppet::FileBucket::File.convert_from(:pson, file.render(:pson))
+        tripped = Puppet::FileBucket::File.convert_from(:binary, file.render)
         expect(tripped.contents).to eq(plaintext)
       end
     end
@@ -47,30 +41,20 @@ describe Puppet::FileBucket::File, :uses_checksums => true do
     it "it uses #{metadata[:digest_algorithm]} as the configured digest algorithm" do
       file = Puppet::FileBucket::File.new(plaintext)
 
-      file.contents.should == plaintext
-      file.checksum_type.should == digest_algorithm
-      file.checksum.should == "{#{digest_algorithm}}#{checksum}"
-      file.name.should == "#{digest_algorithm}/#{checksum}"
+      expect(file.contents).to eq(plaintext)
+      expect(file.checksum_type).to eq(digest_algorithm)
+      expect(file.checksum).to eq("{#{digest_algorithm}}#{checksum}")
+      expect(file.name).to eq("#{digest_algorithm}/#{checksum}")
     end
   end
 
   describe "when using back-ends" do
     it "should redirect using Puppet::Indirector" do
-      Puppet::Indirector::Indirection.instance(:file_bucket_file).model.should equal(Puppet::FileBucket::File)
+      expect(Puppet::Indirector::Indirection.instance(:file_bucket_file).model).to equal(Puppet::FileBucket::File)
     end
 
     it "should have a :save instance method" do
-      Puppet::FileBucket::File.indirection.should respond_to(:save)
+      expect(Puppet::FileBucket::File.indirection).to respond_to(:save)
     end
   end
-
-  it "should convert the contents to PSON" do
-    Puppet.expects(:deprecation_warning).with('Serializing Puppet::FileBucket::File objects to pson is deprecated.')
-    Puppet::FileBucket::File.new("file contents").to_pson.should == '{"contents":"file contents"}'
-  end
-
-  it "should load from PSON" do
-    Puppet.expects(:deprecation_warning).with('Deserializing Puppet::FileBucket::File objects from pson is deprecated. Upgrade to a newer version.')
-    Puppet::FileBucket::File.from_pson({"contents"=>"file contents"}).contents.should == "file contents"
-  end
 end

data/spec/unit/file_serving/base_spec.rb

@@ -8,68 +8,68 @@ describe Puppet::FileServing::Base do
   let(:file) { File.expand_path('/my/file') }
 
   it "should accept a path" do
-    Puppet::FileServing::Base.new(path).path.should == path
+    expect(Puppet::FileServing::Base.new(path).path).to eq(path)
   end
 
   it "should require that paths be fully qualified" do
-    lambda { Puppet::FileServing::Base.new("module/dir/file") }.should raise_error(ArgumentError)
+    expect { Puppet::FileServing::Base.new("module/dir/file") }.to raise_error(ArgumentError)
   end
 
   it "should allow specification of whether links should be managed" do
-    Puppet::FileServing::Base.new(path, :links => :manage).links.should == :manage
+    expect(Puppet::FileServing::Base.new(path, :links => :manage).links).to eq(:manage)
   end
 
   it "should have a :source attribute" do
     file = Puppet::FileServing::Base.new(path)
-    file.should respond_to(:source)
-    file.should respond_to(:source=)
+    expect(file).to respond_to(:source)
+    expect(file).to respond_to(:source=)
   end
 
   it "should consider :ignore links equivalent to :manage links" do
-    Puppet::FileServing::Base.new(path, :links => :ignore).links.should == :manage
+    expect(Puppet::FileServing::Base.new(path, :links => :ignore).links).to eq(:manage)
   end
 
   it "should fail if :links is set to anything other than :manage, :follow, or :ignore" do
-    proc { Puppet::FileServing::Base.new(path, :links => :else) }.should raise_error(ArgumentError)
+    expect { Puppet::FileServing::Base.new(path, :links => :else) }.to raise_error(ArgumentError)
   end
 
   it "should allow links values to be set as strings" do
-    Puppet::FileServing::Base.new(path, :links => "follow").links.should == :follow
+    expect(Puppet::FileServing::Base.new(path, :links => "follow").links).to eq(:follow)
   end
 
   it "should default to :manage for :links" do
-    Puppet::FileServing::Base.new(path).links.should == :manage
+    expect(Puppet::FileServing::Base.new(path).links).to eq(:manage)
   end
 
   it "should allow specification of a path" do
     Puppet::FileSystem.stubs(:exist?).returns(true)
-    Puppet::FileServing::Base.new(path, :path => file).path.should == file
+    expect(Puppet::FileServing::Base.new(path, :path => file).path).to eq(file)
   end
 
   it "should allow specification of a relative path" do
     Puppet::FileSystem.stubs(:exist?).returns(true)
-    Puppet::FileServing::Base.new(path, :relative_path => "my/file").relative_path.should == "my/file"
+    expect(Puppet::FileServing::Base.new(path, :relative_path => "my/file").relative_path).to eq("my/file")
   end
 
   it "should have a means of determining if the file exists" do
-    Puppet::FileServing::Base.new(file).should respond_to(:exist?)
+    expect(Puppet::FileServing::Base.new(file)).to respond_to(:exist?)
   end
 
   it "should correctly indicate if the file is present" do
     Puppet::FileSystem.expects(:lstat).with(file).returns stub('stat')
-    Puppet::FileServing::Base.new(file).exist?.should be_true
+    expect(Puppet::FileServing::Base.new(file).exist?).to be_truthy
   end
 
   it "should correctly indicate if the file is absent" do
     Puppet::FileSystem.expects(:lstat).with(file).raises RuntimeError
-    Puppet::FileServing::Base.new(file).exist?.should be_false
+    expect(Puppet::FileServing::Base.new(file).exist?).to be_falsey
   end
 
   describe "when setting the relative path" do
     it "should require that the relative path be unqualified" do
       @file = Puppet::FileServing::Base.new(path)
       Puppet::FileSystem.stubs(:exist?).returns(true)
-      proc { @file.relative_path = File.expand_path("/qualified/file") }.should raise_error(ArgumentError)
+      expect { @file.relative_path = File.expand_path("/qualified/file") }.to raise_error(ArgumentError)
     end
   end
 
@@ -78,27 +78,27 @@ describe Puppet::FileServing::Base do
     let(:file) { Puppet::FileServing::Base.new(path) }
 
     it "should return the path if there is no relative path" do
-      file.full_path.should == path
+      expect(file.full_path).to eq(path)
     end
 
     it "should return the path if the relative_path is set to ''" do
       file.relative_path = ""
-      file.full_path.should == path
+      expect(file.full_path).to eq(path)
     end
 
     it "should return the path if the relative_path is set to '.'" do
       file.relative_path = "."
-      file.full_path.should == path
+      expect(file.full_path).to eq(path)
     end
 
     it "should return the path joined with the relative path if there is a relative path and it is not set to '/' or ''" do
       file.relative_path = "not/qualified"
-      file.full_path.should == File.join(path, "not/qualified")
+      expect(file.full_path).to eq(File.join(path, "not/qualified"))
     end
 
     it "should strip extra slashes" do
       file = Puppet::FileServing::Base.new(File.join(File.expand_path('/'), "//this//file"))
-      file.full_path.should == path
+      expect(file.full_path).to eq(path)
     end
   end
 
@@ -108,13 +108,13 @@ describe Puppet::FileServing::Base do
 
     it "should preserve double slashes at the beginning of the path" do
       Puppet.features.stubs(:microsoft_windows?).returns(true)
-      file.full_path.should == path
+      expect(file.full_path).to eq(path)
     end
 
     it "should strip double slashes not at the beginning of the path" do
       Puppet.features.stubs(:microsoft_windows?).returns(true)
       file = Puppet::FileServing::Base.new('//server//share//filename')
-      file.full_path.should == path
+      expect(file.full_path).to eq(path)
     end
   end
 
@@ -132,7 +132,7 @@ describe Puppet::FileServing::Base do
 
     it "should fail if the file does not exist" do
       Puppet::FileSystem.expects(:lstat).with(path).raises(Errno::ENOENT)
-      proc { file.stat }.should raise_error(Errno::ENOENT)
+      expect { file.stat }.to raise_error(Errno::ENOENT)
     end
 
     it "should use :lstat if :links is set to :manage" do
@@ -149,20 +149,20 @@ describe Puppet::FileServing::Base do
 
   describe "#absolute?" do
     it "should be accept POSIX paths" do
-      Puppet::FileServing::Base.should be_absolute('/')
+      expect(Puppet::FileServing::Base).to be_absolute('/')
     end
 
     it "should accept Windows paths on Windows" do
       Puppet.features.stubs(:microsoft_windows?).returns(true)
       Puppet.features.stubs(:posix?).returns(false)
 
-      Puppet::FileServing::Base.should be_absolute('c:/foo')
+      expect(Puppet::FileServing::Base).to be_absolute('c:/foo')
     end
 
     it "should reject Windows paths on POSIX" do
       Puppet.features.stubs(:microsoft_windows?).returns(false)
 
-      Puppet::FileServing::Base.should_not be_absolute('c:/foo')
+      expect(Puppet::FileServing::Base).not_to be_absolute('c:/foo')
     end
   end
 end

data/spec/unit/file_serving/configuration/parser_spec.rb

@@ -25,12 +25,12 @@ describe Puppet::FileServing::Configuration::Parser do
 
     it "should allow comments" do
       write_config_file("# this is a comment\n")
-      proc { @parser.parse }.should_not raise_error
+      expect { @parser.parse }.not_to raise_error
     end
 
     it "should allow blank lines" do
       write_config_file("\n")
-      proc { @parser.parse }.should_not raise_error
+      expect { @parser.parse }.not_to raise_error
     end
 
     it "should create a new mount for each section in the configuration" do
@@ -51,18 +51,18 @@ describe Puppet::FileServing::Configuration::Parser do
       write_config_file "[one]\n[two]\n"
 
       result = @parser.parse
-      result["one"].should equal(mount1)
-      result["two"].should equal(mount2)
+      expect(result["one"]).to equal(mount1)
+      expect(result["two"]).to equal(mount2)
     end
 
     it "should only allow mount names that are alphanumeric plus dashes" do
       write_config_file "[a*b]\n"
-      proc { @parser.parse }.should raise_error(ArgumentError)
+      expect { @parser.parse }.to raise_error(ArgumentError)
     end
 
     it "should fail if the value for path/allow/deny starts with an equals sign" do
       write_config_file "[one]\npath = /testing"
-      proc { @parser.parse }.should raise_error(ArgumentError)
+      expect { @parser.parse }.to raise_error(ArgumentError)
     end
 
     it "should validate each created mount" do
@@ -82,13 +82,13 @@ describe Puppet::FileServing::Configuration::Parser do
 
       mount1.expects(:validate).raises RuntimeError
 
-      lambda { @parser.parse }.should raise_error(RuntimeError)
+      expect { @parser.parse }.to raise_error(RuntimeError)
     end
 
     it "should return comprehensible error message, if invalid line detected" do
-      write_config_file "[one]\n\n\x01path /etc/puppet/files\n\x01allow *\n"
+      write_config_file "[one]\n\n\x01path /etc/puppetlabs/puppet/files\n\x01allow *\n"
 
-      proc { @parser.parse }.should raise_error(ArgumentError, /Invalid line.*in.*, line 3/)
+      expect { @parser.parse }.to raise_error(ArgumentError, /Invalid line.*in.*, line 3/)
     end
   end
 
@@ -135,7 +135,7 @@ describe Puppet::FileServing::Configuration::Parser do
     it "should return comprehensible error message, if failed on invalid attribute" do
       write_config_file "[one]\ndo something\n"
 
-      proc { @parser.parse }.should raise_error(ArgumentError, /Invalid argument 'do' in .*, line 2/)
+      expect { @parser.parse }.to raise_error(ArgumentError, /Invalid argument 'do' in .*, line 2/)
     end
   end
 

data/spec/unit/file_serving/configuration_spec.rb

@@ -21,7 +21,7 @@ describe Puppet::FileServing::Configuration do
   end
 
   it "should return the same configuration each time 'configuration' is called" do
-    Puppet::FileServing::Configuration.configuration.should equal(Puppet::FileServing::Configuration.configuration)
+    expect(Puppet::FileServing::Configuration.configuration).to equal(Puppet::FileServing::Configuration.configuration)
   end
 
   describe "when initializing" do
@@ -55,7 +55,7 @@ describe Puppet::FileServing::Configuration do
     it "should set the mount list to the results of parsing" do
       @parser.expects(:parse).returns("one" => mock("mount"))
       config = Puppet::FileServing::Configuration.configuration
-      config.mounted?("one").should be_true
+      expect(config.mounted?("one")).to be_truthy
     end
 
     it "should not raise exceptions" do
@@ -66,12 +66,12 @@ describe Puppet::FileServing::Configuration do
     it "should replace the existing mount list with the results of reparsing" do
       @parser.expects(:parse).returns("one" => mock("mount"))
       config = Puppet::FileServing::Configuration.configuration
-      config.mounted?("one").should be_true
+      expect(config.mounted?("one")).to be_truthy
       # Now parse again
       @parser.expects(:parse).returns("two" => mock('other'))
       config.send(:readconfig, false)
-      config.mounted?("one").should be_false
-      config.mounted?("two").should be_true
+      expect(config.mounted?("one")).to be_falsey
+      expect(config.mounted?("two")).to be_truthy
     end
 
     it "should not replace the mount list until the file is entirely parsed successfully" do
@@ -80,14 +80,14 @@ describe Puppet::FileServing::Configuration do
       config = Puppet::FileServing::Configuration.configuration
       # Now parse again, so the exception gets thrown
       config.send(:readconfig, false)
-      config.mounted?("one").should be_true
+      expect(config.mounted?("one")).to be_truthy
     end
 
     it "should add modules and plugins mounts even if the file does not exist" do
       Puppet::FileSystem.expects(:exist?).returns false # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
-      config.mounted?("modules").should be_true
-      config.mounted?("plugins").should be_true
+      expect(config.mounted?("modules")).to be_truthy
+      expect(config.mounted?("plugins")).to be_truthy
     end
 
     it "should allow all access to modules and plugins if no fileserver.conf exists" do
@@ -121,8 +121,8 @@ describe Puppet::FileServing::Configuration do
       @parser.expects(:parse).returns("one" => mock("mount"))
       Puppet::FileSystem.expects(:exist?).returns true # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
-      config.mounted?("modules").should be_true
-      config.mounted?("plugins").should be_true
+      expect(config.mounted?("modules")).to be_truthy
+      expect(config.mounted?("plugins")).to be_truthy
     end
   end
 
@@ -130,7 +130,7 @@ describe Puppet::FileServing::Configuration do
     it "should choose the named mount if one exists" do
       config = Puppet::FileServing::Configuration.configuration
       config.expects(:mounts).returns("one" => "foo")
-      config.find_mount("one", mock('env')).should == "foo"
+      expect(config.find_mount("one", mock('env'))).to eq("foo")
     end
 
     it "should return nil if there is no such named mount" do
@@ -140,7 +140,7 @@ describe Puppet::FileServing::Configuration do
       mount = mock 'mount'
       config.stubs(:mounts).returns("modules" => mount)
 
-      config.find_mount("foo", env).should be_nil
+      expect(config.find_mount("foo", env)).to be_nil
     end
   end
 
@@ -186,14 +186,14 @@ describe Puppet::FileServing::Configuration do
     it "should return nil if the mount cannot be found" do
       config.expects(:find_mount).returns nil
 
-      config.split_path(request).should be_nil
+      expect(config.split_path(request)).to be_nil
     end
 
     it "should return the mount and the relative path if the mount is found" do
       mount = stub 'mount', :name => "foo"
       config.expects(:find_mount).returns mount
 
-      config.split_path(request).should == [mount, "bar/baz"]
+      expect(config.split_path(request)).to eq([mount, "bar/baz"])
     end
 
     it "should remove any double slashes" do
@@ -201,7 +201,7 @@ describe Puppet::FileServing::Configuration do
       mount = stub 'mount', :name => "foo"
       config.expects(:find_mount).returns mount
 
-      config.split_path(request).should == [mount, "bar/baz"]
+      expect(config.split_path(request)).to eq([mount, "bar/baz"])
     end
 
     it "should fail if the path contains .." do
@@ -217,7 +217,7 @@ describe Puppet::FileServing::Configuration do
       mount = stub 'mount', :name => "foo"
       config.expects(:find_mount).returns mount
 
-      config.split_path(request).should == [mount, nil]
+      expect(config.split_path(request)).to eq([mount, nil])
     end
 
     it "should add 'modules/' to the relative path if the modules mount is used but not specified, for backward compatibility" do
@@ -225,7 +225,7 @@ describe Puppet::FileServing::Configuration do
       mount = stub 'mount', :name => "modules"
       config.expects(:find_mount).returns mount
 
-      config.split_path(request).should == [mount, "foo/bar"]
+      expect(config.split_path(request)).to eq([mount, "foo/bar"])
     end
   end
 end