puppet 3.0.2 → 3.1.0.rc1

data/spec/unit/type/group_spec.rb

@@ -51,4 +51,14 @@ describe Puppet::Type.type(:group) do
     group.provider.expects(:delete)
     group.parameter(:ensure).sync
   end
+
+  it "delegates the existance check to its provider" do
+    provider = @class.provide(:testing) {}
+    provider_instance = provider.new
+    provider_instance.expects(:exists?).returns true
+
+    type = @class.new(:name => "group", :provider => provider_instance)
+
+    type.exists?.should == true
+  end
 end

data/spec/unit/util/autoload_spec.rb

@@ -262,4 +262,10 @@ describe Puppet::Util::Autoload do
       end
     end
   end
+
+  describe "#expand" do
+    it "should expand relative to the autoloader's prefix" do
+      @autoload.expand('bar').should == 'tmp/bar'
+    end
+  end
 end

data/spec/unit/util/command_line_spec.rb

@@ -6,64 +6,62 @@ require 'puppet/util/command_line'
 
 describe Puppet::Util::CommandLine do
   include PuppetSpec::Files
-  let :tty  do stub("tty",  :tty? => true)  end
-  let :pipe do stub("pipe", :tty? => false) end
 
   context "#initialize" do
     it "should pull off the first argument if it looks like a subcommand" do
-      command_line = Puppet::Util::CommandLine.new("puppet", %w{ client --help whatever.pp }, tty)
+      command_line = Puppet::Util::CommandLine.new("puppet", %w{ client --help whatever.pp })
 
       command_line.subcommand_name.should == "client"
       command_line.args.should            == %w{ --help whatever.pp }
     end
 
     it "should return nil if the first argument looks like a .pp file" do
-      command_line = Puppet::Util::CommandLine.new("puppet", %w{ whatever.pp }, tty)
+      command_line = Puppet::Util::CommandLine.new("puppet", %w{ whatever.pp })
 
       command_line.subcommand_name.should == nil
       command_line.args.should            == %w{ whatever.pp }
     end
 
     it "should return nil if the first argument looks like a .rb file" do
-      command_line = Puppet::Util::CommandLine.new("puppet", %w{ whatever.rb }, tty)
+      command_line = Puppet::Util::CommandLine.new("puppet", %w{ whatever.rb })
 
       command_line.subcommand_name.should == nil
       command_line.args.should            == %w{ whatever.rb }
     end
 
     it "should return nil if the first argument looks like a flag" do
-      command_line = Puppet::Util::CommandLine.new("puppet", %w{ --debug }, tty)
+      command_line = Puppet::Util::CommandLine.new("puppet", %w{ --debug })
 
       command_line.subcommand_name.should == nil
       command_line.args.should            == %w{ --debug }
     end
 
     it "should return nil if the first argument is -" do
-      command_line = Puppet::Util::CommandLine.new("puppet", %w{ - }, tty)
+      command_line = Puppet::Util::CommandLine.new("puppet", %w{ - })
 
       command_line.subcommand_name.should == nil
       command_line.args.should            == %w{ - }
     end
 
     it "should return nil if the first argument is --help" do
-      command_line = Puppet::Util::CommandLine.new("puppet", %w{ --help }, tty)
+      command_line = Puppet::Util::CommandLine.new("puppet", %w{ --help })
 
       command_line.subcommand_name.should == nil
     end
 
 
-    it "should return nil if there are no arguments on a tty" do
-      command_line = Puppet::Util::CommandLine.new("puppet", [], tty)
+    it "should return nil if there are no arguments" do
+      command_line = Puppet::Util::CommandLine.new("puppet", [])
 
       command_line.subcommand_name.should == nil
       command_line.args.should            == []
     end
 
-    it "should return nil if there are no arguments on a pipe" do
-      command_line = Puppet::Util::CommandLine.new("puppet", [], pipe)
-
-      command_line.subcommand_name.should == nil
-      command_line.args.should            == []
+    it "should pick up changes to the array of arguments" do
+      args = %w{subcommand}
+      command_line = Puppet::Util::CommandLine.new("puppet", args)
+      args[0] = 'different_subcommand'
+      command_line.subcommand_name.should == 'different_subcommand'
     end
   end
 
@@ -71,40 +69,32 @@ describe Puppet::Util::CommandLine do
     %w{--version -V}.each do |arg|
       it "should print the version and exit if #{arg} is given" do
         expect do
-          described_class.new("puppet", [arg], tty).execute
-        end.to have_printed(Puppet.version)
+          described_class.new("puppet", [arg]).execute
+        end.to have_printed(/^#{Puppet.version}$/)
       end
     end
   end
 
   describe "when dealing with puppet commands" do
     it "should return the executable name if it is not puppet" do
-      command_line = Puppet::Util::CommandLine.new("puppetmasterd", [], tty)
+      command_line = Puppet::Util::CommandLine.new("puppetmasterd", [])
       command_line.subcommand_name.should == "puppetmasterd"
     end
 
     describe "when the subcommand is not implemented" do
       it "should find and invoke an executable with a hyphenated name" do
-        commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'], tty)
+        commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
         Puppet::Util.expects(:which).with('puppet-whatever').
           returns('/dev/null/puppet-whatever')
 
-        # It is important that we abort at the point exec is called, because
-        # the code (reasonably) assumes that if `exec` is called processing
-        # immediately terminates, and we are replaced by the executed process.
-        #
-        # This raise isn't a perfect simulation of that, but it is enough to
-        # validate that the system works, and ... well, if exec is broken we
-        # have two problems, y'know.
-        commandline.expects(:exec).with('/dev/null/puppet-whatever', 'argument').
-          raises(SystemExit)
-
-        expect { commandline.execute }.to raise_error SystemExit
+        Kernel.expects(:exec).with('/dev/null/puppet-whatever', 'argument')
+
+        commandline.execute
       end
 
       describe "and an external implementation cannot be found" do
         it "should abort and show the usage message" do
-          commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'], tty)
+          commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
           Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
           commandline.expects(:exec).never
 
@@ -112,43 +102,45 @@ describe Puppet::Util::CommandLine do
             commandline.execute
           }.to have_printed(/Unknown Puppet subcommand 'whatever'/)
         end
+
+        it "should abort and show the help message" do
+          commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
+          Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
+          commandline.expects(:exec).never
+
+          expect {
+            commandline.execute
+          }.to have_printed(/See 'puppet help' for help on available puppet subcommands/)
+        end
+
+        %w{--version -V}.each do |arg|
+          it "should abort and display #{arg} information" do
+            commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', arg])
+            Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
+            commandline.expects(:exec).never
+
+            expect {
+              commandline.execute
+            }.to have_printed(/^#{Puppet.version}$/)
+          end
+        end
       end
     end
+
     describe 'when loading commands' do
-      let :core_apps do
-        %w{describe filebucket kick queue resource agent cert apply doc master}
-      end
+      it "should deprecate the available_subcommands instance method" do
+        Puppet::Application.expects(:available_application_names)
+        Puppet.expects(:deprecation_warning).with("Puppet::Util::CommandLine#available_subcommands is deprecated; please use Puppet::Application.available_application_names instead.")
 
-      let :command_line do
-        Puppet::Util::CommandLine.new("foo", %w{ client --help whatever.pp }, tty)
+        command_line = Puppet::Util::CommandLine.new("foo", %w{ client --help whatever.pp })
+        command_line.available_subcommands
       end
 
-      it "should expose available_subcommands as a class method" do
-        core_apps.each do |command|
-          command_line.available_subcommands.should include command
-        end
-      end
-      it 'should be able to find all existing commands' do
-        core_apps.each do |command|
-          command_line.available_subcommands.should include command
-        end
-      end
-      describe 'when multiple paths have applications' do
-        before do
-          @dir=tmpdir('command_line_plugin_test')
-          @appdir="#{@dir}/puppet/application"
-          FileUtils.mkdir_p(@appdir)
-          FileUtils.touch("#{@appdir}/foo.rb")
-          $LOAD_PATH.unshift(@dir) # WARNING: MUST MATCH THE AFTER ACTIONS!
-        end
-        it 'should be able to find commands from both paths' do
-          found = command_line.available_subcommands
-          found.should include 'foo'
-          core_apps.each { |cmd| found.should include cmd }
-        end
-        after do
-          $LOAD_PATH.shift        # WARNING: MUST MATCH THE BEFORE ACTIONS!
-        end
+      it "should deprecate the available_subcommands class method" do
+        Puppet::Application.expects(:available_application_names)
+        Puppet.expects(:deprecation_warning).with("Puppet::Util::CommandLine.available_subcommands is deprecated; please use Puppet::Application.available_application_names instead.")
+
+        Puppet::Util::CommandLine.available_subcommands
       end
     end
   end

data/spec/unit/util/manifest_filetype_helper_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+require 'puppet/util/manifest_filetype_helper'
+
+describe Puppet::Util::ManifestFiletypeHelper do
+  subject { Object.new.extend Puppet::Util::ManifestFiletypeHelper }
+
+  describe "#is_ruby_filename?" do
+    it "returns true when Ruby filename is passed as an argument" do
+      subject.is_ruby_filename?("test.rb").should be true
+    end
+
+    it "returns false when not Ruby filename is passed as an argument" do
+      subject.is_ruby_filename?("test").should be false
+    end
+  end
+
+  describe "#is_puppet_filename?" do
+    it "returns true when Puppet filename is passed as an argument" do
+      subject.is_puppet_filename?("test.pp").should be true
+    end
+
+    it "returns false when non-Puppet filename is passed as an argument" do
+      subject.is_puppet_filename?("test").should be false
+    end
+  end
+
+end
+

data/spec/unit/util/metric_spec.rb

@@ -83,13 +83,4 @@ describe Puppet::Util::Metric do
   it "should return nil if the named value cannot be found" do
     @metric["foo"].should == 0
   end
-
-  # LAK: I'm not taking the time to develop these tests right now.
-  # I expect they should actually be extracted into a separate class
-  # anyway.
-  it "should be able to graph metrics using RRDTool"
-
-  it "should be able to create a new RRDTool database"
-
-  it "should be able to store metrics into an RRDTool database"
 end

data/spec/unit/util/posix_spec.rb

@@ -248,8 +248,4 @@ describe Puppet::Util::POSIX do
   it "should be able to iteratively search for posix values" do
     @posix.should respond_to(:search_posix_field)
   end
-
-  describe "when searching for posix values iteratively" do
-    it "should iterate across all of the structs returned by Etc and return the appropriate field from the first matching value"
-  end
 end

data/spec/unit/util/rdoc_spec.rb

@@ -142,18 +142,6 @@ describe Puppet::Util::RDoc do
         # any other output must fail
         Puppet::Util::RDoc.manifestdoc([my_fixture('basic.pp')])
       end
-
-      it "should output resource documentation if needed" do
-        pending "#6634 being fixed"
-        Puppet.settings[:document_all] = true
-        byline = sequence('documentation outputs in line order')
-        Puppet::Util::RDoc.expects(:puts).with("im a class\n").in_sequence(byline)
-        Puppet::Util::RDoc.expects(:puts).with("im a node\n").in_sequence(byline)
-        Puppet::Util::RDoc.expects(:puts).with("im a define\n").in_sequence(byline)
-        Puppet::Util::RDoc.expects(:puts).with("im a resource\n").in_sequence(byline)
-        # any other output must fail
-        Puppet::Util::RDoc.manifestdoc([my_fixture('basic.pp')])
-      end
     end
   end
 end

data/spec/unit/util/zaml_spec.rb

@@ -16,8 +16,24 @@ 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
+  RSpec::Matchers.define :round_trip_through_yaml do
+    match do |object|
+      YAML.load(object.to_yaml) == object
+    end
+  end
+
+  RSpec::Matchers.define :be_equivalent_to do |expected_yaml|
+    match do |object|
+      object.to_yaml == expected_yaml and YAML.load(expected_yaml) == object
+    end
+
+    failure_message_for_should do |object|
+      if object.to_yaml != expected_yaml
+        "#{object} serialized to #{object.to_yaml}"
+      else
+        "#{expected_yaml} deserialized as #{YAML.load(expected_yaml)}"
+      end
+    end
   end
 
   {
@@ -34,14 +50,67 @@ describe "Pure ruby yaml implementation" do
     []           => "--- []",
     :symbol      => "--- !ruby/sym symbol",
     {:a => "A"}  => "--- \n  !ruby/sym a: A",
-    {:a => "x\ny"} => "--- \n  !ruby/sym a: |-\n    x\n    y"
+    {: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
+      data.should be_equivalent_to serialized
+    end
+  end
+
+  context Time do
+    def the_time_in(timezone)
+      Puppet::Util.withenv("TZ" => timezone) do
+        Time.local(2012, "dec", 11, 15, 59, 2)
+      end
+    end
+
+    def the_time_in_yaml_offset_by(offset)
+      "--- 2012-12-11 15:59:02.000000 #{offset}"
+    end
+
+    it "serializes a time in UTC" do
+      pending("not supported on Windows", :if => Puppet.features.microsoft_windows?) do
+        the_time_in("Europe/London").should be_equivalent_to(the_time_in_yaml_offset_by("+00:00"))
+      end
+    end
+
+    it "serializes a time behind UTC" do
+      pending("not supported on Windows", :if => Puppet.features.microsoft_windows?) do
+        the_time_in("America/Chicago").should be_equivalent_to(the_time_in_yaml_offset_by("-06:00"))
+      end
     end
 
-    it "should produce yaml for the #{data.class} #{data.inspect} that can be reconstituted" do
-      can_round_trip data
+    it "serializes a time behind UTC that is not a complete hour (Bug #15496)" do
+      pending("not supported on Windows", :if => Puppet.features.microsoft_windows?) do
+        the_time_in("America/Caracas").should be_equivalent_to(the_time_in_yaml_offset_by("-04:30"))
+      end
+    end
+
+    it "serializes a time ahead of UTC" do
+      pending("not supported on Windows", :if => Puppet.features.microsoft_windows?) do
+        the_time_in("Europe/Berlin").should be_equivalent_to(the_time_in_yaml_offset_by("+01:00"))
+      end
+    end
+
+    it "serializes a time ahead of UTC that is not a complete hour" do
+      pending("not supported on Windows", :if => Puppet.features.microsoft_windows?) do
+        the_time_in("Asia/Kathmandu").should be_equivalent_to(the_time_in_yaml_offset_by("+05:45"))
+      end
+    end
+
+    it "serializes a time more than 12 hours ahead of UTC" do
+      pending("not supported on Windows", :if => Puppet.features.microsoft_windows?) do
+        the_time_in("Pacific/Kiritimati").should be_equivalent_to(the_time_in_yaml_offset_by("+14:00"))
+      end
+    end
+
+    it "should roundtrip Time.now" do
+      tm = Time.now
+      # yaml only emits 6 digits of precision, but on some systems with ruby 1.9
+      # the original time object may contain nanoseconds, which will cause
+      # the equality check to fail. So truncate the time object to only microsecs
+      tm = Time.at(tm.to_i, tm.usec)
+      tm.should round_trip_through_yaml
     end
   end
 
@@ -63,7 +132,7 @@ describe "Pure ruby yaml implementation" do
     { "b:" => { "a" => [] } }
   ].each do |value|
     it "properly escapes #{value.inspect}, which contains YAML characters" do
-      can_round_trip value
+      value.should round_trip_through_yaml
     end
   end
 
@@ -88,11 +157,7 @@ describe "Pure ruby yaml implementation" do
     x = [1, 2]
     y = [3, 4]
     z = [x, y, x, y]
-    z.to_yaml.should == "--- \n  - &id001\n    - 1\n    - 2\n  - &id002\n    - 3\n    - 4\n  - *id001\n  - *id002"
-    z2 = YAML.load(z.to_yaml)
-    z2.should == z
-    z2[0].should equal(z2[2])
-    z2[1].should equal(z2[3])
+    z.should be_equivalent_to("--- \n  - &id001\n    - 1\n    - 2\n  - &id002\n    - 3\n    - 4\n  - *id001\n  - *id002")
   end
 
   it "should emit proper labels and backreferences for recursive objects" do
@@ -106,141 +171,134 @@ describe "Pure ruby yaml implementation" do
     x2[1].should == 2
     x2[2].should equal(x2)
   end
-end
-
-# Note, many of these tests will pass on Ruby 1.8 but fail on 1.9 if the patch
-# fix is not applied to Puppet or there's a regression.  These version
-# dependant failures are intentional since the string encoding behavior changed
-# significantly in 1.9.
-describe "UTF-8 encoded String#to_yaml (Bug #11246)" do
-  # JJM All of these snowmen are different representations of the same
-  # UTF-8 encoded string.
-  let(:snowman)         { 'Snowman: [☃]' }
-  let(:snowman_escaped) { "Snowman: [\xE2\x98\x83]" }
 
-  describe "UTF-8 String Literal" do
-    subject { snowman }
+  # Note, many of these tests will pass on Ruby 1.8 but fail on 1.9 if the patch
+  # fix is not applied to Puppet or there's a regression.  These version
+  # dependant failures are intentional since the string encoding behavior changed
+  # significantly in 1.9.
+  context "UTF-8 encoded String#to_yaml (Bug #11246)" do
+    # JJM All of these snowmen are different representations of the same
+    # UTF-8 encoded string.
+    let(:snowman)         { 'Snowman: [☃]' }
+    let(:snowman_escaped) { "Snowman: [\xE2\x98\x83]" }
 
-    it "should serialize to YAML" do
-      subject.to_yaml
-    end
     it "should serialize and deserialize to the same thing" do
-      YAML.load(subject.to_yaml).should == subject
+      snowman.should round_trip_through_yaml
     end
+
     it "should serialize and deserialize to a String compatible with a UTF-8 encoded Regexp" do
-      YAML.load(subject.to_yaml).should =~ /☃/u
+      YAML.load(snowman.to_yaml).should =~ /☃/u
     end
   end
-end
 
-describe "binary data" do
-  subject { "M\xC0\xDF\xE5tt\xF6" }
+  context "binary data" do
+    subject { "M\xC0\xDF\xE5tt\xF6" }
 
-  if String.method_defined?(:encoding)
-    def binary(str)
-      str.force_encoding('binary')
+    if String.method_defined?(:encoding)
+      def binary(str)
+        str.force_encoding('binary')
+      end
+    else
+      def binary(str)
+        str
+      end
     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
+    it "should not explode encoding binary data" do
+      expect { subject.to_yaml }.not_to raise_error
+    end
 
-  it "should mark the binary data as binary" do
-    subject.to_yaml.should =~ /!binary/
-  end
+    it "should mark the binary data as binary" do
+      subject.to_yaml.should =~ /!binary/
+    end
 
-  it "should round-trip the data" do
-    yaml = subject.to_yaml
-    read = YAML.load(yaml)
-    binary(read).should == binary(subject)
-  end
+    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
+    [
+      "\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
+      end
     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
+  context "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
+        input.should round_trip_through_yaml
+      end
     end
   end
 end