# THIS IS STILL HERE BECAUSE A LOT OF WORK WENT INTO MAKING TESTS AGNOSTIC OF MIME HEADER ORDER.
# HOWEVER, THINGS GOT MESSY SO REVERTED BACK TO COMPARING AGAINST KNOWN GOOD MESSAGES.
# THIS IS HERE JUST IN CASE. IN THE FUTURE, REMOVE IT IF THERE IS NO NEED FOR IT.

gem 'minitest'  # minitest in 1.9 stdlib is crufty
require 'minitest/autorun'
require 'mime'

# may be able to remove in 2.0
Encoding.default_external = 'ASCII-8BIT'

class MIMETest < Minitest::Test

  CRLF              = "\r\n"
  HDR_BDY_SEP       = CRLF * 2
  MESSAGE_ID        = /^Message-ID: <\d+@\d+>\r\n/
  CONTENT_ID        = /^Content-ID: <\d+\.\d+>\r\n/

  CDISPOSITION      = /^Content-Disposition: .*\r\n/
  CTYPE             = /^Content-Type: .*\r\n/

  DATE              = /^Date: ..., \d{1,2} ... \d{4} \d\d:\d\d:\d\d -\d{4}\r\n/
  VERSION           = /^MIME-Version: 1.0 \(Ruby MIME v\d\.\d\)\r\n/
  #BOUNDARY          = /^--Boundary_\d+\.\d+\r\n/
  BOUNDARY          = /^--Boundary_\d+\.\d+(--)?\r\n/
  BOUNDARY_LAST     = /^--Boundary_\d+\.\d+--\r\n/
  CID               = /cid:\d+\.\d+/

  CTYPE_TEXT_PLAIN  = /^Content-Type: text\/plain; charset=us-ascii\r\n/
  CTYPE_TEXT_HTML   = /^Content-Type: text\/html\r\n/
  CTYPE_TEXT_XML    = /^Content-Type: text\/xml\r\n/
  CTYPE_IMAGE_JPEG  = /^Content-Type: image\/jpeg\r\n/
  CTYPE_IMAGE_PNG   = /^Content-Type: image\/png\r\n/
  CTYPE_VIDEO_MPEG  = /^Content-Type: video\/mpeg\r\n/
  CTYPE_AUDIO_MIDI  = /^Content-Type: audio\/midi\r\n/
  CTYPE_APPLICATION = /^Content-Type: application\/octet-stream\r\n/

  CTYPE_MPART_FORM  = /^Content-Type: multipart\/form-data; boundary=Boundary_\d+\.\d+\r\n/
  CTYPE_MPART_ALT   = /^Content-Type: multipart\/alternative; boundary=Boundary_\d+\.\d+\r\n/
  CTYPE_MPART_MIXED = /^Content-Type: multipart\/mixed; boundary=Boundary_\d+\.\d+\r\n/

  XFER_ENC_BINARY   = /^Content-Transfer-Encoding: binary\r\n/
  XFER_ENC_8BIT     = /^Content-Transfer-Encoding: 8bit\r\n/

  BINARY_DATA = '0110000101110101011001000110100101101111' 

  def test_make_top_level_rfc2822_message
    rfc2822_msg = MIME::Message.new
    rfc2822_msg.body = "\r\nmessage body"
    msg = rfc2822_msg.to_s

    assert_match MESSAGE_ID, msg
    assert_match DATE, msg
    assert_match VERSION, msg
    assert_equal_num_headers 3, msg
    assert_equal_body "message body", msg
  end

  # TODO remove audio.msg
  def test_make_audio_message
    audio_media = MIME::AudioMedia.new(BINARY_DATA, 'audio/midi')
    audio_media.content_transfer_encoding = 'binary'
    msg = MIME::Message.new(audio_media).to_s

    [CONTENT_ID, XFER_ENC_BINARY, CTYPE_AUDIO_MIDI].each do |header|
      assert_match header, msg
    end
    assert_equal_num_headers 6, msg
    assert_equal_body BINARY_DATA, msg
  end

  # TODO remove expected_mime_msg = IO.read(sd('/application.msg'))
  def test_make_application_message
    application_media = MIME::ApplicationMedia.new(BINARY_DATA)
    application_media.content_transfer_encoding = 'binary'
    msg = MIME::Message.new(application_media).to_s

    [CONTENT_ID, XFER_ENC_BINARY, CTYPE_APPLICATION].each do |header|
      assert_match header, msg
    end
    assert_equal_num_headers 6, msg
    assert_equal_body BINARY_DATA, msg
  end

  # TODO remove image.msg
  def test_make_image_message
    image = IO.read(sd('/image.jpg'))
    image_media = MIME::ImageMedia.new(image)
    image_media.content_type = 'image/jpeg'
    image_media.content_transfer_encoding = 'binary'
    msg = MIME::Message.new(image_media).to_s

    [CONTENT_ID, XFER_ENC_BINARY, CTYPE_IMAGE_JPEG].each do |header|
      assert_match header, msg
    end

    assert_equal_num_headers 6, msg
    assert_equal_body image, msg
  end

  # TODO remove text.msg
  def test_make_text_message
    body = 'a plain text message'
    msg = MIME::Message.new(MIME::TextMedia.new(body)).to_s

    [CTYPE_TEXT_PLAIN].each do |header|
      assert_match header, msg
    end
  end

  # TODO remove video.msg
  def test_make_video_message
    video_media = MIME::VideoMedia.new(BINARY_DATA)
    video_media.content_type = 'video/mpeg'
    video_media.content_transfer_encoding = 'binary'
    msg = MIME::Message.new(video_media).to_s

    [CONTENT_ID, XFER_ENC_BINARY, CTYPE_VIDEO_MPEG].each do |header|
      assert_match header, msg
    end
    assert_equal_num_headers 6, msg
    assert_equal_body BINARY_DATA, msg
  end

  def test_no_instantiation_of_abstract_classes
    e = MIME::AbstractClassError
    assert_raises(e) {MIME::MediaType.new(nil, nil)}
    assert_raises(e) {MIME::DiscreteMediaType.new(nil)}
    assert_raises(e) {MIME::CompositeMediaType.new(nil)}
    assert_raises(e) {MIME::MultipartMedia.new(nil)}
  end

#  def test_boundaries
#    # CREATE a  multipart message; take simplified version of next form data
#    # test
#    e = msg.scan(BOUNDARY).each
#    first_boundary = e.next
#    assert_equal first_boundary, e.next
#    assert_equal first_boundary, e.next
#    last_boundary = e.next
#    refute_equal first_boundary, last_boundary
#    assert_match /^--Boundary_\d+\.\d+\r\n/, first_boundary
#    assert_match /^--Boundary_\d+\.\d+--\r\n/, last_boundary
#  end
#
#  def test_unique_content_ids_in_multipart_message
#
#    content_ids = msg.scan(/^Content-ID: <(\d+.\d+)>/)
#    assert_equal 4, content_ids.flatten.uniq.size  # all IDs must be unique
#  end

  # TODO rm multipart_form_data_text.msg
  def test_multipart_form_data_with_text_entities
    txt_data = 'text body'
    htm_data = IO.read(sd('data.htm'))
    xml_data = IO.read(sd('data.xml'))

    txt = MIME::TextMedia.new('text body')
    htm = MIME::TextMedia.new(htm_data, 'text/html')
    xml = MIME::TextMedia.new(xml_data, 'text/xml')

    form_data = MIME::MultipartMedia::FormData.new
    form_data.add_entity txt, 'txt'
    form_data.add_entity htm, 'htm'
    form_data.add_entity xml, 'xml'
    msg = form_data.to_s

    parts = msg.split(BOUNDARY)
    assert_equal 5, parts.size, 'main header, 3 entities, last boundary'
    assert_equal '--', parts.pop, 'remnant of last boundary marker'

    # main header
    assert_match CONTENT_ID, parts[0]
    assert_match CTYPE_MPART_FORM, parts[0]
    assert_equal_num_headers 2, parts[0]
    assert_equal_body '', parts[0]

    # xml entity
    assert_match CONTENT_ID, parts[1]
    assert_match CTYPE_TEXT_XML, parts[1]
    assert_match /^Content-Disposition: form-data; name="xml"\r\n/, parts[1]
    assert_equal_num_headers 3, parts[1]
    assert_equal_body xml_data, parts[1]

    # html entity
    assert_match CONTENT_ID, parts[2]
    assert_match CTYPE_TEXT_HTML, parts[2]
    assert_match /^Content-Disposition: form-data; name="htm"\r\n/, parts[2]
    assert_equal_num_headers 3, parts[2]
    assert_equal_body htm_data, parts[2]

    # text entity
    assert_match CONTENT_ID, parts[3]
    assert_match CTYPE_TEXT_PLAIN, parts[3]
    assert_match /^Content-Disposition: form-data; name="txt"\r\n/, parts[3]
    assert_equal_num_headers 3, parts[3]
    assert_equal_body txt_data, parts[3]
  end

  # TODO test that only basename of the file is included in header
  # test if no filename is used, then probably no filename param
  # see next test for ideas
  def test_content_disposition_filename

pass
  end

  # rm multipart_form_data_file.msg 
  # rm multipart_form_data_file_and_text.msg
  def test_multipart_form_data_with_text_and_file_entities
    img1_filename = 'image.jpg'
    img2_filename = 'ruby.png'
    img1_data = IO.read(sd(img1_filename))
    img2_data = IO.read(sd(img2_filename))
    img1 = MIME::ImageMedia.new(img1_data, 'image/jpeg')
    img2 = MIME::ImageMedia.new(img2_data, 'image/png')
    img1.content_transfer_encoding = '8bit'
    img2.content_transfer_encoding = '8bit'

    desc_data = 'This is plain text description of images.'
    desc = MIME::TextMedia.new(desc_data)

    form_data = MIME::MultipartMedia::FormData.new
    form_data.add_entity desc, 'description'
    form_data.add_entity img2, 'image_2', img2_filename
    form_data.add_entity img1, 'image_1', img1_filename
    msg = form_data.to_s

    parts = msg.split(BOUNDARY)
    assert_equal 5, parts.size, 'main header, 3 entities, last boundary'
    assert_equal '--', parts.pop, 'remnant of last boundary marker'

    # main header
    assert_match CONTENT_ID, parts[0]
    assert_match CTYPE_MPART_FORM, parts[0]
    assert_equal_num_headers 2, parts[0]
    assert_equal_body '', parts[0]

    # first image entity
    assert_match CONTENT_ID, parts[1]
    assert_match CTYPE_IMAGE_JPEG, parts[1]
    assert_match XFER_ENC_8BIT, parts[1]
    assert_match /^Content-Disposition: form-data; name="image_1"; filename="#{img1_filename}"\r\n/, parts[1]
    assert_equal_num_headers 4, parts[1]
    assert_equal_body img1_data, parts[1]

    # second image entity
    assert_match CONTENT_ID, parts[2]
    assert_match CTYPE_IMAGE_PNG, parts[2]
    assert_match XFER_ENC_8BIT, parts[2]
    assert_match /^Content-Disposition: form-data; name="image_2"; filename="#{img2_filename}"\r\n/, parts[2]
    assert_equal_num_headers 4, parts[2]
    assert_equal_body img2_data, parts[2]

    # plain text entity
    assert_match CONTENT_ID, parts[3]
    assert_match CTYPE_TEXT_PLAIN, parts[3]
    assert_match /^Content-Disposition: form-data; name="description"\r\n/, parts[3]
    assert_equal_num_headers 3, parts[3]
    assert_equal_body desc_data, parts[3]
  end

  # rm plain_text_email.msg
  def test_construction_of_plain_text_email_message
    subject = 'This is an important email'
    body = 'This is the all important email body.'

    email_msg = MIME::Message.new
    email_msg.to = {
      'john@example.com' => 'John',
      'paul@example.com' => nil,
      'mary@example.com' => 'Mary'
    }
    email_msg.cc = {'Head Honcho' => 'boss@example.com'}
    email_msg.from = {'jane@example.com' => nil}
    email_msg.subject = subject
    email_msg.body = MIME::TextMedia.new(body)

    msg = email_msg.to_s

    assert_equal_num_headers 9, msg
    assert_match MESSAGE_ID, msg
    assert_match CONTENT_ID, msg
    assert_match CTYPE_TEXT_PLAIN, msg
    assert_match DATE, msg
    assert_match VERSION, msg
    assert_match /^Subject: #{subject}\r\n/, msg
    assert_match /^From: jane@example.com\r\n/, msg
    assert_match /^To: .+, .+, .+\r\n/, msg # 3 addresses
    assert_match /^To: .*John <john@example.com>.*\r\n/, msg
    assert_match /^To: .*Mary <mary@example.com>.*\r\n/, msg
    assert_match /^To: .*paul@example.com.*\r\n/, msg
    assert_match /^Cc: boss@example.com <Head Honcho>\r\n/, msg
    assert_equal_body body, msg
  end

  def test_content_type_detection
    (o = Object.new).extend(MIME::ContentTypes)

    # test using file path, relative and absolute
    assert_equal 'application/pdf',          o.file_type('book.pdf')
    assert_equal 'video/quicktime',          o.file_type('mini.mov')
    assert_equal 'application/octet-stream', o.file_type('dsk.iso')
    assert_equal 'audio/mpeg',               o.file_type('/tmp/song.mp3')
    assert_equal 'text/css',                 o.file_type('/tmp/main.css')
    assert_equal nil,                        o.file_type('unknown.yyy')

    # test using file object
    img_type = open(sd('ruby.png')) {|f| o.file_type(f)}
    assert_equal 'image/png', img_type
    refute_equal 'image/jpeg', img_type
  end

  def test_object_instantiation_using_discrete_media_factory
    app_file     = sd('book.pdf')
    audio_file   = sd('song.mp3')
    text_file    = sd('data.xml')
    video_file   = sd('mini.mov')
    image_file   = sd('image.jpg')
    unknown_file = sd('unknown.yyy')

    dmf = MIME::DiscreteMediaFactory

    # test using file path
    assert_kind_of MIME::ApplicationMedia, dmf.create(app_file)
    assert_kind_of MIME::AudioMedia, dmf.create(audio_file)
    assert_kind_of MIME::TextMedia, dmf.create(text_file)
    assert_kind_of MIME::VideoMedia, dmf.create(video_file)
    assert_kind_of MIME::ImageMedia, dmf.create(image_file)

    # test using file object
    open(image_file) do |image_file_obj|
      assert_kind_of MIME::ImageMedia, dmf.create(image_file_obj)
    end
    open(text_file) do |text_file_obj|
      assert_kind_of MIME::TextMedia, dmf.create(text_file_obj)
    end

    # raise for unknown file path and File object
    assert_raises(MIME::UnknownContentError) {dmf.create(unknown_file)}
    open(unknown_file) do |unknown_file_obj|
      assert_raises(MIME::UnknownContentError) {dmf.create(unknown_file_obj)}
    end
  end

  def test_discrete_media_factory_creates_path_singleton_method
    pdf_file_path = sd('book.pdf')

    media_obj = MIME::DiscreteMediaFactory.create(pdf_file_path)
    assert_equal pdf_file_path, media_obj.path

    open(pdf_file_path) do |pdf_file_obj|
      media_obj = MIME::DiscreteMediaFactory.create(pdf_file_obj)
      assert_equal pdf_file_path, media_obj.path
    end
  end

  # rm multipart_alternative.msg
  def test_multipart_alternative_message_construction
    txt_data = "*Header*\nmessage"
    htm_data = "<html><body><h1>Header</h1><p>message</p></body></html>"
    txt_msg = MIME::TextMedia.new(txt_data)
    htm_msg = MIME::TextMedia.new(htm_data)

    txt_msg.content_type = (txt_type = 'text/enhanced; charset=us-ascii')
    htm_msg.content_type = (htm_type = 'text/html; charset=iso-8859-1')

    alt_msg = MIME::MultipartMedia::Alternative.new
    alt_msg.add_entity htm_msg
    alt_msg.add_entity txt_msg
    msg = alt_msg.to_s

    parts = msg.split(BOUNDARY)
    assert_equal 4, parts.size, 'main header, 2 entities, last boundary'
    assert_equal '--', parts.pop, 'remnant of last boundary marker'

    # main header
    assert_match CONTENT_ID, parts[0]
    assert_match CTYPE_MPART_ALT, parts[0]
    assert_equal_num_headers 2, parts[0]
    assert_equal_body '', parts[0]

    # text entity
    assert_match CONTENT_ID, parts[1]
    assert_match /^Content-Type: #{txt_type}\r\n/, parts[1]
    assert_equal_num_headers 2, parts[1]
    assert_equal_body txt_data, parts[1]

    # html entity
    assert_match CONTENT_ID, parts[2]
    assert_match /^Content-Type: #{htm_type}\r\n/, parts[2]
    assert_equal_num_headers 2, parts[2]
    assert_equal_body htm_data, parts[2]
  end

  # rm multipart_mixed_inline_and_attachment.msg 
  def test_multipart_mixed_with_inline_and_attachment
    mixed_msg = MIME::MultipartMedia::Mixed.new

    img_filename = 'image.jpg'
    img_data = ''
    open(sd(img_filename)) do |img_file|
      img_data = img_file.read
      img_msg = MIME::ImageMedia.new(img_data, 'image/jpeg')
      mixed_msg.attach_entity(img_msg, 'filename' => img_file.path)
    end

    txt_data = 'This is plain text.'
    mixed_msg.inline_entity(MIME::TextMedia.new(txt_data))
    msg = mixed_msg.to_s

    parts = msg.split(BOUNDARY)
    assert_equal 4, parts.size, 'main header, 2 entities, last boundary'
    assert_equal '--', parts.pop, 'remnant of last boundary marker'

    # main header
    assert_match CONTENT_ID, parts[0]
    assert_match CTYPE_MPART_MIXED, parts[0]
    assert_equal_num_headers 2, parts[0]
    assert_equal_body '', parts[0]

    # text entity
    assert_match CONTENT_ID, parts[1]
    assert_match CTYPE_TEXT_PLAIN, parts[1]
    assert_match /^Content-Disposition: inline\r\n/, parts[1]
    assert_equal_num_headers 3, parts[1]
    assert_equal_body txt_data, parts[1]

    # image entity
    assert_match CONTENT_ID, parts[2]
    assert_match CTYPE_IMAGE_JPEG, parts[2]
    assert_match /^Content-Disposition: attachment; filename="#{img_filename}"\r\n/, parts[2]
    assert_equal_num_headers 3, parts[2]
    assert_equal_body img_data, parts[2]
  end

  # rm multipart_mixed_inline_and_attachment2.msg
  def test_multipart_mixed_message_construction_using_media_factory
    img1 = sd(img1_filename = 'image.jpg')
    img2 = sd(img2_filename = 'ruby.png')
    txt  = sd(txt_filename = 'data.htm')
    bot_img = MIME::DiscreteMediaFactory.create(img1)
    top_img = MIME::DiscreteMediaFactory.create(img2)
    top_txt = MIME::DiscreteMediaFactory.create(txt)

    mixed_msg = MIME::MultipartMedia::Mixed.new
    mixed_msg.attach_entity(bot_img)
    mixed_msg.attach_entity(top_img)
    mixed_msg.inline_entity(top_txt)
    msg = mixed_msg.to_s

    parts = msg.split(BOUNDARY)
    assert_equal 5, parts.size, 'main header, 2 entities, last boundary'
    assert_equal '--', parts.pop, 'remnant of last boundary marker'

    # main header
    assert_match CONTENT_ID, parts[0]
    assert_match CTYPE_MPART_MIXED, parts[0]
    assert_equal_num_headers 2, parts[0]
    assert_equal_body '', parts[0]

    # html entity
    assert_match CONTENT_ID, parts[1]
    assert_match CTYPE_TEXT_HTML, parts[1]
    assert_match /^Content-Disposition: inline; filename="#{txt_filename}"\r\n/, parts[1]
    assert_equal_num_headers 3, parts[1]
    assert_equal_body top_txt.send(:body), parts[1]

    # png image entity
    assert_match CONTENT_ID, parts[2]
    assert_match CTYPE_IMAGE_PNG, parts[2]
    assert_match /^Content-Disposition: attachment; filename="#{img2_filename}"\r\n/, parts[2]
    assert_equal_num_headers 3, parts[2]
    assert_equal_body top_img.send(:body), parts[2]

    # jpg image entity
    assert_match CONTENT_ID, parts[3]
    assert_match CTYPE_IMAGE_JPEG, parts[3]
    assert_match /^Content-Disposition: attachment; filename="#{img1_filename}"\r\n/, parts[3]
    assert_equal_num_headers 3, parts[3]
    assert_equal_body bot_img.send(:body), parts[3]
  end

  def test_multipart_form_data_with_mixed_entity
    txt = MIME::TextMedia.new('Joe Blow')
    img1 = MIME::DiscreteMediaFactory.create(sd('image.jpg'))
    img2 = MIME::DiscreteMediaFactory.create(sd('ruby.png'))

    mixed_msg = MIME::MultipartMedia::Mixed.new
    mixed_msg.attach_entity(img2)
    mixed_msg.attach_entity(img1)

    form = MIME::MultipartMedia::FormData.new
    form.add_entity(mixed_msg, 'pics')
    form.add_entity(txt, 'field1')

    # similar to example 6 in RFC1867
    expected = IO.read(sd('multipart_form_data_mixed.msg'))

    assert_equal_mime_message expected, form.to_s

#IO.write('/tmp/mime.out', msg)
  end

#  def test_multipart_related_html_message_with_embedded_image
#    img = DiscreteMediaFactory.create(sd('/ruby.png'))
#    img.content_transfer_encoding = 'binary'
#
#    html_msg = TextMedia.new(<<-html, 'text/html; charset=iso-8859-1')
#    <html>
#    <body>
#      <h1>HTML multipart/related message</h1>
#      <p>txt before pix</p>
#      <img alt="cool ruby" src="cid:#{img.content_id}"/>
#      <p>txt after pix</p>
#    </body>
#    </html>
#    html
#    html_msg.content_transfer_encoding = '7bit'
#
#    related_msg = MultipartMedia::Related.new
#    related_msg.inline_entity(img)
#    related_msg.add_entity(html_msg)
#
#    expected = IO.read(sd('/multipart_related.msg'))
#
#    assert_equal_mime_message expected, related_msg.to_s
#  end
#
#  def test_multipart_alternative_with_related_html_entity
#    img = DiscreteMediaFactory.create(sd('/ruby.png'))
#    img.content_transfer_encoding = 'binary'
#
#    html_msg = TextMedia.new(<<-html, 'text/html; charset=iso-8859-1')
#    <html>
#    <body>
#      <h1>HTML multipart/alternative message</h1>
#      <p>txt before pix</p>
#      <img alt="cool ruby" src="cid:#{img.content_id}"/>
#      <p>txt after pix</p>
#    </body>
#    </html>
#    html
#    html_msg.content_transfer_encoding = '7bit'
#
#    text_msg = TextMedia.new(<<-text)
#    *HTML multipart/alternative message*
#    txt before pix
#    <cool ruby image>
#    txt after pix
#    text
#    text_msg.content_transfer_encoding = '7bit'
#
#    related_msg = MultipartMedia::Related.new
#    related_msg.inline_entity(img)
#    related_msg.add_entity(html_msg)
#
#    alt_msg = MultipartMedia::Alternative.new
#    alt_msg.add_entity(related_msg)
#    alt_msg.add_entity(text_msg)
#
#    expected = IO.read(sd('/multipart_alternative_related.msg'))
#
#    assert_equal_mime_message expected, alt_msg.to_s
#  end


  private

  #
  # Test the equality of the normalized +expected+ and +actual+ MIME messages.
  #
  def assert_equal_mime_message expected, actual
    assert_equal normalize_message(expected), normalize_message(actual)
  end

  #
  # Make messages comparable by removing *-ID header values, library version
  # comment in MIME-Version header, Date header value, multipart/related
  # content IDs, and boundaries.
  #
  def normalize_message message
    # these are very delicate REs that are inter-dependent, be careful
    match_id_headers  = /-ID: <[^>]+>\r\n/
    match_boundaries  = /Boundary_\d+\.\d+/
    match_lib_version = / \(Ruby MIME v\d\.\d\)/
    match_date_header = /^Date: .*\d{4}\r\n/
    match_related_cid = /cid:\d+\.\d+/

    message.
      gsub(match_related_cid, "cid").
      gsub(match_id_headers, "-ID:\r\n").
      gsub(match_boundaries, "Boundary_").
      sub(match_date_header, "Date:\r\n").
      sub(match_lib_version, " (Ruby MIME v0.0)")
  end

  def assert_equal_num_headers num, msg
    assert_equal num, msg.split(HDR_BDY_SEP).first.split(CRLF).count
  end

  def assert_equal_body expected_body, msg
    # FIXME the next line should be a fix
    headers, actual_body = msg.split(HDR_BDY_SEP)
    assert_equal expected_body, actual_body.to_s.chomp
    #assert_equal body, msg.split("\r\n").last
  end

  #
  # Return the absolute path of +file+ under the test/scaffold directory.
  #
  def sd file
    File.join(File.dirname(__FILE__), 'scaffold', file)
  end

end