postmark 0.9.19 → 1.0.0

data/spec/unit/postmark/bounce_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Postmark::Bounce do
+  let(:bounce_data) { {:type => "HardBounce",
+                       :message_id => "d12c2f1c-60f3-4258-b163-d17052546ae4",
+                       :type_code => 1,
+                       :details => "test bounce",
+                       :email => "jim@test.com",
+                       :bounced_at => "2013-04-22 18:06:48 +0800",
+                       :dump_available => true,
+                       :inactive => false,
+                       :can_activate => true,
+                       :id => 42,
+                       :subject => "Hello from our app!"} }
+  let(:bounce_data_postmark) { Postmark::HashHelper.to_postmark(bounce_data) }
+  let(:bounces_data) { [bounce_data, bounce_data, bounce_data] }
+
+  let(:bounce) { Postmark::Bounce.new(bounce_data) }
+
+  subject { bounce }
+
+  context "attr readers" do
+
+    it { should respond_to(:email) }
+    it { should respond_to(:bounced_at) }
+    it { should respond_to(:type) }
+    it { should respond_to(:details) }
+    it { should respond_to(:name) }
+    it { should respond_to(:id) }
+    it { should respond_to(:server_id) }
+    it { should respond_to(:tag) }
+    it { should respond_to(:message_id) }
+    it { should respond_to(:subject) }
+
+  end
+
+  context "given a bounce created from bounce_data" do
+
+    it 'is not inactive' do
+      should_not be_inactive
+    end
+
+    it 'allows to activate the bounce' do
+      subject.can_activate?.should be_true
+    end
+
+    it 'has an available dump' do
+      subject.dump_available?.should be_true
+    end
+
+    its(:type) { should eq bounce_data[:type] }
+    its(:message_id) { should eq bounce_data[:message_id] }
+    its(:details) { should eq bounce_data[:details] }
+    its(:email) { should eq bounce_data[:email] }
+    its(:bounced_at) { should == Time.parse(bounce_data[:bounced_at]) }
+    its(:id) { should eq bounce_data[:id] }
+    its(:subject) { should eq bounce_data[:subject] }
+
+  end
+
+  context "given a bounce created from bounce_data_postmark" do
+    subject { Postmark::Bounce.new(bounce_data_postmark) }
+
+    it 'is not inactive' do
+      should_not be_inactive
+    end
+
+    it 'allows to activate the bounce' do
+      subject.can_activate?.should be_true
+    end
+
+    it 'has an available dump' do
+      subject.dump_available?.should be_true
+    end
+
+    its(:type) { should eq bounce_data[:type] }
+    its(:message_id) { should eq bounce_data[:message_id] }
+    its(:details) { should eq bounce_data[:details] }
+    its(:email) { should eq bounce_data[:email] }
+    its(:bounced_at) { should == Time.parse(bounce_data[:bounced_at]) }
+    its(:id) { should eq bounce_data[:id] }
+    its(:subject) { should eq bounce_data[:subject] }
+
+  end
+
+  describe "#dump" do
+
+    let(:bounce_body) { mock }
+    let(:response) { {:body => bounce_body} }
+    let(:api_client) { Postmark.api_client }
+
+    it "calls #dump_bounce on shared api_client instance" do
+      Postmark.api_client.should_receive(:dump_bounce).with(bounce.id) { response }
+      bounce.dump.should == bounce_body
+    end
+
+  end
+
+  describe "#activate" do
+
+    let(:api_client) { Postmark.api_client }
+
+    it "calls #activate_bounce on shared api_client instance" do
+      api_client.should_receive(:activate_bounce).with(bounce.id) { bounce_data }
+      bounce.activate.should be_a Postmark::Bounce
+    end
+
+  end
+
+  describe ".find" do
+    let(:api_client) { Postmark.api_client }
+
+    it "calls #get_bounce on shared api_client instance" do
+      api_client.should_receive(:get_bounce).with(42) { bounce_data }
+      Postmark::Bounce.find(42).should be_a Postmark::Bounce
+    end
+  end
+
+  describe ".all" do
+
+    let(:response) { bounces_data }
+    let(:api_client) { Postmark.api_client }
+
+    it "calls #get_bounces on shared api_client instance" do
+      api_client.should_receive(:get_bounces) { response }
+      Postmark::Bounce.all.should have(3).bounces
+    end
+
+  end
+
+  describe ".tags" do
+
+    let(:api_client) { Postmark.api_client }
+    let(:tags) { ["tag1", "tag2"] }
+
+    it "calls #get_bounced_tags on shared api_client instance" do
+      api_client.should_receive(:get_bounced_tags) { tags }
+      Postmark::Bounce.tags.should == tags
+    end
+  end
+
+end

data/spec/unit/postmark/handlers/mail_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Mail::Postmark do
+  let(:message) do
+    Mail.new do
+      from    "sheldon@bigbangtheory.com"
+      to      "lenard@bigbangtheory.com"
+      subject "Hello!"
+      body    "Hello Sheldon!"
+    end
+  end
+
+  it "can be set as delivery_method" do
+    message.delivery_method Mail::Postmark
+  end
+
+  it "wraps Postmark.send_through_postmark" do
+    Postmark::ApiClient.any_instance.should_receive(:deliver_message).with(message)
+    message.delivery_method Mail::Postmark
+    message.deliver
+  end
+
+  it "returns self by default" do
+    Postmark::ApiClient.any_instance.should_receive(:deliver_message).with(message)
+    message.delivery_method Mail::Postmark
+    message.deliver.should eq message
+  end
+
+  it "returns the actual response if :return_response setting is present" do
+    Postmark::ApiClient.any_instance.should_receive(:deliver_message).with(message)
+    message.delivery_method Mail::Postmark, :return_response => true
+    message.deliver.should eq message
+  end
+
+  it "allows to set the api key" do
+    message.delivery_method Mail::Postmark, {:api_key => 'api-key'}
+    message.delivery_method.settings[:api_key].should == 'api-key'
+  end
+end

data/spec/unit/postmark/helpers/hash_helper_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Postmark::HashHelper do
+  describe ".to_postmark" do
+    let(:source) { {:from => "support@postmarkapp.com", :reply_to => "contact@wildbit.com"} }
+    let(:target) { {"From" => "support@postmarkapp.com", "ReplyTo" => "contact@wildbit.com"} }
+
+    it 'converts Hash keys to Postmark format' do
+      subject.to_postmark(source).should == target
+    end
+
+    it 'acts idempotentely' do
+      subject.to_postmark(target).should == target
+    end
+  end
+
+  describe ".to_ruby" do
+    let(:source) { {"From" => "support@postmarkapp.com", "ReplyTo" => "contact@wildbit.com"} }
+    let(:target) { {:from => "support@postmarkapp.com", :reply_to => "contact@wildbit.com"} }
+
+    it 'converts Hash keys to Ruby format' do
+      subject.to_ruby(source).should == target
+    end
+
+    it 'has compatible mode' do
+      subject.to_ruby(source, true).should == target.merge(source)
+    end
+
+    it 'acts idempotentely' do
+      subject.to_ruby(target).should == target
+    end
+  end
+
+end

data/spec/unit/postmark/helpers/message_helper_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Postmark::MessageHelper do
+  let(:attachments) {
+    [
+      File.open(empty_gif_path),
+      {:name => "img2.gif",
+       :content => Postmark::MessageHelper.encode_in_base64(File.read(empty_gif_path)),
+       :content_type => "application/octet-stream"}
+    ]
+  }
+
+  let(:postmark_attachments) {
+    content = Postmark::MessageHelper.encode_in_base64(File.read(empty_gif_path))
+    [
+      {"Name" => "empty.gif",
+       "Content" => content,
+       "ContentType" => "application/octet-stream"},
+      {"Name" => "img2.gif",
+       "Content" => content,
+       "ContentType" => "application/octet-stream"}
+    ]
+  }
+
+  let(:headers) {
+    [{:name => "CUSTOM-HEADER", :value => "value"}]
+  }
+
+  let(:postmark_headers) {
+    [{"Name" => "CUSTOM-HEADER", "Value" => "value"}]
+  }
+
+
+  describe ".to_postmark" do
+    let(:message) {
+      {
+        :from => "sender@example.com",
+        :to => "receiver@example.com",
+        :cc => "copied@example.com",
+        :bcc => "blank-copied@example.com",
+        :subject => "Test",
+        :tag => "Invitation",
+        :html_body => "<b>Hello</b>",
+        :text_body => "Hello",
+        :reply_to => "reply@example.com"
+      }
+    }
+
+    let(:postmark_message) {
+      {
+        "From" => "sender@example.com",
+        "To" => "receiver@example.com",
+        "Cc" => "copied@example.com",
+        "Bcc"=> "blank-copied@example.com",
+        "Subject" => "Test",
+        "Tag" => "Invitation",
+        "HtmlBody" => "<b>Hello</b>",
+        "TextBody" => "Hello",
+        "ReplyTo" => "reply@example.com"
+      }
+    }
+
+    let(:message_with_headers) {
+      message.merge(:headers => headers)
+    }
+
+    let(:postmark_message_with_headers) {
+      postmark_message.merge("Headers" => postmark_headers)
+    }
+
+    let(:message_with_headers_and_attachments) {
+      message_with_headers.merge(:attachments => attachments)
+    }
+
+    let(:postmark_message_with_headers_and_attachments) {
+      postmark_message_with_headers.merge("Attachments" => postmark_attachments)
+    }
+
+    it 'converts messages without custom headers and attachments correctly' do
+      subject.to_postmark(message).should == postmark_message
+    end
+
+    it 'converts messages with custom headers and without attachments correctly' do
+      subject.to_postmark(message_with_headers).should == postmark_message_with_headers
+    end
+
+    it 'converts messages with custom headers and attachments correctly' do
+      subject.to_postmark(message_with_headers_and_attachments).should == postmark_message_with_headers_and_attachments
+    end
+
+  end
+
+  describe ".headers_to_postmark" do
+    it 'converts headers to Postmark format' do
+      subject.headers_to_postmark(headers).should == postmark_headers
+    end
+
+    it 'accepts single header as a non-array' do
+      subject.headers_to_postmark(headers.first).should == [postmark_headers.first]
+    end
+  end
+
+  describe ".attachments_to_postmark" do
+
+    it 'converts attachments to Postmark format' do
+      subject.attachments_to_postmark(attachments).should == postmark_attachments
+    end
+
+    it 'accepts single attachment as a non-array' do
+      subject.attachments_to_postmark(attachments.first).should == [postmark_attachments.first]
+    end
+
+  end
+
+end

data/spec/unit/postmark/http_client_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+describe Postmark::HttpClient do
+
+  def response_body(status, message = "")
+    body = {"ErrorCode" => status, "Message" => message}.to_json
+  end
+
+  let(:api_key) { "provided-postmark-api-key" }
+  let(:secure) { true }
+  let(:proxy_host) { "providedproxyhostname.com" }
+  let(:proxy_port) { 42 }
+  let(:proxy_user) { "provided proxy user" }
+  let(:proxy_pass) { "provided proxy pass" }
+  let(:host) { "providedhostname.org" }
+  let(:port) { 443 }
+  let(:path_prefix) { "/provided/path/prefix" }
+  let(:http_open_timeout) { 42 }
+  let(:http_read_timeout) { 42 }
+
+  let(:http_client) { Postmark::HttpClient.new(api_key) }
+  subject { http_client }
+
+  context "attr writers" do
+    it { should respond_to(:api_key=) }
+  end
+
+  context "attr readers" do
+    it { should respond_to(:http) }
+    it { should respond_to(:secure) }
+    it { should respond_to(:api_key) }
+    it { should respond_to(:proxy_host) }
+    it { should respond_to(:proxy_port) }
+    it { should respond_to(:proxy_user) }
+    it { should respond_to(:proxy_pass) }
+    it { should respond_to(:host) }
+    it { should respond_to(:port) }
+    it { should respond_to(:path_prefix) }
+    it { should respond_to(:http_open_timeout) }
+    it { should respond_to(:http_read_timeout) }
+  end
+
+  context "when it is created without options" do
+    its(:api_key) { should eq api_key }
+    its(:host) { should eq 'api.postmarkapp.com' }
+    its(:port) { should eq 80 }
+    its(:secure) { should be_false }
+    its(:path_prefix) { should eq '/' }
+    its(:http_read_timeout) { should eq 15 }
+    its(:http_open_timeout) { should eq 5 }
+  end
+
+  context "when it is created with options" do
+    subject { Postmark::HttpClient.new(api_key, 
+                                       :secure => secure,
+                                       :proxy_host => proxy_host,
+                                       :proxy_port => proxy_port,
+                                       :proxy_user => proxy_user,
+                                       :proxy_pass => proxy_pass,
+                                       :host => host,
+                                       :port => port,
+                                       :path_prefix => path_prefix,
+                                       :http_open_timeout => http_open_timeout,
+                                       :http_read_timeout => http_read_timeout) }
+
+    its(:api_key) { should eq api_key }
+    its(:secure) { should == secure }
+    its(:proxy_host) { should == proxy_host }
+    its(:proxy_port) { should == proxy_port }
+    its(:proxy_user) { should == proxy_user }
+    its(:proxy_pass) { should == proxy_pass }
+    its(:host) { should == host }
+    its(:port) { should == port }
+    its(:path_prefix) { should == path_prefix }
+    its(:http_open_timeout) { should == http_open_timeout }
+    its(:http_read_timeout) { should == http_read_timeout }
+  end
+
+  describe "#post" do
+    let(:target_path) { "path/on/server" }
+    let(:target_url) { "http://api.postmarkapp.com/#{target_path}" }
+
+    it "sends a POST request to provided URI" do
+      FakeWeb.register_uri(:post, target_url, :body => response_body(200))
+      subject.post(target_path)
+      FakeWeb.should have_requested(:post, target_url)
+    end
+
+    it "raises a custom error when API key authorization fails" do
+      FakeWeb.register_uri(:post, target_url, :body => response_body(401),
+                                              :status => [ "401", "Unauthorized" ])
+      expect { subject.post(target_path) }.to raise_error Postmark::InvalidApiKeyError
+    end
+
+    it "raises a custom error when sent JSON was not valid" do
+      FakeWeb.register_uri(:post, target_url, :body => response_body(422),
+                                              :status => [ "422", "Invalid" ])
+      expect { subject.post(target_path) }.to raise_error Postmark::InvalidMessageError
+    end
+
+    it "raises a custom error when server fails to process the request" do
+      FakeWeb.register_uri(:post, target_url, :body => response_body(500),
+                                              :status => [ "500", "Internal Server Error" ])
+      expect { subject.post(target_path) }.to raise_error Postmark::InternalServerError
+    end
+
+    it "raises a custom error when the request times out" do
+      subject.http.should_receive(:post).at_least(:once).
+                                             and_raise(Timeout::Error)
+      expect { subject.post(target_path) }.to raise_error Postmark::TimeoutError
+    end
+
+    it "raises a default error when unknown issue occurs" do
+      FakeWeb.register_uri(:post, target_url, :body => response_body(485),
+                                              :status => [ "485", "Custom HTTP response status" ])
+      expect { subject.post(target_path) }.to raise_error Postmark::UnknownError
+    end
+    
+  end
+
+  describe "#get" do
+    let(:target_path) { "path/on/server" }
+    let(:target_url) { "http://api.postmarkapp.com/#{target_path}" }
+
+    it "sends a GET request to provided URI" do
+      FakeWeb.register_uri(:get, target_url, :body => response_body(200))
+      subject.get(target_path)
+      FakeWeb.should have_requested(:get, target_url)
+    end
+
+    it "raises a custom error when API key authorization fails" do
+      FakeWeb.register_uri(:get, target_url, :body => response_body(401),
+                                              :status => [ "401", "Unauthorized" ])
+      expect { subject.get(target_path) }.to raise_error Postmark::InvalidApiKeyError
+    end
+
+    it "raises a custom error when sent JSON was not valid" do
+      FakeWeb.register_uri(:get, target_url, :body => response_body(422),
+                                              :status => [ "422", "Invalid" ])
+      expect { subject.get(target_path) }.to raise_error Postmark::InvalidMessageError
+    end
+
+    it "raises a custom error when server fails to process the request" do
+      FakeWeb.register_uri(:get, target_url, :body => response_body(500),
+                                              :status => [ "500", "Internal Server Error" ])
+      expect { subject.get(target_path) }.to raise_error Postmark::InternalServerError
+    end
+
+    it "raises a custom error when the request times out" do
+      subject.http.should_receive(:get).at_least(:once).
+                                             and_raise(Timeout::Error)
+      expect { subject.get(target_path) }.to raise_error Postmark::TimeoutError
+    end
+
+    it "raises a default error when unknown issue occurs" do
+      FakeWeb.register_uri(:get, target_url, :body => response_body(485),
+                                              :status => [ "485", "Custom HTTP response status" ])
+      expect { subject.get(target_path) }.to raise_error Postmark::UnknownError
+    end
+    
+  end
+
+  describe "#put" do
+    let(:target_path) { "path/on/server" }
+    let(:target_url) { "http://api.postmarkapp.com/#{target_path}" }
+
+    it "sends a PUT request to provided URI" do
+      FakeWeb.register_uri(:put, target_url, :body => response_body(200))
+      subject.put(target_path)
+      FakeWeb.should have_requested(:put, target_url)
+    end
+
+    it "raises a custom error when API key authorization fails" do
+      FakeWeb.register_uri(:put, target_url, :body => response_body(401),
+                                              :status => [ "401", "Unauthorized" ])
+      expect { subject.put(target_path) }.to raise_error Postmark::InvalidApiKeyError
+    end
+
+    it "raises a custom error when sent JSON was not valid" do
+      FakeWeb.register_uri(:put, target_url, :body => response_body(422),
+                                              :status => [ "422", "Invalid" ])
+      expect { subject.put(target_path) }.to raise_error Postmark::InvalidMessageError
+    end
+
+    it "raises a custom error when server fails to process the request" do
+      FakeWeb.register_uri(:put, target_url, :body => response_body(500),
+                                              :status => [ "500", "Internal Server Error" ])
+      expect { subject.put(target_path) }.to raise_error Postmark::InternalServerError
+    end
+
+    it "raises a custom error when the request times out" do
+      subject.http.should_receive(:put).at_least(:once).
+                                             and_raise(Timeout::Error)
+      expect { subject.put(target_path) }.to raise_error Postmark::TimeoutError
+    end
+
+    it "raises a default error when unknown issue occurs" do
+      FakeWeb.register_uri(:put, target_url, :body => response_body(485),
+                                              :status => [ "485", "Custom HTTP response status" ])
+      expect { subject.put(target_path) }.to raise_error Postmark::UnknownError
+    end
+    
+  end
+end