mailgun-ruby 1.0.3 → 1.1.0

data/spec/unit/mailgun_spec.rb

@@ -18,21 +18,22 @@ describe 'The method send_message()' do
     @mb_obj = Mailgun::MessageBuilder.new()
     @mh_obj = {}
 
-    expect {@mg_obj.send_message("test.com", "incorrect data")}.to raise_error
+    expect {@mg_obj.send_message("test.com", "incorrect data")}.to raise_error Mailgun::ParameterError
     expect {@mg_obj.send_message("test.com", @mb_obj)}.not_to raise_error
     expect {@mg_obj.send_message("test.com", @mh_obj)}.not_to raise_error
   end
 
   it 'sends a message' do
-    data = {'from' => 'joe@test.com',
+    data = { 'from' => 'joe@test.com',
                     'to' => 'bob@example.com',
                     'subject' => 'Test',
                     'text' => 'Test Data'}
     result = @mg_obj.send_message("testdomain.com", data)
 
     result.to_h!
-    result.body.should include("message")
-    result.body.should include("id")
+
+    expect(result.body).to include("message")
+    expect(result.body).to include("id")
   end
 
   it 'opens the message MIME and sends the MIME message.' do
@@ -41,8 +42,9 @@ describe 'The method send_message()' do
     result = @mg_obj.send_message("testdomain.com", data)
 
     result.to_h!
-    result.body.should include("message")
-    result.body.should include("id")
+    
+    expect(result.body).to include("message")
+    expect(result.body).to include("id")
   end
 end
 
@@ -59,8 +61,9 @@ describe 'The method post()' do
     result = @mg_obj.post("#{@domain}/messages", data)
 
     result.to_h!
-    result.body.should include("message")
-    result.body.should include("id")
+    
+    expect(result.body).to include("message")
+    expect(result.body).to include("id")
   end
 end
 
@@ -78,13 +81,14 @@ describe 'The method put()' do
     result = @mg_obj.put("lists/#{@list_address}/members#{@member_address}", data)
 
     result.to_h!
-    result.body.should include("member")
-    result.body["member"].should include("vars")
-    result.body["member"]["vars"].should include("age")
-    result.body["member"].should include("name")
-    result.body["member"].should include("subscribed")
-    result.body["member"].should include("address")
-    result.body.should include("message")
+    
+    expect(result.body).to include("member")
+    expect(result.body["member"]).to include("vars")
+    expect(result.body["member"]["vars"]).to include("age")
+    expect(result.body["member"]).to include("name")
+    expect(result.body["member"]).to include("subscribed")
+    expect(result.body["member"]).to include("address")
+    expect(result.body).to include("message")
   end
 
 end
@@ -100,8 +104,9 @@ describe 'The method get()' do
     result = @mg_obj.get("#{@domain}/bounces", query_string)
 
     result.to_h!
-    result.body.should include("total_count")
-    result.body.should include("items")
+    
+    expect(result.body).to include("total_count")
+    expect(result.body).to include("items")
   end
 end
 
@@ -115,7 +120,8 @@ describe 'The method delete()' do
     result = @mg_obj.delete("#{@domain}/campaigns/ABC123")
 
     result.to_h!
-    result.body.should include("message")
-    result.body.should include("id")
+    
+    expect(result.body).to include("message")
+    expect(result.body).to include("id")
   end
 end

data/spec/unit/messages/batch_message_spec.rb

@@ -4,11 +4,12 @@ describe 'BatchMessage attribute readers' do
   it 'should be readable' do
     @mb_client = Mailgun::UnitClient.new("messages")
     @mb_obj = Mailgun::BatchMessage.new(@mb_client, "example.com")
-    @mb_obj.should respond_to(:message_ids)
-    @mb_obj.should respond_to(:message)
-    @mb_obj.should respond_to(:counters)
-    @mb_obj.should respond_to(:recipient_variables)
-    @mb_obj.should respond_to(:domain)
+
+    expect(@mb_obj).to respond_to(:message_ids)
+    expect(@mb_obj).to respond_to(:message)
+    expect(@mb_obj).to respond_to(:counters)
+    expect(@mb_obj).to respond_to(:recipient_variables)
+    expect(@mb_obj).to respond_to(:domain)
   end
 end
 
@@ -20,43 +21,43 @@ describe 'The instantiation of Batch Message' do
   end
 
   it 'contains Message, which should be of type Hash and empty' do
-    @mb_obj.message.should be_a(Hash)
-    @mb_obj.message.length.should eq(0)
+    expect(@mb_obj.message).to be_a(Hash)
+    expect(@mb_obj.message.length).to eq(0)
   end
 
   it 'contains recipient_variables, which should be of type Hash and empty' do
-    @mb_obj.recipient_variables.should be_a(Hash)
-    @mb_obj.recipient_variables.length.should eq(0)
+    expect(@mb_obj.recipient_variables).to be_a(Hash)
+    expect(@mb_obj.recipient_variables.length).to eq(0)
   end
 
   it 'contains domain, which should be of type string and contain example.com' do
-    @mb_obj.domain.should be_a(String)
-    @mb_obj.domain.should eq('example.com')
+    expect(@mb_obj.domain).to be_a(String)
+    expect(@mb_obj.domain).to eq('example.com')
   end
 
   it 'contains message_ids, which should be of type hash and empty' do
-    @mb_obj.message_ids.should be_a(Hash)
-    @mb_obj.message_ids.length.should eq(0)
+    expect(@mb_obj.message_ids).to be_a(Hash)
+    expect(@mb_obj.message_ids.length).to eq(0)
   end
 
   it 'contains counters, which should be of type hash and contain several important counters' do
-    @mb_obj.counters.should be_a(Hash)
-    @mb_obj.counters.should include(:recipients)
+    expect(@mb_obj.counters).to be_a(Hash)
+    expect(@mb_obj.counters).to include(:recipients)
   end
 
   it 'contains counters, which should be of type hash and contain several important counters' do
-    @mb_obj.counters.should be_a(Hash)
-
-    @mb_obj.counters.should include(:recipients)
-    @mb_obj.counters[:recipients].should include(:to)
-    @mb_obj.counters[:recipients].should include(:cc)
-    @mb_obj.counters[:recipients].should include(:bcc)
-
-    @mb_obj.counters.should include(:attributes)
-    @mb_obj.counters[:attributes].should include(:attachment)
-    @mb_obj.counters[:attributes].should include(:campaign_id)
-    @mb_obj.counters[:attributes].should include(:custom_option)
-    @mb_obj.counters[:attributes].should include(:tag)
+    expect(@mb_obj.counters).to be_a(Hash)
+
+    expect(@mb_obj.counters).to include(:recipients)
+    expect(@mb_obj.counters[:recipients]).to include(:to)
+    expect(@mb_obj.counters[:recipients]).to include(:cc)
+    expect(@mb_obj.counters[:recipients]).to include(:bcc)
+
+    expect(@mb_obj.counters).to include(:attributes)
+    expect(@mb_obj.counters[:attributes]).to include(:attachment)
+    expect(@mb_obj.counters[:attributes]).to include(:campaign_id)
+    expect(@mb_obj.counters[:attributes]).to include(:custom_option)
+    expect(@mb_obj.counters[:attributes]).to include(:tag)
   end
 end
 
@@ -77,9 +78,12 @@ describe 'The method add_recipient' do
     1000.times do
       @mb_obj.add_recipient(recipient_type, @address_1, @variables_1)
     end
-    @mb_obj.counters[:recipients][recipient_type].should eq(1000)
+
+    expect(@mb_obj.counters[:recipients][recipient_type]).to eq(1000)
+    
     @mb_obj.add_recipient(recipient_type, @address_1, @variables_1)
-    @mb_obj.counters[:recipients][recipient_type].should eq(1)
+    
+    expect(@mb_obj.counters[:recipients][recipient_type]).to eq(1)
   end
 
   it 'adds recipients to the message, calls finalize, and cleans up' do
@@ -87,11 +91,13 @@ describe 'The method add_recipient' do
     1000.times do
       @mb_obj.add_recipient(recipient_type, @address_1, @variables_1)
     end
-    @mb_obj.counters[:recipients][recipient_type].should eq(1000)
+
+    expect(@mb_obj.counters[:recipients][recipient_type]).to eq(1000)
     @mb_obj.finalize
-    @mb_obj.message['recipient-variables'].length.should eq(0)
-    @mb_obj.message[:to].length.should eq(0)
-    @mb_obj.counters[:recipients][recipient_type].should eq(0)
+
+    expect(@mb_obj.message['recipient-variables'].length).to eq(0)
+    expect(@mb_obj.message[:to].length).to eq(0)
+    expect(@mb_obj.counters[:recipients][recipient_type]).to eq(0)
   end
 
   it 'adds 5,005 recipients to the message body and validates we receive message_ids back' do
@@ -100,13 +106,15 @@ describe 'The method add_recipient' do
       @mb_obj.add_recipient(recipient_type, @address_1, @variables_1)
     end
     @mb_obj.finalize
-    @mb_obj.message_ids.length.should eq(6)
+
+    expect(@mb_obj.message_ids.length).to eq(6)
   end
 
   it 'sets recipient-variables, for batch expansion' do
     recipient_type = :to
     @mb_obj.add_recipient(recipient_type, @address_1, @variables_1)
-    @mb_obj.recipient_variables[@address_1].should eq(@variables_1)
+
+    expect(@mb_obj.recipient_variables[@address_1]).to eq(@variables_1)
   end
 
   it 'sets multiple recipient-variables, for batch expansion' do
@@ -114,9 +122,10 @@ describe 'The method add_recipient' do
     @mb_obj.add_recipient(recipient_type, @address_1, @variables_1)
     @mb_obj.add_recipient(recipient_type, @address_2, @variables_2)
     @mb_obj.add_recipient(recipient_type, @address_3, @variables_3)
-    @mb_obj.recipient_variables[@address_1].should eq(@variables_1)
-    @mb_obj.recipient_variables[@address_2].should eq(@variables_2)
-    @mb_obj.recipient_variables[@address_3].should eq(@variables_3)
+    
+    expect(@mb_obj.recipient_variables[@address_1]).to eq(@variables_1)
+    expect(@mb_obj.recipient_variables[@address_2]).to eq(@variables_2)
+    expect(@mb_obj.recipient_variables[@address_3]).to eq(@variables_3)
   end
 
 end

data/spec/unit/messages/message_builder_spec.rb

@@ -3,8 +3,9 @@ require 'spec_helper'
 describe 'MessageBuilder attribute readers' do
   it 'should be readable' do
     @mb_obj = Mailgun::MessageBuilder.new()
-    @mb_obj.should respond_to(:message)
-    @mb_obj.should respond_to(:counters)
+    
+    expect(@mb_obj).to respond_to(:message)
+    expect(@mb_obj).to respond_to(:counters)
   end
 end
 
@@ -15,21 +16,21 @@ describe 'The instantiation of MessageBuilder' do
   end
 
   it 'contains counters, which should be of type hash and contain several important counters' do
-    @mb_obj.counters.should be_a(Hash)
-    @mb_obj.counters.should include(:recipients)
+    expect(@mb_obj.counters).to be_a(Hash)
+    expect(@mb_obj.counters).to include(:recipients)
   end
 
   it 'contains counters, which should be of type hash and contain several important counters' do
-    @mb_obj.counters.should be_a(Hash)
-    @mb_obj.counters.should include(:recipients)
-    @mb_obj.counters[:recipients].should include(:to)
-    @mb_obj.counters[:recipients].should include(:cc)
-    @mb_obj.counters[:recipients].should include(:bcc)
-    @mb_obj.counters.should include(:attributes)
-    @mb_obj.counters[:attributes].should include(:attachment)
-    @mb_obj.counters[:attributes].should include(:campaign_id)
-    @mb_obj.counters[:attributes].should include(:custom_option)
-    @mb_obj.counters[:attributes].should include(:tag)
+    expect(@mb_obj.counters).to be_a(Hash)
+    expect(@mb_obj.counters).to include(:recipients)
+    expect(@mb_obj.counters[:recipients]).to include(:to)
+    expect(@mb_obj.counters[:recipients]).to include(:cc)
+    expect(@mb_obj.counters[:recipients]).to include(:bcc)
+    expect(@mb_obj.counters).to include(:attributes)
+    expect(@mb_obj.counters[:attributes]).to include(:attachment)
+    expect(@mb_obj.counters[:attributes]).to include(:campaign_id)
+    expect(@mb_obj.counters[:attributes]).to include(:custom_option)
+    expect(@mb_obj.counters[:attributes]).to include(:tag)
   end
 end
 
@@ -43,39 +44,45 @@ describe 'The method add_recipient' do
   it 'adds a "to" recipient type to the message body and counter is incremented' do
     recipient_type = :to
     @mb_obj.add_recipient(recipient_type, @address, @variables)
-    @mb_obj.message[recipient_type][0].should eq("'#{@variables['first']} #{@variables['last']}' <#{@address}>")
-    @mb_obj.counters[:recipients][recipient_type].should eq(1)
+
+    expect(@mb_obj.message[recipient_type][0]).to eq("'#{@variables['first']} #{@variables['last']}' <#{@address}>")
+    expect(@mb_obj.counters[:recipients][recipient_type]).to eq(1)
   end
 
   it 'adds a "cc" recipient type to the message body and counter is incremented' do
     recipient_type = :cc
     @mb_obj.add_recipient(recipient_type, @address, @variables)
-    @mb_obj.message[recipient_type][0].should eq("'#{@variables['first']} #{@variables['last']}' <#{@address}>")
-    @mb_obj.counters[:recipients][recipient_type].should eq(1)
+    
+    expect(@mb_obj.message[recipient_type][0]).to eq("'#{@variables['first']} #{@variables['last']}' <#{@address}>")
+    expect(@mb_obj.counters[:recipients][recipient_type]).to eq(1)
   end
 
   it 'adds a "bcc" recipient type to the message body and counter is incremented' do
     recipient_type = :bcc
     @mb_obj.add_recipient(recipient_type, @address, @variables)
-    @mb_obj.message[recipient_type][0].should eq("'#{@variables['first']} #{@variables['last']}' <#{@address}>")
-    @mb_obj.counters[:recipients][recipient_type].should eq(1)
+    
+    expect(@mb_obj.message[recipient_type][0]).to eq("'#{@variables['first']} #{@variables['last']}' <#{@address}>")
+    expect(@mb_obj.counters[:recipients][recipient_type]).to eq(1)
   end
 
   it 'adds a "h:reply-to" recipient type to the message body and counters are not incremented' do
     recipient_type = 'h:reply-to'
     @mb_obj.add_recipient(recipient_type, @address, @variables)
-    @mb_obj.message[recipient_type][0].should eq("'#{@variables['first']} #{@variables['last']}' <#{@address}>")
-    @mb_obj.counters[:recipients].each_value{|value| value.should eq(0)}
+    
+    expect(@mb_obj.message[recipient_type][0]).to eq("'#{@variables['first']} #{@variables['last']}' <#{@address}>")
+    @mb_obj.counters[:recipients].each_value{|value| expect(value).to eq(0)}
   end
 
   it 'ensures a random recipient type is added to the message body and counters are not incremented' do
     recipient_type = 'im-not-really-real'
     @mb_obj.add_recipient(recipient_type, @address, @variables)
-    @mb_obj.message[recipient_type][0].should eq("'#{@variables['first']} #{@variables['last']}' <#{@address}>")
-    @mb_obj.counters[:recipients].each_value{|value| value.should eq(0)}
+    
+    expect(@mb_obj.message[recipient_type][0]).to eq("'#{@variables['first']} #{@variables['last']}' <#{@address}>")
+    @mb_obj.counters[:recipients].each_value{|value| expect(value).to eq(0)}
   end
   it 'adds too many to recipients and raises an exception.' do
     recipient_type = :to
+    
     expect{
       1001.times do
         @mb_obj.add_recipient(recipient_type, @address, @variables)
@@ -83,6 +90,7 @@ describe 'The method add_recipient' do
   end
   it 'adds too many cc recipients and raises an exception.' do
     recipient_type = :cc
+    
     expect{
       1001.times do
         @mb_obj.add_recipient(recipient_type, @address, @variables)
@@ -90,6 +98,7 @@ describe 'The method add_recipient' do
   end
   it 'adds too many bcc recipients and raises an exception.' do
     recipient_type = :bcc
+    
     expect{
       1001.times do
         @mb_obj.add_recipient(recipient_type, @address, @variables)
@@ -98,48 +107,101 @@ describe 'The method add_recipient' do
 end
 
 describe 'The method set_subject' do
+  it 'warns of set_subject deprecation' do
+    @mb_obj = Mailgun::MessageBuilder.new
+    expect(@mb_obj).to receive :warn
+    @mb_obj.set_subject 'warn on set_subject'
+  end
+end
+
+describe 'The method subject' do
   before(:each) do
     @mb_obj = Mailgun::MessageBuilder.new
   end
+  
   it 'sets the message subject to blank if called and no parameters are provided' do
-    @mb_obj.set_subject
-    @mb_obj.message[:subject][0].should eq('')
+    @mb_obj.subject
+    
+    expect(@mb_obj.message[:subject][0]).to eq('')
   end
+  
   it 'sets the message subject if called with the subject parameter' do
     the_subject = 'This is my subject!'
-    @mb_obj.set_subject(the_subject)
-    @mb_obj.message[:subject][0].should eq(the_subject)
+    @mb_obj.subject(the_subject)
+    
+    expect(@mb_obj.message[:subject][0]).to eq(the_subject)
   end
+
   it 'ensures no duplicate subjects can exist and last setter is stored' do
     the_first_subject = 'This is my first subject!'
     the_second_subject = 'This is my second subject!'
-    @mb_obj.set_subject(the_first_subject)
-    @mb_obj.set_subject(the_second_subject)
-    @mb_obj.message[:subject].length.should eq(1)
-    @mb_obj.message[:subject][0].should eq(the_second_subject)
+    @mb_obj.subject(the_first_subject)
+    @mb_obj.subject(the_second_subject)
+    
+    expect(@mb_obj.message[:subject].length).to eq(1)
+    expect(@mb_obj.message[:subject][0]).to eq(the_second_subject)
   end
 end
 
 describe 'The method set_text_body' do
+  it 'warns of set_text_body deprecation' do
+    @mb_obj = Mailgun::MessageBuilder.new
+    expect(@mb_obj).to receive :warn
+    @mb_obj.set_text_body 'warn on set_text_body'
+  end
+end
+
+describe 'The method body_text' do
   before(:each) do
     @mb_obj = Mailgun::MessageBuilder.new
   end
-  it 'sets the text_body to blank if called and no parameters are provided' do
-    @mb_obj.set_text_body
+  it 'sets the body_text to blank if called and no parameters are provided' do
+    @mb_obj.body_text
     @mb_obj.message[:text] = ''
   end
-  it 'sets the message text if called with the text_body parameter' do
+  it 'sets the message text if called with the body_text parameter' do
     the_text = 'Don\'t mess with Texas!'
-    @mb_obj.set_text_body(the_text)
+    @mb_obj.body_text(the_text)
     @mb_obj.message[:text] = the_text
   end
   it 'ensures no duplicate text bodies can exist and last setter is stored' do
     the_first_text = 'Mess with Texas!'
     the_second_text = 'Don\'t mess with Texas!'
-    @mb_obj.set_text_body(the_first_text)
-    @mb_obj.set_text_body(the_second_text)
-    @mb_obj.message[:text].length.should eq(1)
-    @mb_obj.message[:text][0].should eq(the_second_text)
+    @mb_obj.body_text(the_first_text)
+    @mb_obj.body_text(the_second_text)
+    
+    expect(@mb_obj.message[:text].length).to eq(1)
+    expect(@mb_obj.message[:text][0]).to eq(the_second_text)
+  end
+end
+
+describe 'The method set_from_address' do
+  it 'warns of set_from_address deprecation' do
+    @mb_obj = Mailgun::MessageBuilder.new
+    expect(@mb_obj).to receive :warn
+    @mb_obj.set_from_address 'warn on set_from_address'
+  end
+end
+
+describe 'The method from' do
+  before(:each) do
+    @mb_obj = Mailgun::MessageBuilder.new
+  end
+  
+  it 'sets the from address' do
+    the_from_address = 'test@mailgun.com'
+    @mb_obj.from(the_from_address)
+    
+    expect(@mb_obj.message[:from]).to eq([the_from_address])
+  end
+
+  it 'sets the from address with metadata' do
+    the_from_address = 'test@mailgun.com'
+    the_first_name = 'Magilla'
+    the_last_name = 'Gorilla'
+    @mb_obj.from(the_from_address, {'first' => the_first_name, 'last' => the_last_name})
+    
+    expect(@mb_obj.message[:from]).to eq(["'#{the_first_name} #{the_last_name}' <#{the_from_address}>"])
   end
 end
 
@@ -155,7 +217,18 @@ describe 'The method add_attachment' do
     file_paths = [file1, file2]
 
     file_paths.each {|item| @mb_obj.add_attachment(item)}
-    @mb_obj.message[:attachment].length.should eq(2)
+    
+    expect(@mb_obj.message[:attachment].length).to eq(2)
+  end
+
+  it 'adds file-like objects to the message object' do
+    io = StringIO.new
+    io << File.binread(File.dirname(__FILE__) + "/sample_data/mailgun_icon.png")
+
+    @mb_obj.add_attachment io, 'mailgun_icon.png'
+
+    expect(@mb_obj.message[:attachment].length).to eq(1)
+    expect(@mb_obj.message[:attachment].first.original_filename).to eq 'mailgun_icon.png'
   end
 end
 
@@ -170,65 +243,92 @@ describe 'The method add_inline_image' do
     file_paths = [file1, file2]
 
     file_paths.each {|item| @mb_obj.add_inline_image(item)}
-    @mb_obj.message[:inline].length.should eq(2)
+    
+    expect(@mb_obj.message[:inline].length).to eq(2)
   end
 end
 
 describe 'The method set_test_mode' do
+  it 'warns of set_test_mode deprecation' do
+    @mb_obj = Mailgun::MessageBuilder.new
+    expect(@mb_obj).to receive :warn
+    @mb_obj.set_test_mode 'warn on set_test_mode'
+  end
+end
+
+describe 'The method test_mode' do
   before(:each) do
     @mb_obj = Mailgun::MessageBuilder.new
   end
   it 'turns on test mode with boolean true' do
-    @mb_obj.set_test_mode(true)
-    @mb_obj.message["o:testmode"][0].should eq("yes")
+    @mb_obj.test_mode(true)
+    
+    expect(@mb_obj.message["o:testmode"][0]).to eq("yes")
   end
   it 'turns on test mode with string true' do
-    @mb_obj.set_test_mode("true")
-    @mb_obj.message["o:testmode"][0].should eq("yes")
+    @mb_obj.test_mode("true")
+    
+    expect(@mb_obj.message["o:testmode"][0]).to eq("yes")
   end
   it 'turns off test mode with boolean false' do
-    @mb_obj.set_test_mode(false)
-    @mb_obj.message["o:testmode"][0].should eq("no")
+    @mb_obj.test_mode(false)
+    
+    expect(@mb_obj.message["o:testmode"][0]).to eq("no")
   end
   it 'turns off test mode with string false' do
-    @mb_obj.set_test_mode("false")
-    @mb_obj.message["o:testmode"][0].should eq("no")
+    @mb_obj.test_mode("false")
+    
+    expect(@mb_obj.message["o:testmode"][0]).to eq("no")
   end
   it 'does not allow multiple values' do
-    @mb_obj.set_test_mode("false")
-    @mb_obj.set_test_mode("true")
-    @mb_obj.set_test_mode("false")
-    @mb_obj.message["o:testmode"].length.should eq(1)
-    @mb_obj.message["o:testmode"][0].should eq("no")
+    @mb_obj.test_mode("false")
+    @mb_obj.test_mode("true")
+    @mb_obj.test_mode("false")
+    
+    expect(@mb_obj.message["o:testmode"].length).to eq(1)
+    expect(@mb_obj.message["o:testmode"][0]).to eq("no")
   end
 end
 
 describe 'The method set_dkim' do
+  it 'warns of set_dkim deprecation' do
+    @mb_obj = Mailgun::MessageBuilder.new
+    expect(@mb_obj).to receive :warn
+    @mb_obj.set_dkim 'warn on set_dkim'
+  end
+end
+
+describe 'The method dkim' do
   before(:each) do
     @mb_obj = Mailgun::MessageBuilder.new
   end
   it 'turns on dkim with boolean true' do
-    @mb_obj.set_dkim(true)
-    @mb_obj.message["o:dkim"][0].should eq("yes")
+    @mb_obj.dkim(true)
+    
+    expect(@mb_obj.message["o:dkim"][0]).to eq("yes")
   end
   it 'turns on dkim with string true' do
-    @mb_obj.set_dkim("true")
-    @mb_obj.message["o:dkim"][0].should eq("yes")
+    @mb_obj.dkim("true")
+    
+    expect(@mb_obj.message["o:dkim"][0]).to eq("yes")
   end
   it 'turns off dkim with boolean false' do
-    @mb_obj.set_dkim(false)
-    @mb_obj.message["o:dkim"][0].should eq("no")
+    @mb_obj.dkim(false)
+    
+    expect(@mb_obj.message["o:dkim"][0]).to eq("no")
   end
   it 'turns off dkim with string false' do
-    @mb_obj.set_dkim("false")
-    @mb_obj.message["o:dkim"][0].should eq("no")
+    @mb_obj.dkim("false")
+    
+    expect(@mb_obj.message["o:dkim"][0]).to eq("no")
   end
   it 'does not allow multiple values' do
-    @mb_obj.set_dkim("false")
-    @mb_obj.set_dkim("true")
-    @mb_obj.set_dkim("false")
-    @mb_obj.message["o:dkim"].length.should eq(1)
-    @mb_obj.message["o:dkim"][0].should eq("no")
+    @mb_obj.dkim("false")
+    @mb_obj.dkim("true")
+    @mb_obj.dkim("false")
+    
+    expect(@mb_obj.message["o:dkim"].length).to eq(1)
+    expect(@mb_obj.message["o:dkim"][0]).to eq("no")
   end
 end
 
@@ -238,15 +338,17 @@ describe 'The method add_campaign_id' do
   end
   it 'adds a campaign ID to the message' do
     @mb_obj.add_campaign_id('My-Campaign-Id-1')
-    @mb_obj.message["o:campaign"][0].should eq ("My-Campaign-Id-1")
+    
+    expect(@mb_obj.message["o:campaign"][0]).to eq ("My-Campaign-Id-1")
   end
   it 'adds a few more campaign IDs to the message' do
     @mb_obj.add_campaign_id('My-Campaign-Id-1')
     @mb_obj.add_campaign_id('My-Campaign-Id-2')
     @mb_obj.add_campaign_id('My-Campaign-Id-3')
-    @mb_obj.message["o:campaign"][0].should eq("My-Campaign-Id-1")
-    @mb_obj.message["o:campaign"][1].should eq("My-Campaign-Id-2")
-    @mb_obj.message["o:campaign"][2].should eq("My-Campaign-Id-3")
+    
+    expect(@mb_obj.message["o:campaign"][0]).to eq("My-Campaign-Id-1")
+    expect(@mb_obj.message["o:campaign"][1]).to eq("My-Campaign-Id-2")
+    expect(@mb_obj.message["o:campaign"][2]).to eq("My-Campaign-Id-3")
   end
   it 'adds too many campaign IDs to the message' do
     expect{
@@ -262,15 +364,17 @@ describe 'The method add_tag' do
   end
   it 'adds a tag to the message' do
     @mb_obj.add_tag('My-Tag-1')
-    @mb_obj.message["o:tag"][0].should eq("My-Tag-1")
+    
+    expect(@mb_obj.message["o:tag"][0]).to eq("My-Tag-1")
   end
   it 'adds a few more tags to the message' do
     @mb_obj.add_tag('My-Tag-1')
     @mb_obj.add_tag('My-Tag-2')
     @mb_obj.add_tag('My-Tag-3')
-    @mb_obj.message["o:tag"][0].should eq("My-Tag-1")
-    @mb_obj.message["o:tag"][1].should eq("My-Tag-2")
-    @mb_obj.message["o:tag"][2].should eq("My-Tag-3")
+    
+    expect(@mb_obj.message["o:tag"][0]).to eq("My-Tag-1")
+    expect(@mb_obj.message["o:tag"][1]).to eq("My-Tag-2")
+    expect(@mb_obj.message["o:tag"][2]).to eq("My-Tag-3")
   end
   it 'adds too many tags to the message' do
     expect{
@@ -281,65 +385,118 @@ describe 'The method add_tag' do
 end
 
 describe 'The method set_open_tracking' do
+  it 'warns of set_open_tracking deprecation' do
+    @mb_obj = Mailgun::MessageBuilder.new
+    expect(@mb_obj).to receive :warn
+    @mb_obj.set_open_tracking 'warn on set_open_tracking'
+  end
+end
+
+describe 'The method track_opens' do
   before(:each) do
     @mb_obj = Mailgun::MessageBuilder.new
   end
   it 'enables/disables open tracking on a per message basis.' do
-    @mb_obj.set_open_tracking('Yes')
-    @mb_obj.message["o:tracking-opens"][0].should eq("yes")
-    @mb_obj.set_open_tracking('No')
-    @mb_obj.message["o:tracking-opens"][0].should eq("no")
-    @mb_obj.set_open_tracking(true)
-    @mb_obj.message["o:tracking-opens"][0].should eq("yes")
-    @mb_obj.set_open_tracking(false)
-    @mb_obj.message["o:tracking-opens"][0].should eq("no")
+    @mb_obj.track_opens('Yes')
+    
+    expect(@mb_obj.message["o:tracking-opens"][0]).to eq("yes")
+    
+    @mb_obj.track_opens('No')
+    
+    expect(@mb_obj.message["o:tracking-opens"][0]).to eq("no")
+    
+    @mb_obj.track_opens(true)
+    
+    expect(@mb_obj.message["o:tracking-opens"][0]).to eq("yes")
+    
+    @mb_obj.track_opens(false)
+    
+    expect(@mb_obj.message["o:tracking-opens"][0]).to eq("no")
   end
 end
 
 describe 'The method set_click_tracking' do
+  it 'warns of set_click_tracking deprecation' do
+    @mb_obj = Mailgun::MessageBuilder.new
+    expect(@mb_obj).to receive :warn
+    @mb_obj.set_click_tracking 'warn on set_click_tracking'
+  end
+end
+
+describe 'The method track_clicks' do
   before(:each) do
     @mb_obj = Mailgun::MessageBuilder.new
   end
   it 'enables/disables click tracking on a per message basis.' do
-    @mb_obj.set_click_tracking('Yes')
-    @mb_obj.message["o:tracking-clicks"][0].should eq("yes")
-    @mb_obj.set_click_tracking('No')
-    @mb_obj.message["o:tracking-clicks"][0].should eq("no")
-    @mb_obj.set_click_tracking(true)
-    @mb_obj.message["o:tracking-clicks"][0].should eq("yes")
-    @mb_obj.set_click_tracking(false)
-    @mb_obj.message["o:tracking-clicks"][0].should eq("no")
-    @mb_obj.set_click_tracking('html')
-    @mb_obj.message["o:tracking-clicks"][0].should eq("html")
+    @mb_obj.track_clicks('Yes')
+    
+    expect(@mb_obj.message["o:tracking-clicks"][0]).to eq("yes")
+    
+    @mb_obj.track_clicks('No')
+    
+    expect(@mb_obj.message["o:tracking-clicks"][0]).to eq("no")
+    
+    @mb_obj.track_clicks(true)
+    
+    expect(@mb_obj.message["o:tracking-clicks"][0]).to eq("yes")
+    
+    @mb_obj.track_clicks(false)
+    
+    expect(@mb_obj.message["o:tracking-clicks"][0]).to eq("no")
+    
+    @mb_obj.track_clicks('html')
+    
+    expect(@mb_obj.message["o:tracking-clicks"][0]).to eq("html")
   end
 end
 
 describe 'The method set_delivery_time' do
+  it 'warns of set_delivery_time deprecation' do
+    @mb_obj = Mailgun::MessageBuilder.new
+    expect(@mb_obj).to receive :warn
+    @mb_obj.set_delivery_time 'October 25, 2013 10:00PM CST'
+  end
+end
+
+describe 'The method deliver_at' do
   before(:each) do
     @mb_obj = Mailgun::MessageBuilder.new
   end
   it 'defines a time/date to deliver a message in RFC2822 format.' do
-    @mb_obj.set_delivery_time('October 25, 2013 10:00PM CST')
-    @mb_obj.message["o:deliverytime"][0].should eq("Fri, 25 Oct 2013 22:00:00 -0600")
+    @mb_obj.deliver_at('October 25, 2013 10:00PM CST')
+    
+    expect(@mb_obj.message["o:deliverytime"][0]).to eq("Fri, 25 Oct 2013 22:00:00 -0600")
   end
 end
 
 describe 'The method set_custom_data' do
+  it 'warns of set_custom_data deprecation' do
+    @mb_obj = Mailgun::MessageBuilder.new
+    expect(@mb_obj).to receive :warn
+    @mb_obj.set_custom_data 'my-data', '{"key":"value"}'
+  end
+end
+
+describe 'The method header' do
   before(:each) do
     @mb_obj = Mailgun::MessageBuilder.new
   end
   it 'accepts valid JSON and appends as data to the message.' do
-    @mb_obj.set_custom_data('my-data', '{"key":"value"}')
-    @mb_obj.message["v:my-data"][0].should eq("{\"key\":\"value\"}")
+    @mb_obj.header('my-data', '{"key":"value"}')
+    
+    expect(@mb_obj.message["v:my-data"][0]).to be_kind_of(String)
+    expect(@mb_obj.message["v:my-data"][0].to_s).to eq('{"key"=>"value"}')
   end
   it 'accepts a hash and appends as data to the message.' do
-    data = {'key'=> 'value'}
-    @mb_obj.set_custom_data('my-data', data)
-    @mb_obj.message["v:my-data"][0].should eq("{\"key\":\"value\"}")
+    data = {'key' => 'value'}
+    @mb_obj.header('my-data', data)
+    
+    expect(@mb_obj.message["v:my-data"][0]).to be_kind_of(String)
+    expect(@mb_obj.message["v:my-data"][0].to_s).to eq('{"key"=>"value"}')
   end
   it 'throws an exception on broken JSON.' do
     data = 'This is some crappy JSON.'
-    expect {@mb_obj.set_custom_data('my-data', data)}.to raise_error(Mailgun::ParameterError)
+    expect {@mb_obj.header('my-data', data)}.to raise_error(Mailgun::ParameterError)
   end
 end
 
@@ -349,27 +506,41 @@ describe 'The method add_custom_parameter' do
   end
   it 'adds an undefined parameter to the message.' do
     @mb_obj.add_custom_parameter('h:my-sweet-header', 'datagoeshere')
-    @mb_obj.message["h:my-sweet-header"][0].should eq("datagoeshere")
+    
+    expect(@mb_obj.message["h:my-sweet-header"][0]).to eq("datagoeshere")
   end
 end
 
 describe 'The method set_message_id' do
+  it 'warns of set_message_id deprecation' do
+    @mb_obj = Mailgun::MessageBuilder.new
+    expect(@mb_obj).to receive :warn
+    @mb_obj.set_message_id 'warn on set_message_id'
+  end
+end
+
+describe 'The method message_id' do
   before(:each) do
     @mb_obj = Mailgun::MessageBuilder.new
     @the_message_id = '<20141014000000.11111.11111@example.com>'
   end
   it 'correctly sets the Message-Id header' do
-    @mb_obj.set_message_id(@the_message_id)
-    @mb_obj.message['h:Message-Id'].should eq(@the_message_id)
+    @mb_obj.message_id(@the_message_id)
+    
+    expect(@mb_obj.message['h:Message-Id']).to eq(@the_message_id)
   end
   it 'correctly clears the Message-Id header when passed nil' do
-    @mb_obj.set_message_id(nil)
-    @mb_obj.message.has_key?('h:Message-Id').should eq(false)
+    @mb_obj.message_id(nil)
+    
+    expect(@mb_obj.message.has_key?('h:Message-Id')).to eq(false)
   end
   it 'correctly sets the Message-Id header when passed an empty string' do
-    @mb_obj.set_message_id(@the_message_id)
-    @mb_obj.message.has_key?('h:Message-Id').should eq(true)
-    @mb_obj.set_message_id('')
-    @mb_obj.message.has_key?('h:Message-Id').should eq(false)
+    @mb_obj.message_id(@the_message_id)
+    
+    expect(@mb_obj.message.has_key?('h:Message-Id')).to eq(true)
+    
+    @mb_obj.message_id('')
+    
+    expect(@mb_obj.message.has_key?('h:Message-Id')).to eq(false)
   end
 end