puppet 2.7.26 → 3.0.0.rc4

data/spec/unit/util/reference_serializer_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/util/rails/reference_serializer'
 

data/spec/unit/util/reference_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/util/reference'
 

data/spec/unit/util/resource_template_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/util/resource_template'

data/spec/unit/util/retryaction_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/util/retryaction'

data/spec/unit/util/rubygems_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'puppet/util/rubygems'
+
+describe Puppet::Util::RubyGems::Source do
+  let(:gem_path) { File.expand_path('/foo/gems') }
+  let(:gem_lib) { File.join(gem_path, 'lib') }
+  let(:fake_gem) { stub(:full_gem_path => gem_path) }
+
+  describe "::new" do
+    it "returns NoGemsSource if requiring rubygems fails" do
+      described_class.expects(:require).with('rubygems').raises(LoadError)
+      described_class.new.should be_kind_of(Puppet::Util::RubyGems::NoGemsSource)
+    end
+
+    it "returns Gems18Source if Gem::Specification responds to latest_specs" do
+      Gem::Specification.expects(:respond_to?).with(:latest_specs).returns(true)
+      described_class.new.should be_kind_of(Puppet::Util::RubyGems::Gems18Source)
+    end
+
+    it "returns Gems18Source if Gem::Specification does not respond to latest_specs" do
+      Gem::Specification.expects(:respond_to?).with(:latest_specs).returns(false)
+      described_class.new.should be_kind_of(Puppet::Util::RubyGems::OldGemsSource)
+    end
+  end
+
+  describe '::NoGemsSource' do
+    before(:each) { described_class.stubs(:source).returns(Puppet::Util::RubyGems::NoGemsSource) }
+
+    it "#directories returns an empty list" do
+      described_class.new.directories.should == []
+    end
+  end
+
+  describe '::Gems18Source' do
+    before(:each) { described_class.stubs(:source).returns(Puppet::Util::RubyGems::Gems18Source) }
+
+    it "#directories returns the lib subdirs of Gem::Specification.latest_specs" do
+      Gem::Specification.expects(:latest_specs).returns([fake_gem])
+
+      described_class.new.directories.should == [gem_lib]
+    end
+  end
+
+  describe '::OldGemsSource' do
+    before(:each) { described_class.stubs(:source).returns(Puppet::Util::RubyGems::OldGemsSource) }
+
+    it "#directories returns the contents of Gem.latest_load_paths" do
+      Gem.expects(:latest_load_paths).returns([gem_lib])
+
+      described_class.new.directories.should == [gem_lib]
+    end
+
+    # Older rubygems seem to have a problem with rescanning the gem paths in which they
+    # look for a file in the wrong place and expect it to be there. By caching the first
+    # set of results we don't trigger this bug. This behavior was seen on ruby 1.8.7-p334
+    # using rubygems v1.6.2
+    it "caches the gem paths (works around a bug in older rubygems)" do
+      Gem.expects(:latest_load_paths).returns([gem_lib]).once
+
+      source = described_class.new
+
+      source.directories.should == [gem_lib]
+    end
+  end
+end
+

data/spec/unit/util/run_mode_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe Puppet::Util::RunMode do
@@ -15,8 +15,7 @@ describe Puppet::Util::RunMode do
 
   it "should have confdir ~/.puppet when run as non-root" do
     Puppet.features.stubs(:root?).returns(false)
-    @run_mode.expects(:expand_path).with("~/.puppet").returns("~/.puppet")
-    @run_mode.conf_dir.should == "~/.puppet"
+    @run_mode.conf_dir.should == File.expand_path("~/.puppet")
   end
 
   it "should have vardir /var/lib/puppet when run as root" do
@@ -28,20 +27,16 @@ describe Puppet::Util::RunMode do
 
   it "should have vardir ~/.puppet/var when run as non-root" do
     Puppet.features.stubs(:root?).returns(false)
-    @run_mode.expects(:expand_path).with("~/.puppet/var").returns("~/.puppet/var")
-    @run_mode.var_dir.should == "~/.puppet/var"
+    @run_mode.var_dir.should == File.expand_path("~/.puppet/var")
   end
 
   it "should have rundir depend on vardir" do
     @run_mode.run_dir.should == '$vardir/run'
   end
 
-  it "should have logopts return an array with $vardir/log if runmode is not master" do
-    @run_mode.expects(:master?).returns false
-    @run_mode.logopts.should == ["$vardir/log", "The Puppet log directory."]
-  end
 
   it "should have logopts return a hash with $vardir/log and other metadata if runmode is master" do
+    pending("runmode.logopts functionality is being moved")
     @run_mode.expects(:master?).returns true
     @run_mode.logopts.should == {
       :default => "$vardir/log",

data/spec/unit/util/selinux_spec.rb

@@ -1,7 +1,6 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
-require 'pathname'
 require 'puppet/util/selinux'
 include Puppet::Util::SELinux
 
@@ -34,7 +33,7 @@ describe Puppet::Util::SELinux do
     end
   end
 
-  describe "read_mounts" do
+  describe "filesystem detection" do
     before :each do
       fh = stub 'fh', :close => nil
       File.stubs(:open).with("/proc/mounts").returns fh
@@ -49,17 +48,6 @@ describe Puppet::Util::SELinux do
         '/proc' => 'proc',
         '/dev' => 'tmpfs' }
     end
-  end
-
-  describe "filesystem detection" do
-    before :each do
-      self.stubs(:read_mounts).returns({
-        '/'        => 'ext3',
-        '/sys'     => 'sysfs',
-        '/mnt/nfs' => 'nfs',
-        '/proc'    => 'proc',
-        '/dev'     => 'tmpfs' })
-    end
 
     it "should match a path on / to ext3" do
       find_fs('/etc/puppet/testfile').should == "ext3"
@@ -77,21 +65,41 @@ describe Puppet::Util::SELinux do
       selinux_label_support?('/mnt/nfs/testfile').should be_false
     end
 
-    it "(#8714) don't follow symlinks when determining file systems", :unless => Puppet.features.microsoft_windows? do
-      scratch = Pathname(PuppetSpec::Files.tmpdir('selinux'))
+    it "should follow symlinks when determining file systems" do
+      self.stubs(:realpath).with('/mnt/symlink/testfile').returns('/mnt/nfs/dest/testfile')
 
-      self.stubs(:read_mounts).returns({
-          '/'             => 'ext3',
-          scratch + 'nfs' => 'nfs',
-        })
-
-      (scratch + 'foo').make_symlink('nfs/bar')
-      selinux_label_support?(scratch + 'foo').should be_true
+      selinux_label_support?('/mnt/symlink/testfile').should be_false
     end
 
+  end
+
+  describe "realpath" do
     it "should handle files that don't exist" do
-      scratch = Pathname(PuppetSpec::Files.tmpdir('selinux'))
-      selinux_label_support?(scratch + 'nonesuch').should be_true
+
+      # Since I'm stubbing Pathname.new for this test,
+      # I need to also stub the internal calls to Pathname.new,
+      # which happen in Pathname.dirname and Parthname.basename
+      # I want those to return real Pathname objects,
+      # so I'm creating them before the stub is in place.
+      realpaths = Hash.new {|hash, path| hash[path] = Pathname.new(path) }
+      paths = ['symlink', '/mnt']
+      paths.each { |path| realpaths[path] }
+
+      realpaths['/mnt/symlink'] = stubs "Pathname"
+      realpaths['/mnt/symlink'].stubs(:realpath).returns(realpaths['/mnt/nfs/dest'])
+      realpaths['/mnt/symlink'].stubs(:exist?).returns(true)
+
+      realpaths['/mnt/symlink/nonexistant'] = stubs "Pathname"
+      realpaths['/mnt/symlink/nonexistant'].stubs(:realpath).raises(Errno::ENOENT)
+      realpaths['/mnt/symlink/nonexistant'].stubs(:exist?).returns(false)
+      realpaths['/mnt/symlink/nonexistant'].stubs(:dirname).returns(realpaths['/mnt/symlink'])
+      realpaths['/mnt/symlink/nonexistant'].stubs(:basename).returns(realpaths['nonexistant'])
+
+      realpaths.each do |path, value|
+        Pathname.stubs(:new).with(path).returns(value)
+      end
+
+      realpath('/mnt/symlink/nonexistant').should == '/mnt/nfs/dest/nonexistant'
     end
   end
 

data/spec/unit/util/storage_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'yaml'
@@ -41,7 +41,7 @@ describe Puppet::Util::Storage do
 
   describe "when caching a Puppet::Type" do
     before(:all) do
-      @file_test = Puppet::Type.type(:file).new(:name => @basepath+"/yayness", :check => %w{checksum type})
+      @file_test = Puppet::Type.type(:file).new(:name => @basepath+"/yayness", :audit => %w{checksum type})
       @exec_test = Puppet::Type.type(:exec).new(:name => @basepath+"/bin/ls /yayness")
     end
 
@@ -165,15 +165,6 @@ describe Puppet::Util::Storage do
         Dir.rmdir(Puppet[:statefile])
       end
 
-      it "should fail gracefully on load() if it cannot get a read lock on the state file" do
-        Puppet::Util::FileLocking.expects(:readlock).yields(false)
-        test_yaml = {'File["/yayness"]'=>{"name"=>{:a=>:b,:c=>:d}}}
-        YAML.expects(:load).returns(test_yaml)
-
-        proc { Puppet::Util::Storage.load }.should_not raise_error
-        Puppet::Util::Storage.state.should == test_yaml
-      end
-
       after(:each) do
         @state_file.close!()
         Puppet[:statefile] = @saved_statefile
@@ -205,13 +196,6 @@ describe Puppet::Util::Storage do
       Dir.rmdir(Puppet[:statefile])
     end
 
-    it "should raise an exception if it cannot get a write lock on the state file" do
-      Puppet::Util::FileLocking.expects(:writelock).yields(false)
-      Puppet::Util::Storage.cache(:yayness)
-
-      proc { Puppet::Util::Storage.store }.should raise_error
-    end
-
     it "should load() the same information that it store()s" do
       Puppet::Util::Storage.cache(:yayness)
 

data/spec/unit/util/suidmanager_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 
 require 'spec_helper'
 
@@ -215,9 +215,16 @@ describe Puppet::Util::SUIDManager do
 
     describe "with #run_and_capture" do
       it "should capture the output and return process status" do
-        Puppet::Util.
-          expects(:execute).
-          with('yay', :combine => true, :failonfail => false, :uid => user[:uid], :gid => user[:gid]).
+        Puppet::Util::Execution.
+          expects(:execute).with() do |*args|
+              args[0] == 'yay' &&
+              args[1][:combine] == true &&
+              args[1][:failonfail] == false &&
+              args[1][:uid] == user[:uid] &&
+              args[1][:gid] == user[:gid] &&
+              args[1][:override_locale] == true &&
+              args[1].has_key?(:custom_environment)
+        end .
           returns('output')
         output = Puppet::Util::SUIDManager.run_and_capture 'yay', user[:uid], user[:gid]
 

data/spec/unit/util/symbolic_file_mode_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/util/symbolic_file_mode'

data/spec/unit/util/tagging_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/util/tagging'

data/spec/unit/util/terminal_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/util/terminal'
 

data/spec/unit/util/user_attr_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/util/user_attr'

data/spec/unit/util/warnings_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe Puppet::Util::Warnings do

data/spec/unit/util/windows/registry_spec.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet/util/windows'
+require 'puppet/util/windows/registry'
+
+describe Puppet::Util::Windows::Registry, :if => Puppet::Util::Platform.windows? do
+  subject do
+    class TestRegistry
+      include Puppet::Util::Windows::Registry
+    end
+
+    TestRegistry.new
+  end
+
+  let(:name)   { 'HKEY_LOCAL_MACHINE' }
+  let(:path)   { 'Software\Microsoft' }
+
+  context "#root" do
+    it "should lookup the root hkey" do
+      subject.root(name).should be_instance_of(Win32::Registry::PredefinedKey)
+    end
+
+    it "should raise for unknown root keys" do
+      expect { subject.root('HKEY_BOGUS') }.to raise_error(Puppet::Error, /Invalid registry key/)
+    end
+  end
+
+  context "#open" do
+    let(:hkey)   { mock 'hklm' }
+    let(:subkey) { stub 'subkey' }
+
+    before :each do
+      subject.stubs(:root).returns(hkey)
+    end
+
+    it "should yield the opened the subkey" do
+      hkey.expects(:open).with do |p, _|
+        p.should == path
+      end.yields(subkey)
+
+      yielded = nil
+      subject.open(name, path) {|reg| yielded = reg}
+      yielded.should == subkey
+    end
+
+    [described_class::KEY64, described_class::KEY32].each do |access|
+      it "should open the key for read access 0x#{access.to_s(16)}" do
+        mode = described_class::KEY_READ | access
+        hkey.expects(:open).with(path, mode)
+
+        subject.open(name, path, mode) {|reg| }
+      end
+    end
+
+    it "should default to KEY64" do
+      hkey.expects(:open).with(path, described_class::KEY_READ | described_class::KEY64)
+
+      subject.open(hkey, path) {|hkey| }
+    end
+
+    it "should raise for a path that doesn't exist" do
+      hkey.expects(:keyname).returns('HKEY_LOCAL_MACHINE')
+      hkey.expects(:open).raises(Win32::Registry::Error.new(2)) # file not found
+      expect do
+        subject.open(hkey, 'doesnotexist') {|hkey| }
+      end.to raise_error(Puppet::Error, /Failed to open registry key 'HKEY_LOCAL_MACHINE\\doesnotexist'/)
+    end
+  end
+
+  context "#values" do
+    let(:key) { stub('uninstall') }
+
+    it "should return each value's name and data" do
+      key.expects(:each_value).multiple_yields(
+        ['string', 1, 'foo'], ['dword', 4, 0]
+      )
+      subject.values(key).should == { 'string' => 'foo', 'dword' => 0 }
+    end
+
+    it "should return an empty hash if there are no values" do
+      key.expects(:each_value)
+
+      subject.values(key).should == {}
+    end
+  end
+end

data/spec/unit/util/zaml_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 # encoding: UTF-8
 #
 # The above encoding line is a magic comment to set the default source encoding
@@ -16,71 +16,43 @@ require 'spec_helper'
 require 'puppet/util/monkey_patches'
 
 describe "Pure ruby yaml implementation" do
-  def can_round_trip(value)
-    YAML.load(value.to_yaml).should == value
-  end
-
   {
-    7            => "--- 7",
-    3.14159      => "--- 3.14159",
-    "3.14159"    => '--- "3.14159"',
-    "+3.14159"   => '--- "+3.14159"',
-    "0x123abc"   => '--- "0x123abc"',
-    "-0x123abc"  => '--- "-0x123abc"',
-    "-0x123"     => '--- "-0x123"',
-    "+0x123"     => '--- "+0x123"',
-    "0x123.456"  => '--- "0x123.456"',
-    'test'       => "--- test",
-    []           => "--- []",
-    :symbol      => "--- !ruby/sym symbol",
-    {:a => "A"}  => "--- \n  !ruby/sym a: A",
-    {:a => "x\ny"} => "--- \n  !ruby/sym a: |-\n    x\n    y"
-  }.each do |data, serialized|
-    it "should convert the #{data.class} #{data.inspect} to yaml" do
-      data.to_yaml.should == serialized
-    end
-
-    it "should produce yaml for the #{data.class} #{data.inspect} that can be reconstituted" do
-      can_round_trip data
+  7            => "--- 7",
+  3.14159      => "--- 3.14159",
+  "3.14159"    => '--- "3.14159"',
+  "+3.14159"   => '--- "+3.14159"',
+  "0x123abc"   => '--- "0x123abc"',
+  "-0x123abc"  => '--- "-0x123abc"',
+  "-0x123"     => '--- "-0x123"',
+  "+0x123"     => '--- "+0x123"',
+  "0x123.456"  => "--- 0x123.456",
+  'test'       => "--- test",
+  []           => "--- []",
+  :symbol      => "--- !ruby/sym symbol",
+  {:a => "A"}  => "--- \n  !ruby/sym a: A",
+  {:a => "x\ny"} => "--- \n  !ruby/sym a: |-\n    x\n    y" 
+  }.each { |o,y|
+    it "should convert the #{o.class} #{o.inspect} to yaml" do
+      o.to_yaml.should == y
     end
-  end
-
-  [
-    { :a => "a:" },
-    { :a => "a:", :b => "b:" },
-    ["a:", "b:"],
-    { :a => "/:", :b => "/:" },
-    { :a => "a/:", :b => "a/:" },
-    { :a => "\"" },
-    { :a => {}.to_yaml },
-    { :a => [].to_yaml },
-    { :a => "".to_yaml },
-    { :a => :a.to_yaml },
-
-    { "a:" => "b" },
-    { :a.to_yaml => "b" },
-    { [1, 2, 3] => "b" },
-    { "b:" => { "a" => [] } }
-  ].each do |value|
-    it "properly escapes #{value.inspect}, which contains YAML characters" do
-      can_round_trip value
+    it "should produce yaml for the #{o.class} #{o.inspect} that can be reconstituted" do
+      YAML.load(o.to_yaml).should == o
     end
-  end
-
+  }
   #
   # Can't test for equality on raw objects
   {
-    Object.new                   => "--- !ruby/object {}",
-    [Object.new]                 => "--- \n  - !ruby/object {}",
-    {Object.new => Object.new}   => "--- \n  ? !ruby/object {}\n  : !ruby/object {}"
-  }.each do |o,y|
+  Object.new                   => "--- !ruby/object {}",
+  [Object.new]                 => "--- \n  - !ruby/object {}",
+  {Object.new => Object.new}   => "--- \n  ? !ruby/object {}\n  : !ruby/object {}"
+  }.each { |o,y|
     it "should convert the #{o.class} #{o.inspect} to yaml" do
       o.to_yaml.should == y
     end
     it "should produce yaml for the #{o.class} #{o.inspect} that can be reconstituted" do
       lambda { YAML.load(o.to_yaml) }.should_not raise_error
     end
-  end
+  }
 
   it "should emit proper labels and backreferences for common objects" do
     # Note: this test makes assumptions about the names ZAML chooses
@@ -136,16 +108,6 @@ end
 describe "binary data" do
   subject { "M\xC0\xDF\xE5tt\xF6" }
 
-  if String.method_defined?(:encoding)
-    def binary(str)
-      str.force_encoding('binary')
-    end
-  else
-    def binary(str)
-      str
-    end
-  end
-
   it "should not explode encoding binary data" do
     expect { subject.to_yaml }.not_to raise_error
   end
@@ -157,90 +119,12 @@ describe "binary data" do
   it "should round-trip the data" do
     yaml = subject.to_yaml
     read = YAML.load(yaml)
-    binary(read).should == binary(subject)
-  end
 
-  [
-    "\xC0\xAE",                 # over-long UTF-8 '.' character
-    "\xC0\x80",                 # over-long NULL byte
-    "\xC0\xFF",
-    "\xC1\xAE",
-    "\xC1\x80",
-    "\xC1\xFF",
-    "\x80",                     # first continuation byte
-    "\xbf",                     # last continuation byte
-    # all possible continuation bytes in one shot
-    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F" +
-    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F" +
-    "\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF" +
-    "\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF",
-    # lonely start characters - first, all possible two byte sequences
-    "\xC0 \xC1 \xC2 \xC3 \xC4 \xC5 \xC6 \xC7 \xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF " +
-    "\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 \xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF ",
-    # and so for three byte sequences, four, five, and six, as follow.
-    "\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 \xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF ",
-    "\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 ",
-    "\xF8 \xF9 \xFA \xFB ",
-    "\xFC \xFD ",
-    # sequences with the last byte missing
-    "\xC0", "\xE0", "\xF0\x80\x80", "\xF8\x80\x80\x80", "\xFC\x80\x80\x80\x80",
-    "\xDF", "\xEF\xBF", "\xF7\xBF\xBF", "\xFB\xBF\xBF\xBF", "\xFD\xBF\xBF\xBF\xBF",
-    # impossible bytes
-    "\xFE", "\xFF", "\xFE\xFE\xFF\xFF",
-    # over-long '/' character
-    "\xC0\xAF",
-    "\xE0\x80\xAF",
-    "\xF0\x80\x80\xAF",
-    "\xF8\x80\x80\x80\xAF",
-    "\xFC\x80\x80\x80\x80\xAF",
-    # maximum overlong sequences
-    "\xc1\xbf",
-    "\xe0\x9f\xbf",
-    "\xf0\x8f\xbf\xbf",
-    "\xf8\x87\xbf\xbf\xbf",
-    "\xfc\x83\xbf\xbf\xbf\xbf",
-    # overlong NUL
-    "\xc0\x80",
-    "\xe0\x80\x80",
-    "\xf0\x80\x80\x80",
-    "\xf8\x80\x80\x80\x80",
-    "\xfc\x80\x80\x80\x80\x80",
-  ].each do |input|
-    # It might seem like we should more correctly reject these sequences in
-    # the encoder, and I would personally agree, but the sad reality is that
-    # we do not distinguish binary and textual data in our language, and so we
-    # wind up with the same thing - a string - containing both.
-    #
-    # That leads to the position where we must treat these invalid sequences,
-    # which are both legitimate binary content, and illegitimate potential
-    # attacks on the system, as something that passes through correctly in
-    # a string. --daniel 2012-07-14
-    it "binary encode highly dubious non-compliant UTF-8 input #{input.inspect}" do
-      encoded = ZAML.dump(binary(input))
-      encoded.should =~ /!binary/
-      YAML.load(encoded).should == input
+    if read.respond_to? :force_encoding
+      read.force_encoding('binary')
+      subject.force_encoding('binary')
     end
-  end
-end
 
-describe "multi-line values" do
-  [
-    "none",
-    "one\n",
-    "two\n\n",
-    ["one\n", "two"],
-    ["two\n\n", "three"],
-    { "\nkey"        => "value" },
-    { "key\n"        => "value" },
-    { "\nkey\n"      => "value" },
-    { "key\nkey"     => "value" },
-    { "\nkey\nkey"   => "value" },
-    { "key\nkey\n"   => "value" },
-    { "\nkey\nkey\n" => "value" },
-  ].each do |input|
-    it "handles #{input.inspect} without corruption" do
-      zaml = ZAML.dump(input)
-      YAML.load(zaml).should == input
-    end
+    read.should == subject
   end
 end