mms2r 2.4.1 → 3.0.0

data/test/test_helper.rb

@@ -1,8 +1,14 @@
+require 'rubygems'
 require 'set'
 require 'net/http'
 require 'net/https'
 require 'pp'
 require 'exifr'
+require 'tempfile'
+require 'test/unit'
+require 'mocha'
+require File.join(File.dirname(__FILE__), "..", "lib", "mms2r")
+
 begin require 'redgreen'; rescue LoadError; end
 
 module MMS2R
@@ -14,28 +20,27 @@ module MMS2R
       assert(File::size(file) == size, "file #{file} is #{File::size(file)} bytes, not #{size} bytes")
     end
 
-    def load_mail(file)
-      IO.readlines(mail_fixture(file))
-    end
-
     def mail_fixture(file)
       "#{File.dirname(__FILE__)}/fixtures/#{file}"
     end
 
+    def mail(name)
+      Mail.read(mail_fixture(name))
+    end
+
     def smart_phone_mock(model_text = 'iPhone', jpeg = true)
       mail = mock('mail')
-      mail.expects(:header).at_least_once.returns({'return-path' => '<joe@null.example.com>'})
       mail.expects(:from).at_least_once.returns(['joe@example.com'])
+      mail.expects(:return_path).at_least_once.returns('<joe@example.com>')
       mail.expects(:message_id).returns('abcd0123')
       mail.expects(:multipart?).returns(true)
+
       part = mock('part')
       part.expects(:part_type?).at_least_once.returns("image/#{jpeg ? 'jpeg' : 'tiff'}")
-      part.expects(:sub_header).with('content-type', 'name').returns(nil)
-      part.expects(:sub_header).with('content-disposition', 'filename').returns(nil)
-      part.expects("[]".to_sym).with('content-location').at_least_once.returns("Photo_12.#{jpeg ? 'jpg' : 'tif'}")
-      part.expects(:main_type).with('text').returns(nil)
-      part.expects(:content_type).at_least_once.returns("image/#{jpeg ? 'jpeg' : 'tiff'}")
-      part.expects(:body).at_least_once.returns('abc')
+      part.expects(:body).at_least_once.returns(Mail::Body.new('abc'))
+      part.expects(:multipart?).at_least_once.returns(false)
+      part.expects(:filename).returns("foo.#{jpeg ? 'jpg' : 'tif'}")
+
       mail.expects(:parts).returns([part])
       exif = mock('exif')
       exif.expects(:model).at_least_once.returns(model_text)

data/test/test_mediamessaging_o2_co_uk.rb

@@ -1,52 +1,56 @@
-require File.join(File.dirname(__FILE__), "..", "lib", "mms2r")
 require File.join(File.dirname(__FILE__), "test_helper")
-require 'test/unit'
-require 'rubygems'
-require 'mocha'
-gem 'tmail', '>= 1.2.1'
-require 'tmail'
 
 class TestMediamessagingO2CoUk < Test::Unit::TestCase
   include MMS2R::TestHelper
 
   def test_subject
-    mail = TMail::Mail.parse(load_mail('mediamessaging_o2_co_uk-image-01.mail').join)
+    mail = mail('mediamessaging_o2_co_uk-image-01.mail')
     mms = MMS2R::Media.new(mail)
+    assert_equal "+2068675309", mms.number
+    assert_equal "mediamessaging.o2.co.uk", mms.carrier
     assert_equal "Office pic", mms.subject
     mms.purge
   end
 
   def test_image
-    mail = TMail::Mail.parse(load_mail('mediamessaging_o2_co_uk-image-01.mail').join)
+    mail = mail('mediamessaging_o2_co_uk-image-01.mail')
     mms = MMS2R::Media.new(mail)
-  
+    assert_equal "+2068675309", mms.number
+    assert_equal "mediamessaging.o2.co.uk", mms.carrier
+
     assert_equal 2, mms.media.size
     assert_not_nil mms.media['text/plain']
     assert_equal 1, mms.media['text/plain'].size
     assert_not_nil mms.media['image/jpeg']
     assert_equal 1, mms.media['image/jpeg'].size
     assert mms.media['image/jpeg'].detect{|f| File.size(f) == 337}
-  
+
     mms.purge
   end
 
   def test_default_media_should_return_user_generated_content
-    mail = TMail::Mail.parse(load_mail('mediamessaging_o2_co_uk-image-01.mail').join)
+    mail = mail('mediamessaging_o2_co_uk-image-01.mail')
     mms = MMS2R::Media.new(mail)
+    assert_equal "+2068675309", mms.number
+    assert_equal "mediamessaging.o2.co.uk", mms.carrier
+
     file = mms.default_media
     assert_equal 337, file.size
-    
+
     mms.purge
-  end 
+  end
 
   def test_default_text_should_return_user_generated_content
-    mail = TMail::Mail.parse(load_mail('mediamessaging_o2_co_uk-image-01.mail').join)
+    mail = mail('mediamessaging_o2_co_uk-image-01.mail')
     mms = MMS2R::Media.new(mail)
+    assert_equal "+2068675309", mms.number
+    assert_equal "mediamessaging.o2.co.uk", mms.carrier
+
     file = mms.default_text
     assert_equal 10, file.size
     assert_equal "Office pic", file.read
-    
+
     mms.purge
-  end 
-  
+  end
+
 end

data/test/test_messaging_nextel_com.rb

@@ -1,17 +1,13 @@
-require File.join(File.dirname(__FILE__), "..", "lib", "mms2r")
 require File.join(File.dirname(__FILE__), "test_helper")
-require 'test/unit'
-require 'rubygems'
-require 'mocha'
-gem 'tmail', '>= 1.2.1'
-require 'tmail'
 
 class TestMessagingNextelCom < Test::Unit::TestCase
   include MMS2R::TestHelper
 
   def test_simple_text_is_nil
-    mail = TMail::Mail.parse(load_mail('nextel-image-01.mail').join)
+    mail = mail('nextel-image-01.mail')
     mms = MMS2R::Media.new(mail)
+    assert_equal "2068675309", mms.number
+    assert_equal "messaging.nextel.com", mms.carrier
 
     assert_nil mms.default_text
 
@@ -19,8 +15,10 @@ class TestMessagingNextelCom < Test::Unit::TestCase
   end
 
   def test_simple_default_media
-    mail = TMail::Mail.parse(load_mail('nextel-image-01.mail').join)
+    mail = mail('nextel-image-01.mail')
     mms = MMS2R::Media.new(mail)
+    assert_equal "2068675309", mms.number
+    assert_equal "messaging.nextel.com", mms.carrier
 
     file = mms.default_media
     assert_file_size file, 337
@@ -32,8 +30,10 @@ class TestMessagingNextelCom < Test::Unit::TestCase
   end
 
   def test_simple_image1
-    mail = TMail::Mail.parse(load_mail('nextel-image-01.mail').join)
+    mail = mail('nextel-image-01.mail')
     mms = MMS2R::Media.new(mail)
+    assert_equal "2068675309", mms.number
+    assert_equal "messaging.nextel.com", mms.carrier
 
     assert_equal 1, mms.media.size
     assert_nil mms.media['text/plain']
@@ -47,8 +47,10 @@ class TestMessagingNextelCom < Test::Unit::TestCase
   end
 
   def test_simple_image2
-    mail = TMail::Mail.parse(load_mail('nextel-image-02.mail').join)
+    mail = mail('nextel-image-02.mail')
     mms = MMS2R::Media.new(mail)
+    assert_equal "2068675309", mms.number
+    assert_equal "messaging.nextel.com", mms.carrier
 
     assert_equal 1, mms.media.size
     assert_nil mms.media['text/plain']
@@ -62,8 +64,10 @@ class TestMessagingNextelCom < Test::Unit::TestCase
   end
 
   def test_simple_image3
-    mail = TMail::Mail.parse(load_mail('nextel-image-03.mail').join)
+    mail = mail('nextel-image-03.mail')
     mms = MMS2R::Media.new(mail)
+    assert_equal "2068675309", mms.number
+    assert_equal "messaging.nextel.com", mms.carrier
 
     assert_equal 1, mms.media.size
     assert_nil mms.media['text/plain']
@@ -77,8 +81,10 @@ class TestMessagingNextelCom < Test::Unit::TestCase
   end
 
   def test_simple_image4
-    mail = TMail::Mail.parse(load_mail('nextel-image-04.mail').join)
+    mail = mail('nextel-image-04.mail')
     mms = MMS2R::Media.new(mail)
+    assert_equal "2068675309", mms.number
+    assert_equal "messaging.nextel.com", mms.carrier
 
     assert_equal 1, mms.media.size
     assert_nil mms.media['text/plain']

data/test/test_messaging_sprintpcs_com.rb

@@ -1,17 +1,13 @@
-require File.join(File.dirname(__FILE__), "..", "lib", "mms2r")
 require File.join(File.dirname(__FILE__), "test_helper")
-require 'test/unit'
-require 'rubygems'
-require 'mocha'
-gem 'tmail', '>= 1.2.1'
-require 'tmail'
 
 class TestMessagingSprintpcsCom < Test::Unit::TestCase
   include MMS2R::TestHelper
 
   def test_simple_text
-    mail = TMail::Mail.parse(load_mail('sprint-pcs-text-01.mail').join)
+    mail = mail('sprint-pcs-text-01.mail')
     mms = MMS2R::Media.new(mail)
+    assert_equal "2068675309", mms.number
+    assert_equal "messaging.sprintpcs.com", mms.carrier
 
     assert_equal 1, mms.media.size
     assert_not_nil mms.media['text/plain']
@@ -22,5 +18,5 @@ class TestMessagingSprintpcsCom < Test::Unit::TestCase
     assert_match(/hello world/, text)
     mms.purge
   end
-  
+
 end

data/test/test_mms2r_media.rb

@@ -1,11 +1,4 @@
-require File.join(File.dirname(__FILE__), "..", "lib", "mms2r")
 require File.join(File.dirname(__FILE__), "test_helper")
-require 'tempfile'
-require 'test/unit'
-require 'rubygems'
-require 'mocha'
-gem 'tmail', '>= 1.2.1'
-require 'tmail'
 
 class TestMms2rMedia < Test::Unit::TestCase
   include MMS2R::TestHelper
@@ -34,30 +27,29 @@ class TestMms2rMedia < Test::Unit::TestCase
     MMS2R::Media.conf_dir = @oldconfdir
   end
 
-  def stub_mail(*keys)
-    attrs = { 
-         :message_id => '123', 
-         :from => ['joe@example.com'],
-         :multipart? => false,
-         :parts => [],
-         :main_type => 'text',
-         :content_type => 'text/plain',
-         :part_type? => 'text/plain',
-         :sub_header => 'message.txt',
-
+  def stub_mail(vals = {})
+    attrs = {
+         :from => 'joe@example.com',
+         :to => 'jane@example.com',
+         :subject => 'This is a test email',
          :body => 'a',
-         :header => {}
-        }.except(keys)
-    stub('mail', attrs)
+        }.merge(vals)
+
+    Mail.new do
+      from attrs[:from]
+      to attrs[:to]
+      subject attrs[:subject]
+      body attrs[:body]
+    end
   end
 
   def test_class_parse
-    mms = MMS2R.parse(load_mail('generic.mail').join)
+    mms = mail('generic.mail')
     assert_equal ['noreply@rubyforge.org'], mms.from
   end
 
   def temp_text_file(text)
-    tf = Tempfile.new("test" + Time.now.to_f.to_s)
+    tf = Tempfile.new("test" + rand.to_s)
     tf.puts(text)
     tf.close
     tf.path
@@ -108,7 +100,7 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_instance_initialize_config
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     config = mms.initialize_config(nil)
 
     # test defaults shipped in mms2r_media.yml
@@ -131,8 +123,8 @@ class TestMms2rMedia < Test::Unit::TestCase
 
   def test_create_with_default_processor
     mail = mock()
-    mail.expects(:header).at_least_once.returns({})
     mail.expects(:from).at_least_once.returns(['joe@unknown.example.com'])
+    mail.expects(:return_path).at_least_once.returns('joe@unknown.example.com')
     mms = MMS2R::Media.create(mail)
     assert_equal [MMS2R::Media, 'unknown.example.com'] , mms
   end
@@ -140,8 +132,8 @@ class TestMms2rMedia < Test::Unit::TestCase
   def test_create_with_special_processor
     MMS2R.register('null.example.com', MMS2R::Media::NullCarrier)
     mail = mock()
-    mail.expects(:header).at_least_once.returns({})
     mail.expects(:from).at_least_once.returns(['joe@null.example.com'])
+    mail.expects(:return_path).at_least_once.returns('joe@null.example.com')
     mms = MMS2R::Media.create(mail)
     assert_equal [MMS2R::Media::NullCarrier, 'null.example.com'], mms
   end
@@ -149,22 +141,22 @@ class TestMms2rMedia < Test::Unit::TestCase
   def test_create_with_special_processor_and_return_path
     MMS2R.register('null.example.com', MMS2R::Media::NullCarrier)
     mail = mock()
-    mail.expects(:header).at_least_once.returns({'return-path' => '<joe@null.example.com>'})
     mail.expects(:from).at_least_once.returns([])
+    mail.expects(:return_path).at_least_once.returns('joe@null.example.com')
     mms = MMS2R::Media.create(mail)
     assert_equal [MMS2R::Media::NullCarrier, 'null.example.com'], mms
   end
 
   def test_create_should_fail_gracefully_with_broken_from
     mail = mock()
-    mail.expects(:header).at_least_once.returns({})
     mail.expects(:from).at_least_once.returns(nil)
+    mail.expects(:return_path).at_least_once.returns('joe@unknown.example.com')
     assert_nothing_raised { MMS2R::Media.create(mail) }
   end
 
   def test_aliased_new_returns_custom_processor_instance
     MMS2R.register('null.example.com', MMS2R::Media::NullCarrier)
-    mail = stub_mail(:from)
+    mail = stub_mail
     mail.expects(:from).at_least_once.returns(['joe@null.example.com'])
 
     mms = MMS2R::Media.new(mail)
@@ -174,46 +166,45 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_aliased_new_returns_default_processor_instance
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     assert_not_nil mms
     assert_equal true, mms.respond_to?(:process)
     assert_equal MMS2R::Media, mms.class
   end
 
   def test_lazy_process_option
-    mms = MMS2R::Media.new(stub_mail(), :process => :lazy)
+    mms = MMS2R::Media.new stub_mail, :process => :lazy
     mms.expects(:process).never
   end
 
   def test_logger_option
     logger = mock()
     logger.expects(:info).at_least_once
-    mms = MMS2R::Media.new(stub_mail(), :logger => logger)
+    mms = MMS2R::Media.new stub_mail, :logger => logger
   end
 
   def test_default_processor_initialize_tries_to_open_config_for_carrier
     f = File.join(MMS2R::Media.conf_dir, 'example.com.yml')
     YAML.expects(:load_file).once.with(f)
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
   end
 
   def test_mms_phone_number
-    mail = stub_mail()
+    mail = stub_mail
     mail.stubs(:from).returns(['2068675309@example.com'])
     mms = MMS2R::Media.new(mail)
     assert_equal '2068675309', mms.number
   end
-  
+
   def test_mms_phone_number_from_config
-    mail = stub_mail()
-    mail.stubs(:header).returns({'from' => TMail::AddressHeader.new('from', '"+2068675309" <BCVOZH@mms.vodacom4me.co.za>')})
+    mail = stub_mail(:from => '"+2068675309" <TESTER@mms.vodacom4me.co.za>')
     mms = MMS2R::Media.new(mail)
     mms.expects(:config).once.returns({'number' => ['from', '/^([^\s]+)\s.*/', '\1']})
     assert_equal '+2068675309', mms.number
   end
 
   def test_mms_phone_number_with_errors
-    mail = stub_mail(:from)
+    mail = stub_mail
     mail.stubs(:from).returns(nil)
     mms = MMS2R::Media.new(mail)
     assert_nothing_raised do
@@ -222,7 +213,7 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_transform_text
-    mail = stub_mail()
+    mail = stub_mail
     mail.stubs(:from).returns(nil)
     mms = MMS2R::Media.new(mail)
 
@@ -243,7 +234,7 @@ class TestMms2rMedia < Test::Unit::TestCase
     # has a bad regexp
     mms.expects(:config).once.returns({'transform' => {type => [['(hello)', 'world']]}})
     assert_equal result, mms.transform_text(type, text)
-    
+
     # matches in config
     mms.expects(:config).once.returns({'transform' => {type => [['/(hello)/', 'world']]}})
     assert_equal [type, 'world'], mms.transform_text(type, text)
@@ -263,7 +254,7 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_transform_text_to_utf8
-    mail = TMail::Mail.load(mail_fixture('iconv-fr-text-01.mail'))
+    mail = mail('iconv-fr-text-01.mail')
     mms = MMS2R::Media.new(mail)
 
     assert_equal 2, mms.media.size
@@ -274,15 +265,16 @@ class TestMms2rMedia < Test::Unit::TestCase
     assert_equal true, File::exist?(file)
     text = IO.readlines("#{file}").join
     #assert_match(/D'ici un mois Géorgie/, text)
-    assert_match(/D'ici un mois G\303\203\302\251orgie/, text)
-    assert_equal("sample email message Fwd: sub D'ici un mois G\303\203\302\251orgie", 
-                 mms.subject)
+    assert_match(/D'ici un mois G\303\251orgie/, text)
+    assert_match(/D'ici un mois Géorgie/, text)
+    assert_equal("sample email message Fwd: sub D'ici un mois G\303\251orgie", mms.subject)
+    assert_equal("sample email message Fwd: sub D'ici un mois Géorgie", mms.subject)
     mms.purge
   end
 
   def test_subject
     s = 'hello world'
-    mail = stub_mail()
+    mail = stub_mail
     mail.stubs(:subject).returns(s)
     mms = MMS2R::Media.new(mail)
     assert_equal s, mms.subject
@@ -293,7 +285,7 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_subject_with_bad_mail_subject
-    mail = stub_mail()
+    mail = stub_mail
     mail.stubs(:subject).returns(nil)
     mms = MMS2R::Media.new(mail)
     assert_equal '', mms.subject
@@ -301,7 +293,7 @@ class TestMms2rMedia < Test::Unit::TestCase
 
   def test_subject_with_subject_ignored
     s = 'hello world'
-    mail = stub_mail()
+    mail = stub_mail
     mail.stubs(:subject).returns(s)
     mms = MMS2R::Media.new(mail)
     mms.stubs(:config).returns({'ignore' => {'text/plain' => [s]}})
@@ -310,7 +302,7 @@ class TestMms2rMedia < Test::Unit::TestCase
 
   def test_subject_with_subject_transformed
     s = 'Default Subject: hello world'
-    mail = stub_mail()
+    mail = stub_mail
     mail.stubs(:subject).returns(s)
     mms = MMS2R::Media.new(mail)
     mms.stubs(:config).returns(
@@ -320,29 +312,29 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_attachment_should_return_nil_if_files_for_type_are_not_found
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     mms.stubs(:media).returns({})
     assert_nil mms.send(:attachment, ['text'])
   end
 
   def test_attachment_should_return_nil_if_empty_files_are_found
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     mms.stubs(:media).returns({'text/plain' => [Tempfile.new('test')]})
     assert_nil mms.send(:attachment, ['text'])
   end
 
   def test_type_from_filename(filename)
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     assert_equal 'image/jpeg', mms.send(:type_from_filename, "example.jpg")
   end
 
   def test_type_from_filename_should_be_nil(filename)
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     assert_nil mms.send(:type_from_filename, "example.example")
   end
 
   def test_attachment_should_return_duck_typed_file
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     temp_big = temp_text_file("hello world")
     size = File.size(temp_text_file("hello world"))
     temp_small = temp_text_file("hello")
@@ -358,20 +350,20 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_empty_body
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     mms.stubs(:default_text).returns(nil)
     assert_equal "", mms.body
   end
 
   def test_body
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     temp_big = temp_text_file("hello world")
     mms.stubs(:default_text).returns(File.new(temp_big))
     assert_equal "hello world", mms.body
   end
 
   def test_default_text
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     temp_big = temp_text_file("hello world")
     temp_small = temp_text_file("hello")
     mms.stubs(:media).returns({'text/plain' => [temp_small, temp_big]})
@@ -384,7 +376,7 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_default_media
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     #it doesn't matter that these are text files, we just need say they are images
     temp_big = temp_text_file("hello world")
     temp_small = temp_text_file("hello")
@@ -398,7 +390,7 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_default_media_treats_image_and_video_equally
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     #it doesn't matter that these are text files, we just need say they are images
     temp_big_image = temp_text_file("hello world")
     temp_small_image = temp_text_file("hello")
@@ -415,22 +407,22 @@ class TestMms2rMedia < Test::Unit::TestCase
     assert_equal temp_big_video, mms.default_media.local_path
   end
 
-  def test_default_media_treats_gif_and_jpg_equally
-    #it doesn't matter that these are text files, we just need say they are images
-    temp_big = temp_text_file("hello world")
-    temp_small = temp_text_file("hello")
+  #def test_default_media_treats_gif_and_jpg_equally
+  #  #it doesn't matter that these are text files, we just need say they are images
+  #  temp_big = temp_text_file("hello world")
+  #  temp_small = temp_text_file("hello")
 
-    mms = MMS2R::Media.new(stub_mail())
-    mms.stubs(:media).returns({'image/jpeg' => [temp_big], 'image/gif' => [temp_small]})
-    assert_equal temp_big, mms.default_media.local_path
+  #  mms = MMS2R::Media.new stub_mail
+  #  mms.stubs(:media).returns({'image/jpeg' => [temp_big], 'image/gif' => [temp_small]})
+  #  assert_equal temp_big, mms.default_media.local_path
 
-    mms = MMS2R::Media.new(stub_mail())
-    mms.stubs(:media).returns({'image/gif' => [temp_big], 'image/jpg' => [temp_small]})
-    assert_equal temp_big, mms.default_media.local_path
-  end
+  #  mms = MMS2R::Media.new stub_mail
+  #  mms.stubs(:media).returns({'image/gif' => [temp_big], 'image/jpg' => [temp_small]})
+  #  assert_equal temp_big, mms.default_media.local_path
+  #end
 
   def test_purge
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     mms.purge
     assert_equal false, File.exist?(mms.media_dir)
   end
@@ -438,43 +430,43 @@ class TestMms2rMedia < Test::Unit::TestCase
   def test_ignore_media_by_filename_equality
     name = 'foo.txt'
     type = 'text/plain'
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     mms.stubs(:config).returns({'ignore' => {type => [name]}})
 
     # type is not in the ingore
-    part = stub(:sub_header => name, :body => 'a')
+    part = stub(:body => Mail::Body.new('a'))
     assert_equal false, mms.ignore_media?('text/test', part)
     # type and filename are in the ingore
-    part = stub(:sub_header => name)
+    part = stub(:filename => name, :body => Mail::Body.new('a'))
     assert_equal true, mms.ignore_media?(type, part)
     # type but not file name are in the ignore
-    part = stub(:sub_header => 'bar.txt', :body => 'a')
+    part = stub(:filename => 'bar.txt', :body => Mail::Body.new('a'))
     assert_equal false, mms.ignore_media?(type, part)
   end
 
   def test_filename
-    name = 'x' * 300 + '.txt'
-    mms = MMS2R::Media.new(stub_mail())
-    part = stub(:sub_header => name, :content_type => 'text/plain')
-    assert_equal 'x' * 251 + '.txt', mms.filename?(part)
+    name = 'foo.txt'
+    mms = MMS2R::Media.new stub_mail
+    part = stub(:filename => name)
+    assert_equal 'foo.txt', mms.filename?(part)
   end
 
   def test_long_filename
-    name = 'foo.txt'
-    mms = MMS2R::Media.new(stub_mail())
-    part = stub(:sub_header => name, :content_type => 'text/plain')
-    assert_equal 'foo.txt', mms.filename?(part)
+    name = 'x' * 300 + '.txt'
+    mms = MMS2R::Media.new stub_mail
+    part = stub(:filename => name)
+    assert_equal 'x' * 251 + '.txt', mms.filename?(part)
   end
 
   def test_filename_when_file_extension_missing_part
     name = 'foo'
-    mms = MMS2R::Media.new(stub_mail())
-    part = stub(:sub_header => name, :content_type => 'text/plain', :part_type? => 'text/plain')
+    mms = MMS2R::Media.new stub_mail
+    part = stub(:filename => name, :content_type => 'text/plain', :part_type? => 'text/plain')
     assert_equal 'foo.txt', mms.filename?(part)
 
     name = 'foo.janky'
-    mms = MMS2R::Media.new(stub_mail())
-    part = stub(:sub_header => name, :content_type => 'text/plain', :part_type? => 'text/plain')
+    mms = MMS2R::Media.new stub_mail
+    part = stub(:filename => name, :content_type => 'text/plain', :part_type? => 'text/plain')
     assert_equal 'foo.janky.txt', mms.filename?(part)
   end
 
@@ -482,17 +474,17 @@ class TestMms2rMedia < Test::Unit::TestCase
     name = 'foo.txt'
     regexp = '/foo\.txt/i'
     type = 'text/plain'
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     mms.stubs(:config).returns({'ignore' => {type => [regexp, 'nil.txt']}})
 
     # type is not in the ingore
-    part = stub(:sub_header => name, :body => 'a')
+    part = stub(:filename => name, :body => Mail::Body.new('a'))
     assert_equal false, mms.ignore_media?('text/test', part)
     # type and regexp for the filename are in the ingore
-    part = stub(:sub_header => name)
+    part = stub(:filename => name)
     assert_equal true, mms.ignore_media?(type, part)
     # type but not regexp for filename are in the ignore
-    part = stub(:sub_header => 'bar.txt', :body => 'a')
+    part = stub(:filename => 'bar.txt', :body => Mail::Body.new('a'))
     assert_equal false, mms.ignore_media?(type, part)
   end
 
@@ -501,37 +493,37 @@ class TestMms2rMedia < Test::Unit::TestCase
     content = "aaaaaaahello worldbbbbbbbbb"
     regexp = '/.*Hello World.*/i'
     type = 'text/plain'
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     mms.stubs(:config).returns({'ignore' => {type => ['nil.txt', regexp]}})
 
-    part = stub(:sub_header => name, :body => content)
+    part = stub(:filename => name, :body => Mail::Body.new(content))
 
     # type is not in the ingore
     assert_equal false, mms.ignore_media?('text/test', part)
     # type and regexp for the content are in the ingore
     assert_equal true, mms.ignore_media?(type, part)
     # type but not regexp for content are in the ignore
-    part = stub(:sub_header => name, :body => 'no teapots')
+    part = stub(:filename => name, :body => Mail::Body.new('no teapots'))
     assert_equal false, mms.ignore_media?(type, part)
   end
 
   def test_ignore_media_when_file_content_is_empty
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
 
     # there is no conf but the part's body is empty
-    part = stub(:sub_header => 'foo.txt', :body => "")
+    part = stub(:filename => 'foo.txt', :body => Mail::Body.new)
     assert_equal true, mms.ignore_media?('text/test', part)
 
     # there is no conf but the part's body is white space
-    part = stub(:sub_header => 'foo.txt', :body => "\t\n\t\n            ")
+    part = stub(:filename => 'foo.txt', :body => Mail::Body.new("\t\n\t\n            "))
     assert_equal true, mms.ignore_media?('text/test', part)
   end
 
   def test_add_file
     MMS2R.register('null.example.com', MMS2R::Media::NullCarrier)
-    mail = stub_mail()
+    mail = stub_mail
     mail.stubs(:from).returns(['joe@null.example.com'])
-  
+
     mms = MMS2R::Media.new(mail)
     mms.stubs(:media).returns({})
 
@@ -544,16 +536,16 @@ class TestMms2rMedia < Test::Unit::TestCase
 
   def test_temp_file
     name = 'foo.txt'
-    mms = MMS2R::Media.new(stub_mail())
-    part = stub(:sub_header => name)
+    mms = MMS2R::Media.new stub_mail
+    part = stub(:filename => name)
     assert_equal name, File.basename(mms.temp_file(part))
   end
 
   def test_process_media_for_text
     name = 'foo.txt'
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     mms.stubs(:transform_text_part).returns(['text/plain', nil])
-    part = stub(:sub_header => name, :content_type => 'text/plain', :part_type? => 'text/plain', :main_type => 'text')
+    part = stub(:filename => name, :content_type => 'text/plain', :part_type? => 'text/plain', :main_type => 'text')
 
     assert_equal ['text/plain', nil], mms.process_media(part)
 
@@ -566,9 +558,9 @@ class TestMms2rMedia < Test::Unit::TestCase
 
   def test_process_media_with_empty_text
     name = 'foo.txt'
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     mms.stubs(:transform_text_part).returns(['text/plain', nil])
-    part = stub(:sub_header => name, :content_type => 'text/plain', :part_type? => 'text/plain', :main_type => 'text')
+    part = stub(:filename => name, :content_type => 'text/plain', :part_type? => 'text/plain', :main_type => 'text')
 
     assert_equal ['text/plain', nil], mms.process_media(part)
 
@@ -579,9 +571,9 @@ class TestMms2rMedia < Test::Unit::TestCase
 
   def test_process_media_for_application_smil
     name = 'foo.txt'
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     mms.stubs(:transform_text_part).returns(['application/smil', nil])
-    part = stub(:sub_header => name, :content_type => 'application/smil', :part_type? => 'application/smil', :main_type => 'application')
+    part = stub(:filename => name, :content_type => 'application/smil', :part_type? => 'application/smil', :main_type => 'application')
 
     assert_equal ['application/smil', nil], mms.process_media(part)
 
@@ -594,8 +586,8 @@ class TestMms2rMedia < Test::Unit::TestCase
 
   def test_process_media_for_application_octet_stream_when_image
     name = 'fake.jpg'
-    mms = MMS2R::Media.new(stub_mail())
-    part = stub(:sub_header => name, :content_type => 'application/octet-stream', :part_type? => 'application/octet-stream', :body => "data", :main_type => 'application')
+    mms = MMS2R::Media.new stub_mail
+    part = stub(:filename => name, :content_type => 'application/octet-stream', :part_type? => 'application/octet-stream', :body => Mail::Body.new("data"), :main_type => 'application')
     result = mms.process_media(part)
     assert_equal 'image/jpeg', result.first
     assert_match(/fake\.jpg$/, result.last)
@@ -604,14 +596,12 @@ class TestMms2rMedia < Test::Unit::TestCase
 
   def test_process_media_for_all_other_media
     name = 'foo.txt'
-    mms = MMS2R::Media.new(stub_mail())
-    part = stub(:sub_header => name, :content_type => 'faux/text', :part_type? => 'faux/text', :body => nil)
-    part.expects(:main_type).with('text').returns('faux')
+    mms = MMS2R::Media.new stub_mail
+    part = stub(:filename => name, :main_type => 'faux', :part_type? => 'faux/text', :body => Mail::Body.new(nil))
 
     assert_equal ['faux/text', nil], mms.process_media(part)
 
-    part = stub(:sub_header => name, :content_type => 'faux/text', :part_type? => 'faux/text', :body => 'hello world')
-    part.expects(:main_type).with('text').returns('faux')
+    part = stub(:filename => name, :main_type => 'faux', :part_type? => 'faux/text', :body => Mail::Body.new('hello world'))
     result = mms.process_media(part)
     assert_equal 'faux/text', result.first
     assert_equal 'hello world', IO.read(result.last)
@@ -619,20 +609,19 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_process
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     assert_equal 1, mms.media.size
     assert_not_nil mms.media['text/plain']
     assert_equal 1, mms.media['text/plain'].size
-    assert_equal 'message.txt', File.basename(mms.media['text/plain'].first)
     assert_equal true, File.exist?(mms.media['text/plain'].first)
     assert_equal 1, File.size(mms.media['text/plain'].first)
     mms.purge
   end
 
   def test_process_with_multipart_double_parts
-    mail = TMail::Mail.parse(load_mail('apple-double-image-01.mail').join)
+    mail = mail('apple-double-image-01.mail')
     mms = MMS2R::Media.new(mail)
-    
+
     assert_equal 2, mms.media.size
 
     assert_not_nil mms.media['application/applefile']
@@ -648,12 +637,19 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_process_with_multipart_alternative_parts
-    mail = stub_mail()
-    plain = stub(:sub_header => 'message.txt', :content_type => 'text/plain', :part_type? => 'text/plain', :body => 'a', :main_type => 'text')
-    html = stub(:sub_header => 'message.html', :content_type => 'text/html', :part_type? => 'text/html', :body => 'a', :main_type => 'text')
-    multi = stub(:content_type => 'multipart/alternative', :part_type? => 'multipart/alternative', :parts => [plain, html])
-    mail.stubs(:multipart?).returns(true)
-    mail.stubs(:parts).returns([multi])
+    mail = stub_mail
+
+    plain = stub('plain', :filename => 'message.txt', :content_type => 'text/plain', :part_type? => 'text/plain', :body => Mail::Body.new('a'), :main_type => 'text')
+    plain.stubs(:multipart?).at_least_once.returns(false)
+
+    html = stub('html', :filename => 'message.html', :content_type => 'text/html', :part_type? => 'text/html', :body => Mail::Body.new('a'), :main_type => 'text')
+    html.stubs(:multipart?).at_least_once.returns(false)
+
+    multi = stub('multi', :content_type => 'multipart/alternative', :part_type? => 'multipart/alternative', :parts => [plain, html])
+    multi.stubs(:multipart?).at_least_once.returns(true)
+
+    mail.stubs(:multipart?).at_least_once.returns(true)
+    mail.stubs(:parts).at_least_once.returns([multi])
 
     # the multipart/alternative should get flattend to text and html
     mms = MMS2R::Media.new(mail)
@@ -673,12 +669,20 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_process_when_media_is_ignored
-    mail = stub_mail()
-    plain = stub(:sub_header => 'message.txt', :content_type => 'text/plain', :part_type? => 'text/plain', :body => '')
-    html = stub(:sub_header => 'message.html', :content_type => 'text/html', :part_type? => 'text/html', :body => '')
-    multi = stub(:content_type => 'multipart/alternative', :part_type? => 'multipart/alternative', :parts => [plain, html])
-    mail.stubs(:multipart?).returns(true)
-    mail.stubs(:parts).returns([multi])
+    mail = stub_mail
+    plain = stub('plain', :filename => 'message.txt', :content_type => 'text/plain', :part_type? => 'text/plain', :body => Mail::Body.new(''), :main_type => 'text')
+    plain.stubs(:multipart?).at_least_once.returns(false)
+
+    html = stub('html', :filename => 'message.html', :content_type => 'text/html', :part_type? => 'text/html', :body => Mail::Body.new(''), :main_type => 'text')
+    html.stubs(:multipart?).at_least_once.returns(false)
+
+
+    multi = stub('multi', :content_type => 'multipart/alternative', :part_type? => 'multipart/alternative', :parts => [plain, html])
+    multi.stubs(:multipart?).at_least_once.returns(true)
+
+    mail.stubs(:multipart?).at_least_once.returns(true)
+    mail.stubs(:parts).at_least_once.returns([multi])
+
     mms = MMS2R::Media.new(mail, :process => :lazy)
     mms.stubs(:config).returns({'ignore' => {'text/plain' => ['message.txt'],
                                              'text/html' => ['message.html']}})
@@ -690,12 +694,19 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_process_when_yielding_to_a_block
-    mail = stub_mail()
+    mail = stub_mail
 
-    plain = stub(:sub_header => 'message.txt', :content_type => 'text/plain', :part_type? => 'text/plain', :body => 'a', :main_type => 'text')
-    html = stub(:sub_header => 'message.html', :content_type => 'text/html', :part_type? => 'text/html', :body => 'b', :main_type => 'text')
-    mail.stubs(:multipart?).returns(true)
-    mail.stubs(:parts).returns([plain, html])
+    plain = stub('plain', :filename => 'message.txt', :content_type => 'text/plain', :part_type? => 'text/plain', :body => Mail::Body.new('a'), :main_type => 'text')
+    plain.stubs(:multipart?).at_least_once.returns(false)
+
+    html = stub('html', :filename => 'message.html', :content_type => 'text/html', :part_type? => 'text/html', :body => Mail::Body.new('b'), :main_type => 'text')
+    html.stubs(:multipart?).at_least_once.returns(false)
+
+    multi = stub('multi', :content_type => 'multipart/alternative', :part_type? => 'multipart/alternative', :parts => [plain, html])
+    multi.stubs(:multipart?).at_least_once.returns(true)
+
+    mail.stubs(:multipart?).at_least_once.returns(true)
+    mail.stubs(:parts).at_least_once.returns([multi])
 
     # the multipart/alternative should get flattend to text and html
     mms = MMS2R::Media.new(mail)
@@ -712,16 +723,16 @@ class TestMms2rMedia < Test::Unit::TestCase
 
   def test_domain_from_return_path
     mail = mock()
-    mail.expects(:header).at_least_once.returns({'return-path' => '<joe@null.example.com>'})
     mail.expects(:from).at_least_once.returns([])
+    mail.expects(:return_path).at_least_once.returns('joe@null.example.com')
     domain = MMS2R::Media.domain(mail)
     assert_equal 'null.example.com', domain
   end
 
   def test_domain_from_from
     mail = mock()
-    mail.expects(:header).at_least_once.returns({})
     mail.expects(:from).at_least_once.returns(['joe@null.example.com'])
+    mail.expects(:return_path).at_least_once.returns('joe@null.example.com')
     domain = MMS2R::Media.domain(mail)
     assert_equal 'null.example.com', domain
   end
@@ -730,14 +741,14 @@ class TestMms2rMedia < Test::Unit::TestCase
     f = File.join(MMS2R::Media.conf_dir, 'from.yml')
     YAML.expects(:load_file).once.with(f).returns(['example.com'])
     mail = mock()
-    mail.expects(:header).at_least_once.returns({'return-path' => '<joe@null.example.com>'})
     mail.expects(:from).at_least_once.returns(['joe@example.com'])
+    mail.expects(:return_path).at_least_once.returns('joe@null.example.com')
     domain = MMS2R::Media.domain(mail)
     assert_equal 'example.com', domain
   end
 
   def test_unknown_device_type
-    mail = TMail::Mail.load(mail_fixture('generic.mail'))
+    mail = mail('generic.mail')
     mms = MMS2R::Media.new(mail)
     assert_equal :unknown, mms.device_type?
     assert_equal false, mms.is_mobile?
@@ -747,7 +758,7 @@ class TestMms2rMedia < Test::Unit::TestCase
     iphones = ['att-iphone-01.mail',
                'iphone-image-01.mail']
     iphones.each do |iphone|
-      mail = TMail::Mail.load(mail_fixture(iphone))
+      mail = mail(iphone)
       mms = MMS2R::Media.new(mail)
       assert_equal :iphone, mms.device_type?, "fixture #{iphone} was not a iphone"
       assert_equal true, mms.is_mobile?
@@ -761,7 +772,7 @@ class TestMms2rMedia < Test::Unit::TestCase
   end
 
   def test_exif_load_error
-    mms = MMS2R::Media.new(stub_mail())
+    mms = MMS2R::Media.new stub_mail
     mms.expects(:require).with('exifr').raises(LoadError)
 
     assert_equal :unknown, mms.device_type?
@@ -825,15 +836,14 @@ class TestMms2rMedia < Test::Unit::TestCase
                'verizon-blackberry.mail',
                'verizon-blackberry.mail']
     berries.each do |berry|
-      mail = TMail::Mail.load(mail_fixture(berry))
-      mms = MMS2R::Media.new(mail)
+      mms = MMS2R::Media.new(mail(berry))
       assert_equal :blackberry, mms.device_type?, "fixture #{berry} was not a blackberrry"
       assert_equal true, mms.is_mobile?
     end
   end
 
   def test_handset_device_type
-    mail = TMail::Mail.load(mail_fixture('att-image-01.mail'))
+    mail = mail('att-image-01.mail')
     mms = MMS2R::Media.new(mail)
     assert_equal :handset, mms.device_type?
     assert_equal true, mms.is_mobile?